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