oscam-conf-chk.c

   1 #define MODULE_LOG_PREFIX "config"
   2
   3 #include "globals.h"
   4 #include "oscam-array.h"
   5 #include "oscam-conf-chk.h"
   6 #include "oscam-garbage.h"
   7 #include "oscam-net.h"
   8 #include "oscam-string.h"
   9
  10 void chk_iprange(char *value, struct s_ip **base)
  11 {
  12         int32_t i = 0;
  13         char *ptr1, *ptr2, *saveptr1 = NULL;
  14         struct s_ip *fip, *lip, *cip;
  15
  16         if(!cs_malloc(&cip, sizeof(struct s_ip)))
  17                 { return; }
  18         fip = cip;
  19
  20         for(ptr1 = strtok_r(value, ",", &saveptr1); ptr1; ptr1 = strtok_r(NULL, ",", &saveptr1))
  21         {
  22                 if(i == 0)
  23                         { ++i; }
  24                 else
  25                 {
  26                         if(!cs_malloc(&cip, sizeof(struct s_ip)))
  27                                 { break; }
  28                         lip->next = cip;
  29                 }
  30
  31                 if((ptr2 = strchr(trim(ptr1), '-')))
  32                 {
  33                         *ptr2++ = '\0';
  34                         cs_inet_addr(trim(ptr1), &cip->ip[0]);
  35                         cs_inet_addr(trim(ptr2), &cip->ip[1]);
  36                 }
  37                 else
  38                 {
  39                         cs_inet_addr(ptr1, &cip->ip[0]);
  40                         IP_ASSIGN(cip->ip[1], cip->ip[0]);
  41                 }
  42                 lip = cip;
  43         }
  44         lip = *base;
  45         *base = fip;
  46         clear_sip(&lip);
  47 }
  48
  49 void chk_caidtab(char *value, CAIDTAB *caidtab)
  50 {
  51         caidtab_clear(caidtab);
  52         char *ptr, *saveptr1 = NULL;
  53         for(ptr = strtok_r(value, ",", &saveptr1); ptr; ptr = strtok_r(NULL, ",", &saveptr1))
  54         {
  55                 CAIDTAB_DATA d;
  56                 memset(&d, 0, sizeof(d));
  57                 d.mask = 0xffff;
  58                 char *caid_end_ptr = strchr(ptr, ':'); // caid_end_ptr + 1 -> cmap
  59                 if(caid_end_ptr) {
  60                         *caid_end_ptr++ = '\0';
  61                         d.cmap = a2i(caid_end_ptr, 2);
  62                         if (errno == EINVAL) continue;
  63                 }
  64                 char *mask_start_ptr = strchr(ptr, '&'); // mask_start_ptr + 1 -> mask
  65                 errno = 0;
  66                 if(mask_start_ptr) { // Mask is optional
  67                         *mask_start_ptr++ = '\0';
  68                         d.mask = a2i(mask_start_ptr, 2);
  69                         if (errno == EINVAL) continue;
  70                 }
  71                 d.caid = a2i(ptr, 2);
  72                 if (errno == EINVAL) continue;
  73                 if (d.caid || d.cmap)
  74                         caidtab_add(caidtab, &d);
  75         }
  76 }
  77
  78 void chk_caidvaluetab(char *value, CAIDVALUETAB *caidvaluetab)
  79 {
  80         caidvaluetab_clear(caidvaluetab);
  81         char *ptr, *saveptr1 = NULL;
  82         for(ptr = strtok_r(value, ",", &saveptr1); ptr; ptr = strtok_r(NULL, ",", &saveptr1))
  83         {
  84                 CAIDVALUETAB_DATA d;
  85                 memset(&d, 0, sizeof(d));
  86                 char *caid_end_ptr = strchr(ptr, ':'); // caid_end_ptr + 1 -> value
  87                 if(!caid_end_ptr)
  88                         continue;
  89                 *caid_end_ptr++ = '\0';
  90                 errno = 0;
  91                 d.caid = a2i(ptr, 2);
  92                 if (errno == EINVAL)
  93                         continue;
  94                 d.value = atoi(caid_end_ptr);
  95                 if (d.caid && d.value < 10000)
  96                         caidvaluetab_add(caidvaluetab, &d);
  97         }
  98 }
  99
 100 void chk_cacheex_valuetab(char *lbrlt, CECSPVALUETAB *tab)
 101 {
 102         //[caid][&mask][@provid][$servid][:awtime][:]dwtime
 103         char *ptr = NULL, *saveptr1 = NULL;
 104         cecspvaluetab_clear(tab);
 105
 106         int32_t i;
 107         for(i = 0, ptr = strtok_r(lbrlt, ",", &saveptr1); (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++)
 108         {
 109                 CECSPVALUETAB_DATA d;
 110                 memset(&d, 0, sizeof(d));
 111
 112                 int32_t caid = -1, cmask = -1, srvid = -1;
 113                 int32_t j, provid = -1;
 114                 int16_t awtime = -1, dwtime = -1;
 115                 char *ptr1 = NULL, *ptr2 = NULL, *ptr3 = NULL, *ptr4 = NULL, *ptr5 = NULL, *saveptr2 = NULL;
 116
 117                 if((ptr4 = strchr(trim(ptr), ':')))
 118                 {
 119                         //awtime & dwtime
 120                         *ptr4++ = '\0';
 121                         for(j = 0, ptr5 = strtok_r(ptr4, ":", &saveptr2); (j < 2) && ptr5; ptr5 = strtok_r(NULL, ":", &saveptr2), j++)
 122                         {
 123                                 if(!j)
 124                                 {
 125                                         dwtime = atoi(ptr5);
 126                                 }
 127                                 if(j)
 128                                 {
 129                                         awtime = dwtime;
 130                                         dwtime = atoi(ptr5);
 131                                 }
 132                         }
 133                 }
 134                 if((ptr3 = strchr(trim(ptr), '$')))
 135                 {
 136                         *ptr3++ = '\0';
 137                         srvid = a2i(ptr3, 4);
 138                 }
 139                 if((ptr2 = strchr(trim(ptr), '@')))
 140                 {
 141                         *ptr2++ = '\0';
 142                         provid = a2i(ptr2, 6);
 143                 }
 144                 if((ptr1 = strchr(ptr, '&')))
 145                 {
 146                         *ptr1++ = '\0';
 147                         cmask = a2i(ptr1, -2);
 148                 }
 149                 if(!ptr1 && !ptr2 && !ptr3 && !ptr4)  //only dwtime
 150                         { dwtime = atoi(ptr); }
 151                 else
 152                         { caid = a2i(ptr, 2); }
 153                 if((i == 0 && (caid <= 0)) || (caid > 0))
 154                 {
 155                         d.caid = caid;
 156                         d.cmask = cmask;
 157                         d.prid = provid;
 158                         d.srvid = srvid;
 159                         d.awtime = awtime;
 160                         d.dwtime = dwtime;
 161                         cecspvaluetab_add(tab, &d);
 162                 }
 163         }
 164 }
 165
 166
 167 void chk_cacheex_cwcheck_valuetab(char *lbrlt, CWCHECKTAB *tab)
 168 {
 169         //caid[&mask][@provid][$servid]:mode:counter
 170         int32_t i;
 171         char *ptr = NULL, *saveptr1 = NULL;
 172         cwcheckvaluetab_clear(tab);
 173
 174         for(i = 0, ptr = strtok_r(lbrlt, ",", &saveptr1); (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++)
 175         {
 176                 CWCHECKTAB_DATA d;
 177                 memset(&d, 0, sizeof(d));
 178
 179                 int32_t caid = -1, cmask = -1, provid = -1, srvid = -1;
 180                 int16_t mode = -1, counter = -1;
 181
 182                 char *ptr1 = NULL, *ptr2 = NULL, *ptr3 = NULL, *ptr4 = NULL, *ptr5 = NULL, *saveptr2 = NULL;
 183
 184                 if((ptr4 = strchr(trim(ptr), ':')))
 185                 {
 186                         *ptr4++ = '\0';
 187                         ptr5 = strtok_r(ptr4, ":", &saveptr2);
 188                         if(ptr5) mode = atoi(ptr5);
 189                         ptr5 = strtok_r(NULL, ":", &saveptr2);
 190                         if(ptr5) counter = atoi(ptr5);
 191                 }
 192                 if((ptr3 = strchr(trim(ptr), '$')))
 193                 {
 194                         *ptr3++ = '\0';
 195                         srvid = a2i(ptr3, 4);
 196                 }
 197                 if((ptr2 = strchr(trim(ptr), '@')))
 198                 {
 199                         *ptr2++ = '\0';
 200                         provid = a2i(ptr2, 6);
 201                 }
 202                 if((ptr1 = strchr(ptr, '&')))
 203                 {
 204                         *ptr1++ = '\0';
 205                         cmask = a2i(ptr1, -2);
 206                 }
 207
 208                 caid = a2i(ptr, 2);
 209
 210                 if((i == 0 && (caid <= 0)) || (caid > 0))
 211                 {
 212                         d.caid = caid;
 213                         d.cmask = cmask;
 214                         d.prid = provid;
 215                         d.srvid = srvid;
 216                         d.mode = mode;
 217                         d.counter = counter;
 218                         cwcheckvaluetab_add(tab, &d);
 219                 }
 220
 221         }
 222 }
 223
 224
 225 void chk_cacheex_hitvaluetab(char *lbrlt, CECSPVALUETAB *tab)
 226 {
 227         //[caid][&mask][@provid][$servid]
 228         int32_t i;
 229         char *ptr = NULL, *saveptr1 = NULL;
 230         cecspvaluetab_clear(tab);
 231
 232         for(i = 0, ptr = strtok_r(lbrlt, ",", &saveptr1); (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++)
 233         {
 234                 CECSPVALUETAB_DATA d;
 235                 memset(&d, 0, sizeof(d));
 236
 237                 int32_t caid = -1, cmask = -1, srvid = -1;
 238                 int32_t provid = -1;
 239                 char *ptr1 = NULL, *ptr2 = NULL, *ptr3 = NULL;
 240
 241                 if((ptr3 = strchr(trim(ptr), '$')))
 242                 {
 243                         *ptr3++ = '\0';
 244                         srvid = a2i(ptr3, 4);
 245                 }
 246                 if((ptr2 = strchr(trim(ptr), '@')))
 247                 {
 248                         *ptr2++ = '\0';
 249                         provid = a2i(ptr2, 6);
 250                 }
 251                 if((ptr1 = strchr(ptr, '&')))
 252                 {
 253                         *ptr1++ = '\0';
 254                         cmask = a2i(ptr1, -2);
 255                 }
 256                 caid = a2i(ptr, 2);
 257                 if(caid > 0)
 258                 {
 259                         d.caid = caid;
 260                         d.cmask = cmask;
 261                         d.prid = provid;
 262                         d.srvid = srvid;
 263                         cecspvaluetab_add(tab, &d);
 264                 }
 265         }
 266
 267 }
 268
 269 void chk_tuntab(char *tunasc, TUNTAB *ttab)
 270 {
 271         int32_t i;
 272         tuntab_clear(ttab);
 273         errno = 0;
 274         char *caid_ptr, *savecaid_ptr = NULL;
 275         for(i = 0, caid_ptr = strtok_r(tunasc, ",", &savecaid_ptr); (caid_ptr); caid_ptr = strtok_r(NULL, ",", &savecaid_ptr), i++)
 276         {
 277                 TUNTAB_DATA d;
 278                 char *srvid_ptr  = strchr(trim(caid_ptr), '.');
 279                 char *caidto_ptr = strchr(trim(caid_ptr), ':');
 280                 if (!srvid_ptr)
 281                         continue;
 282                 *srvid_ptr++ = '\0';
 283                 if (caidto_ptr)
 284                         *caidto_ptr++ = '\0';
 285                 d.bt_caidfrom = a2i(caid_ptr, 2);
 286                 d.bt_srvid    = a2i(srvid_ptr, 2);
 287                 d.bt_caidto   = 0;
 288                 if (caidto_ptr)
 289                         d.bt_caidto = a2i(caidto_ptr, 2);
 290                 if (errno == EINVAL)
 291                         continue;
 292                 if (d.bt_caidfrom | d.bt_srvid | d.bt_caidto)
 293                         tuntab_add(ttab, &d);
 294         }
 295 }
 296
 297 void chk_services(char *labels, SIDTABS *sidtabs)
 298 {
 299         int32_t i;
 300         char *ptr, *saveptr1 = NULL;
 301         SIDTAB *sidtab;
 302         SIDTABBITS newsidok, newsidno;
 303         newsidok = newsidno = 0;
 304         for(ptr = strtok_r(labels, ",", &saveptr1); ptr; ptr = strtok_r(NULL, ",", &saveptr1))
 305         {
 306                 for(trim(ptr), i = 0, sidtab = cfg.sidtab; sidtab; sidtab = sidtab->next, i++)
 307                 {
 308                         if(!strcmp(sidtab->label, ptr)) { newsidok |= ((SIDTABBITS)1 << i); }
 309                         if((ptr[0] == '!') && (!strcmp(sidtab->label, ptr + 1))) { newsidno |= ((SIDTABBITS)1 << i); }
 310                 }
 311         }
 312         sidtabs->ok = newsidok;
 313         sidtabs->no = newsidno;
 314 }
 315
 316 void chk_ftab(char *value, FTAB *ftab)
 317 {
 318         ftab_clear(ftab);
 319         char *ptr1, *saveptr1 = NULL;
 320         errno = 0;
 321         for(ptr1 = strtok_r(value, ";", &saveptr1); (ptr1); ptr1 = strtok_r(NULL, ";", &saveptr1))
 322         {
 323                 FILTER d;
 324                 memset(&d, 0, sizeof(d));
 325                 char *caid_end_ptr = strchr(ptr1, ':'); // caid_end_ptr + 1 -> headers
 326                 if(!caid_end_ptr)
 327                         continue;
 328                 caid_end_ptr[0] = '\0';
 329                 d.caid = a2i(ptr1, 4);
 330                 if (!d.caid || errno == EINVAL)
 331                 {
 332                         errno = 0;
 333                         continue;
 334                 }
 335                 ptr1 = caid_end_ptr + 1; // -> headers
 336                 char *ident_ptr, *saveident_ptr = NULL;
 337                 for(ident_ptr = strtok_r(ptr1, ",", &saveident_ptr); ident_ptr && d.nprids < ARRAY_SIZE(d.prids); ident_ptr = strtok_r(NULL, ",", &saveident_ptr))
 338                 {
 339                         uint32_t ident = a2i(ident_ptr, 4);
 340                         if (errno == EINVAL)
 341                         {
 342                                 errno = 0;
 343                                 continue;
 344                         }
 345                         d.prids[d.nprids++] = ident;
 346                 }
 347                 if (d.nprids)
 348                         ftab_add(ftab, &d);
 349         }
 350 }
 351
 352 void chk_cltab(char *classasc, CLASSTAB *clstab)
 353 {
 354         int32_t max_an = 0, max_bn = 0;
 355         char *ptr1, *saveptr1 = NULL, *classasc_org;
 356         CLASSTAB newclstab, oldclstab;
 357         memset(&newclstab, 0, sizeof(newclstab));
 358         newclstab.an = newclstab.bn = 0;
 359
 360         if(!cs_malloc(&classasc_org, sizeof(char)*strlen(classasc)+1))
 361                 { return; }
 362
 363         cs_strncpy(classasc_org, classasc, sizeof(char)*strlen(classasc)+1);
 364
 365         for(ptr1 = strtok_r(classasc, ",", &saveptr1); ptr1; ptr1 = strtok_r(NULL, ",", &saveptr1))
 366         {
 367                 ptr1 = trim(ptr1);
 368                 if(ptr1[0] == '!')
 369                         { max_bn++; }
 370                 else
 371                         { max_an++; }
 372         }
 373
 374         if(max_an && !cs_malloc(&newclstab.aclass, sizeof(uint8_t) * max_an))
 375                 { NULLFREE(classasc_org); return; }
 376
 377         if(max_bn && !cs_malloc(&newclstab.bclass, sizeof(uint8_t) * max_bn))
 378                 { NULLFREE(newclstab.aclass); NULLFREE(classasc_org); return; }
 379
 380         classasc = classasc_org;
 381
 382         for(ptr1 = strtok_r(classasc, ",", &saveptr1); ptr1; ptr1 = strtok_r(NULL, ",", &saveptr1))
 383         {
 384                 ptr1 = trim(ptr1);
 385                 if(ptr1[0] == '!')
 386                         { newclstab.bclass[newclstab.bn++] = (uint8_t)a2i(ptr1 + 1, 2); }
 387                 else
 388                         { newclstab.aclass[newclstab.an++] = (uint8_t)a2i(ptr1, 2); }
 389         }
 390
 391         NULLFREE(classasc_org);
 392
 393         memcpy(&oldclstab, clstab, sizeof(CLASSTAB));
 394         memcpy(clstab, &newclstab, sizeof(CLASSTAB));
 395
 396         NULLFREE(oldclstab.aclass);
 397         NULLFREE(oldclstab.bclass);
 398 }
 399
 400 void chk_port_tab(char *portasc, PTAB *ptab)
 401 {
 402         int32_t i, j, nfilts, ifilt, iport;
 403         PTAB *newptab;
 404         char *ptr1, *ptr2, *ptr3, *saveptr1 = NULL;
 405         char *ptr[CS_MAXPORTS] = {0};
 406         int32_t port[CS_MAXPORTS] = {0};
 407         if(!cs_malloc(&newptab, sizeof(PTAB)))
 408                 { return; }
 409
 410         for(nfilts = i = 0, ptr1 = strtok_r(portasc, ";", &saveptr1); (i < CS_MAXPORTS) && (ptr1); ptr1 = strtok_r(NULL, ";", &saveptr1), i++)
 411         {
 412                 ptr[i] = ptr1;
 413
 414                 if(!newptab->ports[i].ncd && !cs_malloc(&newptab->ports[i].ncd, sizeof(struct ncd_port)))
 415                         { break; }
 416
 417                 if((ptr2 = strchr(trim(ptr1), '@')))
 418                 {
 419                         *ptr2++ = '\0';
 420                         newptab->ports[i].s_port = atoi(ptr1);
 421
 422                         //checking for des key for port
 423                         newptab->ports[i].ncd->ncd_key_is_set = false;
 424                         if((ptr3 = strchr(trim(ptr1), '{')))
 425                         {
 426                                 *ptr3++ = '\0';
 427                                 if(key_atob_l(ptr3, newptab->ports[i].ncd->ncd_key, sizeof(newptab->ports[i].ncd->ncd_key) * 2))
 428                                         { fprintf(stderr, "newcamd: error in DES Key for port %s -> ignored\n", ptr1); }
 429                                 else
 430                                         { newptab->ports[i].ncd->ncd_key_is_set = true; }
 431                         }
 432
 433                         ptr[i] = ptr2;
 434                         port[i] = newptab->ports[i].s_port;
 435                         newptab->nports++;
 436                 }
 437                 nfilts++;
 438         }
 439
 440         if(nfilts == 1 && strlen(portasc) < 6 && newptab->ports[0].s_port == 0)
 441         {
 442                 newptab->ports[0].s_port = atoi(portasc);
 443                 newptab->nports = 1;
 444         }
 445
 446         iport = ifilt = 0;
 447         for(i = 0; i < nfilts; i++)
 448         {
 449                 if(port[i] != 0)
 450                         { iport = i; }
 451                 for(j = 0, ptr3 = strtok_r(ptr[i], ",", &saveptr1); (j < CS_MAXPROV) && (ptr3); ptr3 = strtok_r(NULL, ",", &saveptr1), j++)
 452                 {
 453                         if((ptr2 = strchr(trim(ptr3), ':')))
 454                         {
 455                                 *ptr2++ = '\0';
 456                                 ifilt = newptab->ports[iport].ncd->ncd_ftab.nfilts++;
 457                                 j = 0;
 458                                 newptab->ports[iport].ncd->ncd_ftab.filts[ifilt].caid = (uint16_t)a2i(ptr3, 4);
 459                                 newptab->ports[iport].ncd->ncd_ftab.filts[ifilt].prids[j] = a2i(ptr2, 6);
 460                         }
 461                         else
 462                         {
 463                                 newptab->ports[iport].ncd->ncd_ftab.filts[ifilt].prids[j] = a2i(ptr3, 6);
 464                         }
 465                         newptab->ports[iport].ncd->ncd_ftab.filts[ifilt].nprids++;
 466                 }
 467         }
 468         memcpy(ptab, newptab, sizeof(PTAB));
 469         NULLFREE(newptab);
 470 }
 471
 472 void chk_port_camd35_tab(char *portasc, PTAB *ptab)
 473 {
 474         int32_t i, j, nfilts;
 475         PTAB *newptab;
 476         char *ptr1, *ptr2, *ptr4, *provids, *saveptr1 = NULL, *saveptr2 = NULL;
 477         if(!cs_malloc(&newptab, sizeof(PTAB)))
 478                 { return; }
 479
 480         for(nfilts = i = 0, ptr1 = strtok_r(portasc, ";", &saveptr1); (i < CS_MAXPORTS) && (ptr1); ptr1 = strtok_r(NULL, ";", &saveptr1), i++)
 481         {
 482                 if(!newptab->ports[newptab->nports].ncd && !cs_malloc(&newptab->ports[i].ncd, sizeof(struct ncd_port)))
 483                         { break; }
 484                 newptab->ports[newptab->nports].s_port = atoi(ptr1);
 485                 if((ptr2 = strchr(trim(ptr1), '@')))
 486                 {
 487                         *ptr2++ = '\0'; // clean up @ symbol
 488                         newptab->ports[newptab->nports].s_port = atoi(ptr1);
 489                         if((provids = strchr(trim(ptr2), ':')))
 490                                 {
 491                                         *provids++ = '\0'; // clean up : symbol
 492                                         for(j = 0, ptr4 = strtok_r(provids, ",", &saveptr2); (i < CS_MAXPORTS) && (ptr4); ptr4 = strtok_r(NULL, ",", &saveptr2), j++)
 493                                         {
 494                                                 newptab->ports[newptab->nports].ncd->ncd_ftab.filts[0].prids[j] = a2i(ptr4, 6);
 495                                         }
 496                                         newptab->ports[newptab->nports].ncd->ncd_ftab.filts[0].nprids=j;
 497                                 }
 498                         newptab->ports[newptab->nports].ncd->ncd_ftab.filts[0].caid = (uint16_t)a2i(ptr2, sizeof(ptr2));
 499                         newptab->nports++;
 500                 }
 501                 else
 502                 {
 503                         newptab->ports[newptab->nports].s_port = atoi(ptr1);
 504                         if (newptab->ports[newptab->nports].s_port) { newptab->nports++; };
 505                 }
 506                 nfilts++;
 507         }
 508         memcpy(ptab, newptab, sizeof(PTAB));
 509         NULLFREE(newptab);
 510 }
 511
 512 void chk_ecm_whitelist(char *value, ECM_WHITELIST *ecm_whitelist)
 513 {
 514         ecm_whitelist_clear(ecm_whitelist);
 515         char *ptr, *saveptr1 = NULL;
 516         for(ptr = strtok_r(value, ";", &saveptr1); ptr; ptr = strtok_r(NULL, ";", &saveptr1))
 517         {
 518                 ECM_WHITELIST_DATA d;
 519                 memset(&d, 0, sizeof(d));
 520                 char *caid_end_ptr = strchr(ptr, ':'); // caid_end_ptr + 1 -> headers
 521                 char *provid_ptr = strchr(ptr, '@'); // provid_ptr + 1 -> provid
 522                 char *headers = ptr;
 523                 if(caid_end_ptr)
 524                 {
 525                         caid_end_ptr[0] = '\0';
 526                         if (provid_ptr)
 527                         {
 528                                 provid_ptr[0] = '\0';
 529                                 provid_ptr++;
 530                                 d.ident = a2i(provid_ptr, 6);
 531                         }
 532                         d.caid = dyn_word_atob(ptr);
 533                         headers = caid_end_ptr + 1; // -> headers
 534                 } else if(provid_ptr) {
 535                         provid_ptr[0] = '\0';
 536                         d.ident = a2i(provid_ptr, 6);
 537                 }
 538                 if (d.caid == 0xffff) d.caid = 0;
 539                 if (d.ident == 0xffff) d.ident = 0;
 540                 char *len_ptr, *savelen_ptr = NULL;
 541                 for(len_ptr = strtok_r(headers, ",", &savelen_ptr); len_ptr; len_ptr = strtok_r(NULL, ",", &savelen_ptr))
 542                 {
 543                         d.len = dyn_word_atob(len_ptr);
 544                         if (d.len == 0xffff)
 545                                 continue;
 546                         ecm_whitelist_add(ecm_whitelist, &d);
 547                 }
 548         }
 549 }
 550
 551 void chk_ecm_hdr_whitelist(char *value, ECM_HDR_WHITELIST *ecm_hdr_whitelist)
 552 {
 553         ecm_hdr_whitelist_clear(ecm_hdr_whitelist);
 554         char *ptr, *saveptr = NULL;
 555         for(ptr = strtok_r(value, ";", &saveptr); ptr; ptr = strtok_r(NULL, ";", &saveptr))
 556         {
 557                 ECM_HDR_WHITELIST_DATA d;
 558                 memset(&d, 0, sizeof(d));
 559                 char *caid_end_ptr = strchr(ptr, ':'); // caid_end_ptr + 1 -> headers
 560                 char *provid_ptr = strchr(ptr, '@'); // provid_ptr + 1 -> provid
 561                 char *headers = ptr;
 562                 if(caid_end_ptr)
 563                 {
 564                         caid_end_ptr[0] = '\0';
 565                         if (provid_ptr)
 566                         {
 567                                 provid_ptr[0] = '\0';
 568                                 provid_ptr++;
 569                                 d.provid = a2i(provid_ptr, 6);
 570                         }
 571                         d.caid = dyn_word_atob(ptr);
 572                         headers = caid_end_ptr + 1; // -> headers
 573                 } else if(provid_ptr) {
 574                         provid_ptr[0] = '\0';
 575                         d.provid = a2i(provid_ptr, 6);
 576                 }
 577                 if (d.caid == 0xffff) d.caid = 0;
 578                 if (d.provid == 0xffff) d.provid = 0;
 579                 char *hdr_ptr, *savehdr_ptr = NULL;
 580                 for(hdr_ptr = strtok_r(headers, ",", &savehdr_ptr); hdr_ptr; hdr_ptr = strtok_r(NULL, ",", &savehdr_ptr))
 581                 {
 582                         hdr_ptr = trim(hdr_ptr);
 583                         d.len = strlen(hdr_ptr);
 584                         if (d.len / 2 > sizeof(d.header))
 585                                 d.len = sizeof(d.header) * 2;
 586                         if (d.len > 1)
 587                         {
 588                                 key_atob_l(hdr_ptr, d.header, d.len);
 589                                 ecm_hdr_whitelist_add(ecm_hdr_whitelist, &d);
 590                         }
 591                 }
 592         }
 593 }
 594
 595 /* Clears the s_ip structure provided. The pointer will be set to NULL so everything is cleared.*/
 596 void clear_sip(struct s_ip **sip)
 597 {
 598         struct s_ip *cip = *sip;
 599         for(*sip = NULL; cip != NULL; cip = cip->next)
 600         {
 601                 add_garbage(cip);
 602         }
 603 }
 604
 605 /* Clears the s_ptab struct provided by setting nfilts and nprids to zero. */
 606 void clear_ptab(struct s_ptab *ptab)
 607 {
 608         int32_t i;
 609         ptab->nports = 0;
 610         for(i = 0; i < CS_MAXPORTS; i++)
 611         {
 612                 if(ptab->ports[i].ncd)
 613                 {
 614                         ptab->ports[i].ncd->ncd_ftab.nfilts = 0;
 615                         ptab->ports[i].ncd->ncd_ftab.filts[0].nprids = 0;
 616                         NULLFREE(ptab->ports[i].ncd);
 617                         ptab->ports[i].ncd = NULL;
 618                 }
 619         }
 620 }
 621
 622 /* Clears given csptab */
 623 void clear_cacheextab(CECSPVALUETAB *ctab)
 624 {
 625         ctab->cevnum = 0;
 626         NULLFREE(ctab->cevdata);
 627 }