module-cccshare.c

   1 #define MODULE_LOG_PREFIX "cccam"
   2
   3 #include "globals.h"
   4
   5 #if defined(MODULE_CCCAM) && defined(MODULE_CCCSHARE)
   6
   7 #include "module-cccam.h"
   8 #include "module-cccam-data.h"
   9 #include "module-cccshare.h"
  10 #include "oscam-chk.h"
  11 #include "oscam-client.h"
  12 #include "oscam-lock.h"
  13 #include "oscam-string.h"
  14 #include "oscam-time.h"
  15 #include "oscam-work.h"
  16
  17 extern uint32_t cfg_sidtab_generation;
  18
  19 static uint32_t cc_share_id = 0x64;
  20 static LLIST *reported_carddatas_list[CAID_KEY];
  21 static CS_MUTEX_LOCK cc_shares_lock;
  22
  23 static int32_t card_added_count;
  24 static int32_t card_removed_count;
  25 static int32_t card_dup_count;
  26 static pthread_t share_updater_thread;
  27 static bool share_updater_thread_active;
  28 static bool share_updater_refresh;
  29
  30 int32_t card_valid_for_client(struct s_client *cl, struct cc_card *card);
  31 int32_t flt = 0;
  32
  33 LLIST *get_cardlist(uint16_t caid, LLIST **list)
  34 {
  35         caid = (caid >> 8) % CAID_KEY;
  36         if(!list[caid])
  37                 { list[caid] = ll_create("card_list"); }
  38         return list[caid];
  39 }
  40
  41 LLIST **get_and_lock_sharelist(void)
  42 {
  43         cs_readlock(__func__, &cc_shares_lock);
  44         return reported_carddatas_list;
  45 }
  46
  47 void unlock_sharelist(void)
  48 {
  49         cs_readunlock(__func__, &cc_shares_lock);
  50 }
  51
  52 void add_good_sids(struct s_sidtab *ptr, struct cc_card *card)
  53 {
  54         int32_t l;
  55         for(l = 0; l < ptr->num_srvid; l++)
  56         {
  57                 struct cc_srvid *srvid;
  58                 if(!cs_malloc(&srvid, sizeof(struct cc_srvid)))
  59                         { return; }
  60                 srvid->sid = ptr->srvid[l];
  61                 srvid->chid = 0;
  62                 srvid->ecmlen = 0; // 0=undefined, also not used with "O" CCcam
  63
  64                 if(!ll_contains_data(card->goodsids, srvid, sizeof(struct cc_srvid)))
  65                         { ll_append(card->goodsids, srvid); }
  66                 else { NULLFREE(srvid);}
  67         }
  68 }
  69
  70 void add_bad_sids(struct s_sidtab *ptr, struct cc_card *card)
  71 {
  72         int32_t l;
  73         for(l = 0; l < ptr->num_srvid; l++)
  74         {
  75                 struct cc_srvid_block *srvid;
  76                 if(!cs_malloc(&srvid, sizeof(struct cc_srvid_block)))
  77                         { return; }
  78                 srvid->sid = ptr->srvid[l];
  79                 srvid->chid = 0;
  80                 srvid->ecmlen = 0; // 0=undefined, also not used with "O" CCcam
  81                 srvid->blocked_till = 0;
  82
  83                 if(!ll_contains_data(card->badsids, srvid, sizeof(struct cc_srvid_block)))
  84                         { ll_append(card->badsids, srvid); }
  85                 else { NULLFREE(srvid); }
  86         }
  87 }
  88
  89 void add_good_bad_sids_by_rdr(struct s_reader *rdr, struct cc_card *card)
  90 {
  91         struct s_sidtab *ptr;
  92         int32_t n, i;
  93         for(n = 0, ptr = cfg.sidtab; ptr; ptr = ptr->next, n++)
  94         {
  95                 if(rdr->sidtabs.ok & ((SIDTABBITS)1 << n))
  96                 {
  97                         for(i = 0; i < ptr->num_caid; i++)
  98                         {
  99                                 if(ptr->caid[i] == card->caid)
 100                                         { add_good_sids(ptr, card); }
 101                         }
 102                 }
 103                 else if(rdr->sidtabs.no & ((SIDTABBITS)1 << n))
 104                 {
 105                         for(i = 0; i < ptr->num_caid; i++)
 106                         {
 107                                 if(ptr->caid[i] == card->caid)
 108                                         { add_bad_sids(ptr, card); }
 109                         }
 110                 }
 111         }
 112 }
 113
 114 int32_t can_use_ext(struct cc_card *card)
 115 {
 116         if(card->card_type == CT_REMOTECARD)
 117                 { return card->is_ext; }
 118
 119         if(card->sidtab)
 120                 { return (card->sidtab->num_srvid > 0); }
 121         else
 122                 { return ll_count(card->goodsids) || ll_count(card->badsids); }
 123         return 0;
 124 }
 125
 126 int32_t write_card(struct cc_data *cc, uint8_t *buf, struct cc_card *card, int32_t add_own, int32_t ext, int32_t au_allowed, struct s_client *cl)
 127 {
 128         memset(buf, 0, CC_MAXMSGSIZE);
 129         buf[0] = card->id >> 24;
 130         buf[1] = card->id >> 16;
 131         buf[2] = card->id >> 8;
 132         buf[3] = card->id & 0xff;
 133         buf[4] = card->remote_id >> 24;
 134         buf[5] = card->remote_id >> 16;
 135         buf[6] = card->remote_id >> 8;
 136         buf[7] = card->remote_id & 0xFF;
 137         buf[8] = card->caid >> 8;
 138         buf[9] = card->caid & 0xff;
 139         buf[10] = card->hop;
 140         buf[11] = card->reshare;
 141         if(au_allowed)
 142                 { memcpy(buf + 12, card->hexserial, 8); }
 143
 144         // with cccam 2.2.0 we have assigned and rejected sids:
 145         int32_t ofs = ext ? 23 : 21;
 146
 147         // write providers:
 148         LL_ITER it = ll_iter_create(card->providers);
 149         struct cc_provider *prov;
 150         while((prov = ll_iter_next(&it)))
 151         {
 152                 uint32_t prid = prov->prov;
 153                 buf[ofs + 0] = prid >> 16;
 154                 buf[ofs + 1] = prid >> 8;
 155                 buf[ofs + 2] = prid & 0xFF;
 156                 if(au_allowed)
 157                         { memcpy(buf + ofs + 3, prov->sa, 4); }
 158                 buf[20]++;
 159                 ofs += 7;
 160         }
 161
 162         // write sids only if cccam 2.2.x:
 163         if(ext)
 164         {
 165                 if(card->sidtab)
 166                 {
 167                         // good sids:
 168                         struct s_sidtab *ptr = card->sidtab;
 169                         int32_t l;
 170                         for(l = 0; l < ptr->num_srvid; l++)
 171                         {
 172                                 buf[ofs + 0] = ptr->srvid[l] >> 8;
 173                                 buf[ofs + 1] = ptr->srvid[l] & 0xFF;
 174                                 ofs += 2;
 175                                 buf[21]++; // nassign
 176                                 if(buf[21] >= 240)
 177                                         { break; }
 178                         }
 179
 180                         // bad sids:
 181                         int32_t n;
 182                         for(n = 0, ptr = cfg.sidtab; ptr; ptr = ptr->next, n++)
 183                         {
 184                                 if((cl->sidtabs.no & ((SIDTABBITS)1 << n)) || (card->sidtabno & ((SIDTABBITS)1 << n)))
 185                                 {
 186                                         int32_t m;
 187                                         int32_t ok_caid = 0;
 188                                         for(m = 0; m < ptr->num_caid; m++) // search bad sids for this caid:
 189                                         {
 190                                                 if(ptr->caid[m] == card->caid)
 191                                                 {
 192                                                         ok_caid = 1;
 193                                                         break;
 194                                                 }
 195                                         }
 196                                         if(ok_caid)
 197                                         {
 198                                                 for(l = 0; l < ptr->num_srvid; l++)
 199                                                 {
 200                                                         buf[ofs + 0] = ptr->srvid[l] >> 8;
 201                                                         buf[ofs + 1] = ptr->srvid[l] & 0xFF;
 202                                                         ofs += 2;
 203                                                         buf[22]++; // nreject
 204                                                         if(buf[22] >= 240)
 205                                                                 { break; }
 206                                                 }
 207                                         }
 208                                 }
 209                                 if(buf[22] >= 240)
 210                                         { break; }
 211                         }
 212
 213                 }
 214                 else
 215                 {
 216                         // assigned sids:
 217                         it = ll_iter_create(card->goodsids);
 218                         struct cc_srvid *srvid;
 219                         struct cc_srvid_block *srvidblock;
 220                         while((srvid = ll_iter_next(&it)))
 221                         {
 222                                 buf[ofs + 0] = srvid->sid >> 8;
 223                                 buf[ofs + 1] = srvid->sid & 0xFF;
 224                                 ofs += 2;
 225                                 buf[21]++; // nassign
 226                                 if(buf[21] >= 200)
 227                                         { break; }
 228                         }
 229
 230                         // reject sids:
 231                         it = ll_iter_create(card->badsids);
 232                         while((srvidblock = ll_iter_next(&it)))
 233                         {
 234                                 if(srvidblock->blocked_till > 0)
 235                                 {
 236                                         continue;
 237                                 }
 238                                 buf[ofs + 0] = srvidblock->sid >> 8;
 239                                 buf[ofs + 1] = srvidblock->sid & 0xFF;
 240                                 ofs += 2;
 241                                 buf[22]++; // nreject
 242                                 if(buf[22] >= 200)
 243                                         { break; }
 244                         }
 245                 }
 246         }
 247
 248         // write remote nodes
 249         int32_t nremote_ofs = ofs;
 250         ofs++;
 251         it = ll_iter_create(card->remote_nodes);
 252         uint8_t *remote_node;
 253         while((remote_node = ll_iter_next(&it)))
 254         {
 255                 memcpy(buf + ofs, remote_node, 8);
 256                 ofs += 8;
 257                 buf[nremote_ofs]++;
 258         }
 259         if(add_own)
 260         {
 261                 memcpy(buf + ofs, cc->node_id, 8);
 262                 ofs += 8;
 263                 buf[nremote_ofs]++;
 264         }
 265         return ofs;
 266 }
 267
 268 static int32_t is_client_au_allowed(struct cc_card *card, struct s_client *cl)
 269 {
 270         if(!card || !card->origin_reader)
 271         {
 272                 return 0;
 273         }
 274
 275         if(!cl || !cl->aureader_list || !ll_count(cl->aureader_list))
 276         {
 277                 return 0;
 278         }
 279
 280         struct s_reader *rdr = NULL;
 281         LL_ITER itr = ll_iter_create(cl->aureader_list);
 282         while((rdr = ll_iter_next(&itr)))
 283         {
 284                 if(rdr == card->origin_reader)
 285                 {
 286                         return 1;
 287                 }
 288         }
 289
 290         return 0;
 291 }
 292
 293 static int32_t send_card_to_client(struct cc_card *card, struct s_client *cl)
 294 {
 295         uint8_t buf[CC_MAXMSGSIZE];
 296
 297         if(!card_valid_for_client(cl, card))
 298                 { return 0; }
 299
 300         int8_t usr_reshare = cl->account->cccreshare;
 301         if(usr_reshare == -1)
 302                 { usr_reshare = cfg.cc_reshare; }
 303
 304         int8_t ignorereshare = cl->account->cccignorereshare;
 305         if(ignorereshare == -1)
 306                 { ignorereshare = cfg.cc_ignore_reshare; }
 307
 308         int8_t reader_reshare = card->origin_reader ? card->rdr_reshare : usr_reshare;
 309         if(reader_reshare == -1)
 310                 { reader_reshare = cfg.cc_reshare; }
 311
 312         int8_t reshare = (reader_reshare < usr_reshare) ? reader_reshare : usr_reshare;
 313         int8_t new_reshare;
 314         if(card->card_type == CT_CARD_BY_SERVICE_USER)
 315         {
 316                 new_reshare = usr_reshare;
 317         }
 318         else if(ignorereshare)
 319         {
 320                 new_reshare = reshare;
 321         }
 322         else
 323         {
 324                 new_reshare = card->reshare;
 325                 if(card->card_type == CT_REMOTECARD)
 326                         { new_reshare--; }
 327                 if(new_reshare > reshare)
 328                         { new_reshare = reshare; }
 329         }
 330         if(new_reshare < 0)
 331                 { return 0; }
 332
 333         if(!card->id)
 334                 { card->id = cc_share_id++; }
 335
 336         struct cc_data *cc = cl->cc;
 337         int32_t is_ext = cc->cccam220 && can_use_ext(card);
 338         int32_t len = write_card(cc, buf, card, 1, is_ext, is_client_au_allowed(card, cl), cl);
 339         //buf[10] = card->hop-1;
 340         buf[11] = new_reshare;
 341
 342         struct s_clientmsg *clientmsg;
 343         if(cs_malloc(&clientmsg, sizeof(struct s_clientmsg)))
 344         {
 345                 memcpy(clientmsg->msg, buf, len);
 346                 clientmsg->len = len;
 347                 clientmsg->cmd = is_ext ? MSG_NEW_CARD_SIDINFO : MSG_NEW_CARD;
 348                 add_job(cl, ACTION_CLIENT_SEND_MSG, clientmsg, sizeof(struct s_clientmsg));
 349         }
 350         return 1;
 351 }
 352
 353 int32_t hide_card_to_client(struct cc_card *card, struct s_client *cl)
 354 {
 355         if(!card || !card->id)
 356                 { return 0; }
 357
 358         uint8_t buf[4];
 359         buf[0] = card->id >> 24;
 360         buf[1] = card->id >> 16;
 361         buf[2] = card->id >> 8;
 362         buf[3] = card->id & 0xFF;
 363
 364         struct s_clientmsg *clientmsg;
 365         struct cc_data *cc = cl->cc;
 366         if(cc && (cl->typ == 'c') && !cl->kill && (get_module(cl)->num == R_CCCAM)) //CCCam-Client!
 367         {
 368                 if(card_valid_for_client(cl, card))
 369                 {
 370                         if(cs_malloc(&clientmsg, sizeof(struct s_clientmsg)))
 371                         {
 372                                 memcpy(clientmsg->msg, buf, sizeof(buf));
 373                                 clientmsg->len = sizeof(buf);
 374                                 clientmsg->cmd = MSG_CARD_REMOVED;
 375                                 add_job(cl, ACTION_CLIENT_SEND_MSG, clientmsg, sizeof(struct s_clientmsg));
 376                                 return 1;
 377                         }
 378                 }
 379         }
 380         return 0;
 381 }
 382
 383 int32_t unhide_card_to_client(struct cc_card *card, struct s_client *cl)
 384 {
 385         return send_card_to_client(card, cl);
 386 }
 387
 388 int32_t hidecards_card_valid_for_client(struct s_client *cl, struct cc_card *card)
 389 {
 390         return card_valid_for_client(cl, card);
 391 }
 392
 393 int32_t send_card_to_all_clients(struct cc_card *card)
 394 {
 395         int32_t count = 0;
 396         struct s_client *cl;
 397         cs_readlock(__func__, &clientlist_lock);
 398         for(cl = first_client; cl; cl = cl->next)
 399         {
 400                 if(cl->cc && cl->typ == 'c' && !cl->kill && get_module(cl)->num == R_CCCAM) // CCCam-Client!
 401                 {
 402                         count += send_card_to_client(card, cl);
 403                 }
 404         }
 405         cs_readunlock(__func__, &clientlist_lock);
 406         return count;
 407 }
 408
 409 void send_remove_card_to_clients(struct cc_card *card)
 410 {
 411         if(!card || !card->id)
 412                 { return; }
 413
 414         uint8_t buf[4];
 415         buf[0] = card->id >> 24;
 416         buf[1] = card->id >> 16;
 417         buf[2] = card->id >> 8;
 418         buf[3] = card->id & 0xFF;
 419
 420         struct s_client *cl;
 421         struct s_clientmsg *clientmsg;
 422         cs_readlock(__func__, &clientlist_lock);
 423         for(cl = first_client; cl; cl = cl->next)
 424         {
 425                 struct cc_data *cc = cl->cc;
 426                 if(cc && cl->typ == 'c' && !cl->kill && get_module(cl)->num == R_CCCAM) // CCCam-Client!
 427                 {
 428                         if(card_valid_for_client(cl, card))
 429                         {
 430                                 if(cs_malloc(&clientmsg, sizeof(struct s_clientmsg)))
 431                                 {
 432                                         memcpy(clientmsg->msg, buf, sizeof(buf));
 433                                         clientmsg->len = sizeof(buf);
 434                                         clientmsg->cmd = MSG_CARD_REMOVED;
 435                                         add_job(cl, ACTION_CLIENT_SEND_MSG, clientmsg, sizeof(struct s_clientmsg));
 436                                 }
 437                         }
 438                 }
 439         }
 440         cs_readunlock(__func__, &clientlist_lock);
 441 }
 442
 443
 444 /**
 445  * if idents defined on an cccam reader, the cards caid+provider are checked.
 446  * return 1 a) if no ident defined b) card is in identlist
 447  *        0 if card is not in identlist
 448  *
 449  * a card is in the identlist, if the cards caid is matching and mininum a provider is matching
 450  **/
 451 int32_t chk_ident(FTAB *ftab, struct cc_card *card)
 452 {
 453
 454         int32_t j, k;
 455         int32_t res = 1;
 456
 457         if(ftab && ftab->filts)
 458         {
 459                 for(j = 0; j < ftab->nfilts; j++)
 460                 {
 461                         if(ftab->filts[j].caid)
 462                         {
 463                                 res = 0;
 464                                 if(ftab->filts[j].caid == card->caid) // caid matches!
 465                                 {
 466
 467                                         int32_t nprids = ftab->filts[j].nprids;
 468                                         if(!nprids) // No Provider ->Ok
 469                                                 { return 1; }
 470
 471
 472                                         LL_ITER it = ll_iter_create(card->providers);
 473                                         struct cc_provider *prov;
 474
 475                                         while((prov = ll_iter_next(&it)))
 476                                         {
 477                                                 for(k = 0; k < nprids; k++)
 478                                                 {
 479                                                         uint32_t prid = ftab->filts[j].prids[k];
 480                                                         if(prid == prov->prov) // Provider matches
 481                                                         {
 482                                                                 return 1;
 483                                                         }
 484                                                 }
 485                                         }
 486                                 }
 487                         }
 488                 }
 489         }
 490         return res;
 491 }
 492
 493 int32_t cc_clear_reported_carddata(LLIST *reported_carddatas, LLIST *except, int32_t send_removed)
 494 {
 495         int32_t i = 0;
 496         LL_ITER it = ll_iter_create(reported_carddatas);
 497         struct cc_card *card;
 498         while((card = ll_iter_next(&it)))
 499         {
 500                 struct cc_card *card2 = NULL;
 501                 if(except)
 502                 {
 503                         LL_ITER it2 = ll_iter_create(except);
 504                         while((card2 = ll_iter_next(&it2)))
 505                         {
 506                                 if(card == card2)
 507                                         { break; }
 508                         }
 509                 }
 510
 511                 if(!card2 && ll_iter_remove(&it)) // check result of ll_iter_remove, because another thread could removed it
 512                 {
 513                         if(send_removed)
 514                         {
 515                                 cs_log_dbg(D_TRACE, "s-card removed: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
 516                                                         card->id, card->remote_id, card->caid, card->hop, card->reshare, card->origin_id, card->card_type);
 517
 518                                 send_remove_card_to_clients(card);
 519                         }
 520                         cc_free_card(card);
 521                         i++;
 522                 }
 523         }
 524         return i;
 525 }
 526
 527 int32_t cc_free_reported_carddata(LLIST *reported_carddatas, LLIST *except, int32_t send_removed)
 528 {
 529         int32_t i = 0;
 530         if(reported_carddatas)
 531         {
 532                 i = cc_clear_reported_carddata(reported_carddatas, except, send_removed);
 533                 ll_destroy(&reported_carddatas);
 534         }
 535         return i;
 536 }
 537
 538 int32_t card_valid_for_client(struct s_client *cl, struct cc_card *card)
 539 {
 540
 541         // Check group:
 542         if(card->grp && !(card->grp & cl->grp))
 543                 { return 0; }
 544
 545         // Check idents:
 546         if(!chk_ident(&cl->ftab, card))
 547                 { return 0; }
 548
 549         // Check caids:
 550         if(!chk_ctab(card->caid, &cl->ctab))
 551                 { return 0; }
 552
 553         // Check reshare
 554         if(card->card_type == CT_REMOTECARD)
 555         {
 556                 int8_t ignorereshare = cl->account->cccignorereshare;
 557                 if(ignorereshare == -1) { ignorereshare = cfg.cc_ignore_reshare; }
 558                 if(!ignorereshare && !card->reshare)
 559                         { return 0; }
 560         }
 561
 562         // Check account maxhops:
 563         if(cl->account->cccmaxhops < card->hop)
 564                 { return 0; }
 565
 566         // Check remote node id, if card is from there, ignore it!
 567         LL_ITER it = ll_iter_create(card->remote_nodes);
 568         uint8_t *node;
 569         struct cc_data *cc = cl->cc;
 570         while((node = ll_iter_next(&it)))
 571         {
 572                 if(!memcmp(node, cc->peer_node_id, 8))
 573                 {
 574                         return 0;
 575                 }
 576         }
 577
 578         // Check Services:
 579         if(ll_count(card->providers))
 580         {
 581                 it = ll_iter_create(card->providers);
 582                 struct cc_provider *prov;
 583                 int8_t found = 0;
 584                 while((prov = ll_iter_next(&it)))
 585                 {
 586                         uint32_t prid = prov->prov;
 587                         if(chk_srvid_by_caid_prov(cl, card->caid, prid))
 588                         {
 589                                 found = 1;
 590                                 break;
 591                         }
 592                 }
 593                 if(!found) { return 0; }
 594         }
 595         else
 596         {
 597                 if(!chk_srvid_by_caid_prov(cl, card->caid, 0))
 598                         { return 0; }
 599         }
 600
 601         // Check Card created by Service:
 602         if(card->sidtab)
 603         {
 604                 struct s_sidtab *ptr;
 605                 int32_t j;
 606                 int32_t ok = !cl->sidtabs.ok && !cl->sidtabs.no; // default valid if no positive services and no negative services
 607                 if(!ok)
 608                 {
 609                         if(!cl->sidtabs.ok) // no positive services, so ok by default if no negative found
 610                                 { ok = 1; }
 611
 612                         for(j = 0, ptr = cfg.sidtab; ptr; ptr = ptr->next, j++)
 613                         {
 614                                 if(ptr == card->sidtab)
 615                                 {
 616                                         if(cl->sidtabs.no & ((SIDTABBITS)1 << j))
 617                                                 { return 0; }
 618                                         if(cl->sidtabs.ok & ((SIDTABBITS)1 << j))
 619                                                 { ok = 1; }
 620                                         break;
 621                                 }
 622                         }
 623                 }
 624                 if(!ok)
 625                         { return 0; }
 626         }
 627
 628         return 1;
 629 }
 630
 631 uint32_t get_reader_prid(struct s_reader *rdr, int32_t j)
 632 {
 633         return b2i(3, &rdr->prid[j][1]);
 634 }
 635 //uint32_t get_reader_prid(struct s_reader *rdr, int32_t j) {
 636 //  uint32_t prid;
 637 //  if (!is_cascading_reader(rdr)) { // Real cardreaders have 4-byte Providers
 638 //      prid = b2i(4, &rdr->prid[j][0]);
 639 //      //prid = (rdr->prid[j][0] << 24) | (rdr->prid[j][1] << 16)
 640 //      //      | (rdr->prid[j][2] << 8) | (rdr->prid[j][3] & 0xFF);
 641 //  } else { // Cascading/Network-reader 3-bytes Providers
 642 //      prid = b2i(3, &rdr->prid[j][0]);
 643 //      //prid = (rdr->prid[j][0] << 16) | (rdr->prid[j][1] << 8)
 644 //      //      | (rdr->prid[j][2] & 0xFF);
 645 //
 646 //  }
 647 //  return prid;
 648 //}
 649
 650 void copy_good_sids(LLIST *dst, LLIST *src)
 651 {
 652         LL_ITER it_src = ll_iter_create(src);
 653         LL_ITER it_dst = ll_iter_create(dst);
 654         struct cc_srvid *srvid_src;
 655         struct cc_srvid *srvid_dst;
 656         while((srvid_src = ll_iter_next(&it_src)))
 657         {
 658                 ll_iter_reset(&it_dst);
 659                 while((srvid_dst = ll_iter_next(&it_dst)))
 660                 {
 661                         if(sid_eq(srvid_src, srvid_dst))
 662                                 { break; }
 663                 }
 664                 if(!srvid_dst)
 665                 {
 666                         if(!cs_malloc(&srvid_dst, sizeof(struct cc_srvid)))
 667                                 { break; }
 668                         memcpy(srvid_dst, srvid_src, sizeof(struct cc_srvid));
 669                         ll_iter_insert(&it_dst, srvid_dst);
 670                 }
 671         }
 672 }
 673
 674 void copy_bad_sids(LLIST *dst, LLIST *src)
 675 {
 676         LL_ITER it_src = ll_iter_create(src);
 677         LL_ITER it_dst = ll_iter_create(dst);
 678         struct cc_srvid_block *srvid_src;
 679         struct cc_srvid_block *srvid_dst;
 680         while((srvid_src = ll_iter_next(&it_src)))
 681         {
 682                 ll_iter_reset(&it_dst);
 683                 while((srvid_dst = ll_iter_next(&it_dst)))
 684                 {
 685                         if(sid_eq_bb(srvid_src, srvid_dst))
 686                                 { break; }
 687                 }
 688                 if(!srvid_dst)
 689                 {
 690                         if(!cs_malloc(&srvid_dst, sizeof(struct cc_srvid_block)))
 691                                 { break; }
 692                         memcpy(srvid_dst, srvid_src, sizeof(struct cc_srvid_block));
 693                         ll_iter_insert(&it_dst, srvid_dst);
 694                 }
 695         }
 696 }
 697
 698 int32_t add_card_providers(struct cc_card *dest_card, struct cc_card *card, int32_t copy_remote_nodes)
 699 {
 700         int32_t modified = 0;
 701
 702         // 1. Copy nonexisting providers, ignore double:
 703         struct cc_provider *prov_info;
 704         LL_ITER it_src = ll_iter_create(card->providers);
 705         LL_ITER it_dst = ll_iter_create(dest_card->providers);
 706
 707         struct cc_provider *provider;
 708         while((provider = ll_iter_next(&it_src)))
 709         {
 710                 ll_iter_reset(&it_dst);
 711                 while((prov_info = ll_iter_next(&it_dst)))
 712                 {
 713                         if(prov_info->prov == provider->prov)
 714                                 { break; }
 715                 }
 716                 if(!prov_info)
 717                 {
 718                         struct cc_provider *prov_new;
 719                         if(!cs_malloc(&prov_new, sizeof(struct cc_provider)))
 720                                 { break; }
 721                         memcpy(prov_new, provider, sizeof(struct cc_provider));
 722                         ll_iter_insert(&it_dst, prov_new);
 723                         modified = 1;
 724                 }
 725         }
 726
 727         if(copy_remote_nodes)
 728         {
 729                 // 2. Copy nonexisting remote_nodes, ignoring existing:
 730                 it_src = ll_iter_create(card->remote_nodes);
 731                 it_dst = ll_iter_create(dest_card->remote_nodes);
 732                 uint8_t *remote_node;
 733                 uint8_t *remote_node2;
 734                 while((remote_node = ll_iter_next(&it_src)))
 735                 {
 736                         ll_iter_reset(&it_dst);
 737                         while((remote_node2 = ll_iter_next(&it_dst)))
 738                         {
 739                                 if(memcmp(remote_node, remote_node2, 8) == 0)
 740                                         { break; }
 741                         }
 742                         if(!remote_node2)
 743                         {
 744                                 uint8_t *remote_node_new;
 745                                 if(!cs_malloc(&remote_node_new, 8))
 746                                         { break; }
 747                                 memcpy(remote_node_new, remote_node, 8);
 748                                 ll_iter_insert(&it_dst, remote_node_new);
 749                                 modified = 1;
 750                         }
 751                 }
 752         }
 753         return modified;
 754 }
 755
 756 #define TIMEOUT_SECONDS 3600
 757
 758 void set_card_timeout(struct cc_card *card)
 759 {
 760         card->timeout = time(NULL) + TIMEOUT_SECONDS + ((rand() & 0xff) - 128) * 2;
 761 }
 762
 763 struct cc_card *create_card(struct cc_card *card)
 764 {
 765         struct cc_card *card2;
 766         if(!cs_malloc(&card2, sizeof(struct cc_card)))
 767                 { return NULL; }
 768         if(card)
 769                 { memcpy(card2, card, sizeof(struct cc_card)); }
 770         else
 771                 { memset(card2, 0, sizeof(struct cc_card)); }
 772         card2->providers = ll_create("providers");
 773         card2->badsids = ll_create("badsids");
 774         card2->goodsids = ll_create("goodsids");
 775         card2->remote_nodes = ll_create("remote_nodes");
 776
 777         if(card)
 778         {
 779                 copy_good_sids(card2->goodsids, card->goodsids);
 780                 copy_bad_sids(card2->badsids, card->badsids);
 781                 card2->id = 0;
 782         }
 783         else
 784                 { set_card_timeout(card2); }
 785
 786         return card2;
 787 }
 788
 789 struct cc_card *create_card2(struct s_reader *rdr, int32_t j, uint16_t caid, uint8_t reshare)
 790 {
 791
 792         struct cc_card *card = create_card(NULL);
 793         if(!card)
 794                 { return NULL; }
 795         card->remote_id = (rdr ? (rdr->cc_id << 16) : 0x7F7F8000) | j;
 796         card->caid = caid;
 797         card->reshare = reshare;
 798         card->origin_reader = rdr;
 799         if(rdr)
 800         {
 801                 card->grp = rdr->grp;
 802                 card->rdr_reshare = rdr->cc_reshare > -1 ? rdr->cc_reshare : cfg.cc_reshare; //copy reshare because reader could go offline
 803                 card->sidtabno = rdr->sidtabs.no;
 804                 card->hop = rdr->cc_hop;
 805         }
 806         else { card->rdr_reshare = reshare; }
 807         return card;
 808 }
 809
 810 /**
 811  * num_same_providers checks if card1 has exactly the same providers as card2
 812  * returns same provider count
 813  **/
 814 int32_t num_same_providers(struct cc_card *card1, struct cc_card *card2)
 815 {
 816
 817         int32_t found = 0;
 818
 819         LL_ITER it1 = ll_iter_create(card1->providers);
 820         LL_ITER it2 = ll_iter_create(card2->providers);
 821
 822         struct cc_provider *prov1, *prov2;
 823
 824         while((prov1 = ll_iter_next(&it1)))
 825         {
 826
 827                 ll_iter_reset(&it2);
 828                 while((prov2 = ll_iter_next(&it2)))
 829                 {
 830                         if(prov1->prov == prov2->prov)
 831                         {
 832                                 found++;
 833                                 break;
 834                         }
 835
 836                 }
 837         }
 838         return found;
 839 }
 840
 841 /**
 842  * equal_providers checks if card1 has exactly the same providers as card2
 843  * returns 1=equal 0=different
 844  **/
 845 int32_t equal_providers(struct cc_card *card1, struct cc_card *card2)
 846 {
 847
 848         if(ll_count(card1->providers) != ll_count(card2->providers))
 849                 { return 0; }
 850         if(ll_count(card1->providers) == 0)
 851                 { return 1; }
 852
 853         LL_ITER it1 = ll_iter_create(card1->providers);
 854         LL_ITER it2 = ll_iter_create(card2->providers);
 855
 856         struct cc_provider *prov1, *prov2;
 857
 858         while((prov1 = ll_iter_next(&it1)))
 859         {
 860
 861                 ll_iter_reset(&it2);
 862                 while((prov2 = ll_iter_next(&it2)))
 863                 {
 864                         if(prov1->prov == prov2->prov)
 865                         {
 866                                 break;
 867                         }
 868
 869                 }
 870                 if(!prov2) { break; }
 871         }
 872         return (prov1 == NULL);
 873 }
 874
 875 int32_t is_au_card(struct cc_card *card)
 876 {
 877         if(card && card->origin_reader)
 878                 { return !card->origin_reader->audisabled && cc_UA_valid(card->hexserial); }
 879         return 0;
 880 }
 881
 882 void merge_sids(struct cc_card *carddst, struct cc_card *cardsrc)
 883 {
 884         LL_ITER it;
 885         struct cc_srvid *srvid;
 886         struct cc_srvid_block *srvidb;
 887
 888         int32_t goodSidCountSrc = ll_count(cardsrc->goodsids);
 889         int32_t goodSidCountDst = ll_count(carddst->goodsids);
 890
 891         if(goodSidCountDst == 0)
 892         {
 893                 // remove sid blocks good+notbad from src
 894                 it = ll_iter_create(cardsrc->goodsids);
 895                 while((srvid = ll_iter_next(&it)))
 896                 {
 897                         if(!is_sid_blocked(cardsrc, srvid))
 898                                 { remove_sid_block(carddst, srvid); }
 899                 }
 900         }
 901         else
 902         {
 903                 if(goodSidCountSrc == 0)
 904                 {
 905                         // del goods from dst
 906                         ll_clear(carddst->goodsids);
 907
 908                         // del bads from dst
 909                         ll_clear(carddst->badsids);
 910
 911                         // add bads from src
 912                         it = ll_iter_create(cardsrc->badsids);
 913                         while((srvidb = ll_iter_next(&it)))
 914                         {
 915                                 { add_sid_block(carddst, (struct cc_srvid*)srvidb, false); }
 916                         }
 917                 }
 918                 else
 919                 {
 920                         // add good sid good+notbad from src
 921                         it = ll_iter_create(cardsrc->goodsids);
 922                         while((srvid = ll_iter_next(&it)))
 923                         {
 924                                 if(!is_sid_blocked(cardsrc, srvid))
 925                                         { add_good_sid(carddst, srvid); }
 926                         }
 927                 }
 928         }
 929
 930 }
 931
 932 /**
 933  * Adds a new card to a cardlist.
 934  */
 935 int32_t add_card_to_serverlist(LLIST *cardlist, struct cc_card *card, int8_t free_card)
 936 {
 937
 938         int32_t modified = 0;
 939         if(!card)
 940                 { return modified; }
 941
 942         LL_ITER it = ll_iter_create(cardlist);
 943         struct cc_card *card2;
 944
 945         // Minimize all, transmit just CAID, merge providers:
 946         if(cfg.cc_minimize_cards == MINIMIZE_CAID && !cfg.cc_forward_origin_card)
 947         {
 948                 while((card2 = ll_iter_next(&it)))
 949                 {
 950                         // compare caid, hexserial, cardtype and sidtab (if any):
 951                         if(same_card2(card, card2, 0))
 952                         {
 953                                 // Merge cards only if resulting providercount is smaller than CS_MAXPROV
 954                                 int32_t nsame, ndiff, nnew;
 955
 956                                 nsame = num_same_providers(card, card2); // count same cards
 957                                 ndiff = ll_count(card->providers) - nsame; // cound different cards, this cound will be added
 958                                 nnew = ndiff + ll_count(card2->providers); // new card count after add. because its limited to CS_MAXPROV, dont add it
 959
 960                                 if(nnew <= CS_MAXPROV)
 961                                         { break; }
 962                         }
 963                 }
 964
 965                 if(!card2) // Not found->add it:
 966                 {
 967                         if(free_card) // Use this card
 968                         {
 969                                 free_card = 0;
 970                                 ll_iter_insert(&it, card);
 971                         }
 972                         else
 973                         {
 974                                 card2 = create_card(card); // Copy card
 975                                 if(!card2)
 976                                         { return modified; }
 977                                 card2->hop = 0;
 978                                 ll_iter_insert(&it, card2);
 979                                 add_card_providers(card2, card, 1); // copy providers to new card. Copy remote nodes to new card
 980                         }
 981                         modified = 1;
 982
 983                 }
 984                 else // found, merge providers:
 985                 {
 986                         card_dup_count++;
 987                         card2->grp |= card->grp; // add group to the card
 988                         add_card_providers(card2, card, 0); // merge all providers
 989                         ll_clear_data(card2->remote_nodes); // clear remote nodes
 990                         merge_sids(card2, card);
 991                 }
 992         }
 993
 994         // Removed duplicate cards, keeping card with lower hop:
 995         else if(cfg.cc_minimize_cards == MINIMIZE_HOPS && !cfg.cc_forward_origin_card)
 996         {
 997                 while((card2 = ll_iter_next(&it)))
 998                 {
 999                         // compare caid, hexserial, cardtype, sidtab (if any), providers:
1000                         if(same_card2(card, card2, 0) && equal_providers(card, card2))
1001                         {
1002                                 break;
1003                         }
1004                 }
1005
1006                 if(card2 && card2->hop > card->hop) // hop is smaller, drop old card
1007                 {
1008                         ll_iter_remove(&it);
1009                         cc_free_card(card2);
1010                         card2 = NULL;
1011                         card_dup_count++;
1012                 }
1013
1014                 if(!card2) // Not found->add it:
1015                 {
1016                         if(free_card) // use this card
1017                         {
1018                                 free_card = 0;
1019                                 ll_iter_insert(&it, card);
1020                         }
1021                         else
1022                         {
1023                                 card2 = create_card(card); // copy card
1024                                 if(!card2)
1025                                         { return modified; }
1026                                 ll_iter_insert(&it, card2);
1027                                 add_card_providers(card2, card, 1); // copy providers to new card. Copy remote nodes to new card
1028                         }
1029                         modified = 1;
1030                 }
1031                 else // found, merge cards (providers are same!)
1032                 {
1033                         card_dup_count++;
1034                         card2->grp |= card->grp; //add group to the card
1035                         add_card_providers(card2, card, 0);
1036                         merge_sids(card2, card);
1037                 }
1038
1039         }
1040         // like cccam:
1041         else // just remove duplicate cards (same ids)
1042         {
1043                 while((card2 = ll_iter_next(&it)))
1044                 {
1045                         // compare remote_id, first_node, caid, hexserial, cardtype, sidtab (if any), providers:
1046                         if(same_card(card, card2))
1047                                 { break; }
1048                 }
1049
1050                 if(card2 && card2->hop > card->hop) // same card, if hop greater drop card
1051                 {
1052                         ll_iter_remove(&it);
1053                         cc_free_card(card2);
1054                         card2 = NULL;
1055                         card_dup_count++;
1056                 }
1057                 if(!card2) // Not found, add it:
1058                 {
1059                         if(free_card)
1060                         {
1061                                 free_card = 0;
1062                                 ll_iter_insert(&it, card);
1063                         }
1064                         else
1065                         {
1066                                 card2 = create_card(card);
1067                                 if(!card2)
1068                                         { return modified; }
1069                                 ll_iter_insert(&it, card2);
1070                                 add_card_providers(card2, card, 1);
1071                         }
1072                         modified = 1;
1073                 }
1074                 else // Found, everything is same (including providers)
1075                 {
1076                         card_dup_count++;
1077                 }
1078         }
1079
1080         if(free_card)
1081                 { cc_free_card(card); }
1082
1083         return modified;
1084 }
1085
1086 /**
1087  * returns true if timeout-time is reached
1088  * only local cards needs to be renewed after 1h. "O" CCCam throws away cards older than 1,2h
1089  **/
1090 int32_t card_timed_out(struct cc_card *card)
1091 {
1092         //!=CT_REMOTECARD = LOCALCARD (or virtual cards by caid/ident/service)
1093         //timeout is set in future, so if current time is bigger, timeout is reached
1094         int32_t res = (card->card_type != CT_REMOTECARD) && (card->timeout < time(NULL)); //local card is older than 1h?
1095         if(res)
1096                 { cs_log_dbg(D_TRACE, "card %08X timed out! refresh forced", card->id ? card->id : card->origin_id); }
1097         return res;
1098 }
1099
1100 /**
1101  * returns true if card1 is already reported.
1102  * "reported" means, we already have this card1 in our sharelist.
1103  * if the card1 is already reported, we throw it away, because we build a new sharelist
1104  * so after finding all reported cards, we have a list of reported cards, which aren't used anymore
1105  **/
1106 int32_t find_reported_card(struct cc_card *card1)
1107 {
1108         LL_ITER it = ll_iter_create(get_cardlist(card1->caid, reported_carddatas_list));
1109         struct cc_card *card2;
1110         while((card2 = ll_iter_next(&it)))
1111         {
1112                 if(same_card(card1, card2) && !card_timed_out(card2))
1113                 {
1114                         card1->id = card2->id; //Set old id !!
1115                         card1->timeout = card2->timeout;
1116                         cc_free_card(card2);
1117                         ll_iter_remove(&it);
1118                         return 1; //Old card and new card are equal!
1119                 }
1120         }
1121         return 0; //Card not found
1122 }
1123
1124 /**
1125 * Server:
1126 * Adds a cccam-carddata buffer to the list of reported carddatas
1127 */
1128 void cc_add_reported_carddata(LLIST *reported_carddatas, struct cc_card *card)
1129 {
1130         ll_append(reported_carddatas, card);
1131 }
1132
1133 /**
1134  * adds the card to the list of the new reported carddatas - this is the new sharelist
1135  * if this card is not already reported, we send them to the clients
1136  * if this card is already reported, find_reported_card throws the "origin" card away
1137  * so the "old" sharelist is reduced
1138  **/
1139 void report_card(struct cc_card *card, LLIST *new_reported_carddatas, LLIST *new_cards)
1140 {
1141         if(!find_reported_card(card))    //Add new card:
1142         {
1143
1144                 cs_log_dbg(D_TRACE, "s-card added: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
1145                                           card->id, card->remote_id, card->caid, card->hop, card->reshare, card->origin_id, card->card_type);
1146
1147                 ll_append(new_cards, card);
1148
1149                 card_added_count++;
1150         }
1151         cc_add_reported_carddata(new_reported_carddatas, card);
1152 }
1153
1154
1155 /**
1156  * Server:
1157  * Reports all caid/providers to the connected clients
1158  * returns 1=ok, 0=error
1159  * cfg.cc_reshare_services  =0 CCCAM reader reshares only received cards + defined reader services
1160  *              =1 CCCAM reader reshares received cards + defined services
1161  *              =2 CCCAM reader reshares only defined reader-services as virtual cards
1162  *              =3 CCCAM reader reshares only defined user-services as virtual cards
1163  *              =4 CCCAM reader reshares only received cards
1164  */
1165 void update_card_list(void)
1166 {
1167         int32_t i, j, k, l, card_count = 0;
1168
1169         LLIST *server_cards[CAID_KEY];
1170         LLIST *new_reported_carddatas[CAID_KEY];
1171
1172         LL_ITER it, it2;
1173         struct cc_card *card;
1174
1175         memset(server_cards, 0, sizeof(server_cards));
1176         memset(new_reported_carddatas, 0, sizeof(new_reported_carddatas));
1177
1178         card_added_count = 0;
1179         card_removed_count = 0;
1180         card_dup_count = 0;
1181
1182         //User-Services:
1183         if(cfg.cc_reshare_services == 3 && cfg.sidtab)
1184         {
1185                 struct s_sidtab *ptr;
1186                 for(j = 0, ptr = cfg.sidtab; ptr; ptr = ptr->next, j++)
1187                 {
1188                         for(k = 0; k < ptr->num_caid; k++)
1189                         {
1190                                 card = create_card2(NULL, (j << 8) | k, ptr->caid[k], cfg.cc_reshare);
1191                                 if(!card)
1192                                         { return; }
1193                                 card->card_type = CT_CARD_BY_SERVICE_USER;
1194                                 card->sidtab = ptr;
1195                                 for(l = 0; l < ptr->num_provid; l++)
1196                                 {
1197                                         struct cc_provider *prov;
1198                                         if(!cs_malloc(&prov, sizeof(struct cc_provider)))
1199                                                 { return; }
1200                                         prov->prov = ptr->provid[l];
1201                                         ll_append(card->providers, prov);
1202                                 }
1203
1204                                 add_card_to_serverlist(get_cardlist(card->caid, server_cards), card, 1);
1205                         }
1206                         flt = 1;
1207                 }
1208         }
1209         else
1210         {
1211                 struct s_reader *rdr;
1212                 int32_t r = 0;
1213
1214                 cs_readlock(__func__, &readerlist_lock);
1215
1216                 for(rdr = first_active_reader; rdr; rdr = rdr->next)
1217                 {
1218                         //Generate a uniq reader id:
1219                         if(!rdr->cc_id)
1220                         {
1221                                 rdr->cc_id = ++r;
1222                                 struct s_reader *rdr2;
1223                                 for(rdr2 = first_active_reader; rdr2; rdr2 = rdr2->next)
1224                                 {
1225                                         if(rdr2 != rdr && rdr2->cc_id == rdr->cc_id)
1226                                         {
1227                                                 rdr2 = first_active_reader;
1228                                                 rdr->cc_id = ++r;
1229                                         }
1230                                 }
1231                         }
1232
1233                         flt = 0;
1234
1235                         int8_t reshare = rdr->cc_reshare > -1 ? rdr->cc_reshare : cfg.cc_reshare;
1236
1237                         //Reader-Services:
1238                         if((cfg.cc_reshare_services == 1 || cfg.cc_reshare_services == 2 || (!rdr->caid && rdr->typ != R_CCCAM && cfg.cc_reshare_services != 4)) &&
1239                                         cfg.sidtab && (rdr->sidtabs.no || rdr->sidtabs.ok))
1240                         {
1241                                 struct s_sidtab *ptr;
1242                                 for(j = 0, ptr = cfg.sidtab; ptr; ptr = ptr->next, j++)
1243                                 {
1244                                         if(!(rdr->sidtabs.no & ((SIDTABBITS)1 << j)) && (rdr->sidtabs.ok & ((SIDTABBITS)1 << j)))
1245                                         {
1246                                                 for(k = 0; k < ptr->num_caid; k++)
1247                                                 {
1248                                                         card = create_card2(rdr, (j << 8) | k, ptr->caid[k], reshare);
1249                                                         if(!card)
1250                                                         {
1251                                                                 cs_readunlock(__func__, &readerlist_lock);
1252                                                                 return;
1253                                                         }
1254                                                         card->card_type = CT_CARD_BY_SERVICE_READER;
1255                                                         card->sidtab = ptr;
1256                                                         for(l = 0; l < ptr->num_provid; l++)
1257                                                         {
1258                                                                 struct cc_provider *prov;
1259                                                                 if(!cs_malloc(&prov, sizeof(struct cc_provider)))
1260                                                                 {
1261                                                                         cs_readunlock(__func__, &readerlist_lock);
1262                                                                         return;
1263                                                                 }
1264                                                                 prov->prov = ptr->provid[l];
1265                                                                 ll_append(card->providers, prov);
1266                                                         }
1267
1268                                                         if(chk_ident(&rdr->ftab, card) && chk_ctab(card->caid, &rdr->ctab))
1269                                                         {
1270                                                                 if(!rdr->audisabled)
1271                                                                         { cc_UA_oscam2cccam(rdr->hexserial, card->hexserial, card->caid); }
1272
1273                                                                 add_card_to_serverlist(get_cardlist(card->caid, server_cards), card, 1);
1274                                                                 flt = 1;
1275                                                         }
1276                                                         else
1277                                                                 { cc_free_card(card); }
1278                                                 }
1279                                         }
1280                                 }
1281                         }
1282
1283                         //Filts by Hardware readers:
1284                         if((rdr->typ != R_CCCAM) && rdr->ftab.filts && !flt)
1285                         {
1286                                 for(j = 0; j < rdr->ftab.nfilts; j++)
1287                                 {
1288                                         uint16_t caid = rdr->ftab.filts[j].caid;
1289                                         if(caid)
1290                                         {
1291                                                 card = create_card2(rdr, j, caid, reshare);
1292                                                 if(!card)
1293                                                 {
1294                                                         cs_readunlock(__func__, &readerlist_lock);
1295                                                         return;
1296                                                 }
1297                                                 card->card_type = CT_LOCALCARD;
1298
1299                                                 //Setting UA: (Unique Address):
1300                                                 if(!rdr->audisabled)
1301                                                         { cc_UA_oscam2cccam(rdr->hexserial, card->hexserial, caid); }
1302                                                 //cs_log("Ident CCcam card report caid: %04X readr %s subid: %06X", rdr->ftab.filts[j].caid, rdr->label, rdr->cc_id);
1303                                                 for(k = 0; k < rdr->ftab.filts[j].nprids; k++)
1304                                                 {
1305                                                         struct cc_provider *prov;
1306                                                         if(!cs_malloc(&prov, sizeof(struct cc_provider)))
1307                                                         {
1308                                                                 cs_readunlock(__func__, &readerlist_lock);
1309                                                                 return;
1310                                                         }
1311                                                         prov->prov = rdr->ftab.filts[j].prids[k];
1312
1313                                                         //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1314                                                         if(!rdr->audisabled)
1315                                                         {
1316                                                                 for(l = 0; l < rdr->nprov; l++)
1317                                                                 {
1318                                                                         uint32_t rprid = get_reader_prid(rdr, l);
1319                                                                         if(rprid == prov->prov)
1320                                                                                 { cc_SA_oscam2cccam(&rdr->sa[l][0], prov->sa); }
1321                                                                 }
1322                                                         }
1323
1324                                                         ll_append(card->providers, prov);
1325                                                 }
1326
1327                                                 add_good_bad_sids_by_rdr(rdr, card);
1328                                                 add_card_to_serverlist(get_cardlist(caid, server_cards), card, 1);
1329                                                 flt = 1;
1330                                         }
1331                                 }
1332                         }
1333
1334                         if((rdr->typ != R_CCCAM) && !rdr->caid && !flt)
1335                         {
1336                                 for(j = 0; j < rdr->ctab.ctnum; j++)
1337                                 {
1338                                         CAIDTAB_DATA *d = &rdr->ctab.ctdata[j];
1339                                         //cs_log("CAID map CCcam card report caid: %04X cmap: %04X", d->caid, d->cmap);
1340                                         uint16_t lcaid = d->caid;
1341
1342                                         if(!lcaid || (lcaid == 0xFFFF))
1343                                                 { lcaid = d->cmap; }
1344
1345                                         if(lcaid && (lcaid != 0xFFFF))
1346                                         {
1347                                                 card = create_card2(rdr, j, lcaid, reshare);
1348                                                 if(!card)
1349                                                 {
1350                                                         cs_readunlock(__func__, &readerlist_lock);
1351                                                         return;
1352                                                 }
1353                                                 card->card_type = CT_CARD_BY_CAID1;
1354                                                 if(!rdr->audisabled)
1355                                                         { cc_UA_oscam2cccam(rdr->hexserial, card->hexserial, lcaid); }
1356
1357                                                 add_good_bad_sids_by_rdr(rdr, card);
1358                                                 add_card_to_serverlist(get_cardlist(lcaid, server_cards), card, 1);
1359                                                 flt = 1;
1360                                         }
1361                                 }
1362                         }
1363
1364                         if((rdr->typ != R_CCCAM) && rdr->ctab.ctnum && !flt)
1365                         {
1366                                 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1367                                 int32_t c;
1368                                 if(rdr->tcp_connected || rdr->card_status == CARD_INSERTED)
1369                                 {
1370                                         for(c = 0; c < rdr->ctab.ctnum; c++)
1371                                         {
1372                                                 CAIDTAB_DATA *d = &rdr->ctab.ctdata[c];
1373                                                 uint16_t caid = d->caid;
1374                                                 if(!caid) { break; }
1375
1376                                                 card = create_card2(rdr, c, caid, reshare);
1377                                                 if(!card)
1378                                                         { break; }
1379                                                 card->card_type = CT_CARD_BY_CAID2;
1380
1381                                                 if(!rdr->audisabled)
1382                                                         { cc_UA_oscam2cccam(rdr->hexserial, card->hexserial, caid); }
1383                                                 for(j = 0; j < rdr->nprov; j++)
1384                                                 {
1385                                                         uint32_t prid = get_reader_prid(rdr, j);
1386                                                         struct cc_provider *prov;
1387                                                         if(!cs_malloc(&prov, sizeof(struct cc_provider)))
1388                                                         {
1389                                                                 cs_readunlock(__func__, &readerlist_lock);
1390                                                                 return;
1391                                                         }
1392                                                         prov->prov = prid;
1393                                                         //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1394                                                         if(!rdr->audisabled)
1395                                                         {
1396                                                                 //Setting SA (Shared Addresses):
1397                                                                 cc_SA_oscam2cccam(rdr->sa[j], prov->sa);
1398                                                         }
1399                                                         ll_append(card->providers, prov);
1400                                                         //cs_log("Main CCcam card report provider: %02X%02X%02X%02X", buf[21+(j*7)], buf[22+(j*7)], buf[23+(j*7)], buf[24+(j*7)]);
1401                                                 }
1402                                                 add_good_bad_sids_by_rdr(rdr, card);
1403                                                 add_card_to_serverlist(get_cardlist(caid, server_cards), card, 1);
1404                                                 flt = 1;
1405                                         }
1406                                 }
1407                         }
1408
1409
1410                         if((rdr->typ != R_CCCAM) && rdr->caid && !flt)
1411                         {
1412                                 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1413                                 if(rdr->tcp_connected || rdr->card_status == CARD_INSERTED)
1414                                 {
1415                                         uint16_t caid = rdr->caid;
1416                                         card = create_card2(rdr, 1, caid, reshare);
1417                                         if(!card)
1418                                         {
1419                                                 cs_readunlock(__func__, &readerlist_lock);
1420                                                 return;
1421                                         }
1422                                         card->card_type = CT_CARD_BY_CAID3;
1423
1424                                         if(!rdr->audisabled)
1425                                                 { cc_UA_oscam2cccam(rdr->hexserial, card->hexserial, caid); }
1426                                         for(j = 0; j < rdr->nprov; j++)
1427                                         {
1428                                                 uint32_t prid = get_reader_prid(rdr, j);
1429                                                 struct cc_provider *prov;
1430                                                 if(!cs_malloc(&prov, sizeof(struct cc_provider)))
1431                                                 {
1432                                                         cs_readunlock(__func__, &readerlist_lock);
1433                                                         return;
1434                                                 }
1435                                                 prov->prov = prid;
1436                                                 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1437                                                 if(!rdr->audisabled)
1438                                                 {
1439                                                         //Setting SA (Shared Addresses):
1440                                                         cc_SA_oscam2cccam(rdr->sa[j], prov->sa);
1441                                                 }
1442                                                 ll_append(card->providers, prov);
1443                                                 //cs_log("Main CCcam card report provider: %02X%02X%02X%02X", buf[21+(j*7)], buf[22+(j*7)], buf[23+(j*7)], buf[24+(j*7)]);
1444                                         }
1445                                         add_good_bad_sids_by_rdr(rdr, card);
1446                                         add_card_to_serverlist(get_cardlist(caid, server_cards), card, 1);
1447                                 }
1448                         }
1449
1450                         if(rdr->typ == R_CCCAM && rdr->tcp_connected &&
1451                                         (cfg.cc_reshare_services < 2 || cfg.cc_reshare_services == 4) && rdr->card_status != CARD_FAILURE)
1452                         {
1453
1454                                 cs_log_dbg(D_TRACE, "asking reader %s for cards...", rdr->label);
1455
1456                                 struct s_client *rc = rdr->client;
1457                                 struct cc_data *rcc = rc ? rc->cc : NULL;
1458
1459                                 int32_t count = 0;
1460                                 if(rcc && rcc->cards && !rc->kill)
1461                                 {
1462                                         cs_readlock(__func__, &rcc->cards_busy);
1463
1464                                         it = ll_iter_create(rcc->cards);
1465                                         while((card = ll_iter_next(&it)))
1466                                         {
1467                                                 if(chk_ctab(card->caid, &rdr->ctab))
1468                                                 {
1469                                                         int32_t dont_ignore = ll_count(card->providers) ?  0 : 1;
1470
1471                                                         it2 = ll_iter_create(card->providers);
1472                                                         struct cc_provider *prov;
1473                                                         while((prov = ll_iter_next(&it2)))
1474                                                         {
1475                                                                 uint32_t prid = prov->prov;
1476                                                                 if(chk_srvid_by_caid_prov(rc, card->caid, prid))
1477                                                                 {
1478                                                                         dont_ignore = 1;
1479                                                                         break;
1480                                                                 }
1481                                                         }
1482
1483                                                         if(dont_ignore)    //Filtered by service
1484                                                         {
1485                                                                 add_card_to_serverlist(get_cardlist(card->caid, server_cards), card, 0);
1486                                                                 count++;
1487                                                         }
1488                                                 }
1489                                         }
1490                                         cs_readunlock(__func__, &rcc->cards_busy);
1491                                 }
1492                                 else
1493                                         { cs_log_dbg(D_TRACE, "reader %s not active!", rdr->label); }
1494                                 cs_log_dbg(D_TRACE, "got %d cards from %s", count, rdr->label);
1495                         }
1496                 }
1497                 cs_readunlock(__func__, &readerlist_lock);
1498         }
1499
1500         LLIST *new_cards = ll_create("new_cards"); //List of new (added) cards
1501
1502         cs_writelock(__func__, &cc_shares_lock);
1503
1504         //report reshare cards:
1505         //cs_log_dbg(D_TRACE, "%s reporting %d cards", getprefix(), ll_count(server_cards));
1506         for(i = 0; i < CAID_KEY; i++)
1507         {
1508                 if(server_cards[i])
1509                 {
1510                         it = ll_iter_create(server_cards[i]);
1511
1512                         //we compare every card of our new list (server_cards) with the last list.
1513                         while((card = ll_iter_next(&it)))
1514                         {
1515                                 //cs_log_dbg(D_TRACE, "%s card %d caid %04X hop %d", getprefix(), card->id, card->caid, card->hop);
1516
1517                                 if(!new_reported_carddatas[i])
1518                                         { new_reported_carddatas[i] = ll_create("new_cardlist"); }
1519                                 report_card(card, new_reported_carddatas[i], new_cards);
1520                                 ll_iter_remove(&it);
1521                         }
1522                         cc_free_cardlist(server_cards[i], 1);
1523                 }
1524
1525                 //remove unsed, remaining cards:
1526                 card_removed_count += cc_free_reported_carddata(reported_carddatas_list[i], new_reported_carddatas[i], 1);
1527                 reported_carddatas_list[i] = new_reported_carddatas[i];
1528                 card_count += ll_count(reported_carddatas_list[i]);
1529                 //cs_log_dbg(D_TRACE, "CARDS FOR INDEX %d=%d", i, ll_count(reported_carddatas[i]));
1530         }
1531
1532         //now send new cards. Always remove first, then add new:
1533         it = ll_iter_create(new_cards);
1534         while((card = ll_iter_next(&it)))
1535         {
1536                 send_card_to_all_clients(card);
1537         }
1538         ll_destroy(&new_cards);
1539
1540
1541         cs_writeunlock(__func__, &cc_shares_lock);
1542
1543         cs_log_dbg(D_TRACE, "reported/updated +%d/-%d/dup %d of %d cards to sharelist",
1544                                   card_added_count, card_removed_count, card_dup_count, card_count);
1545 }
1546
1547 int32_t cc_srv_report_cards(struct s_client *cl)
1548 {
1549
1550         struct cc_card *card;
1551         int32_t i, count = 0;
1552         LL_ITER it;
1553         cs_readlock(__func__, &cc_shares_lock);
1554         for(i = 0; i < CAID_KEY; i++)
1555         {
1556                 if(reported_carddatas_list[i])
1557                 {
1558                         it = ll_iter_create(reported_carddatas_list[i]);
1559                         while(cl->cc && !cl->kill && (card = ll_iter_next(&it)))
1560                         {
1561                                 count += send_card_to_client(card, cl);
1562                         }
1563                 }
1564         }
1565         cs_readunlock(__func__, &cc_shares_lock);
1566         cs_log_dbg(D_TRACE, "reported %d cards for %s", count, username(cl));
1567
1568         return cl->cc && !cl->kill;
1569 }
1570
1571 void refresh_shares(void)
1572 {
1573         update_card_list();
1574 }
1575
1576 #define DEFAULT_INTERVAL 30
1577
1578 void share_updater(void)
1579 {
1580         int32_t i = DEFAULT_INTERVAL + cfg.waitforcards_extra_delay / 1000;
1581         uint32_t last_check = 0;
1582         uint32_t last_check_rdroptions = 0;
1583         uint32_t cur_check_rdroptions = 0;
1584         uint32_t last_card_check = 0;
1585         uint32_t last_sidtab_generation = 0;
1586         uint32_t card_count = 0;
1587         while(share_updater_thread_active)
1588         {
1589                 const uint32_t sleep_step = 500;
1590                 uint32_t sleep_time;
1591                 uint32_t slept;
1592                 if(i > 0 && card_count < 100)    //fast refresh only if we have less cards
1593                 {
1594                         cs_log_dbg(D_TRACE, "share-updater mode=initfast t=1s i=%d", i);
1595                         sleep_time = 1000;
1596                         i--;
1597                 }
1598                 else if(i > 0)
1599                 {
1600                         cs_log_dbg(D_TRACE, "share-updater mode=initslow t=6s i=%d", i);
1601                         sleep_time = 6000; //1s later than garbage collector because this list uses much space
1602                         i -= 6;
1603                 }
1604                 else
1605                 {
1606                         if(cfg.cc_update_interval <= 10)
1607                                 { cfg.cc_update_interval = DEFAULT_UPDATEINTERVAL; }
1608                         cs_log_dbg(D_TRACE, "share-updater mode=interval t=%ds", cfg.cc_update_interval);
1609                         sleep_time = cfg.cc_update_interval * 1000;
1610                 }
1611                 for(slept = 0; slept < sleep_time; slept += sleep_step)
1612                 {
1613                         if(!share_updater_thread_active || share_updater_refresh)
1614                         {
1615                                 share_updater_refresh = 0;
1616                                 break;
1617                         }
1618                         cs_sleepms(sleep_step);
1619                 }
1620                 if(!share_updater_thread_active)
1621                         { break; }
1622
1623                 cs_log_dbg(D_TRACE, "share-updater check");
1624
1625                 uint32_t cur_check = 0;
1626                 uint32_t cur_card_check = 0;
1627                 int8_t rdroptionchange = 0;
1628                 card_count = 0;
1629                 struct s_reader *rdr;
1630                 struct cc_data *cc;
1631
1632                 cs_readlock(__func__, &readerlist_lock);
1633
1634                 for(rdr = first_active_reader; rdr; rdr = rdr->next)
1635                 {
1636                         struct s_client *cl = rdr->client;
1637                         if(cl && (cc = cl->cc))  //check cccam-cardlist:
1638                         {
1639                                 cur_card_check += cc->card_added_count;
1640                                 cur_card_check += cc->card_removed_count;
1641                                 card_count += ll_count(cc->cards);
1642                         }
1643                         cur_check = crc32(cur_check, (uint8_t *)&rdr->tcp_connected, sizeof(rdr->tcp_connected));
1644                         cur_check = crc32(cur_check, (uint8_t *)&rdr->card_status, sizeof(rdr->card_status));
1645
1646                         //Check hexserial/UA changes only on lokal readers:
1647                         if(!is_network_reader(rdr))
1648                         {
1649                                 cur_check = crc32(cur_check, (uint8_t *)&rdr->hexserial, 8); //check hexserial
1650                                 cur_check = crc32(cur_check, (uint8_t *)&rdr->prid, rdr->nprov * sizeof(rdr->prid[0])); //check providers
1651                                 cur_check = crc32(cur_check, (uint8_t *)&rdr->sa, rdr->nprov * sizeof(rdr->sa[0])); //check provider-SA
1652                         }
1653
1654                         if(rdr->changes_since_shareupdate)
1655                         {
1656                                 rdr->changes_since_shareupdate = 0;
1657                                 rdroptionchange = 1;
1658                         }
1659                 }
1660                 if(rdroptionchange)
1661                 {
1662                         cur_check_rdroptions = 0;
1663                         for(rdr = first_active_reader; rdr; rdr = rdr->next)
1664                         {
1665                                 cur_check_rdroptions = crc32(cur_check_rdroptions, (uint8_t *)&rdr->ftab, sizeof(FTAB)); //check reader
1666                                 cur_check_rdroptions = crc32(cur_check_rdroptions, (uint8_t *)&rdr->ctab, sizeof(CAIDTAB)); //check caidtab
1667                                 cur_check_rdroptions = crc32(cur_check_rdroptions, (uint8_t *)&rdr->fchid, sizeof(FTAB)); //check chids
1668                                 cur_check_rdroptions = crc32(cur_check_rdroptions, (uint8_t *)&rdr->sidtabs.ok, sizeof(rdr->sidtabs.ok)); //check assigned ok services
1669                                 cur_check_rdroptions = crc32(cur_check_rdroptions, (uint8_t *)&rdr->sidtabs.no, sizeof(rdr->sidtabs.no)); //check assigned no services
1670                         }
1671                 }
1672
1673                 cs_readunlock(__func__, &readerlist_lock);
1674
1675                 //update cardlist if reader config has changed, also set interval to 1s / 30times
1676                 if(cur_check != last_check || last_sidtab_generation != cfg_sidtab_generation || last_check_rdroptions != cur_check_rdroptions)
1677                 {
1678                         last_sidtab_generation = cfg_sidtab_generation;
1679                         i = DEFAULT_INTERVAL;
1680                         cs_log_dbg(D_TRACE, "share-update [1] %u %u", cur_check, last_check);
1681                         refresh_shares();
1682                         last_check = cur_check;
1683                         last_card_check = cur_card_check;
1684                 }
1685                 //update cardlist if cccam cards has changed:
1686                 else if(cur_card_check != last_card_check)
1687                 {
1688                         cs_log_dbg(D_TRACE, "share-update [2] %u %u", cur_card_check, last_card_check);
1689                         refresh_shares();
1690                         last_card_check = cur_card_check;
1691                 }
1692                 last_check_rdroptions = cur_check_rdroptions;
1693         }
1694         for(i = 0; i < CAID_KEY; i++)
1695                 { cc_free_reported_carddata(reported_carddatas_list[i], NULL, 0); }
1696 }
1697
1698 int32_t compare_cards_by_hop(struct cc_card **pcard1, struct cc_card **pcard2)
1699 {
1700         struct cc_card *card1 = (*pcard1), *card2 = (*pcard2);
1701
1702         int32_t res = card1->hop - card2->hop;
1703         if(res) { return res; }
1704         res = card1->caid - card2->caid;
1705         if(res) { return res; }
1706         res = card1->reshare - card2->reshare;
1707         if(res) { return res; }
1708         res = card1->id - card2->id;
1709         return res;
1710 }
1711
1712 int32_t compare_cards_by_hop_r(struct cc_card **pcard1, struct cc_card **pcard2)
1713 {
1714         return -compare_cards_by_hop(pcard1, pcard2);
1715 }
1716
1717 struct cc_card **get_sorted_card_copy(LLIST *cards, int32_t reverse, int32_t *size)
1718 {
1719         if(reverse)
1720                 { return (struct cc_card **)ll_sort(cards, compare_cards_by_hop_r, size); }
1721         else
1722                 { return (struct cc_card **)ll_sort(cards, compare_cards_by_hop, size); }
1723 }
1724
1725 void cccam_init_share(void)
1726 {
1727         memset(reported_carddatas_list, 0, sizeof(reported_carddatas_list));
1728         cs_lock_create(__func__, &cc_shares_lock, "cc_shares_lock", 200000);
1729
1730         share_updater_thread = 0;
1731         share_updater_thread_active = 1;
1732         share_updater_refresh = 0;
1733
1734         pthread_t temp;
1735         int32_t ret = start_thread("share updater", (void *)&share_updater, NULL, &temp, 1, 1);
1736         if(!ret)
1737         {
1738                 share_updater_thread = temp;
1739         }
1740 }
1741
1742 void cccam_done_share(void)
1743 {
1744         if(share_updater_thread)
1745         {
1746                 share_updater_thread_active = 0;
1747                 share_updater_thread = 0;
1748         }
1749 }
1750
1751 void cccam_refresh_share(void)
1752 {
1753         share_updater_refresh = 1;
1754 }
1755 #endif