module-gbox-cards.c

   1 #define MODULE_LOG_PREFIX "gbox"
   2
   3 #include "globals.h"
   4
   5 #ifdef MODULE_GBOX
   6 #include "module-gbox.h"
   7 #include "module-gbox-cards.h"
   8 #include "module-gbox-helper.h"
   9 #include "oscam-lock.h"
  10 #include "oscam-garbage.h"
  11 #include "oscam-files.h"
  12 #include "oscam-chk.h"
  13 #include "oscam-string.h"
  14 #include "oscam-time.h"
  15
  16 LLIST *gbox_cards;
  17 CS_MUTEX_LOCK gbox_cards_lock;
  18 uint8_t checkcode[7];
  19 uint8_t last_checkcode[7];
  20 uint8_t sid_verified = 0;
  21
  22 GBOX_CARDS_ITER *gbox_cards_iter_create(void)
  23 {
  24         GBOX_CARDS_ITER *gci;
  25         if(!cs_malloc(&gci, sizeof(GBOX_CARDS_ITER)))
  26                 { return NULL; }
  27         cs_readlock(__func__, &gbox_cards_lock);
  28         gci->it = ll_iter_create(gbox_cards);
  29         return gci;
  30 }
  31
  32 void gbox_cards_iter_destroy(GBOX_CARDS_ITER *gci)
  33 {
  34         cs_readunlock(__func__, &gbox_cards_lock);
  35         if (gci) { add_garbage(gci); }
  36 }
  37
  38 struct gbox_card *gbox_cards_iter_next(GBOX_CARDS_ITER *gci)
  39 {
  40         if (gci) { return ll_iter_next(&gci->it); }
  41         else { return NULL; }
  42 }
  43
  44 uint8_t gbox_get_crd_dist_lev(uint16_t crd_id)
  45 {
  46         uint8_t crd_dist = 0;
  47         uint8_t crd_level = 0;
  48         struct gbox_card *card;
  49         cs_readlock(__func__, &gbox_cards_lock);
  50         LL_ITER it = ll_iter_create(gbox_cards);
  51         while((card = ll_iter_next(&it)))
  52         {
  53                 if ((card->type == GBOX_CARD_TYPE_GBOX || card->type == GBOX_CARD_TYPE_CCCAM) && card->id.peer == crd_id)
  54                 {
  55                         crd_dist = card->dist;
  56                         crd_level = card->lvl;
  57                         break;
  58                 }
  59         }
  60         cs_readunlock(__func__, &gbox_cards_lock);
  61         return ((crd_level << 4) | (crd_dist & 0xf));
  62 }
  63
  64 void gbox_write_share_cards_info(void)
  65 {
  66         uint16_t card_count_shared = 0;
  67         char *fext = FILE_SHARED_CARDS_INFO;
  68         char *fname = get_gbox_tmp_fname(fext);
  69         FILE *fhandle_shared;
  70         fhandle_shared = fopen(fname, "w");
  71         if(!fhandle_shared)
  72         {
  73                 cs_log("Couldn't open %s: %s", fname, strerror(errno));
  74                 return;
  75         }
  76
  77         struct gbox_card *card;
  78         cs_readlock(__func__, &gbox_cards_lock);
  79         LL_ITER it = ll_iter_create(gbox_cards);
  80         while((card = ll_iter_next(&it)))
  81         {
  82                 if (card->type == GBOX_CARD_TYPE_GBOX)
  83                 {
  84                         fprintf(fhandle_shared, "CardID %d at %s Card %08X Sl:%d Lev:%1d dist:%1d id:%04X\n",
  85                                 card_count_shared, card->origin_peer->hostname, card->caprovid,
  86                                 card->id.slot, card->lvl, card->dist, card->id.peer);
  87                         card_count_shared++;
  88                 }
  89         }
  90         cs_readunlock(__func__, &gbox_cards_lock);
  91 //char tmp[32];
  92 //fprintf(fhandle_shared, "my checkcode: %s",cs_hexdump(1, gbox_get_my_checkcode(), 7, tmp, sizeof(tmp)));
  93         fclose(fhandle_shared);
  94         cs_log_dbg(D_READER,"share.info written");
  95         //cs_log("share.info written");
  96         return;
  97 }
  98
  99 uint16_t gbox_write_local_cards_info(void)
 100 {
 101         uint16_t card_count_local = 0;
 102         char *fext = FILE_LOCAL_CARDS_INFO;
 103         char *fname = get_gbox_tmp_fname(fext);
 104         FILE *fhandle_local;
 105         fhandle_local = fopen(fname, "w");
 106         if(!fhandle_local)
 107         {
 108                 cs_log("Couldn't open %s: %s", fname, strerror(errno));
 109                 return 0;
 110         }
 111
 112         struct gbox_card *card;
 113         cs_readlock(__func__, &gbox_cards_lock);
 114         LL_ITER it = ll_iter_create(gbox_cards);
 115         while((card = ll_iter_next(&it)))
 116         {
 117                 switch (card->type)
 118                 {
 119                 case GBOX_CARD_TYPE_GBOX:
 120                         break;
 121                 case GBOX_CARD_TYPE_LOCAL:
 122                         fprintf(fhandle_local, "CardID:%2d %s %08X Sl:%2d id:%04X\n",
 123                                 card_count_local, "Local_Card", card->caprovid, card->id.slot, card->id.peer);
 124                         card_count_local++;
 125                         break;
 126                 case GBOX_CARD_TYPE_BETUN:
 127                         fprintf(fhandle_local, "CardID:%2d %s %08X Sl:%2d id:%04X\n",
 128                                 card_count_local, "Betun_Card", card->caprovid, card->id.slot, card->id.peer);
 129                         card_count_local++;
 130                         break;
 131                 case GBOX_CARD_TYPE_CCCAM:
 132                         fprintf(fhandle_local, "CardID:%2d %s %08X Sl:%2d id:%04X\n",
 133                                 card_count_local, "CCcam_Card", card->caprovid, card->id.slot, card->id.peer);
 134                         card_count_local++;
 135                         break;
 136                 case GBOX_CARD_TYPE_PROXY:
 137                         fprintf(fhandle_local, "CardID:%2d %s %08X Sl:%2d id:%04X\n",
 138                                 card_count_local, "Proxy_Card", card->caprovid, card->id.slot, card->id.peer);
 139                         card_count_local++;
 140                         break;
 141                 default:
 142                         cs_log("Invalid card type: %d in gbox_write_cards_info", card->type);
 143                         break;
 144                 }
 145         }
 146         cs_readunlock(__func__, &gbox_cards_lock);
 147         fclose(fhandle_local);
 148         cs_log_dbg(D_READER,"sc.info written");
 149         //cs_log("sc.info written");
 150         return card_count_local;
 151 }
 152
 153 void gbox_write_stats(void)
 154 {
 155         int32_t card_count = 0;
 156         struct gbox_good_srvid *srvid_good = NULL;
 157         struct gbox_bad_srvid *srvid_bad = NULL;
 158         char *fext = FILE_STATS;
 159         char *fname = get_gbox_tmp_fname(fext);
 160         FILE *fhandle;
 161         fhandle = fopen(fname, "w");
 162         if(!fhandle)
 163         {
 164                 cs_log("Couldn't open %s: %s", fname, strerror(errno));
 165                 return;
 166         }
 167         fprintf(fhandle, "Statistics for peer cards received\n");
 168         struct gbox_card *card;
 169         cs_readlock(__func__, &gbox_cards_lock);
 170         LL_ITER it = ll_iter_create(gbox_cards);
 171         while((card = ll_iter_next(&it)))
 172         {
 173                 if (card->type == GBOX_CARD_TYPE_GBOX)
 174                 {
 175                         fprintf(fhandle, "\nCard# %04d  CaProv:%08X ID:%04X #CWs:%d AVGtime:%d ms",
 176                                         card_count +1, card->caprovid, card->id.peer, card->no_cws_returned, card->average_cw_time);
 177                         fprintf(fhandle, "\n Good SID: ");
 178                         LL_ITER it2 = ll_iter_create(card->goodsids);
 179                         while((srvid_good = ll_iter_next(&it2)))
 180                                 { fprintf(fhandle, "%04X ", srvid_good->srvid.sid); }
 181                         fprintf(fhandle, "\n Bad SID: ");
 182                         it2 = ll_iter_create(card->badsids);
 183                         while((srvid_bad = ll_iter_next(&it2)))
 184                                 { fprintf(fhandle, "%04X ", srvid_bad->srvid.sid); }
 185                         card_count++;
 186                 }
 187         } // end of while ll_iter_next
 188         cs_readunlock(__func__, &gbox_cards_lock);
 189
 190         fclose(fhandle);
 191         return;
 192 }
 193
 194 void init_gbox_cards_list(void)
 195 {
 196         gbox_cards = ll_create("gbox.cards");
 197         cs_lock_create(__func__, &gbox_cards_lock, "gbox_cards_lock", 5000);
 198 }
 199
 200 static void gbox_free_card(struct gbox_card *card)
 201 {
 202         ll_destroy_data(&card->badsids);
 203         ll_destroy_data(&card->goodsids);
 204         add_garbage(card);
 205         return;
 206 }
 207
 208 uint8_t *gbox_get_my_checkcode(void)
 209 {
 210         return &checkcode[0];
 211 }
 212
 213 uint8_t *gbox_update_my_checkcode(void)
 214 {
 215         checkcode[0] = 0x15;
 216         checkcode[1] = 0x30;
 217         checkcode[2] = 0x02;
 218         checkcode[3] = 0x04;
 219         checkcode[4] = 0x19;
 220         checkcode[5] = 0x19;
 221         checkcode[6] = 0x66;
 222
 223         struct gbox_card *card;
 224         cs_readlock(__func__, &gbox_cards_lock);
 225         LL_ITER it = ll_iter_create(gbox_cards);
 226                 while((card = ll_iter_next(&it)))
 227                         {
 228                                 if(card->lvl)
 229                                 {
 230                                         checkcode[0] ^= (0xFF & (card->caprovid >> 24));
 231                                         checkcode[1] ^= (0xFF & (card->caprovid >> 16));
 232                                         checkcode[2] ^= (0xFF & (card->caprovid >> 8));
 233                                         checkcode[3] ^= (0xFF & (card->caprovid));
 234                                         checkcode[4] ^= (0xFF & (card->id.slot));
 235                                         checkcode[5] ^= (0xFF & (card->id.peer >> 8));
 236                                         checkcode[6] ^= (0xFF & (card->id.peer));
 237                                 }
 238                         }
 239         cs_readunlock(__func__, &gbox_cards_lock);
 240
 241         if(memcmp(last_checkcode, checkcode, 7))
 242         {
 243                 memcpy(last_checkcode, checkcode, 7);
 244                 //cs_log_dump(gbox_get_my_checkcode(), 7, "my checkcode updated:");
 245                 cs_log_dump_dbg(D_READER, gbox_get_my_checkcode(), 7, "my checkcode updated:");
 246         }
 247         return &checkcode[0];
 248 }
 249
 250 uint16_t gbox_count_cards(void)
 251 {
 252         return ll_count(gbox_cards);
 253 }
 254
 255 uint16_t gbox_count_peer_cards(uint16_t peer_id)
 256 {
 257         uint16_t counter = 0;
 258         struct gbox_card *card;
 259
 260         cs_readlock(__func__, &gbox_cards_lock);
 261         LL_ITER it = ll_iter_create(gbox_cards);
 262         while((card = ll_iter_next(&it)))
 263         {
 264                 if (card->origin_peer && card->origin_peer->gbox.id == peer_id)
 265                         { counter++; }
 266         }
 267         cs_readunlock(__func__, &gbox_cards_lock);
 268
 269         return counter;
 270 }
 271
 272 void gbox_delete_cards(uint8_t delete_type, uint16_t criteria)
 273 {
 274         struct gbox_card *card;
 275         uint8_t found;
 276
 277         cs_writelock(__func__, &gbox_cards_lock);
 278         LL_ITER it = ll_iter_create(gbox_cards);
 279         while((card = ll_iter_next(&it)))
 280         {
 281                 found = 0;
 282                 switch (delete_type)
 283                 {
 284                 case GBOX_DELETE_FROM_PEER:
 285                         if (card->origin_peer && card->origin_peer->gbox.id == criteria)
 286                                 { found = 1; }
 287                         break;
 288                 case GBOX_DELETE_WITH_ID:
 289                         if (card->id.peer == criteria)
 290                                 { found = 1; }
 291                         break;
 292                 case GBOX_DELETE_WITH_TYPE:
 293                         if (card->type == criteria)
 294                                 { found = 1; }
 295                         break;
 296                 default:
 297                         cs_log("Invalid delete type: %d in gbox_delete_cards", delete_type);
 298                         break;
 299                 }
 300                 if (found)
 301                 {
 302                         cs_log_dbg(D_READER, "remove card from card_list - peer: %04X %08X dist %d", card->id.peer, card->caprovid, card->dist);
 303                         ll_remove(gbox_cards, card);
 304                 }
 305         }
 306         cs_writeunlock(__func__, &gbox_cards_lock);
 307         return;
 308 }
 309 static uint8_t check_card_properties(uint32_t caprovid, uint16_t id_peer, uint8_t slot, uint8_t distance, uint8_t type)
 310 {
 311         uint8_t ret = 1;
 312
 313         if (!distance) //local card
 314                 { return ret; }
 315
 316         struct gbox_card *card;
 317         cs_writelock(__func__, &gbox_cards_lock);
 318         LL_ITER it = ll_iter_create(gbox_cards);
 319                         while((card = ll_iter_next(&it)))
 320                                 {
 321                                         if (card->caprovid == caprovid && card->id.peer == id_peer && card->id.slot == slot && type != GBOX_CARD_TYPE_CCCAM)
 322                                                 {
 323                                                         if (distance < card->dist) //better card
 324                                                                 {
 325                                                                         ll_remove(gbox_cards, card);
 326                                                                         ret = 1; //let card pass
 327                                                                         break;
 328                                                                 }
 329                                                         else
 330                                                                 {
 331                                                                         ret = 0; //skip card
 332                                                                         break;
 333                                                                 }
 334                                                 }
 335                                                 if (card->caprovid == caprovid && card->id.peer == id_peer && type == GBOX_CARD_TYPE_CCCAM)
 336                                                 {
 337                                                         if (distance < card->dist) //better card
 338                                                                 {
 339                                                                         ll_remove(gbox_cards, card);
 340                                                                         ret = 1; //let card pass
 341                                                                         break;
 342                                                                 }
 343                                                         else
 344                                                                 {
 345                                                                         ret = 0; //skip card
 346                                                                         break;
 347                                                                 }
 348                                                 }
 349                                 }
 350         cs_writeunlock(__func__, &gbox_cards_lock);
 351         return ret;
 352 }
 353
 354 void gbox_add_card(uint16_t id_peer, uint32_t caprovid, uint8_t slot, uint8_t level, uint8_t distance, uint8_t type, struct gbox_peer *origin_peer)
 355 {
 356         uint16_t caid = gbox_get_caid(caprovid);
 357         uint32_t provid = gbox_get_provid(caprovid);
 358
 359                         if(!caprovid) //skip caprov 00000000
 360                                 { return; }
 361                                 //don't insert 0100:000000
 362                         if(caid_is_seca(caid) && (!provid))
 363                                 { return; }
 364                                 //skip CAID 18XX providers
 365 //                      if(caid_is_nagra(caid) && (provid))
 366 //                              { return; }
 367
 368                 struct gbox_card *card;
 369                         if(!cs_malloc(&card, sizeof(struct gbox_card)))
 370                                 {
 371                                         cs_log("Card allocation failed");
 372                                         return;
 373                                 }
 374                         if (check_card_properties(caprovid, id_peer, slot, distance, type) && !check_peer_ignored(id_peer))
 375                                 {
 376                                         cs_log_dbg(D_READER, "add card to card_list - peer: %04X %08X dist %d", id_peer, caprovid, distance);
 377                                         card->caprovid = caprovid;
 378                                         card->id.peer = id_peer;
 379                                         card->id.slot = slot;
 380                                         card->dist = distance;
 381                                         card->lvl = level;
 382                                         card->badsids = ll_create("badsids");
 383                                         card->goodsids = ll_create("goodsids");
 384                                         card->no_cws_returned = 0;
 385                                         card->average_cw_time = 0;
 386                                         card->type = type;
 387                                         card->origin_peer = origin_peer;
 388                                         cs_writelock(__func__, &gbox_cards_lock);
 389                                         ll_append(gbox_cards, card);
 390                                         cs_writeunlock(__func__, &gbox_cards_lock);
 391                                 }
 392         return;
 393 }
 394
 395 static void gbox_free_list(LLIST *card_list)
 396 {
 397         if(card_list)
 398         {
 399                 cs_writelock(__func__, &gbox_cards_lock);
 400                 LL_ITER it = ll_iter_create(card_list);
 401                 struct gbox_card *card;
 402                 while((card = ll_iter_next_remove(&it)))
 403                         { gbox_free_card(card); }
 404                 ll_destroy(&gbox_cards);
 405                 cs_writeunlock(__func__, &gbox_cards_lock);
 406         }
 407         return;
 408 }
 409
 410 void gbox_free_cardlist(void)
 411 {
 412         gbox_free_list(gbox_cards);
 413         return;
 414 }
 415
 416 void gbox_add_good_sid(uint16_t id_card, uint16_t caid, uint8_t slot, uint16_t sid_ok, uint32_t cw_time)
 417 {
 418         struct gbox_card *card = NULL;
 419         struct gbox_good_srvid *srvid = NULL;
 420         uint8_t factor = 0;
 421
 422         cs_writelock(__func__, &gbox_cards_lock);
 423         LL_ITER it = ll_iter_create(gbox_cards);
 424         while((card = ll_iter_next(&it)))
 425         {
 426                 if(card->id.peer == id_card && gbox_get_caid(card->caprovid) == caid && card->id.slot == slot)
 427                 {
 428                         card->no_cws_returned++;
 429                         if (!card->no_cws_returned)
 430                                 { card->no_cws_returned = 10; } // wrap around
 431                         if (card->no_cws_returned < 10)
 432                                 { factor = card->no_cws_returned; }
 433                         else
 434                                 { factor = 10; }
 435                                 card->average_cw_time = ((card->average_cw_time * (factor-1)) + cw_time) / factor;
 436                         LL_ITER it2 = ll_iter_create(card->goodsids);
 437                         while((srvid = ll_iter_next(&it2)))
 438                         {
 439                                 if(srvid->srvid.sid == sid_ok)
 440                                 {
 441                                         srvid->last_cw_received = time(NULL);
 442                                         cs_writeunlock(__func__, &gbox_cards_lock);
 443                                         return; // sid_ok is already in the list of goodsids
 444                                 }
 445                         }
 446
 447                         if(!cs_malloc(&srvid, sizeof(struct gbox_good_srvid)))
 448                         {
 449                                 cs_writeunlock(__func__, &gbox_cards_lock);
 450                                 cs_log("Good SID allocation failed");
 451                                 return;
 452                         }
 453                         srvid->srvid.sid = sid_ok;
 454                         srvid->srvid.provid_id = gbox_get_provid(card->caprovid);
 455                         srvid->last_cw_received = time(NULL);
 456                         cs_log_dbg(D_READER, "Adding good SID: %04X for CAID: %04X Provider: %04X on CardID: %04X", sid_ok, caid, gbox_get_provid(card->caprovid), id_card);
 457                         ll_append(card->goodsids, srvid);
 458                         break;
 459                 }
 460         } // end of ll_iter_next
 461         // return dist_c;
 462         cs_writeunlock(__func__, &gbox_cards_lock);
 463         return;
 464 }
 465
 466 void gbox_remove_bad_sid(uint16_t id_peer, uint8_t id_slot, uint16_t sid)
 467 {
 468         struct gbox_card *card = NULL;
 469         struct gbox_bad_srvid *srvid = NULL;
 470
 471         cs_writelock(__func__, &gbox_cards_lock);
 472         LL_ITER it2 = ll_iter_create(gbox_cards);
 473         while((card = ll_iter_next(&it2)))
 474         {
 475                 if(card->id.peer == id_peer && card->id.slot == id_slot)
 476                 {
 477                         LL_ITER it3 = ll_iter_create(card->badsids);
 478                         while((srvid = ll_iter_next(&it3)))
 479                         {
 480                                 if(srvid->srvid.sid == sid)
 481                                 {
 482                                         ll_iter_remove_data(&it3); // remove sid_ok from badsids
 483                                         break;
 484                                 }
 485                         }
 486                 }
 487         }
 488         cs_writeunlock(__func__, &gbox_cards_lock);
 489 }
 490
 491 uint8_t gbox_next_free_slot(uint16_t id)
 492 {
 493         struct gbox_card *c;
 494         uint8_t lastslot = 0;
 495
 496         cs_readlock(__func__, &gbox_cards_lock);
 497         LL_ITER it = ll_iter_create(gbox_cards);
 498         while((c = ll_iter_next(&it)))
 499         {
 500                 if(id == c->id.peer && c->id.slot > lastslot)
 501                         { lastslot = c->id.slot; }
 502         }
 503         cs_readunlock(__func__, &gbox_cards_lock);
 504         return ++lastslot;
 505 }
 506
 507 static int8_t is_already_pending(LLIST *pending_cards, uint16_t peer_id, uint8_t slot)
 508 {
 509         if (!pending_cards)
 510                 { return -1; }
 511
 512         int8_t ret = 0;
 513         struct gbox_card_id *current_id;
 514         LL_LOCKITER *li = ll_li_create(pending_cards, 0);
 515         while ((current_id = ll_li_next(li)))
 516         {
 517                 if (current_id->peer == peer_id && current_id->slot == slot)
 518                 {
 519                         ret = 1;
 520                         break;
 521                 }
 522         }
 523         ll_li_destroy(li);
 524         return ret;
 525 }
 526
 527 uint8_t gbox_get_cards_for_ecm(uint8_t *send_buf, int32_t len2, uint8_t max_cards, ECM_REQUEST *er, uint32_t *current_avg_card_time, uint16_t peer_id, uint8_t force_remm)
 528 {
 529         if (!send_buf || !er)
 530                 { return 0; }
 531
 532         uint8_t nb_matching_crds = 0;
 533         struct gbox_good_srvid *srvid_good = NULL;
 534         struct gbox_bad_srvid *srvid_bad = NULL;
 535         uint8_t enough = 0;
 536         time_t time_since_lastcw;
 537
 538         // loop over good only
 539         cs_readlock(__func__, &gbox_cards_lock);
 540         LL_ITER it = ll_iter_create(gbox_cards);
 541         LL_ITER it2;
 542         struct gbox_card *card;
 543
 544         while((card = ll_iter_next(&it)))
 545         {
 546                 if(card->origin_peer && card->origin_peer->gbox.id == peer_id && card->type == GBOX_CARD_TYPE_GBOX &&
 547                         gbox_get_caid(card->caprovid) == er->caid && gbox_get_provid(card->caprovid) == er->prid && !is_already_pending(er->gbox_cards_pending, card->id.peer, card->id.slot))
 548                 {
 549                         sid_verified = 0;
 550
 551                         // check if sid is good
 552                         it2 = ll_iter_create(card->goodsids);
 553                         while((srvid_good = ll_iter_next(&it2)))
 554                         {
 555                                 if(srvid_good->srvid.provid_id == er->prid && srvid_good->srvid.sid == er->srvid)
 556                                 {
 557                                         if (!enough || *current_avg_card_time > card->average_cw_time)
 558                                         {
 559                                                 time_since_lastcw = llabs(srvid_good->last_cw_received - time(NULL));
 560                                                 *current_avg_card_time = card->average_cw_time;
 561                                                 if (enough)
 562                                                         { len2 = len2 - 3; }
 563                                                 else
 564                                                 {
 565                                                         nb_matching_crds++;
 566                                                         if (time_since_lastcw < GBOX_SID_CONFIRM_TIME && er->gbox_ecm_status == GBOX_ECM_NEW_REQ)
 567                                                                 { enough = 1; }
 568                                                 }
 569                                                 i2b_buf(2, card->id.peer, send_buf + len2);
 570                                                 send_buf[len2 + 2] = card->id.slot;
 571                                                 len2 = len2 + 3;
 572                                                 sid_verified = 1;
 573                                                 break;
 574                                         }
 575                                 }
 576                         }
 577
 578                         if(nb_matching_crds == max_cards)
 579                                 { break; }
 580                 }
 581         }
 582         cs_readunlock(__func__, &gbox_cards_lock);
 583
 584         // loop over bad and unknown cards
 585         cs_writelock(__func__, &gbox_cards_lock);
 586         it = ll_iter_create(gbox_cards);
 587         while((card = ll_iter_next(&it)))
 588         {
 589                 if(card->origin_peer && card->origin_peer->gbox.id == peer_id && card->type == GBOX_CARD_TYPE_GBOX &&
 590                         gbox_get_caid(card->caprovid) == er->caid && gbox_get_provid(card->caprovid) == er->prid && !is_already_pending(er->gbox_cards_pending, card->id.peer, card->id.slot) && !enough)
 591                 {
 592                         sid_verified = 0;
 593
 594                         // check if sid is good
 595                         it2 = ll_iter_create(card->goodsids);
 596                         while((srvid_good = ll_iter_next(&it2)))
 597                         {
 598                                 if(srvid_good->srvid.provid_id == er->prid && srvid_good->srvid.sid == er->srvid)
 599                                 {
 600                                         sid_verified = 1;
 601                                         cs_log_dbg(D_READER, "ID: %04X SL: %02X SID: %04X is good", card->id.peer, card->id.slot, srvid_good->srvid.sid);
 602                                 }
 603                         }
 604                         if(!sid_verified)
 605                         {
 606                                 // check if sid is bad
 607                                 LL_ITER itt = ll_iter_create(card->badsids);
 608                                 while((srvid_bad = ll_iter_next(&itt)))
 609                                 {
 610                                         if(srvid_bad->srvid.provid_id == er->prid && srvid_bad->srvid.sid == er->srvid)
 611                                         {
 612                                                 if (srvid_bad->bad_strikes < 3)
 613                                                 {
 614                                                  sid_verified = 2;
 615                                                         if(!force_remm)
 616                                                                 {
 617                                                                         srvid_bad->bad_strikes++;
 618                                                                 }
 619                                                         else
 620                                                                 {
 621                                                                         srvid_bad->bad_strikes = 1;
 622                                                                         //cs_log("cards.c - get card for ecm - Block bad SID: %04X - %d bad strikes", srvid_bad->srvid.sid, srvid_bad->bad_strikes);
 623                                                                 }
 624                                                 }
 625                                                 else
 626                                                         { sid_verified = 1; }
 627                                                 cs_log_dbg(D_READER, "CRD_ID: %04X Slot: %d SID: %04X failed to relpy %d times", card->id.peer, card->id.slot, srvid_bad->srvid.sid, srvid_bad->bad_strikes);
 628                                                 break;
 629                                         }
 630                                 }
 631
 632                                 // sid is neither good nor bad
 633                                 if(sid_verified != 1)
 634                                 {
 635                                         i2b_buf(2, card->id.peer, send_buf + len2);
 636                                         send_buf[len2 + 2] = card->id.slot;
 637                                         len2 = len2 + 3;
 638                                         nb_matching_crds++;
 639
 640                                         if (!sid_verified)
 641                                         {
 642                                                 if(!cs_malloc(&srvid_bad, sizeof(struct gbox_bad_srvid)))
 643                                                 {
 644                                                         cs_log("ServID allocation failed");
 645                                                         cs_writeunlock(__func__, &gbox_cards_lock);
 646                                                         return 0;
 647                                                 }
 648
 649                                                 srvid_bad->srvid.sid = er->srvid;
 650                                                 srvid_bad->srvid.provid_id = gbox_get_provid(card->caprovid);
 651                                                 srvid_bad->bad_strikes = 1;
 652                                                 ll_append(card->badsids, srvid_bad);
 653                                                 cs_log_dbg(D_READER, "ID: %04X SL: %02X SID: %04X is not checked", card->id.peer, card->id.slot, srvid_bad->srvid.sid);
 654                                         }
 655                                 }
 656                         }
 657
 658                         if(nb_matching_crds == max_cards)
 659                                 { break; }
 660                 }
 661         }
 662         cs_writeunlock(__func__, &gbox_cards_lock);
 663         return nb_matching_crds;
 664 }
 665
 666 #endif