oscam-emm.c

   1 #define MODULE_LOG_PREFIX "emm"
   2
   3 #include "globals.h"
   4 #include "cscrypt/md5.h"
   5 #include "module-dvbapi.h"
   6 #include "module-led.h"
   7 #include "oscam-client.h"
   8 #include "oscam-config.h"
   9 #include "oscam-emm.h"
  10 #include "oscam-string.h"
  11 #include "oscam-time.h"
  12 #include "oscam-work.h"
  13 #include "reader-common.h"
  14 #include "oscam-chk.h"
  15 #include "oscam-emm-cache.h"
  16
  17 const char *entitlement_type[] = { "", "package", "PPV-Event", "chid", "tier", "class", "PBM", "admin" };
  18
  19 static struct timeb last_emm_clean;
  20 static int8_t cs_emmlen_is_blocked(struct s_reader *rdr, int16_t len)
  21 {
  22         struct s_emmlen_range *blocklen;
  23         if(!rdr->blockemmbylen)
  24                 { return 0; }
  25         LL_ITER it = ll_iter_create(rdr->blockemmbylen);
  26         while((blocklen = ll_iter_next(&it)))
  27         {
  28                 if(blocklen->min <= len
  29                                 && (len <= blocklen->max || blocklen->max == 0))
  30                         { return 1; }
  31         }
  32         return 0;
  33 }
  34
  35 /**
  36  * Function to filter emm by cardsystem.
  37  * Every cardsystem can export a function "get_emm_filter"
  38  *
  39  * the emm is checked against it and returns 1 for a valid emm or 0 if not
  40  */
  41 static int8_t do_simple_emm_filter(struct s_reader *rdr, const struct s_cardsystem *csystem, EMM_PACKET *ep, int8_t cl_dvbapi)
  42 {
  43         if(is_network_reader(rdr)) { return 1; }  // dont evaluate on network readers, server with local reader will check it
  44
  45         //copied and enhanced from module-dvbapi.c
  46         //dvbapi_start_emm_filter()
  47         int32_t i, k, match;
  48         uint8_t flt, mask;
  49         struct s_csystem_emm_filter *dmx_filter = NULL;
  50         unsigned int j, filter_count = 0;
  51
  52         // Call cardsystems emm filter
  53         csystem->get_emm_filter(rdr, &dmx_filter, &filter_count);
  54
  55         // Only check matching emmtypes:
  56         uint8_t org_emmtype;
  57         if(ep->type == UNKNOWN)
  58                 { org_emmtype = EMM_UNKNOWN; }
  59         else
  60                 { org_emmtype = 1 << (ep->type - 1); }
  61
  62         // Now check all filter values
  63
  64
  65         for(j = 0; j < filter_count; j++)
  66         {
  67                 if(dmx_filter[j].enabled == 0)
  68                         { continue; }
  69
  70                 uint8_t emmtype = dmx_filter[j].type;
  71                 if(emmtype != org_emmtype)
  72                         { continue; }
  73
  74                 match = 1;
  75                 for(i = 0, k = 0; i < 16 && k < ep->emmlen && match; i++, k++)
  76                 {
  77                         mask = dmx_filter[j].mask[i];
  78                         if(k == 1 && cl_dvbapi)  // fixup for emms send by dvbapi
  79                                 { k += 2; } //skip emm len bytes
  80                         if(!mask)
  81                                 { continue; }
  82                         //cs_log("**** filter %d [%d] = %02X, filter mask[%d] = %02X, flt&mask = %02X , ep->emm[%d] = %02X, ep->emm[%d] & mask = %02X ****", j, i,
  83                         //  dmx_filter[j].filter[i], i, dmx_filter[j].mask[i], flt&mask, k, ep->emm[k], k, ep->emm[k] & mask);
  84                         flt = (dmx_filter[j].filter[i] & mask);
  85                         match = (flt == (ep->emm[k] & mask));
  86                         if(!match)
  87                                 { break; }
  88                 }
  89                 if(match)
  90                 {
  91                         NULLFREE(dmx_filter);
  92                         return 1; //valid emm
  93                 }
  94         }
  95
  96         NULLFREE(dmx_filter);
  97
  98         return 0; //emm filter does not match, illegal emm, return
  99 }
 100
 101 static void reader_log_emm(struct s_reader *reader, EMM_PACKET *ep, int32_t count, int32_t rc, struct timeb *tps)
 102 {
 103         char *rtxt[] =
 104         {
 105                 "error",
 106                 is_network_reader(reader) ? "sent" : "written",
 107                 "skipped",
 108                 "blocked"
 109         };
 110         char *typedesc[] = { "unknown", "unique", "shared", "global" };
 111         struct s_client *cl = reader->client;
 112         struct timeb tpe;
 113
 114         if(reader->logemm & (1 << rc))
 115         {
 116                 cs_ftime(&tpe);
 117                 if(!tps)
 118                         { tps = &tpe; }
 119
 120                 rdr_log(reader, "%s emmtype=%s, len=%d (hex: 0x%.2X), cnt=%d: %s (%"PRId64" ms)",
 121                                 username(ep->client), typedesc[ep->type], SCT_LEN(ep->emm)-3, SCT_LEN(ep->emm)-3, count, rtxt[rc], comp_timeb(&tpe, tps));
 122         }
 123
 124         if(rc)
 125         {
 126                 cl->lastemm = time(NULL);
 127                 led_status_emm_ok();
 128         }
 129
 130 #if defined(WEBIF) || defined(LCDSUPPORT)
 131         //counting results
 132         switch(rc)
 133         {
 134         case 0:
 135                 reader->emmerror[ep->type]++;
 136                 reader->webif_emmerror[ep->type]++;
 137                 break;
 138         case 1:
 139                 reader->emmwritten[ep->type]++;
 140                 reader->webif_emmwritten[ep->type]++;
 141                 break;
 142         case 2:
 143                 reader->emmskipped[ep->type]++;
 144                 reader->webif_emmskipped[ep->type]++;
 145                 break;
 146         case 3:
 147                 reader->emmblocked[ep->type]++;
 148                 reader->webif_emmblocked[ep->type]++;
 149                 break;
 150         }
 151 #endif
 152 }
 153
 154 int32_t emm_reader_match(struct s_reader *reader, uint16_t caid, uint32_t provid)
 155 {
 156         int32_t i;
 157
 158         // if physical reader a card needs to be inserted
 159         if(!is_network_reader(reader) && reader->card_status != CARD_INSERTED)
 160                 { return 0; }
 161
 162         if(reader->audisabled)
 163                 { return 0; }
 164
 165         if(reader->caid != caid)
 166         {
 167                 int caid_found = 0;
 168                 if (!reader->csystem)
 169                         return 0;
 170                 for(i = 0; reader->csystem->caids[i]; i++)
 171                 {
 172                         uint16_t cs_caid = reader->csystem->caids[i];
 173                         if (reader->caid && cs_caid == caid)
 174                         {
 175                                 caid_found = 1;
 176                                 break;
 177                         }
 178
 179                         if ( (reader->caid == 0) && chk_ctab_ex(caid, &reader->ctab) )
 180                         {
 181                                 caid_found = 1;
 182                                 break;
 183                         }
 184
 185                 }
 186                 if(!caid_found)
 187                 {
 188                         rdr_log_dbg(reader, D_EMM, "reader_caid %04X != emmpid caid %04X -> SKIP!", reader->caid, caid);
 189                         return 0;
 190                 }
 191         }
 192
 193         //if (!hexserialset(reader)) { There are cards without serial, they should get emm of type global and shared!
 194         //  rdr_log_dbg(reader, D_EMM, "no hexserial is set");
 195         //  return 0;
 196         //}
 197
 198         if(!provid)
 199         {
 200                 rdr_log_dbg(reader, D_EMM, "reader %04X match since emmpid has no provid -> SEND!", caid);
 201                 return 1;
 202         }
 203
 204         uint32_t prid = reader->auprovid;
 205
 206         if(caid_is_viaccess(caid) && (prid != 0) && ((prid &0xFFFFF0) != prid)) // viaccess fixup last digit of provid is a dont care!
 207         {
 208                 prid &= 0xFFFFF0;
 209                 rdr_log_dbg(reader, D_EMM, "reader auprovid = %06X fixup to %06X (ignoring last digit)", reader->auprovid, prid);
 210         }
 211
 212         if(prid == provid)
 213         {
 214                 rdr_log_dbg(reader, D_EMM, "reader auprovid = %06X matching with emm provid = %06X -> SEND!", prid, provid);
 215                 return 1;
 216         }
 217
 218         for(i = 0; i < reader->nprov; i++)
 219         {
 220                 prid = b2i(4, reader->prid[i]);
 221
 222                 if(caid_is_viaccess(caid) && (prid != 0) && ((prid &0xFFFFF0) != prid)) // viaccess fixup last digit of provid is a dont care!
 223                 {
 224                         rdr_log_dbg(reader, D_EMM, "reader provid = %06X fixup to %06X (ignoring last digit)", prid, (prid &0xFFFFF0));
 225                         prid &= 0xFFFFF0;
 226                 }
 227
 228                 if(prid == provid)
 229                 {
 230                         rdr_log_dbg(reader, D_EMM, "reader provid %06X matching with emm provid %06X -> SEND!", prid, provid);
 231                         return 1;
 232                 }
 233
 234                 if((reader->typ == R_CAMD35 || reader->typ == R_CS378X) && (prid & 0xFFFF) == (provid & 0xFFFF))
 235                 {
 236                         rdr_log_dbg(reader, D_EMM, "CS378: Match after fixing reader provid %06X to ??%04X and emm provid %06X to ??%04X -> SEND!", prid, prid&0xFFFF, provid, provid&0xFFFF);
 237                         return 1;
 238                 }
 239
 240                 rdr_log_dbg(reader, D_EMM, "reader provid %06X no match with emm provid %06X -> SKIP!", prid, provid);
 241         }
 242         return 0;
 243 }
 244
 245 static char *get_emmlog_filename(char *dest, size_t destlen, const char *basefilename, const char *type, const char *ext)
 246 {
 247         char filename[64 + 16];
 248         snprintf(filename, sizeof(filename), "%s_%s_emm.%s", basefilename, type, ext);
 249         if(!cfg.emmlogdir)
 250         {
 251                 get_config_filename(dest, destlen, filename);
 252         }
 253         else
 254         {
 255                 const char *slash = "/";
 256                 if(cfg.emmlogdir[strlen(cfg.emmlogdir) - 1] == '/') { slash = ""; }
 257                 snprintf(dest, destlen, "%s%s%s", cfg.emmlogdir, slash, filename);
 258         }
 259         return dest;
 260 }
 261
 262 static void saveemm(struct s_reader *aureader, EMM_PACKET *ep, const char *proceded)
 263 {
 264         FILE *fp_log;
 265         char tmp[17];
 266         char buf[80];
 267         char token_log[256];
 268         char *tmp2;
 269         time_t rawtime;
 270         uint32_t emmtype;
 271         struct tm timeinfo;
 272         if(ep->type == UNKNOWN)
 273                 { emmtype = EMM_UNKNOWN; }
 274         else
 275                 { emmtype = 1 << (ep->type - 1); }
 276         // should this nano be saved?
 277         if(((1 << (ep->emm[0] % 0x80)) & aureader->s_nano) || (aureader->saveemm & emmtype))
 278         {
 279                 time(&rawtime);
 280                 localtime_r(&rawtime, &timeinfo); // to access LOCAL date/time info
 281                 int32_t emm_length = SCT_LEN(ep->emm);
 282                 strftime(buf, sizeof(buf), "%Y/%m/%d %H:%M:%S", &timeinfo);
 283                 switch(ep->type)
 284                 {
 285                         case GLOBAL:
 286                                 fp_log = fopen(get_emmlog_filename(token_log, sizeof(token_log), aureader->label, "global", "log"), "a");
 287                                 break;
 288                         case SHARED:
 289                                 fp_log = fopen(get_emmlog_filename(token_log, sizeof(token_log), aureader->label, "shared", "log"), "a");
 290                                 break;
 291                         case UNIQUE:
 292                                 fp_log = fopen(get_emmlog_filename(token_log, sizeof(token_log), aureader->label, "unique", "log"), "a");
 293                                 break;
 294                         case UNKNOWN:
 295                         default:
 296                                 fp_log = fopen(get_emmlog_filename(token_log, sizeof(token_log), aureader->label, "unknown", "log"), "a");
 297                 }
 298
 299                 if(!fp_log)
 300                 {
 301                         rdr_log(aureader, "ERROR: Cannot open file '%s' (errno=%d: %s)\n", token_log, errno, strerror(errno));
 302                 }
 303                 else
 304                 {
 305                         if(cs_malloc(&tmp2, emm_length * 2 + 1))
 306                         {
 307                                 fprintf(fp_log, "%s   %s   ", buf, cs_hexdump(0, ep->hexserial, 8, tmp, sizeof(tmp)));
 308                                 fprintf(fp_log, "%s   %s\n", cs_hexdump(0, ep->emm, emm_length, tmp2, emm_length * 2 + 1), proceded);
 309                                 NULLFREE(tmp2);
 310                                 rdr_log(aureader, "Successfully added EMM to %s", token_log);
 311                         }
 312                         fclose(fp_log);
 313                 }
 314         }
 315 }
 316
 317 void do_emm(struct s_client *client, EMM_PACKET *ep)
 318 {
 319         char *typtext[] = {"unknown", "unique", "shared", "global"};
 320         char tmp[17];
 321         int32_t emmnok = 0;
 322         bool lastseendone = false;
 323
 324         struct s_reader *aureader = NULL;
 325         uint16_t sct_len;
 326
 327         if(ep->emmlen < 3)
 328         {
 329                 cs_log("EMM size %d invalid, ignored! client %s", ep->emmlen, username(client));
 330                 return;
 331         }
 332
 333         if(ep->emmlen > MAX_EMM_SIZE)
 334         {
 335                 cs_log("EMM size %d > Max EMM size %d, ignored! client %s", ep->emmlen, MAX_EMM_SIZE, username(client));
 336                 return;
 337         }
 338
 339         sct_len = SCT_LEN(ep->emm);
 340         if(sct_len > ep->emmlen)
 341         {
 342                 cs_log("Real EMM size %d > EMM size %d, ignored! client %s", sct_len, ep->emmlen, username(client));
 343                 return;
 344         }
 345         ep->emmlen = sct_len;
 346
 347         cs_log_dump_dbg(D_EMM, ep->emm, ep->emmlen, "emm:");
 348
 349         int8_t assemble = 0;
 350         bool cl_dvbapi = is_dvbapi_usr(client->account->usr);
 351         if(client->account->emm_reassembly > 1 || (client->account->emm_reassembly && cl_dvbapi))
 352                 { assemble = 1; }
 353
 354         LL_ITER itr = ll_iter_create(client->aureader_list);
 355         while((aureader = ll_iter_next(&itr)))
 356         {
 357                 if(!aureader->enable)
 358                         { continue; }
 359
 360                 uint16_t caid = b2i(2, ep->caid);
 361                 uint32_t provid = b2i(4, ep->provid);
 362
 363                 if(caid_is_viaccess(caid)) // viaccess fixup last digit is a dont care!
 364                 {
 365                          provid &= 0xFFFFF0;
 366                 }
 367
 368                 if(aureader->audisabled)
 369                 {
 370                         rdr_log_dbg(aureader, D_EMM, "AU is disabled");
 371                         /* we have to write the log for blocked EMM here because
 372                          this EMM never reach the reader module where the rest
 373                          of EMM log is done. */
 374                         if(aureader->logemm & 0x10)
 375                         {
 376                                 rdr_log(aureader, "%s emmtype=%s, len=%d (hex: 0x%02X), idx=0, cnt=1: audisabled (0 ms)",
 377                                                 client->account->usr,
 378                                                 typtext[ep->type],
 379                                                 SCT_LEN(ep->emm)-3,
 380                                                 SCT_LEN(ep->emm)-3);
 381                         }
 382                         continue;
 383                 }
 384
 385                 if(!(aureader->grp & client->grp))
 386                 {
 387                         rdr_log_dbg(aureader, D_EMM, "skip emm, group mismatch");
 388                         continue;
 389                 }
 390
 391                 //TODO: provider possibly not set yet, this is done in get_emm_type()
 392                 if(!emm_reader_match(aureader, caid, provid))
 393                         { continue; }
 394
 395                 const struct s_cardsystem *csystem = NULL;
 396
 397                 if(is_network_reader(aureader))    // network reader (R_CAMD35 R_NEWCAMD R_CS378X R_CCCAM)
 398                 {
 399                         if(!aureader->ph.c_send_emm)  // no emm support
 400                                 { continue; }
 401
 402                         csystem = get_cardsystem_by_caid(caid);
 403                         if(!csystem)
 404                         {
 405                                 rdr_log_dbg(aureader, D_EMM, "unable to find cardsystem for caid %04X", caid);
 406                                 continue;
 407                         }
 408                 }
 409                 else     // local reader
 410                 {
 411                         if(aureader->csystem_active)
 412                                 { csystem = aureader->csystem; }
 413                 }
 414
 415                 if(csystem && csystem->get_emm_type)
 416                 {
 417                         if(!csystem->get_emm_type(ep, aureader))
 418                         {
 419                                 rdr_log_dbg(aureader, D_EMM, "emm skipped, get_emm_type() returns error");
 420                                 emmnok++;
 421                                 continue;
 422                         }
 423                 }
 424
 425                 if(!ep->skip_filter_check && csystem && csystem->get_emm_filter)
 426                 {
 427                         if(!do_simple_emm_filter(aureader, csystem, ep, 1)) // do check with dvbapi fixup enabled
 428                         {
 429                                 if(!do_simple_emm_filter(aureader, csystem, ep, 0)) // do check with dvbapi fixup disabled
 430                                 {
 431                                         rdr_log_dbg(aureader, D_EMM, "emm skipped, do_simple_emm_filter() returns invalid");
 432                                         emmnok++;
 433                                         continue;
 434                                 }
 435                         }
 436                 }
 437
 438                 if(csystem && csystem->do_emm_reassembly)
 439                 {
 440                         if(assemble)
 441                         {
 442                                 if(!csystem->do_emm_reassembly(aureader, client, ep))
 443                                         { continue; } // skip this reader
 444                         }
 445                         else
 446                         {
 447                                 rdr_log_dbg(aureader, D_EMM, "processing raw emm");
 448                         }
 449                 }
 450
 451                 rdr_log_dbg_sensitive(aureader, D_EMM, "emmtype %s. Reader serial {%s}.", typtext[ep->type],
 452                                                                  cs_hexdump(0, aureader->hexserial, 8, tmp, sizeof(tmp)));
 453                 rdr_log_dbg_sensitive(aureader, D_EMM, "emm UA/SA: {%s}.",
 454                                                                  cs_hexdump(0, ep->hexserial, 8, tmp, sizeof(tmp)));
 455
 456                 client->last = time(NULL);
 457
 458                 int32_t is_blocked = 0;
 459
 460                 if (aureader->fix_07 == 1 && ep->type == UNIQUE)
 461                 {
 462                         if((caid == 0x098D || caid == 0x098C || caid == 0x09C4) && ep->emm[1] == 0x70 && (ep->emm[8] * 0x100 + ep->emm[9] != 0x200))
 463                         {
 464                                 rdr_log(aureader,"emmtype 0x%04X marked as unknown for caid 0x%04X", (ep->emm[8] * 0x100 + ep->emm[9]),caid);
 465                                 ep->type = UNKNOWN;
 466                         }
 467
 468                         if((caid == 0x098D || caid == 0x098C || caid == 0x09C4) && ep->emm[1] == 0 && (ep->emm[4] * 0x100 + ep->emm[5] != 0x200))
 469                         {
 470                                 rdr_log(aureader,"emmtype 0x%04X marked as unknown for caid 0x%04X", (ep->emm[4] * 0x100 + ep->emm[5]),caid);
 471                                 ep->type = UNKNOWN;
 472                         }
 473
 474                         if(caid == 0x09AF && ep->emm[1] == 0x70 && ep->emm[11] != 2)
 475                         {
 476                                 rdr_log(aureader,"emmtype 0x%02X marked as unknown for caid 0x%04X", ep->emm[11],caid);
 477                                 ep->type = UNKNOWN;
 478                         }
 479
 480                         if(caid == 0x09AF && ep->emm[1] == 0 && ep->emm[7] != 2)
 481                         {
 482                                 rdr_log(aureader,"emmtype 0x%02X marked as unknown for caid 0x%04X", ep->emm[7],caid);
 483                                 ep->type = UNKNOWN;
 484                         }
 485                 }
 486
 487                 switch(ep->type)
 488                 {
 489                 case UNKNOWN:
 490                         is_blocked = (aureader->blockemm & EMM_UNKNOWN) == EMM_UNKNOWN;
 491                         break;
 492                 case UNIQUE :
 493                         is_blocked = (aureader->blockemm & EMM_UNIQUE) == EMM_UNIQUE;
 494                         break;
 495                 case SHARED :
 496                         is_blocked = (aureader->blockemm & EMM_SHARED) == EMM_SHARED;
 497                         break;
 498                 case GLOBAL :
 499                         is_blocked = (aureader->blockemm & EMM_GLOBAL) == EMM_GLOBAL;
 500                         break;
 501                 }
 502
 503                 // if not already blocked we check for block by len
 504                 if(!is_blocked) { is_blocked = cs_emmlen_is_blocked(aureader, SCT_LEN(ep->emm)-3) ; }
 505
 506                 if(is_blocked != 0)
 507                 {
 508 #ifdef WEBIF
 509                         aureader->emmblocked[ep->type]++;
 510                         aureader->webif_emmblocked[ep->type]++;
 511                         is_blocked = aureader->emmblocked[ep->type];
 512 #endif
 513                         /* we have to write the log for blocked EMM here because
 514                          this EMM never reach the reader module where the rest
 515                          of EMM log is done. */
 516                         if(aureader->logemm & 0x08)
 517                         {
 518                                 rdr_log(aureader, "%s emmtype=%s, len=%d (hex: 0x%02X), idx=0, cnt=%d: blocked (0 ms)",
 519                                                 client->account->usr,
 520                                                 typtext[ep->type],
 521                                                 SCT_LEN(ep->emm)-3,
 522                                                 SCT_LEN(ep->emm)-3,
 523                                                 is_blocked);
 524                         }
 525                         saveemm(aureader, ep, "blocked");
 526                         continue;
 527                 }
 528
 529                 client->lastemm = time((time_t *)0);
 530
 531                 client->emmok++;
 532                 if(client->account)
 533                         { client->account->emmok++; }
 534                 first_client->emmok++;
 535
 536                 ep->client = client;
 537
 538                 int32_t writeemm = 1; // 0= dont write emm, 1=write emm, default = write
 539
 540                 if(aureader->cachemm && !(caid_is_irdeto(caid) || caid_is_videoguard(caid))) //Check emmcache early:
 541                 {
 542                         unsigned char md5tmp[MD5_DIGEST_LENGTH];
 543
 544                         MD5(ep->emm, SCT_LEN(ep->emm), md5tmp);
 545
 546                         struct s_emmcache *emmcache = find_emm_cache(md5tmp); // check emm cache
 547                         if(emmcache && !lastseendone)
 548                         {
 549                                 cs_ftime(&emmcache->lastseen);
 550                                 lastseendone = true; // in case several aureaders, only do lastseen once!
 551                         }
 552
 553                         struct s_emmstat *emmstat = get_emm_stat(aureader, md5tmp, ep->type);
 554                         if(emmstat)
 555                         {
 556                                 rdr_log_dbg(aureader, D_EMM, "emm count %d rewrite %d", emmstat->count, aureader->rewritemm);
 557
 558                                 if(emmstat->count >= aureader->rewritemm)
 559                                 {
 560                                         reader_log_emm(aureader, ep, emmstat->count, 2, NULL);
 561                                         writeemm = 0; // dont write emm!
 562                                         saveemm(aureader, ep, "emmcache");
 563                                         continue; // found emm match needs no further handling, proceed with next reader!
 564                                 }
 565                         }
 566                 }
 567
 568                 if(writeemm)   // only write on no cache hit or cache hit that needs further rewrite
 569                 {
 570                         EMM_PACKET *emm_pack;
 571                         if(cs_malloc(&emm_pack, sizeof(EMM_PACKET)))
 572                         {
 573                                 rdr_log_dbg(aureader, D_EMM, "emm is being sent to reader");
 574                                 memcpy(emm_pack, ep, sizeof(EMM_PACKET));
 575                                 add_job(aureader->client, ACTION_READER_EMM, emm_pack, sizeof(EMM_PACKET));
 576                                 saveemm(aureader, ep, "written");
 577                         }
 578                 }
 579
 580         } // done with this reader, process next reader!
 581
 582         if(emmnok > 0 && emmnok == ll_count(client->aureader_list))
 583         {
 584                 client->emmnok++;
 585                 if(client->account)
 586                         { client->account->emmnok++; }
 587                 first_client->emmnok++;
 588         }
 589 }
 590
 591
 592 int32_t reader_do_emm(struct s_reader *reader, EMM_PACKET *ep)
 593 {
 594         int32_t rc, ecs = 0,count = 0;
 595         unsigned char md5tmp[MD5_DIGEST_LENGTH];
 596         struct timeb tps;
 597
 598         cs_ftime(&tps);
 599         uint16_t caid = b2i(2, ep->caid);
 600         if(reader->cachemm && !(caid_is_irdeto(caid) || caid_is_videoguard(caid)))
 601         {
 602                 MD5(ep->emm, SCT_LEN(ep->emm), md5tmp);
 603                 int64_t gone = comp_timeb(&tps, &last_emm_clean);
 604                 if(gone > (int64_t)1000*60*60*24*30 || gone < 0) // dont run every time, only on first emm oscam is started and then every 30 days
 605                 {
 606                         last_emm_clean = tps;
 607                         count = clean_stale_emm_cache_and_stat(md5tmp, (int64_t)1000*60*60*24*30); // clean global all emms from all readers after 30 days emm is last seen!
 608                         cs_log_dbg(D_EMM, "Cleaned %d emm stale stats and cache entries", count);
 609                 }
 610
 611                 struct s_emmcache *emmcache = find_emm_cache(md5tmp); // check emm cache
 612                 if(!emmcache)
 613                 {
 614                         emm_edit_cache(md5tmp, ep, true);
 615                 }
 616
 617                 struct s_emmstat *emmstat = get_emm_stat(reader, md5tmp, ep->type);
 618                 if(emmstat)
 619                 {
 620                         if(reader->cachemm && emmstat->count >= reader->rewritemm)
 621                         {
 622                                 ecs = 2; //skip emm
 623                         }
 624                         else
 625                         {
 626                                 ecs = 1; //rewrite emm
 627                                 if(!emmstat->count)
 628                                 {
 629                                         cs_ftime(&emmstat->firstwritten);
 630                                         emmstat->lastwritten = emmstat->firstwritten;
 631                                 }
 632                                 else
 633                                 {
 634                                         cs_ftime(&emmstat->lastwritten);
 635                                 }
 636                                 count = ++emmstat->count;
 637                         }
 638                 }
 639                 else
 640                 {
 641                         cs_log("abort: oscam seems out of resources!");
 642                         return 0;
 643                 }
 644         }
 645
 646         // Ecs=0 not found in cache
 647         // Ecs=1 found in cache, rewrite emm
 648         // Ecs=2 skip
 649         if((rc = ecs) < 2)
 650         {
 651                 if(is_network_reader(reader))
 652                 {
 653                         rdr_log_dbg(reader, D_READER, "network emm reader");
 654                         if(reader->ph.c_send_emm)
 655                         {
 656                                 rc = reader->ph.c_send_emm(ep);
 657                         }
 658                         else
 659                         {
 660                                 rdr_log_dbg(reader, D_READER, "send_emm() support missing");
 661                                 rc = 0;
 662                         }
 663                 }
 664                 else
 665                 {
 666                         rdr_log_dbg(reader, D_READER, "local emm reader");
 667                         rc = cardreader_do_emm(reader, ep);
 668                 }
 669         }
 670
 671         reader_log_emm(reader, ep, count, rc, &tps);
 672
 673         return rc;
 674 }
 675
 676 void do_emm_from_file(struct s_reader *reader)
 677 {
 678         if(!reader->emmfile)
 679                 { return; }
 680
 681         char token[256];
 682         FILE *fp;
 683
 684         if(reader->emmfile[0] == '/')
 685                 { snprintf(token, sizeof(token), "%s", reader->emmfile); } //pathname included
 686         else
 687                 { get_config_filename(token, sizeof(token), reader->emmfile); } //only file specified, look in confdir for this file
 688
 689         if(!(fp = fopen(token, "rb")))
 690         {
 691                 rdr_log(reader, "ERROR: Cannot open EMM file '%s' (errno=%d %s)\n", token, errno, strerror(errno));
 692                 return;
 693         }
 694
 695         EMM_PACKET *eptmp;
 696         if(!cs_malloc(&eptmp, sizeof(EMM_PACKET)))
 697         {
 698                 fclose(fp);
 699                 return;
 700         }
 701
 702         size_t ret = fread(eptmp, sizeof(EMM_PACKET), 1, fp);
 703         if(ret < 1 && ferror(fp))
 704         {
 705                 rdr_log(reader, "ERROR: Can't read EMM from file '%s' (errno=%d %s)", token, errno, strerror(errno));
 706                 NULLFREE(eptmp);
 707                 fclose(fp);
 708                 return;
 709         }
 710         fclose(fp);
 711
 712         if (eptmp) {
 713         eptmp->caid[0] = (reader->caid >> 8) & 0xFF;
 714         eptmp->caid[1] = reader->caid & 0xFF;
 715         if(reader->nprov > 0)
 716                 { memcpy(eptmp->provid, reader->prid[0], sizeof(eptmp->provid)); }
 717         eptmp->emmlen = SCT_LEN(eptmp->emm);
 718 }
 719         const struct s_cardsystem *csystem = get_cardsystem_by_caid(reader->caid);
 720         if(csystem && csystem->get_emm_type && !csystem->get_emm_type(eptmp, reader))
 721         {
 722                 rdr_log_dbg(reader, D_EMM, "emm skipped, get_emm_type() returns error");
 723                 NULLFREE(eptmp);
 724                 return;
 725         }
 726
 727         //save old b_nano value
 728         //clear lsb and lsb+1, so no blocking, and no saving for this nano
 729         uint16_t save_s_nano = reader->s_nano;
 730         uint16_t save_b_nano = reader->b_nano;
 731         uint32_t save_saveemm = reader->saveemm;
 732
 733         reader->s_nano = reader->b_nano = 0;
 734         reader->saveemm = 0;
 735
 736     int32_t rc = 0;
 737         rc = cardreader_do_emm(reader, eptmp);
 738         if(rc == OK)
 739                 { rdr_log(reader, "EMM from file %s was successfully written.", token); }
 740         else
 741                 { rdr_log(reader, "ERROR: EMM read from file %s NOT processed correctly! (rc=%d)", token, rc); }
 742
 743         //restore old block/save settings
 744         reader->s_nano = save_s_nano;
 745         reader->b_nano = save_b_nano;
 746         reader->saveemm = save_saveemm;
 747
 748         NULLFREE(eptmp);
 749 }
 750
 751 void emm_sort_nanos(unsigned char *dest, const unsigned char *src, int32_t len)
 752 {
 753         int32_t w = 0, c = -1, j = 0;
 754         while(1)
 755         {
 756                 int32_t n = 256;
 757                 for(j = 0; j < len;)
 758                 {
 759                         int32_t l = src[j + 1] + 2;
 760                         if(src[j] == c)
 761                         {
 762                                 if(w + l > len)
 763                                 {
 764                                         cs_log_dbg(D_EMM, "sortnanos: sanity check failed. Exceeding memory area. Probably corrupted nanos!");
 765                                         memset(dest, 0, len); // zero out everything
 766                                         return;
 767                                 }
 768                                 memcpy(&dest[w], &src[j], l);
 769                                 w += l;
 770                         }
 771                         else if(src[j] > c && src[j] < n)
 772                         {
 773                                 n = src[j];
 774                         }
 775                         j += l;
 776                 }
 777                 if(n >= 256)
 778                         { break; }
 779                 c = n;
 780         }
 781 }