oscam-reader.c

   1 #define MODULE_LOG_PREFIX "reader"
   2
   3 #include "globals.h"
   4 #include "module-cccam.h"
   5 #include "module-led.h"
   6 #include "module-stat.h"
   7 #include "module-dvbapi.h"
   8 #include "oscam-cache.h"
   9 #include "oscam-chk.h"
  10 #include "oscam-client.h"
  11 #include "oscam-ecm.h"
  12 #include "oscam-garbage.h"
  13 #include "oscam-lock.h"
  14 #include "oscam-net.h"
  15 #include "oscam-reader.h"
  16 #include "oscam-string.h"
  17 #include "oscam-time.h"
  18 #include "oscam-work.h"
  19 #include "reader-common.h"
  20 #include "oscam-config.h"
  21
  22 extern CS_MUTEX_LOCK system_lock;
  23 extern CS_MUTEX_LOCK ecmcache_lock;
  24 extern struct ecm_request_t *ecmcwcache;
  25 extern const struct s_cardsystem *cardsystems[];
  26
  27 const char *RDR_CD_TXT[] =
  28 {
  29         "cd", "dsr", "cts", "ring", "none",
  30         "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7",
  31         NULL
  32 };
  33
  34 /* Overide ratelimit priority for dvbapi request */
  35 static int32_t dvbapi_override_prio(struct s_reader *reader, ECM_REQUEST *er, int32_t maxecms, struct timeb *actualtime)
  36 {
  37         if (!module_dvbapi_enabled() || !is_dvbapi_usr(er->client->account->usr))
  38                 return -1;
  39
  40         int32_t foundspace = -1;
  41         int64_t gone = 0;
  42
  43         if (reader->lastdvbapirateoverride.time == 0) // fixup for first run!
  44                 gone = comp_timeb(actualtime, &reader->lastdvbapirateoverride);
  45
  46         if (gone > reader->ratelimittime) {
  47                 int32_t h;
  48                 struct timeb minecmtime = *actualtime;
  49                 for (h = 0; h < MAXECMRATELIMIT; h++) {
  50                         gone = comp_timeb(&minecmtime, &reader->rlecmh[h].last);
  51                         if (gone > 0) {
  52                                 minecmtime = reader->rlecmh[h].last;
  53                                 foundspace = h;
  54                         }
  55                 }
  56                 reader->lastdvbapirateoverride = *actualtime;
  57                 cs_log_dbg(D_CLIENT, "prioritizing DVBAPI user %s over other watching client", er->client->account->usr);
  58                 cs_log_dbg(D_CLIENT, "ratelimiter forcing srvid %04X into slot %d/%d of reader %s", er->srvid, foundspace + 1, maxecms, reader->label);
  59         } else {
  60                 cs_log_dbg(D_CLIENT, "DVBAPI User %s is switching too fast for ratelimit and can't be prioritized!",
  61                                            er->client->account->usr);
  62         }
  63         return foundspace;
  64 }
  65
  66 static int32_t ecm_ratelimit_findspace(struct s_reader *reader, ECM_REQUEST *er, struct ecmrl rl, int32_t reader_mode)
  67 {
  68
  69         int32_t h, foundspace = -1;
  70         int32_t maxecms = MAXECMRATELIMIT; // init maxecms
  71         int32_t totalecms = 0; // init totalecms
  72         struct timeb actualtime;
  73         cs_ftime(&actualtime);
  74         for(h = 0; h < MAXECMRATELIMIT; h++)    // release slots with srvid that are overtime, even if not called from reader module to maximize available slots!
  75         {
  76                 if(reader->rlecmh[h].last.time == -1) { continue; }
  77                 int64_t gone = comp_timeb(&actualtime, &reader->rlecmh[h].last);
  78                 if( gone >= (reader->rlecmh[h].ratelimittime + reader->rlecmh[h].srvidholdtime) || gone < 0) // gone <0 fixup for bad systemtime on dvb receivers while changing transponders
  79                 {
  80                         cs_log_dbg(D_CLIENT, "ratelimiter srvid %04X released from slot %d/%d of reader %s (%"PRId64">=%d ratelimit ms + %d ms srvidhold!)",
  81                                                   reader->rlecmh[h].srvid, h + 1, MAXECMRATELIMIT, reader->label, gone,
  82                                                   reader->rlecmh[h].ratelimittime, reader->rlecmh[h].srvidholdtime);
  83                         reader->rlecmh[h].last.time = -1;
  84                         reader->rlecmh[h].srvid = -1;
  85                         reader->rlecmh[h].kindecm = 0;
  86                         reader->rlecmh[h].once = 0;
  87                 }
  88                 if(reader->rlecmh[h].last.time == -1) { continue; }
  89                 if(reader->rlecmh[h].ratelimitecm < maxecms) { maxecms = reader->rlecmh[h].ratelimitecm; }  // we found a more critical ratelimit srvid
  90                 totalecms++;
  91         }
  92
  93         cs_log_dbg(D_CLIENT, "ratelimiter found total of %d srvid for reader %s most critical is limited to %d requests", totalecms, reader->label, maxecms);
  94
  95         if(reader->cooldown[0] && reader->cooldownstate != 1) { maxecms = MAXECMRATELIMIT; }  // dont apply ratelimits if cooldown isnt in use or not in effect
  96
  97         for(h = 0; h < MAXECMRATELIMIT; h++)    // check if srvid is already in a slot
  98         {
  99                 if(reader->rlecmh[h].last.time == -1) { continue; }
 100                 if(reader->rlecmh[h].srvid == er->srvid && reader->rlecmh[h].caid == rl.caid && reader->rlecmh[h].provid == rl.provid
 101                                 && (!reader->rlecmh[h].chid || (reader->rlecmh[h].chid == rl.chid)))
 102                 {
 103                         int64_t gone = comp_timeb(&actualtime, &reader->rlecmh[h].last);
 104                         cs_log_dbg(D_CLIENT, "ratelimiter found srvid %04X for %"PRId64" ms in slot %d/%d of reader %s", er->srvid, gone, h + 1, MAXECMRATELIMIT, reader->label);
 105
 106                         // check ecmunique if enabled and ecmunique time is done
 107                         if(reader_mode && reader->ecmunique)
 108                         {
 109                                 gone = comp_timeb(&actualtime, &reader->rlecmh[h].last);
 110                                 if(gone < reader->ratelimittime)
 111                                 {
 112                                         if(memcmp(reader->rlecmh[h].ecmd5, er->ecmd5, CS_ECMSTORESIZE)) //some boxes seem to send different ecms but asking in fact for same cw!
 113                                         {   // different ecm request than one in the slot!
 114                                                 if(er->ecm[0] == reader->rlecmh[h].kindecm)
 115                                                 {
 116                                                         // same ecm type!
 117                                                         char ecmd5[17 * 3];
 118                                                         cs_hexdump(0, reader->rlecmh[h].ecmd5, 16, ecmd5, sizeof(ecmd5));
 119                                                         cs_log_dbg(D_CLIENT, "ratelimiter ecm %s in this slot for next %d ms!", ecmd5,
 120                                                                                   (int)(reader->rlecmh[h].ratelimittime - gone));
 121
 122                                                         struct ecm_request_t *erold = NULL;
 123                                                         if(!cs_malloc(&erold, sizeof(struct ecm_request_t)))
 124                                                                 { return -2; }
 125                                                         memcpy(erold, er, sizeof(struct ecm_request_t)); // copy ecm all
 126                                                         memcpy(erold->ecmd5, reader->rlecmh[h].ecmd5, CS_ECMSTORESIZE); // replace md5 hash
 127                                                         struct ecm_request_t *ecm = NULL;
 128                                                         ecm = check_cache(erold, erold->client); //CHECK IF FOUND ECM IN CACHE
 129                                                         NULLFREE(erold);
 130                                                         if(ecm)   //found in cache
 131                                                                 { write_ecm_answer(reader, er, ecm->rc, ecm->rcEx, ecm->cw, NULL, 0, &ecm->cw_ex); } // return controlword of the ecm sitting in the slot!
 132                                                         else
 133                                                                 { write_ecm_answer(reader, er, E_NOTFOUND, E2_RATELIMIT, NULL, "Ratelimiter: no slots free!", 0, NULL); }
 134
 135                                                         NULLFREE(ecm);
 136                                                         return -2;
 137                                                 }
 138                                         }
 139                                 }
 140                                 if((er->ecm[0] != reader->rlecmh[h].kindecm) && (gone <= reader->ratelimittime))
 141                                 {
 142                                         if(!reader->rlecmh[h].once) // 1 premature ecmtype change is allowed (useful right after zapping to a channel!)
 143                                         {
 144                                                 reader->rlecmh[h].once = 1;
 145                                                 cs_log_dbg(D_CLIENT, "ratelimiter changing slot %d srvid %04X ecmtype once from %s to %s!", h+1, er->srvid,
 146                                                         (reader->rlecmh[h].kindecm == 0x80 ? "even":"odd"), (er->ecm[0] == 0x80 ? "even":"odd"));
 147                                         }
 148                                         else
 149                                         {
 150                                                 cs_log_dbg(D_CLIENT, "ratelimiter srvid %04X only allowing ecmtype %s for next %d ms in slot %d/%d of reader %s -> skipping this slot!", reader->rlecmh[h].srvid,
 151                                                         (reader->rlecmh[h].kindecm == 0x80 ? "even" : "odd"), (int)(reader->rlecmh[h].ratelimittime - gone), h + 1, maxecms, reader->label);
 152                                                         continue;
 153                                         }
 154                                 }
 155                         }
 156
 157                         if(h > 0)
 158                         {
 159                                 for(foundspace = 0; foundspace < h; foundspace++)    // check for free lower slot
 160                                 {
 161                                         if(reader->rlecmh[foundspace].last.time == -1)
 162                                         {
 163                                                 reader->rlecmh[foundspace] = reader->rlecmh[h]; // replace ecm request info
 164                                                 reader->rlecmh[h].last.time = -1;
 165                                                 reader->rlecmh[h].srvid = -1;
 166                                                 reader->rlecmh[h].kindecm = 0;
 167                                                 reader->rlecmh[h].once = 0;
 168                                                 if(foundspace < maxecms)
 169                                                 {
 170                                                         cs_log_dbg(D_CLIENT, "ratelimiter moved srvid %04X to slot %d/%d of reader %s", er->srvid, foundspace + 1, maxecms, reader->label);
 171                                                         return foundspace; // moving to lower free slot!
 172                                                 }
 173                                                 else
 174                                                 {
 175                                                         cs_log_dbg(D_CLIENT, "ratelimiter removed srvid %04X from slot %d/%d of reader %s", er->srvid, foundspace + 1, maxecms, reader->label);
 176                                                         reader->rlecmh[foundspace].last.time = -1; // free this slot since we are over ratelimit!
 177                                                         return -1; // sorry, ratelimit!
 178                                                 }
 179                                         }
 180                                 }
 181                         }
 182                         if(h < maxecms)    // found but cant move to lower position!
 183                         {
 184                                 return h; // return position if within ratelimits!
 185                         }
 186                         else
 187                         {
 188                                 reader->rlecmh[h].last.time = -1; // free this slot since we are over ratelimit!
 189                                 reader->rlecmh[h].srvid = -1;
 190                                 reader->rlecmh[h].kindecm = 0;
 191                                 reader->rlecmh[h].once = 0;
 192                                 cs_log_dbg(D_CLIENT, "ratelimiter removed srvid %04X from slot %d/%d of reader %s", er->srvid, h + 1, maxecms, reader->label);
 193                                 return -1; // sorry, ratelimit!
 194                         }
 195                 }
 196         }
 197
 198         // srvid not found in slots!
 199
 200         // do we use cooldown at all, are we in cooldown fase?
 201         if((reader->cooldown[0] && reader->cooldownstate == 1) || !reader->cooldown[0])
 202         {
 203                 // we are in cooldown or no cooldown configured!
 204                 if(totalecms + 1 > maxecms || totalecms + 1 > rl.ratelimitecm)  // check if this channel fits in!
 205                 {
 206                         cs_log_dbg(D_CLIENT, "ratelimiter for reader %s has no free slots!", reader->label);
 207                         return -1;
 208                 }
 209         }
 210         else
 211         {
 212                 maxecms = MAXECMRATELIMIT; // no limits right now!
 213         }
 214
 215         for(h = 0; h < maxecms; h++)    // check for free slot
 216         {
 217                 if(reader->rlecmh[h].last.time == -1)
 218                 {
 219                         if(reader_mode) { cs_log_dbg(D_CLIENT, "ratelimiter added srvid %04X to slot %d/%d of reader %s", er->srvid, h + 1, maxecms, reader->label); }
 220                         return h; // free slot found -> assign it!
 221                 }
 222                 else {
 223                         int64_t gone = comp_timeb(&actualtime, &reader->rlecmh[h].last);
 224                 cs_log_dbg(D_CLIENT, "ratelimiter srvid %04X for %"PRId64" ms present in slot %d/%d of reader %s", reader->rlecmh[h].srvid, gone , h + 1,
 225                         maxecms, reader->label); }  //occupied slots
 226         }
 227
 228         foundspace = dvbapi_override_prio(reader, er, maxecms, &actualtime);
 229         if (foundspace > -1)
 230                 return foundspace;
 231
 232         return (-1); // no slot found
 233 }
 234
 235 static void sort_ecmrl(struct s_reader *reader)
 236 {
 237         int32_t i, j, loc;
 238         struct ecmrl tmp;
 239
 240         for(i = 0; i < reader->ratelimitecm; i++)   // inspect all slots
 241         {
 242                 if(reader->rlecmh[i].last.time == -1) { continue; }  // skip empty slots
 243                 loc = i;
 244                 tmp = reader->rlecmh[i]; // tmp is ecm in slot to evaluate
 245
 246                 for(j = i + 1; j < MAXECMRATELIMIT; j++)   // inspect all slots above the slot to be inspected
 247                 {
 248                         if(reader->rlecmh[j].last.time == -1) { continue; }  // skip empty slots
 249                         int32_t gone = comp_timeb(&reader->rlecmh[i].last, &tmp.last);
 250                         if(gone > 0)   // is higher slot holding a younger ecmrequest?
 251                         {
 252                                 loc = j; // found a younger one
 253                                 tmp = reader->rlecmh[j]; // copy the ecm in younger slot
 254                         }
 255                 }
 256
 257                 if(loc != i)   // Did we find a younger ecmrequest?
 258                 {
 259                         reader->rlecmh[loc] = reader->rlecmh[i]; // place older request in slot of younger one we found
 260                         reader->rlecmh[i] = tmp; // place younger request in slot of older request
 261                 }
 262         }
 263
 264         // release all slots above ratelimit ecm
 265         for(i = reader->ratelimitecm; i < MAXECMRATELIMIT; i++)
 266         {
 267                 reader->rlecmh[i].last.time = -1;
 268                 reader->rlecmh[i].srvid = -1;
 269                 reader->rlecmh[i].kindecm = 0;
 270                 reader->rlecmh[i].once = 0;
 271         }
 272
 273 }
 274
 275 int32_t ecm_ratelimit_check(struct s_reader *reader, ECM_REQUEST *er, int32_t reader_mode)
 276 // If reader_mode is 1, ECM_REQUEST need to be assigned to reader and slot.
 277 // Else just report if a free slot is available.
 278 {
 279         // No rate limit set
 280         if(!reader->ratelimitecm)
 281         {
 282                 return OK;
 283         }
 284
 285         int32_t foundspace = -1, h, maxslots = MAXECMRATELIMIT; //init slots to oscam global maximums
 286         struct ecmrl rl;
 287         struct timeb now;
 288         rl = get_ratelimit(er);
 289
 290         if(rl.ratelimitecm > 0)
 291         {
 292                 cs_log_dbg(D_CLIENT, "ratelimit found for CAID: %04X PROVID: %06X SRVID: %04X CHID: %04X maxecms: %d cycle: %d ms srvidhold: %d ms",
 293                                           rl.caid, rl.provid, rl.srvid, rl.chid, rl.ratelimitecm, rl.ratelimittime, rl.srvidholdtime);
 294         }
 295         else   // nothing found: apply general reader limits
 296         {
 297                 rl.ratelimitecm = reader->ratelimitecm;
 298                 rl.ratelimittime = reader->ratelimittime;
 299                 rl.srvidholdtime = reader->srvidholdtime;
 300                 rl.caid = er->caid;
 301                 rl.provid = er->prid;
 302                 rl.chid = er->chid;
 303                 rl.srvid = er->srvid;
 304                 cs_log_dbg(D_CLIENT, "ratelimiter apply readerdefault for CAID: %04X PROVID: %06X SRVID: %04X CHID: %04X maxecms: %d cycle: %d ms srvidhold: %d ms",
 305                                           rl.caid, rl.provid, rl.srvid, rl.chid, rl.ratelimitecm, rl.ratelimittime, rl.srvidholdtime);
 306         }
 307         // Below this line: rate limit functionality.
 308         // No cooldown set
 309         if(!reader->cooldown[0])
 310         {
 311                 cs_log_dbg(D_CLIENT, "ratelimiter find a slot for srvid %04X on reader %s", er->srvid, reader->label);
 312                 foundspace = ecm_ratelimit_findspace(reader, er, rl, reader_mode);
 313                 if(foundspace < 0)
 314                 {
 315                         if(reader_mode)
 316                         {
 317                                 if(foundspace != -2)
 318                                 {
 319                                         cs_log_dbg(D_CLIENT, "ratelimiter no free slot for srvid %04X on reader %s -> dropping!", er->srvid, reader->label);
 320                                         write_ecm_answer(reader, er, E_NOTFOUND, E2_RATELIMIT, NULL, "Ratelimiter: no slots free!", 0, NULL);
 321                                 }
 322                         }
 323
 324                         return ERROR; // not even trowing an error... obvious reason ;)
 325                 }
 326                 else  //we are within ecmratelimits
 327                 {
 328                         if(reader_mode)
 329                         {
 330                                 // Register new slot
 331                                 //reader->rlecmh[foundspace].srvid=er->srvid; // register srvid
 332                                 reader->rlecmh[foundspace] = rl; // register this srvid ratelimit params
 333                                 cs_ftime(&reader->rlecmh[foundspace].last); // register request time
 334                                 memcpy(reader->rlecmh[foundspace].ecmd5, er->ecmd5, CS_ECMSTORESIZE);// register ecmhash
 335                                 reader->rlecmh[foundspace].kindecm = er->ecm[0]; // register kind of ecm
 336                         }
 337
 338                         return OK;
 339                 }
 340         }
 341
 342         // Below this line: rate limit functionality with cooldown option.
 343
 344         // Cooldown state cycle:
 345         // state = 0: Cooldown setup phase. No rate limit set.
 346         //  If number of ecm request exceed reader->ratelimitecm, cooldownstate goes to 2.
 347         // state = 2: Cooldown delay phase. No rate limit set.
 348         //  If number of ecm request still exceed reader->ratelimitecm at end of cooldown delay phase,
 349         //      cooldownstate goes to 1 (rate limit phase).
 350         //  Else return back to setup phase (state 0).
 351         // state = 1: Cooldown ratelimit phase. Rate limit set.
 352         //  If cooldowntime reader->cooldown[1] is elapsed, return to cooldown setup phase (state 0).
 353
 354         cs_ftime(&now);
 355         int32_t gone = comp_timeb(&now, &reader->cooldowntime);
 356         if(reader->cooldownstate == 1)    // Cooldown in ratelimit phase
 357         {
 358                 if(gone <= reader->cooldown[1]*1000)  // check if cooldowntime is elapsed
 359                         { maxslots = reader->ratelimitecm; } // use user defined ratelimitecm
 360                 else   // Cooldown time is elapsed
 361                 {
 362                         reader->cooldownstate = 0; // set cooldown setup phase
 363                         reader->cooldowntime.time = -1; // reset cooldowntime
 364                         maxslots = MAXECMRATELIMIT; //use oscam defined max slots
 365                         cs_log("Reader: %s ratelimiter returning to setup phase cooling down period of %d seconds is done!",
 366                                    reader->label, reader->cooldown[1]);
 367                 }
 368         } // if cooldownstate == 1
 369
 370         if(reader->cooldownstate == 2 && gone > reader->cooldown[0]*1000)
 371         {
 372                 // Need to check if the otherslots are not exceeding the ratelimit at the moment that
 373                 // cooldown[0] time was exceeded!
 374                 // time_t actualtime = reader->cooldowntime + reader->cooldown[0];
 375                 maxslots = 0; // maxslots is used as counter
 376                 for(h = 0; h < MAXECMRATELIMIT; h++)
 377                 {
 378                         if(reader->rlecmh[h].last.time == -1) { continue; }  // skip empty slots
 379                         // how many active slots are registered at end of cooldown delay period
 380
 381                         gone = comp_timeb(&now, &reader->rlecmh[h].last);
 382                         if(gone <= (reader->ratelimittime + reader->srvidholdtime))
 383                         {
 384                                 maxslots++;
 385                                 if(maxslots >= reader->ratelimitecm) { break; }  // Need to go cooling down phase
 386                         }
 387                 }
 388
 389                 if(maxslots < reader->ratelimitecm)
 390                 {
 391                         reader->cooldownstate = 0; // set cooldown setup phase
 392                         reader->cooldowntime.time = -1; // reset cooldowntime
 393                         maxslots = MAXECMRATELIMIT; // maxslots is maxslots again
 394                         cs_log("Reader: %s ratelimiter returning to setup phase after %d seconds cooldowndelay!",
 395                                    reader->label, reader->cooldown[0]);
 396                 }
 397                 else
 398                 {
 399                         reader->cooldownstate = 1; // Entering ratelimit for cooldown ratelimitseconds
 400                         cs_ftime(&reader->cooldowntime); // set time to enforce ecmratelimit for defined cooldowntime
 401                         maxslots = reader->ratelimitecm; // maxslots is maxslots again
 402                         sort_ecmrl(reader); // keep youngest ecm requests in list + housekeeping
 403                         cs_log("Reader: %s ratelimiter starting cooling down period of %d seconds!", reader->label, reader->cooldown[1]);
 404                 }
 405         } // if cooldownstate == 2
 406
 407         cs_log_dbg(D_CLIENT, "ratelimiter cooldownphase %d find a slot for srvid %04X on reader %s", reader->cooldownstate, er->srvid, reader->label);
 408         foundspace = ecm_ratelimit_findspace(reader, er, rl, reader_mode);
 409
 410         if(foundspace < 0)
 411         {
 412                 if(reader_mode)
 413                 {
 414                         if(foundspace != -2)
 415                         {
 416                                 cs_log_dbg(D_CLIENT, "ratelimiter cooldownphase %d no free slot for srvid %04X on reader %s -> dropping!",
 417                                                           reader->cooldownstate, er->srvid, reader->label);
 418                                 write_ecm_answer(reader, er, E_NOTFOUND, E2_RATELIMIT, NULL, "Ratelimiter: cooldown no slots free!", 0, NULL);
 419                         }
 420                 }
 421
 422                 return ERROR; // not even trowing an error... obvious reason ;)
 423         }
 424         else  //we are within ecmratelimits
 425         {
 426                 if(reader_mode)
 427                 {
 428                         // Register new slot
 429                         //reader->rlecmh[foundspace].srvid=er->srvid; // register srvid
 430                         reader->rlecmh[foundspace] = rl; // register this srvid ratelimit params
 431                         cs_ftime(&reader->rlecmh[foundspace].last); // register request time
 432                         memcpy(reader->rlecmh[foundspace].ecmd5, er->ecmd5, CS_ECMSTORESIZE);// register ecmhash
 433                         reader->rlecmh[foundspace].kindecm = er->ecm[0]; // register kind of ecm
 434                 }
 435         }
 436
 437         if(reader->cooldownstate == 0 && foundspace >= reader->ratelimitecm)
 438         {
 439                 if(!reader_mode)    // No actual ecm request, just check
 440                 {
 441
 442                         return OK;
 443                 }
 444                 cs_log("Reader: %s ratelimiter cooldown detected overrun ecmratelimit of %d during setup phase!",
 445                            reader->label, (foundspace - reader->ratelimitecm + 1));
 446                 reader->cooldownstate = 2; // Entering cooldowndelay phase
 447                 cs_ftime(&reader->cooldowntime); // Set cooldowntime to calculate delay
 448                 cs_log_dbg(D_CLIENT, "ratelimiter cooldowndelaying %d seconds", reader->cooldown[0]);
 449         }
 450
 451         // Cooldown state housekeeping is done. There is a slot available.
 452         if(reader_mode)
 453         {
 454                 // Register new slot
 455                 //reader->rlecmh[foundspace].srvid=er->srvid; // register srvid
 456                 reader->rlecmh[foundspace] = rl; // register this srvid ratelimit params
 457                 cs_ftime(&reader->rlecmh[foundspace].last); // register request time
 458                 memcpy(reader->rlecmh[foundspace].ecmd5, er->ecmd5, CS_ECMSTORESIZE);// register ecmhash
 459                 reader->rlecmh[foundspace].kindecm = er->ecm[0]; // register kind of ecm
 460         }
 461
 462         return OK;
 463 }
 464
 465 const struct s_cardsystem *get_cardsystem_by_caid(uint16_t caid)
 466 {
 467         int32_t i, j;
 468         for(i = 0; cardsystems[i]; i++)
 469         {
 470                 const struct s_cardsystem *csystem = cardsystems[i];
 471                 for(j = 0; csystem->caids[j]; j++)
 472                 {
 473                         uint16_t cs_caid = csystem->caids[j];
 474                         if(!cs_caid)
 475                                 { continue; }
 476                         if(cs_caid == caid || cs_caid == caid >> 8)
 477                                 { return csystem; }
 478                 }
 479         }
 480         return NULL;
 481 }
 482
 483 struct s_reader *get_reader_by_label(char *lbl)
 484 {
 485         struct s_reader *rdr;
 486         LL_ITER itr = ll_iter_create(configured_readers);
 487         while((rdr = ll_iter_next(&itr)))
 488         {
 489                 if(streq(lbl, rdr->label))
 490                         { break; }
 491         }
 492         return rdr;
 493 }
 494
 495 const char *reader_get_type_desc(struct s_reader *rdr, int32_t extended)
 496 {
 497         const char *desc = "unknown";
 498         if(rdr->crdr && rdr->crdr->desc)
 499                 { return rdr->crdr->desc; }
 500         if(is_network_reader(rdr) || rdr->typ == R_SERIAL)
 501         {
 502                 if(rdr->ph.desc)
 503                         { desc = rdr->ph.desc; }
 504         }
 505         if(rdr->typ == R_NEWCAMD && rdr->ncd_proto == NCD_524)
 506                 { desc = "newcamd524"; }
 507         else if(rdr->typ == R_CCCAM)
 508         {
 509                 desc = "cccam";
 510                 if(extended && cccam_client_extended_mode(rdr->client)) desc = "cccam_ext";
 511                 if(cccam_client_multics_mode(rdr->client)) desc = "cccam_mcs";
 512         }
 513         return desc;
 514 }
 515
 516 bool hexserialset(struct s_reader *rdr)
 517 {
 518         int i;
 519         if(!rdr)
 520                 { return false; }
 521         for(i = 0; i < 8; i++)
 522         {
 523                 if(rdr->hexserial[i])
 524                         { return true; }
 525         }
 526         return false;
 527 }
 528
 529 void hexserial_to_newcamd(uchar *source, uchar *dest, uint16_t caid)
 530 {
 531         if(caid_is_bulcrypt(caid))
 532         {
 533                 dest[0] = 0x00;
 534                 dest[1] = 0x00;
 535                 memcpy(dest + 2, source, 4);
 536         }
 537         else if(caid_is_irdeto(caid) || caid_is_betacrypt(caid))
 538         {
 539                 // only 4 Bytes Hexserial for newcamd clients (Hex Base + Hex Serial)
 540                 // first 2 Byte always 00
 541                 dest[0] = 0x00; //serial only 4 bytes
 542                 dest[1] = 0x00; //serial only 4 bytes
 543                 // 1 Byte Hex Base (see reader-irdeto.c how this is stored in "source")
 544                 dest[2] = source[3];
 545                 // 3 Bytes Hex Serial (see reader-irdeto.c how this is stored in "source")
 546                 dest[3] = source[0];
 547                 dest[4] = source[1];
 548                 dest[5] = source[2];
 549         }
 550         else if(caid_is_viaccess(caid) || caid_is_cryptoworks(caid))
 551         {
 552                 dest[0] = 0x00;
 553                 memcpy(dest + 1, source, 5);
 554         }
 555         else
 556         {
 557                 memcpy(dest, source, 6);
 558         }
 559 }
 560
 561 void newcamd_to_hexserial(uchar *source, uchar *dest, uint16_t caid)
 562 {
 563         if(caid_is_bulcrypt(caid))
 564         {
 565                 memcpy(dest, source + 2, 4);
 566                 dest[4] = 0x00;
 567                 dest[5] = 0x00;
 568         }
 569         else if(caid_is_irdeto(caid) || caid_is_betacrypt(caid))
 570         {
 571                 memcpy(dest, source + 3, 3);
 572                 dest[3] = source[2];
 573                 dest[4] = 0;
 574                 dest[5] = 0;
 575         }
 576         else if(caid_is_viaccess(caid) || caid_is_cryptoworks(caid))
 577         {
 578                 memcpy(dest, source + 1, 5);
 579                 dest[5] = 0;
 580         }
 581         else
 582         {
 583                 memcpy(dest, source, 6);
 584         }
 585 }
 586
 587 /**
 588  * add or find one entitlement item to entitlements of reader
 589  * use add = 0 for find only, or add > 0 to find and add if not found
 590  **/
 591 S_ENTITLEMENT *cs_add_entitlement(struct s_reader *rdr, uint16_t caid, uint32_t provid, uint64_t id, uint32_t class, time_t start, time_t end, uint8_t type, uint8_t add)
 592 {
 593         if(!rdr->ll_entitlements)
 594         {
 595                 rdr->ll_entitlements = ll_create("ll_entitlements");
 596         }
 597
 598         S_ENTITLEMENT *item = NULL;
 599         LL_ITER it;
 600
 601         it = ll_iter_create(rdr->ll_entitlements);
 602         while((item = ll_iter_next(&it)) != NULL)
 603         {
 604                 if(
 605                         (caid && item->caid != caid) ||
 606                         (provid && item->provid != provid) ||
 607                         (id && item->id != id) ||
 608                         (class && item->class != class) ||
 609                         (start && ((!add && item->start < start) || (add && item->start !=start))) ||
 610                         (end && ((!add && item->end < end) || (add && item->end != end))) ||
 611                         (type && item->type != type))
 612                 {
 613                         continue; // no match, try next!
 614                 }
 615                 break; // match found!
 616         }
 617
 618         if(add && item == NULL)
 619         {
 620                 if(cs_malloc(&item, sizeof(S_ENTITLEMENT)))
 621                 {
 622                         // fill item
 623                         item->caid = caid;
 624                         item->provid = provid;
 625                         item->id = id;
 626                         item->class = class;
 627                         item->start = start;
 628                         item->end = end;
 629                         item->type = type;
 630
 631                         //add item
 632                         ll_append(rdr->ll_entitlements, item);
 633                         // cs_log_dbg(D_TRACE, "entitlement: Add caid %4X id %4X %s - %s ", item->caid, item->id, item->start, item->end);
 634                 }
 635                 else
 636                 {
 637                         cs_log("ERROR: Can't allocate entitlement to reader!");
 638
 639                 }
 640         }
 641
 642         return item;
 643 }
 644
 645 /**
 646  * clears entitlements of reader.
 647  **/
 648 void cs_clear_entitlement(struct s_reader *rdr)
 649 {
 650         if(!rdr->ll_entitlements)
 651                 { return; }
 652
 653         ll_clear_data(rdr->ll_entitlements);
 654 }
 655
 656
 657 void casc_check_dcw(struct s_reader *reader, int32_t idx, int32_t rc, uchar *cw)
 658 {
 659         int32_t i, pending = 0;
 660         time_t t = time(NULL);
 661         ECM_REQUEST *ecm;
 662         struct s_client *cl = reader->client;
 663
 664         if(!check_client(cl)) { return; }
 665
 666         for(i = 0; i < cfg.max_pending; i++)
 667         {
 668                 ecm = &cl->ecmtask[i];
 669                 if((ecm->rc >= E_NOCARD) && ecm->caid == cl->ecmtask[idx].caid && (!memcmp(ecm->ecmd5, cl->ecmtask[idx].ecmd5, CS_ECMSTORESIZE)))
 670                 {
 671                         if(rc==2)  //E_INVALID from camd35 CMD08
 672                         {
 673                                 write_ecm_answer(reader, ecm, E_INVALID, 0, cw, NULL, 0, NULL);
 674                         }
 675                         else if(rc)
 676                         {
 677                                 write_ecm_answer(reader, ecm, E_FOUND, 0, cw, NULL, 0, NULL);
 678                         }
 679                         else
 680                         {
 681                                 write_ecm_answer(reader, ecm, E_NOTFOUND, 0 , NULL, NULL, 0, NULL);
 682                         }
 683                         ecm->idx = 0;
 684                         ecm->rc = E_FOUND;
 685                 }
 686
 687                 if(ecm->rc >= E_NOCARD && (t - (uint32_t)ecm->tps.time > ((cfg.ctimeout + 500) / 1000) + 1))  // drop timeouts
 688                 {
 689                         ecm->rc = E_FOUND;
 690                 }
 691
 692                 if(ecm->rc >= E_NOCARD)
 693                         { pending++; }
 694         }
 695         cl->pending = pending;
 696 }
 697
 698 int32_t hostResolve(struct s_reader *rdr)
 699 {
 700         struct s_client *cl = rdr->client;
 701
 702         if(!cl) { return 0; }
 703
 704         IN_ADDR_T last_ip;
 705         IP_ASSIGN(last_ip, cl->ip);
 706         cs_resolve(rdr->device, &cl->ip, &cl->udp_sa, &cl->udp_sa_len);
 707         IP_ASSIGN(SIN_GET_ADDR(cl->udp_sa), cl->ip);
 708
 709         if(!IP_EQUAL(cl->ip, last_ip))
 710         {
 711                 cs_log("%s: resolved ip=%s", rdr->device, cs_inet_ntoa(cl->ip));
 712         }
 713
 714         return IP_ISSET(cl->ip);
 715 }
 716
 717 void clear_block_delay(struct s_reader *rdr)
 718 {
 719         rdr->tcp_block_delay = 0;
 720         cs_ftime(&rdr->tcp_block_connect_till);
 721 }
 722
 723 void block_connect(struct s_reader *rdr)
 724 {
 725         if(!rdr->tcp_block_delay)
 726                 { rdr->tcp_block_delay = 100; } //starting blocking time, 100ms
 727         cs_ftime(&rdr->tcp_block_connect_till);
 728         add_ms_to_timeb(&rdr->tcp_block_connect_till, rdr->tcp_block_delay);
 729         rdr->tcp_block_delay *= 4; //increment timeouts
 730         if(rdr->tcp_block_delay >= rdr->tcp_reconnect_delay)
 731                 { rdr->tcp_block_delay = rdr->tcp_reconnect_delay; }
 732         rdr_log_dbg(rdr, D_TRACE, "tcp connect blocking delay set to %d", rdr->tcp_block_delay);
 733 }
 734
 735 int32_t is_connect_blocked(struct s_reader *rdr)
 736 {
 737         struct timeb cur_time;
 738         cs_ftime(&cur_time);
 739         int32_t diff = comp_timeb(&cur_time, &rdr->tcp_block_connect_till);
 740         int32_t blocked = rdr->tcp_block_delay && diff < 0;
 741         if(blocked)
 742                 rdr_log_dbg(rdr, D_TRACE, "connection blocked, retrying in %d ms", -diff);
 743         return blocked;
 744 }
 745
 746 int32_t network_tcp_connection_open(struct s_reader *rdr)
 747 {
 748         if(!rdr) { return -1; }
 749         struct s_client *client = rdr->client;
 750         struct SOCKADDR loc_sa;
 751
 752         memset((char *)&client->udp_sa, 0, sizeof(client->udp_sa));
 753
 754         IN_ADDR_T last_ip;
 755         IP_ASSIGN(last_ip, client->ip);
 756         if(!hostResolve(rdr))
 757                 { return -1; }
 758
 759         if(!IP_EQUAL(last_ip, client->ip))  //clean blocking delay on ip change:
 760                 { clear_block_delay(rdr); }
 761
 762         if(is_connect_blocked(rdr))    //inside of blocking delay, do not connect!
 763         {
 764                 return -1;
 765         }
 766
 767         if(client->reader->r_port <= 0)
 768         {
 769                 rdr_log(client->reader, "invalid port %d for server %s", client->reader->r_port, client->reader->device);
 770                 return -1;
 771         }
 772
 773         client->is_udp = (rdr->typ == R_CAMD35);
 774
 775         rdr_log(rdr, "connecting to %s:%d", rdr->device, rdr->r_port);
 776
 777         if(client->udp_fd)
 778                 { rdr_log(rdr, "WARNING: client->udp_fd was not 0"); }
 779
 780         int s_domain = PF_INET;
 781         int s_family = AF_INET;
 782 #ifdef IPV6SUPPORT
 783         if(!IN6_IS_ADDR_V4MAPPED(&rdr->client->ip) && !IN6_IS_ADDR_V4COMPAT(&rdr->client->ip))
 784         {
 785                 s_domain = PF_INET6;
 786                 s_family = AF_INET6;
 787         }
 788 #endif
 789         int s_type   = client->is_udp ? SOCK_DGRAM : SOCK_STREAM;
 790         int s_proto  = client->is_udp ? IPPROTO_UDP : IPPROTO_TCP;
 791
 792         if((client->udp_fd = socket(s_domain, s_type, s_proto)) < 0)
 793         {
 794                 rdr_log(rdr, "Socket creation failed (errno=%d %s)", errno, strerror(errno));
 795                 client->udp_fd = 0;
 796                 block_connect(rdr);
 797                 return -1;
 798         }
 799
 800         set_socket_priority(client->udp_fd, cfg.netprio);
 801
 802         int32_t keep_alive = 1;
 803         setsockopt(client->udp_fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&keep_alive, sizeof(keep_alive));
 804
 805         int32_t flag = 1;
 806         setsockopt(client->udp_fd, IPPROTO_TCP, TCP_NODELAY, (void *)&flag, sizeof(flag));
 807
 808         if(setsockopt(client->udp_fd, SOL_SOCKET, SO_REUSEADDR, (void *)&flag, sizeof(flag)) < 0)
 809         {
 810                 rdr_log(rdr, "setsockopt failed (errno=%d: %s)", errno, strerror(errno));
 811                 client->udp_fd = 0;
 812                 block_connect(rdr);
 813                 return -1;
 814         }
 815
 816         set_so_reuseport(client->udp_fd);
 817
 818         memset((char *)&loc_sa, 0, sizeof(loc_sa));
 819         SIN_GET_FAMILY(loc_sa) = s_family;
 820         if(IP_ISSET(cfg.srvip))
 821                 { IP_ASSIGN(SIN_GET_ADDR(loc_sa), cfg.srvip); }
 822         else
 823                 { SIN_GET_ADDR(loc_sa) = ADDR_ANY; }
 824
 825         if(client->reader->l_port)
 826                 { SIN_GET_PORT(loc_sa) = htons(client->reader->l_port); }
 827         if(client->is_udp && bind(client->udp_fd, (struct sockaddr *)&loc_sa, sizeof(loc_sa)) < 0)
 828         {
 829                 rdr_log(rdr, "bind failed (errno=%d %s)", errno, strerror(errno));
 830                 close(client->udp_fd);
 831                 client->udp_fd = 0;
 832                 block_connect(rdr);
 833                 return -1;
 834         }
 835
 836 #ifdef IPV6SUPPORT
 837         if(IN6_IS_ADDR_V4MAPPED(&rdr->client->ip) || IN6_IS_ADDR_V4COMPAT(&rdr->client->ip))
 838         {
 839                 ((struct sockaddr_in *)(&client->udp_sa))->sin_family = AF_INET;
 840                 ((struct sockaddr_in *)(&client->udp_sa))->sin_port = htons((uint16_t)client->reader->r_port);
 841         }
 842         else
 843         {
 844                 ((struct sockaddr_in6 *)(&client->udp_sa))->sin6_family = AF_INET6;
 845                 ((struct sockaddr_in6 *)(&client->udp_sa))->sin6_port = htons((uint16_t)client->reader->r_port);
 846         }
 847 #else
 848         client->udp_sa.sin_family = AF_INET;
 849         client->udp_sa.sin_port = htons((uint16_t)client->reader->r_port);
 850 #endif
 851
 852         rdr_log_dbg(rdr, D_TRACE, "socket open fd=%d", client->udp_fd);
 853
 854         if(client->is_udp)
 855         {
 856                 rdr->tcp_connected = 1;
 857                 return client->udp_fd;
 858         }
 859
 860         set_nonblock(client->udp_fd, true);
 861
 862         int32_t res = connect(client->udp_fd, (struct sockaddr *)&client->udp_sa, client->udp_sa_len);
 863         if(res == -1)
 864         {
 865                 int32_t r = -1;
 866                 if(errno == EINPROGRESS || errno == EALREADY)
 867                 {
 868                         struct pollfd pfd;
 869                         pfd.fd = client->udp_fd;
 870                         pfd.events = POLLOUT;
 871                         int32_t rc = poll(&pfd, 1, 3000);
 872                         if(rc > 0)
 873                         {
 874                                 uint32_t l = sizeof(r);
 875                                 if(getsockopt(client->udp_fd, SOL_SOCKET, SO_ERROR, &r, (socklen_t *)&l) != 0)
 876                                         { r = -1; }
 877                                 else
 878                                         { errno = r; }
 879                         }
 880                         else
 881                         {
 882                                 errno = ETIMEDOUT;
 883                         }
 884                 }
 885                 if(r != 0)
 886                 {
 887                         rdr_log(rdr, "connect failed: %s", strerror(errno));
 888                         block_connect(rdr); //connect has failed. Block connect for a while
 889                         close(client->udp_fd);
 890                         client->udp_fd = 0;
 891                         return -1;
 892                 }
 893         }
 894
 895         set_nonblock(client->udp_fd, false); //restore blocking mode
 896
 897         setTCPTimeouts(client->udp_fd);
 898         clear_block_delay(rdr);
 899         client->last = client->login = time((time_t *)0);
 900         client->last_caid = NO_CAID_VALUE;
 901         client->last_provid = NO_PROVID_VALUE;
 902         client->last_srvid = NO_SRVID_VALUE;
 903         client->pfd = client->udp_fd;
 904         rdr->tcp_connected = 1;
 905         rdr_log_dbg(rdr, D_TRACE, "connect successful fd=%d", client->udp_fd);
 906         return client->udp_fd;
 907 }
 908
 909 void network_tcp_connection_close(struct s_reader *reader, char *reason)
 910 {
 911         if(!reader)
 912         {
 913                 //only proxy reader should call this, client connections are closed on thread cleanup
 914                 cs_log("WARNING: invalid client");
 915                 cs_disconnect_client(cur_client());
 916                 return;
 917         }
 918
 919         struct s_client *cl = reader->client;
 920         if(!cl) { return; }
 921         int32_t fd = cl->udp_fd;
 922
 923         int32_t i;
 924
 925         if(fd)
 926         {
 927                 rdr_log(reader, "disconnected: reason %s", reason ? reason : "undef");
 928                 close(fd);
 929
 930                 cl->udp_fd = 0;
 931                 cl->pfd = 0;
 932         }
 933
 934         reader->tcp_connected = 0;
 935         reader->card_status = UNKNOWN;
 936         cl->logout = time((time_t *)0);
 937
 938         if(cl->ecmtask)
 939         {
 940                 for(i = 0; i < cfg.max_pending; i++)
 941                 {
 942                         cl->ecmtask[i].idx = 0;
 943                         cl->ecmtask[i].rc = E_FOUND;
 944                 }
 945         }
 946         // newcamd message ids are stored as a reference in ecmtask[].idx
 947         // so we need to reset them aswell
 948         if(reader->typ == R_NEWCAMD)
 949                 { cl->ncd_msgid = 0; }
 950 }
 951
 952 int32_t casc_process_ecm(struct s_reader *reader, ECM_REQUEST *er)
 953 {
 954         int32_t rc, n, i, sflag, pending = 0;
 955         time_t t;//, tls;
 956         struct s_client *cl = reader->client;
 957
 958         if(!cl || !cl->ecmtask)
 959         {
 960                 rdr_log(reader, "WARNING: ecmtask not available");
 961                 return -1;
 962         }
 963
 964         t = time((time_t *)0);
 965         ECM_REQUEST *ecm;
 966         for(i = 0; i < cfg.max_pending; i++)
 967         {
 968                 ecm = &cl->ecmtask[i];
 969                 if((ecm->rc >= E_NOCARD) && (t - (uint32_t)ecm->tps.time > ((cfg.ctimeout + 500) / 1000) + 1))  // drop timeouts
 970                 {
 971                         ecm->rc = E_FOUND;
 972                 }
 973         }
 974
 975         for(n = -1, i = 0, sflag = 1; i < cfg.max_pending; i++)
 976         {
 977                 ecm = &cl->ecmtask[i];
 978                 if(n < 0 && (ecm->rc < E_NOCARD))  // free slot found
 979                         { n = i; }
 980
 981                 // ecm already pending
 982                 // ... this level at least
 983                 if((ecm->rc >= E_NOCARD) &&  er->caid == ecm->caid && (!memcmp(er->ecmd5, ecm->ecmd5, CS_ECMSTORESIZE)))
 984                         { sflag = 0; }
 985
 986                 if(ecm->rc >= E_NOCARD)
 987                         { pending++; }
 988         }
 989         cl->pending = pending;
 990
 991         if(n < 0)
 992         {
 993                 rdr_log(reader, "WARNING: reader ecm pending table overflow !!");
 994                 return (-2);
 995         }
 996
 997         memcpy(&cl->ecmtask[n], er, sizeof(ECM_REQUEST));
 998         cl->ecmtask[n].matching_rdr = NULL; //This avoids double free of matching_rdr!
 999 #ifdef CS_CACHEEX
1000         cl->ecmtask[n].csp_lastnodes = NULL; //This avoids double free of csp_lastnodes!
1001 #endif
1002         cl->ecmtask[n].parent = er;
1003
1004         if(reader->typ == R_NEWCAMD)
1005                 { cl->ecmtask[n].idx = (cl->ncd_msgid == 0) ? 2 : cl->ncd_msgid + 1; }
1006         else
1007         {
1008                 if(!cl->idx)
1009                         { cl->idx = 1; }
1010                 cl->ecmtask[n].idx = cl->idx++;
1011         }
1012
1013         cl->ecmtask[n].rc = E_NOCARD;
1014         cs_log_dbg(D_TRACE, "---- ecm_task %d, idx %d, sflag=%d", n, cl->ecmtask[n].idx, sflag);
1015
1016         cs_log_dump_dbg(D_ATR, er->ecm, er->ecmlen, "casc ecm (%s):", (reader) ? reader->label : "n/a");
1017         rc = 0;
1018         if(sflag)
1019         {
1020                 rc = reader->ph.c_send_ecm(cl, &cl->ecmtask[n]);
1021                 if(rc != 0)
1022                 {
1023                         casc_check_dcw(reader, n, 0, cl->ecmtask[n].cw); // simulate "not found"
1024                 }
1025                 else
1026                         { cl->last_idx = cl->ecmtask[n].idx; }
1027                 reader->last_s = t;   // used for inactive_timeout and reconnect_timeout in TCP reader
1028         }
1029
1030         if(cl->idx > 0x1ffe) { cl->idx = 1; }
1031
1032         return (rc);
1033 }
1034
1035 void reader_get_ecm(struct s_reader *reader, ECM_REQUEST *er)
1036 {
1037         if(!reader) { return; }
1038         struct s_client *cl = reader->client;
1039         if(!check_client(cl)) { return; }
1040
1041         if(!chk_bcaid(er, &reader->ctab))
1042         {
1043                 rdr_log_dbg(reader, D_READER, "caid %04X filtered", er->caid);
1044                 write_ecm_answer(reader, er, E_NOTFOUND, E2_CAID, NULL, NULL, 0, NULL);
1045                 return;
1046         }
1047
1048         //CHECK if ecm already sent to reader
1049         struct s_ecm_answer *ea_er = get_ecm_answer(reader, er);
1050         if(!ea_er) { return; }
1051
1052         struct s_ecm_answer *ea = NULL, *ea_prev = NULL;
1053         struct ecm_request_t *ecm;
1054         time_t timeout;
1055
1056         cs_readlock(__func__, &ecmcache_lock);
1057         for(ecm = ecmcwcache; ecm; ecm = ecm->next)
1058         {
1059                 timeout = time(NULL) - ((cfg.ctimeout+500)/1000+1);
1060                 if(ecm->tps.time <= timeout)
1061                         { break; }
1062
1063                 if(!ecm->matching_rdr || ecm == er || ecm->rc == E_99) { continue; }
1064
1065                 //match same ecm
1066                 if(er->caid == ecm->caid && !memcmp(er->ecmd5, ecm->ecmd5, CS_ECMSTORESIZE))
1067                 {
1068                         //check if ask this reader
1069                         ea = get_ecm_answer(reader, ecm);
1070                         if(ea && !ea->is_pending && (ea->status & REQUEST_SENT) && ea->rc != E_TIMEOUT && ea->rcEx != E2_RATELIMIT) { break; }
1071                         ea = NULL;
1072                 }
1073         }
1074         cs_readunlock(__func__, &ecmcache_lock);
1075         if(ea)   //found ea in cached ecm, asking for this reader
1076         {
1077                 ea_er->is_pending = true;
1078
1079                 cs_readlock(__func__, &ea->ecmanswer_lock);
1080                 if(ea->rc < E_99)
1081                 {
1082                         cs_readunlock(__func__, &ea->ecmanswer_lock);
1083                         cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [reader_get_ecm] ecm already sent to reader %s (%s)", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, reader ? reader->label : "-", ea->rc==E_FOUND?"OK":"NOK");
1084
1085                         //e.g. we cannot send timeout, because "ea_temp->er->client" could wait/ask other readers! Simply set not_found if different from E_FOUND!
1086                         write_ecm_answer(reader, er, (ea->rc==E_FOUND? E_FOUND : E_NOTFOUND), ea->rcEx, ea->cw, NULL, ea->tier, &ea->cw_ex);
1087                         return;
1088                 }
1089                 else
1090                 {
1091                         ea_prev = ea->pending;
1092                         ea->pending = ea_er;
1093                         ea->pending->pending_next = ea_prev;
1094                         cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [reader_get_ecm] ecm already sent to reader %s... set as pending", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, reader ? reader->label : "-");
1095                 }
1096                 cs_readunlock(__func__, &ea->ecmanswer_lock);
1097                 return;
1098         }
1099
1100         lb_update_last(ea_er, reader);
1101
1102         if(ecm_ratelimit_check(reader, er, 1) != OK)
1103         {
1104                 rdr_log_dbg(reader, D_READER, "ratelimiter has no space left -> skip!");
1105                 return;
1106         }
1107
1108         if(is_cascading_reader(reader))     // forward request to proxy reader
1109         {
1110                 cl->last_srvid = er->srvid;
1111                 cl->last_caid = er->caid;
1112                 cl->last_provid = er->prid;
1113                 casc_process_ecm(reader, er);
1114                 cl->lastecm = time((time_t *)0);
1115                 return;
1116         }
1117
1118         cardreader_process_ecm(reader, cl, er);  // forward request to physical reader
1119 }
1120
1121 void reader_do_card_info(struct s_reader *reader)
1122 {
1123         cardreader_get_card_info(reader);
1124         if(reader->ph.c_card_info)
1125                 { reader->ph.c_card_info(); }
1126 }
1127
1128 void reader_do_idle(struct s_reader *reader)
1129 {
1130         if(reader->ph.c_idle)
1131                 { reader->ph.c_idle(); }
1132         else if (reader->tcp_ito > 0)
1133         {
1134                 time_t now;
1135                 int32_t time_diff;
1136                 time(&now);
1137                 time_diff = llabs(now - reader->last_s);
1138                 if(time_diff > reader->tcp_ito)
1139                 {
1140                         struct s_client *cl = reader->client;
1141                         if(check_client(cl) && reader->tcp_connected && reader->ph.type == MOD_CONN_TCP)
1142                         {
1143                                 rdr_log_dbg(reader, D_READER, "inactive_timeout, close connection (fd=%d)", cl->pfd);
1144                                 network_tcp_connection_close(reader, "inactivity");
1145                         }
1146                         else
1147                                 { reader->last_s = now; }
1148                 }
1149         }
1150 }
1151
1152 int32_t reader_init(struct s_reader *reader)
1153 {
1154         struct s_client *client = reader->client;
1155
1156         if(is_cascading_reader(reader))
1157         {
1158                 client->typ = 'p';
1159                 client->port = reader->r_port;
1160                 set_null_ip(&client->ip);
1161
1162                 if(!(reader->ph.c_init))
1163                 {
1164                         rdr_log(reader, "FATAL: protocol not supporting cascading");
1165                         return 0;
1166                 }
1167
1168                 if(reader->ph.c_init(client))
1169                 {
1170                         //proxy reader start failed
1171                         return 0;
1172                 }
1173
1174                 if(client->ecmtask)
1175                 {
1176                         add_garbage(client->ecmtask);
1177                         client->ecmtask = NULL;
1178                 }
1179
1180                 if(!cs_malloc(&client->ecmtask, cfg.max_pending * sizeof(ECM_REQUEST)))
1181                         { return 0; }
1182
1183                 rdr_log(reader, "proxy initialized, server %s:%d", reader->device, reader->r_port);
1184         }
1185         else
1186         {
1187                 if(!cardreader_init(reader))
1188                         { return 0; }
1189         }
1190
1191         ll_destroy_data(&reader->emmstat);
1192
1193         client->login = time((time_t *)0);
1194         client->init_done = 1;
1195
1196         return 1;
1197 }
1198
1199 #if !defined(WITH_CARDREADER) && (defined(WITH_STAPI) || defined(WITH_STAPI5))
1200 /* Dummy function stub for stapi compiles without cardreader as libstapi needs it. */
1201 int32_t ATR_InitFromArray(ATR *atr, const unsigned char atr_buffer[ATR_MAX_SIZE], uint32_t length)
1202 {
1203         (void)atr;
1204         (void)atr_buffer;
1205         (void)length;
1206         return 0;
1207 }
1208 #endif
1209
1210 void cs_card_info(void)
1211 {
1212         struct s_client *cl;
1213         for(cl = first_client->next; cl ; cl = cl->next)
1214         {
1215                 if(cl->typ == 'r' && cl->reader)
1216                         { add_job(cl, ACTION_READER_CARDINFO, NULL, 0); }
1217         }
1218 }
1219
1220
1221 /* Adds a reader to the list of active readers so that it can serve ecms. */
1222 static void add_reader_to_active(struct s_reader *rdr)
1223 {
1224         struct s_reader *rdr2, *rdr_prv = NULL, *rdr_tmp = NULL;
1225         int8_t at_first = 1;
1226
1227         if(rdr->next)
1228                 { remove_reader_from_active(rdr); }
1229
1230         cs_writelock(__func__, &readerlist_lock);
1231         cs_writelock(__func__, &clientlist_lock);
1232
1233         // search configured position:
1234         LL_ITER it = ll_iter_create(configured_readers);
1235         while((rdr2 = ll_iter_next(&it)))
1236         {
1237                 if(rdr2 == rdr)
1238                         { break; }
1239                 if(rdr2->client && rdr2->enable)
1240                 {
1241                         rdr_prv = rdr2;
1242                         at_first = 0;
1243                 }
1244         }
1245
1246         // insert at configured position:
1247         if(first_active_reader)
1248         {
1249                 if(at_first)
1250                 {
1251                         rdr->next = first_active_reader;
1252                         first_active_reader = rdr;
1253                         //resort client list:
1254                         struct s_client *prev, *cl;
1255                         for(prev = first_client, cl = first_client->next;
1256                                         prev->next != NULL; prev = prev->next, cl = cl->next)
1257                         {
1258                                 if(rdr->client == cl)
1259                                         { break; }
1260                         }
1261                         if(cl && rdr->client == cl)
1262                         {
1263                                 prev->next = cl->next; //remove client from list
1264                                 cl->next = first_client->next;
1265                                 first_client->next = cl;
1266                         }
1267                 }
1268                 else
1269                 {
1270                         for(rdr2 = first_active_reader; rdr2->next && rdr2 != rdr_prv ; rdr2 = rdr2->next) { ; }  //search last element
1271                         rdr_prv = rdr2;
1272                         rdr_tmp = rdr2->next;
1273                         rdr2->next = rdr;
1274                         rdr->next = rdr_tmp;
1275                         //resort client list:
1276                         struct s_client *prev, *cl;
1277                         for(prev = first_client, cl = first_client->next;
1278                                         prev->next != NULL; prev = prev->next, cl = cl->next)
1279                         {
1280                                 if(rdr->client == cl)
1281                                         { break; }
1282                         }
1283                         if(cl && rdr->client == cl)
1284                         {
1285                                 prev->next = cl->next; //remove client from list
1286                                 cl->next = rdr_prv->client->next;
1287                                 rdr_prv->client->next = cl;
1288                         }
1289                 }
1290         }
1291         else
1292         {
1293                 first_active_reader = rdr;
1294         }
1295         rdr->active = 1;
1296         cs_writeunlock(__func__, &clientlist_lock);
1297         cs_writeunlock(__func__, &readerlist_lock);
1298 }
1299
1300 /* Removes a reader from the list of active readers so that no ecms can be requested anymore. */
1301 void remove_reader_from_active(struct s_reader *rdr)
1302 {
1303         struct s_reader *rdr2, *prv = NULL;
1304         //rdr_log(rdr, "CHECK: REMOVE READER FROM ACTIVE");
1305         cs_writelock(__func__, &readerlist_lock);
1306         for(rdr2 = first_active_reader; rdr2 ; prv = rdr2, rdr2 = rdr2->next)
1307         {
1308                 if(rdr2 == rdr)
1309                 {
1310                         if(prv) { prv->next = rdr2->next; }
1311                         else { first_active_reader = rdr2->next; }
1312                         break;
1313                 }
1314         }
1315         rdr->next = NULL;
1316         rdr->active = 0;
1317         cs_writeunlock(__func__, &readerlist_lock);
1318 }
1319
1320 /* Starts or restarts a cardreader without locking. If restart=1, the existing thread is killed before restarting,
1321    if restart=0 the cardreader is only started. */
1322 static int32_t restart_cardreader_int(struct s_reader *rdr, int32_t restart)
1323 {
1324         struct s_client *cl = rdr->client;
1325         if(restart)
1326         {
1327                 remove_reader_from_active(rdr); // remove from list
1328                 kill_thread(cl); // kill old thread
1329                 cs_sleepms(1500);  //we have to wait a bit so free_client is ended and socket closed too!
1330         }
1331
1332         while(restart && is_valid_client(cl))
1333         {
1334                 // If we quick disable+enable a reader (webif), remove_reader_from_active is called from
1335                 // cleanup. this could happen AFTER reader is restarted, so oscam crashes or reader is hidden
1336                 // rdr_log(rdr, "CHECK: WAITING FOR CLEANUP");
1337                 cs_sleepms(500);
1338         }
1339
1340         rdr->client = NULL;
1341         rdr->tcp_connected = 0;
1342         rdr->card_status = UNKNOWN;
1343         rdr->tcp_block_delay = 100;
1344         cs_ftime(&rdr->tcp_block_connect_till);
1345
1346         if(rdr->device[0] && is_cascading_reader(rdr))
1347         {
1348                 if(!rdr->ph.num)
1349                 {
1350                         rdr_log(rdr, "Protocol Support missing. (typ=%d)", rdr->typ);
1351                         return 0;
1352                 }
1353         }
1354
1355         if(!rdr->enable)
1356                 { return 0; }
1357
1358         if(rdr->device[0])
1359         {
1360                 if(restart)
1361                 {
1362                         rdr_log(rdr, "Restarting reader");
1363                 }
1364                 cl = create_client(first_client->ip);
1365                 if(cl == NULL)
1366                         { return 0; }
1367                 cl->reader  = rdr;
1368                 rdr_log(rdr, "creating thread for device %s", rdr->device);
1369
1370                 cl->sidtabs.ok = rdr->sidtabs.ok;
1371                 cl->sidtabs.no = rdr->sidtabs.no;
1372                 cl->lb_sidtabs.ok = rdr->lb_sidtabs.ok;
1373                 cl->lb_sidtabs.no = rdr->lb_sidtabs.no;
1374                 cl->grp = rdr->grp;
1375
1376                 rdr->client = cl;
1377
1378                 cl->typ = 'r';
1379
1380                 add_job(cl, ACTION_READER_INIT, NULL, 0);
1381                 add_reader_to_active(rdr);
1382
1383                 return 1;
1384         }
1385         return 0;
1386 }
1387
1388 /* Starts or restarts a cardreader with locking. If restart=1, the existing thread is killed before restarting,
1389    if restart=0 the cardreader is only started. */
1390 int32_t restart_cardreader(struct s_reader *rdr, int32_t restart)
1391 {
1392         cs_writelock(__func__, &system_lock);
1393         int32_t result = restart_cardreader_int(rdr, restart);
1394         cs_writeunlock(__func__, &system_lock);
1395         return result;
1396 }
1397
1398 void init_cardreader(void)
1399 {
1400         cs_log_dbg(D_TRACE, "cardreader: Initializing");
1401         cs_writelock(__func__, &system_lock);
1402         struct s_reader *rdr;
1403
1404         cardreader_init_locks();
1405         LL_ITER itr = ll_iter_create(configured_readers);
1406         while((rdr = ll_iter_next(&itr)))
1407         {
1408                 if(rdr->enable)
1409                 {
1410                         restart_cardreader_int(rdr, 0);
1411                 }
1412         }
1413
1414         load_stat_from_file();
1415         cs_writeunlock(__func__, &system_lock);
1416 }
1417
1418 void kill_all_readers(void)
1419 {
1420         struct s_reader *rdr;
1421         for(rdr = first_active_reader; rdr; rdr = rdr->next)
1422         {
1423                 struct s_client *cl = rdr->client;
1424                 if(!cl)
1425                         { continue; }
1426                 rdr_log(rdr, "Killing reader");
1427                 kill_thread(cl);
1428         }
1429         first_active_reader = NULL;
1430 }
1431
1432 int32_t reader_slots_available(struct s_reader *reader, ECM_REQUEST *er)
1433 {
1434         if(ecm_ratelimit_check(reader, er, 0) != OK)   //check ratelimiter & cooldown -> in check mode: dont register srvid!!!
1435         {
1436                 return 0; // no slot free
1437         }
1438         else
1439         {
1440                 return 1; // slots available!
1441         }
1442 }