oscam-emm-cache.c

   1 #define MODULE_LOG_PREFIX "emmcache"
   2
   3 #include "globals.h"
   4 #include "oscam-config.h"
   5 #include "oscam-string.h"
   6 #include "oscam-emm-cache.h"
   7 #include "oscam-files.h"
   8 #include "oscam-time.h"
   9 #include "oscam-lock.h"
  10 #include "cscrypt/md5.h"
  11 #define LINESIZE 1024
  12 #define DEFAULT_LOCK_TIMEOUT 1000000
  13
  14 static LLIST *emm_cache;
  15
  16 bool emm_cache_configured(void)
  17 {
  18         struct s_reader *rdr;
  19         bool enable = false;
  20         LL_ITER itr = ll_iter_create(configured_readers);
  21         while((rdr = ll_iter_next(&itr)))
  22         {
  23                 if(rdr->cachemm == 1)
  24                 {
  25                         enable = true;
  26                 }
  27         }
  28         return enable;
  29 }
  30
  31 void emm_save_cache(void)
  32 {
  33         if(boxtype_is("dbox2")) return; // don't save emmcache on these boxes, they lack resources and will crash!
  34
  35         if(!emm_cache_configured()){
  36                 cs_log("saving emmcache disabled since no reader is using it!");
  37                 return;
  38         }
  39
  40         char fname[256];
  41         struct timeb ts, te;
  42
  43         if(!cfg.emmlogdir)
  44         {
  45                 get_tmp_dir_filename(fname, sizeof(fname), "oscam.emmcache");
  46         }
  47         else
  48         {
  49                 get_config_filename(fname, sizeof(fname), "oscam.emmcache");
  50         }
  51         FILE *file = fopen(fname, "w");
  52
  53         if(!file)
  54         {
  55                 cs_log("can't write emmcache to file %s", fname);
  56                 return;
  57         }
  58
  59         cs_ftime(&ts);
  60         int32_t count = 0, result = 0;
  61         LL_ITER it = ll_iter_create(emm_cache);
  62         struct s_emmcache *c;
  63
  64         while((c = ll_iter_next(&it)))
  65         {
  66                 uint8_t tmp_emmd5[MD5_DIGEST_LENGTH * 2 + 1];
  67                 char_to_hex(c->emmd5, MD5_DIGEST_LENGTH, tmp_emmd5);
  68                 uint8_t tmp_emm[c->len * 2 + 1];
  69                 char_to_hex(c->emm, c->len, tmp_emm);
  70
  71                 result = fprintf(file, "%s,%ld,%ld,%02X,%04X,%s\n", tmp_emmd5, c->firstseen.time, c->lastseen.time, c->type, c->len, tmp_emm);
  72                 if(result < 0)
  73                 {
  74                         fclose(file);
  75                         result = remove(fname);
  76                         if(!result)
  77                         {
  78                                 cs_log("error writing cache -> cache file removed!");
  79                         }
  80                         else
  81                         {
  82                                 cs_log("error writing cache -> cache file could not be removed either!");
  83                         }
  84                         return;
  85                 }
  86                 count++;
  87         }
  88
  89         fclose(file);
  90         cs_ftime(&te);
  91         int64_t load_time = comp_timeb(&te, &ts);
  92         cs_log("saved %d emmcache records to %s in %"PRId64" ms", count, fname, load_time);
  93 }
  94
  95 void load_emmstat_from_file(void)
  96 {
  97         if(boxtype_is("dbox2")) return; // dont load emmstat on these boxes, they lack resources and will crash!
  98
  99         if(!emm_cache_configured()){
 100                 cs_log("loading emmstats disabled since no reader is using it!");
 101                 return;
 102         }
 103
 104         char buf[256];
 105         char fname[256];
 106         char *line;
 107         FILE *file;
 108
 109         if(!cfg.emmlogdir)
 110         {
 111                 get_tmp_dir_filename(fname, sizeof(fname), "oscam.emmstat");
 112         }
 113         else
 114         {
 115                 get_config_filename(fname, sizeof(fname), "oscam.emmstat");
 116         }
 117
 118         file = fopen(fname, "r");
 119         if(!file)
 120         {
 121                 cs_log_dbg(D_TRACE, "can't read emmstats from file %s", fname);
 122                 return;
 123         }
 124
 125         if(!cs_malloc(&line, LINESIZE))
 126         {
 127                 fclose(file);
 128                 return;
 129         }
 130
 131         struct timeb ts, te;
 132         cs_ftime(&ts);
 133
 134         struct s_reader *rdr = NULL;
 135         struct s_emmstat *s;
 136
 137         int32_t i = 1;
 138         int32_t valid = 0;
 139         int32_t count = 0;
 140         char *ptr, *saveptr1 = NULL;
 141         char *split[7];
 142
 143         while(fgets(line, LINESIZE, file))
 144         {
 145                 if(!line[0] || line[0] == '#' || line[0] == ';')
 146                         { continue; }
 147
 148                 if(!cs_malloc(&s, sizeof(struct s_emmstat)))
 149                         { continue; }
 150
 151                 for(i = 0, ptr = strtok_r(line, ",", &saveptr1); ptr && i < 7 ; ptr = strtok_r(NULL, ",", &saveptr1), i++)
 152                 { split[i] = ptr; }
 153
 154                 valid = (i == 6);
 155                 if(valid)
 156                 {
 157                         cs_strncpy(buf, split[0], sizeof(buf));
 158                         key_atob_l(split[1], s->emmd5, MD5_DIGEST_LENGTH * 2);
 159                         s->firstwritten.time = atol(split[2]);
 160                         s->lastwritten.time = atol(split[3]);
 161                         s->type = a2i(split[4], 2);
 162                         s->count = a2i(split[5], 4);
 163
 164                         LL_ITER itr = ll_iter_create(configured_readers);
 165
 166                         while((rdr = ll_iter_next(&itr)))
 167                         {
 168                                 if(rdr->cachemm !=1) // skip: emmcache save is disabled
 169                                 {
 170                                         continue;
 171                                 }
 172
 173                                 if(strcmp(rdr->label, buf) == 0)
 174                                 {
 175                                         break;
 176                                 }
 177                         }
 178
 179                         if(rdr != NULL)
 180                         {
 181                                 if(!rdr->emmstat)
 182                                 {
 183                                         rdr->emmstat = ll_create("emmstat");
 184                                         cs_lock_create(__func__, &rdr->emmstat_lock, rdr->label, DEFAULT_LOCK_TIMEOUT);
 185                                 }
 186
 187                                 ll_append(rdr->emmstat, s);
 188                                 count++;
 189                         }
 190                         else
 191                         {
 192                                 cs_log("emmstats could not be loaded for %s", buf);
 193                                 NULLFREE(s);
 194                         }
 195                 }
 196                 else
 197                 {
 198                         cs_log_dbg(D_EMM, "emmstat ERROR: %s count=%d type=%d", buf, s->count, s->type);
 199                         NULLFREE(s);
 200                 }
 201         }
 202
 203         fclose(file);
 204         NULLFREE(line);
 205
 206         cs_ftime(&te);
 207         int64_t load_time = comp_timeb(&te, &ts);
 208         cs_log("loaded %d emmstat records from %s in %"PRId64" ms", count, fname, load_time);
 209 }
 210
 211 void save_emmstat_to_file(void)
 212 {
 213         if(boxtype_is("dbox2")) return; // don't save emmstat on these boxes, they lack resources and will crash!
 214
 215         if(!emm_cache_configured())
 216         {
 217                 cs_log("saving emmstats disabled since no reader is using it!");
 218                 return;
 219         }
 220
 221         char fname[256];
 222
 223         if(!cfg.emmlogdir)
 224         {
 225                 get_tmp_dir_filename(fname, sizeof(fname), "oscam.emmstat");
 226         }
 227         else
 228         {
 229                 get_config_filename(fname, sizeof(fname), "oscam.emmstat");
 230         }
 231         FILE *file = fopen(fname, "w");
 232
 233         if(!file)
 234         {
 235                 cs_log("can't write to file %s", fname);
 236                 return;
 237         }
 238
 239         struct timeb ts, te;
 240         cs_ftime(&ts);
 241
 242         int32_t count = 0, result = 0;
 243         struct s_reader *rdr;
 244         LL_ITER itr = ll_iter_create(configured_readers);
 245         while((rdr = ll_iter_next(&itr)))
 246         {
 247                 if(!rdr->cachemm || rdr->cachemm == 2)
 248                 {
 249                         cs_log("reader %s skipped since emmcache save is disabled", rdr->label);
 250                         continue;
 251                 }
 252
 253                 if(rdr->emmstat)
 254                 {
 255                         cs_writelock(__func__, &rdr->emmstat_lock);
 256                         LL_ITER it = ll_iter_create(rdr->emmstat);
 257                         struct s_emmstat *s;
 258                         while((s = ll_iter_next(&it)))
 259                         {
 260                                 uint8_t tmp_emmd5[MD5_DIGEST_LENGTH * 2 + 1];
 261                                 char_to_hex(s->emmd5, MD5_DIGEST_LENGTH, tmp_emmd5);
 262                                 result = fprintf(file, "%s,%s,%ld,%ld,%02X,%04X\n", rdr->label, tmp_emmd5, s->firstwritten.time, s->lastwritten.time, s->type, s->count);
 263                                 if(result < 0)
 264                                 {
 265                                         cs_writeunlock(__func__, &rdr->emmstat_lock);
 266                                         fclose(file);
 267                                         result = remove(fname);
 268                                         if(!result)
 269                                         {
 270                                                 cs_log("error writing stats -> stat file removed!");
 271                                         }
 272                                         else
 273                                         {
 274                                                 cs_log("error writing stats -> stat file could not be removed either!");
 275                                         }
 276                                         return;
 277                                 }
 278                                 count++;
 279                         }
 280                         cs_writeunlock(__func__, &rdr->emmstat_lock);
 281                 }
 282         }
 283
 284         fclose(file);
 285
 286         cs_ftime(&te);
 287         int64_t load_time = comp_timeb(&te, &ts);
 288
 289         cs_log("saved %d emmstat records to %s in %"PRId64" ms", count, fname, load_time);
 290 }
 291
 292 void emm_load_cache(void)
 293 {
 294         if(boxtype_is("dbox2")) return; // don't load emmcache on these boxes, they lack resources and will crash!
 295
 296         if(!emm_cache_configured()){
 297                 cs_log("loading emmcache disabled since no reader is using it!");
 298                 return;
 299         }
 300
 301         char fname[256];
 302         char line[1024];
 303         FILE *file;
 304         struct s_emmcache *c;
 305
 306         if(!cfg.emmlogdir)
 307         {
 308                 get_tmp_dir_filename(fname, sizeof(fname), "oscam.emmcache");
 309         }
 310         else
 311         {
 312                 get_config_filename(fname, sizeof(fname), "oscam.emmcache");
 313         }
 314
 315         file = fopen(fname, "r");
 316         if(!file)
 317         {
 318                 cs_log_dbg(D_TRACE, "can't read emmcache from file %s", fname);
 319                 return;
 320         }
 321
 322         struct timeb ts, te;
 323         cs_ftime(&ts);
 324
 325         int32_t count = 0;
 326         int32_t i = 1;
 327         int32_t valid = 0;
 328         char *ptr, *saveptr1 = NULL;
 329         char *split[7];
 330
 331         memset(line, 0, sizeof(line));
 332         while(fgets(line, sizeof(line), file))
 333         {
 334                 if(!line[0] || line[0] == '#' || line[0] == ';')
 335                         { continue; }
 336
 337                 for(i = 0, ptr = strtok_r(line, ",", &saveptr1); ptr && i < 7 ; ptr = strtok_r(NULL, ",", &saveptr1), i++)
 338                 {
 339                         split[i] = ptr;
 340                 }
 341
 342                 valid = (i == 6);
 343                 if(valid)
 344                 {
 345                         if(!cs_malloc(&c, sizeof(struct s_emmcache)))
 346                         { continue; }
 347                         key_atob_l(split[0], c->emmd5, MD5_DIGEST_LENGTH*2);
 348                         c->firstseen.time = atol(split[1]);
 349                         c->lastseen.time = atol(split[2]);
 350                         c->type = a2i(split[3], 2);
 351                         c->len = a2i(split[4], 4);
 352                         key_atob_l(split[5], c->emm, c->len*2);
 353
 354                         if(valid && c->len != 0)
 355                         {
 356                                 if(!emm_cache)
 357                                 {
 358                                         emm_cache = ll_create("emm cache");
 359                                 }
 360
 361                                 ll_append(emm_cache, c);
 362                                 count++;
 363                         }
 364                         else
 365                         {
 366                                 NULLFREE(c);
 367                         }
 368                 }
 369         }
 370         fclose(file);
 371         cs_ftime(&te);
 372         int64_t load_time = comp_timeb(&te, &ts);
 373         cs_log("loaded %d emmcache records from %s in %"PRId64" ms", count, fname, load_time);
 374 }
 375
 376 struct s_emmcache *find_emm_cache(uint8_t *emmd5)
 377 {
 378         struct s_emmcache *c;
 379         LL_ITER it;
 380
 381         if(!emm_cache)
 382                 { emm_cache = ll_create("emm cache"); }
 383
 384         it = ll_iter_create(emm_cache);
 385         while((c = ll_iter_next(&it)))
 386         {
 387                 if(!memcmp(emmd5, c->emmd5, MD5_DIGEST_LENGTH))
 388                 {
 389                         cs_log_dump_dbg(D_EMM, c->emmd5, MD5_DIGEST_LENGTH, "found emmcache match");
 390                         return c;
 391                 }
 392         }
 393         return NULL;
 394 }
 395
 396 int32_t clean_stale_emm_cache_and_stat(uint8_t *emmd5, int64_t gone)
 397 {
 398         struct timeb now;
 399         cs_ftime(&now);
 400         int32_t count = 0;
 401
 402         struct s_emmcache *c;
 403         LL_ITER it;
 404
 405         if(!emm_cache)
 406                 { emm_cache = ll_create("emm cache"); }
 407
 408         it = ll_iter_create(emm_cache);
 409         while((c = ll_iter_next(&it)))
 410         {
 411                 if(comp_timeb(&now, &c->lastseen) > gone && memcmp(c->emmd5, emmd5, MD5_DIGEST_LENGTH)) // clean older than gone ms and dont clean if its the current emm!
 412                 {
 413                         struct s_reader *rdr;
 414                         LL_ITER rdr_itr = ll_iter_create(configured_readers);
 415                         while((rdr = ll_iter_next(&rdr_itr)))
 416                         {
 417                                 if(rdr->emmstat && !(caid_is_irdeto(rdr->caid) || caid_is_videoguard(rdr->caid)))
 418                                 {
 419                                         remove_emm_stat(rdr, c->emmd5); // clean stale entry from stats
 420                                         count++;
 421                                 }
 422                         }
 423                         ll_iter_remove_data(&it); // clean stale entry from emmcache
 424                 }
 425         }
 426         return count;
 427 }
 428
 429 int32_t emm_edit_cache(uint8_t *emmd5, EMM_PACKET *ep, bool add)
 430 {
 431         struct s_emmcache *c;
 432         LL_ITER it;
 433         int32_t count = 0;
 434
 435         if(!emm_cache)
 436                 { emm_cache = ll_create("emm cache"); }
 437
 438         it = ll_iter_create(emm_cache);
 439         while((c = ll_iter_next(&it)))
 440         {
 441                 if(!memcmp(emmd5, c->emmd5, MD5_DIGEST_LENGTH))
 442                 {
 443                         if(add)
 444                         {
 445                                 return 0; // already added
 446                         }
 447                         ll_iter_remove_data(&it);
 448                         count++;
 449                 }
 450         }
 451
 452         if(add)
 453         {
 454                 if(!cs_malloc(&c, sizeof(struct s_emmcache)))
 455                         { return count; }
 456                 memcpy(c->emmd5, emmd5, MD5_DIGEST_LENGTH);
 457                 c->type = ep->type;
 458                 c->len = SCT_LEN(ep->emm);
 459                 cs_ftime(&c->firstseen);
 460                 c->lastseen = c->firstseen;
 461                 memcpy(c->emm, ep->emm, c->len);
 462                 ll_append(emm_cache, c);
 463 #ifdef WITH_DEBUG
 464                 cs_log_dump_dbg(D_EMM, c->emmd5, MD5_DIGEST_LENGTH, "added emm to cache:");
 465 #endif
 466                 count++;
 467         }
 468
 469         return count;
 470 }
 471
 472 int32_t remove_emm_stat(struct s_reader *rdr, uint8_t *emmd5)
 473 {
 474         int32_t count = 0;
 475         if(rdr && rdr->emmstat)
 476         {
 477                 cs_writelock(__func__, &rdr->emmstat_lock);
 478                 struct s_emmstat *c;
 479                 LL_ITER itr = ll_iter_create(rdr->emmstat);
 480                 while((c = ll_iter_next(&itr)))
 481                 {
 482                         if(!memcmp(emmd5, c->emmd5, MD5_DIGEST_LENGTH))
 483                         {
 484                                 ll_iter_remove_data(&itr);
 485                                 count++;
 486                                 break;
 487                         }
 488                 }
 489
 490                 cs_writeunlock(__func__, &rdr->emmstat_lock);
 491         }
 492         return count;
 493 }
 494
 495 struct s_emmstat *get_emm_stat(struct s_reader *rdr, uint8_t *emmd5, uint8_t emmtype)
 496 {
 497         if(!rdr->cachemm) return NULL;
 498
 499         struct s_emmstat *c;
 500         LL_ITER it;
 501
 502         if(!rdr->emmstat)
 503                 { rdr->emmstat = ll_create("emm stat"); }
 504
 505         it = ll_iter_create(rdr->emmstat);
 506         while((c = ll_iter_next(&it)))
 507         {
 508                 if(!memcmp(emmd5, c->emmd5, MD5_DIGEST_LENGTH))
 509                 {
 510                         cs_log_dump_dbg(D_EMM, c->emmd5, MD5_DIGEST_LENGTH, "found emmstat match (reader:%s, count:%d)", rdr->label, c->count);
 511                         return c;
 512                 }
 513         }
 514
 515         if(cs_malloc(&c, sizeof(struct s_emmstat)))
 516         {
 517                 memcpy(c->emmd5, emmd5, MD5_DIGEST_LENGTH);
 518                 c->type = emmtype;
 519                 ll_append(rdr->emmstat, c);
 520                 cs_log_dump_dbg(D_EMM, c->emmd5, MD5_DIGEST_LENGTH, "added emmstat (reader:%s, count:%d)", rdr->label, c->count);
 521         }
 522         return c;
 523 }