module-dvbapi-stapi.c

   1 #define MODULE_LOG_PREFIX "dvbstapi"
   2
   3 #include "globals.h"
   4
   5 #if defined(HAVE_DVBAPI) && defined(WITH_STAPI)
   6
   7 #include "module-dvbapi.h"
   8 #include "module-dvbapi-stapi.h"
   9 #include "oscam-client.h"
  10 #include "oscam-files.h"
  11 #include "oscam-string.h"
  12 #include "oscam-time.h"
  13
  14 extern int32_t exit_oscam;
  15
  16 struct STDEVICE
  17 {
  18         char name[20];
  19         uint32_t SessionHandle;
  20         uint32_t SignalHandle;
  21         pthread_t thread;
  22         struct filter_s demux_fd[MAX_DEMUX][MAX_FILTER];
  23 };
  24
  25 struct read_thread_param
  26 {
  27         int32_t id;
  28         struct s_client *cli;
  29 };
  30
  31 #define BUFFLEN 1024
  32 #define PROCDIR "/proc/stpti4_core/"
  33
  34 /* These functions are in liboscam_stapi.a */
  35 extern uint32_t oscam_stapi_Capability(char *name);
  36 extern char *oscam_stapi_LibVersion(void);
  37 extern uint32_t oscam_stapi_Open(char *name, uint32_t *sessionhandle);
  38 extern uint32_t oscam_stapi_SignalAllocate(uint32_t sessionhandle, uint32_t *signalhandle);
  39 extern uint32_t oscam_stapi_FilterAllocate(uint32_t sessionhandle, uint32_t *filterhandle);
  40 extern uint32_t oscam_stapi_SlotInit(uint32_t sessionhandle, uint32_t signalhandle, uint32_t *bufferhandle, uint32_t *slothandle, uint16_t pid);
  41 extern uint32_t oscam_stapi_FilterSet(uint32_t filterhandle, uchar *filt, uchar *mask);
  42 extern uint32_t oscam_stapi_FilterAssociate(uint32_t filterhandle, uint32_t slothandle);
  43 extern uint32_t oscam_stapi_SlotDeallocate(uint32_t slothandle);
  44 extern uint32_t oscam_stapi_BufferDeallocate(uint32_t bufferhandle);
  45 extern uint32_t oscam_stapi_FilterDeallocate(uint32_t filterhandle);
  46 extern uint32_t oscam_stapi_Close(uint32_t sessionhandle);
  47 extern uint32_t oscam_stapi_CheckVersion(void);
  48 extern uint32_t oscam_stapi_DescramblerAssociate(uint32_t deschandle, uint32_t slot);
  49 extern uint32_t oscam_stapi_DescramblerDisassociate(uint32_t deschandle, uint32_t slot);
  50 extern uint32_t oscam_stapi_DescramblerAllocate(uint32_t sessionhandle, uint32_t *deschandle);
  51 extern uint32_t oscam_stapi_DescramblerDeallocate(uint32_t deschandle);
  52 extern uint32_t oscam_stapi_DescramblerSet(uint32_t deschandle, int32_t parity, uchar *cw);
  53 extern uint32_t oscam_stapi_SignalWaitBuffer(uint32_t signalhandle, uint32_t *qbuffer, int32_t timeout);
  54 extern uint32_t oscam_stapi_BufferReadSection(uint32_t bufferhandle, uint32_t *filterlist, int32_t maxfilter, uint32_t *filtercount, int32_t *crc, uchar *buf, int32_t bufsize, uint32_t *size);
  55 extern uint32_t oscam_stapi_SignalAbort(uint32_t signalhandle);
  56 extern uint32_t oscam_stapi_PidQuery(char *name, uint16_t pid);
  57 extern uint32_t oscam_stapi_BufferFlush(uint32_t bufferhandle);
  58 extern uint32_t oscam_stapi_SlotClearPid(uint32_t slot);
  59
  60 // Local functions
  61 static void *stapi_read_thread(void *);
  62 static int32_t stapi_do_set_filter(int32_t demux_id, FILTERTYPE *filter, uint16_t *pids, int32_t pidcount, uchar *filt, uchar *mask, int32_t dev_id);
  63 static int32_t stapi_do_remove_filter(int32_t demux_id, FILTERTYPE *filter, int32_t dev_id);
  64
  65 // These variables are declared in module-dvbapi.c
  66 extern int32_t disable_pmt_files;
  67 extern struct s_dvbapi_priority *dvbapi_priority;
  68 extern DEMUXTYPE demux[MAX_DEMUX];
  69
  70 static int32_t stapi_on;
  71 static pthread_mutex_t filter_lock;
  72 static struct STDEVICE dev_list[PTINUM];
  73
  74 static void stapi_off(void)
  75 {
  76         int32_t i;
  77
  78         SAFE_MUTEX_LOCK(&filter_lock);
  79
  80         cs_log("stapi shutdown");
  81
  82         disable_pmt_files = 1;
  83         stapi_on = 0;
  84         for(i = 0; i < MAX_DEMUX; i++)
  85         {
  86                 dvbapi_stop_descrambling(i, 0);
  87         }
  88
  89         for(i = 0; i < PTINUM; i++)
  90         {
  91                 if(dev_list[i].SessionHandle > 0)
  92                 {
  93                         if(dev_list[i].SignalHandle > 0)
  94                         {
  95                                 oscam_stapi_SignalAbort(dev_list[i].SignalHandle);
  96                         }
  97                         pthread_cancel(dev_list[i].thread);
  98                 }
  99         }
 100
 101         SAFE_MUTEX_UNLOCK(&filter_lock);
 102         sleep(2);
 103         return;
 104 }
 105
 106 int32_t stapi_open(void)
 107 {
 108         uint32_t ErrorCode;
 109
 110         DIR *dirp;
 111         struct dirent entry, *dp = NULL;
 112         struct stat buf;
 113         int32_t i;
 114         char pfad[80];
 115         stapi_on = 1;
 116         int32_t stapi_priority = 0;
 117
 118         dirp = opendir(PROCDIR);
 119         if(!dirp)
 120         {
 121                 cs_log("opendir failed (errno=%d %s)", errno, strerror(errno));
 122                 return 0;
 123         }
 124
 125         memset(dev_list, 0, sizeof(struct STDEVICE)*PTINUM);
 126
 127         if(dvbapi_priority)
 128         {
 129                 struct s_dvbapi_priority *p;
 130                 for(p = dvbapi_priority; p != NULL; p = p->next)
 131                 {
 132                         if(p->type == 's')
 133                         {
 134                                 stapi_priority = 1;
 135                                 break;
 136                         }
 137                 }
 138         }
 139
 140         if(!stapi_priority)
 141         {
 142                 cs_log("WARNING: no PTI devices defined, stapi disabled");
 143                 return 0;
 144         }
 145
 146         oscam_stapi_CheckVersion();
 147
 148         i = 0;
 149         while(!cs_readdir_r(dirp, &entry, &dp))
 150         {
 151                 if(!dp) { break; }
 152
 153                 snprintf(pfad, sizeof(pfad), "%s%s", PROCDIR, dp->d_name);
 154                 if(stat(pfad, &buf) != 0)
 155                         { continue; }
 156
 157                 if(!(buf.st_mode & S_IFDIR && strncmp(dp->d_name, ".", 1) != 0))
 158                         { continue; }
 159
 160                 int32_t do_open = 0;
 161                 struct s_dvbapi_priority *p;
 162
 163                 for(p = dvbapi_priority; p != NULL; p = p->next)
 164                 {
 165                         if(p->type != 's') { continue; }
 166                         if(strcmp(dp->d_name, p->devname) == 0)
 167                         {
 168                                 do_open = 1;
 169                                 break;
 170                         }
 171                 }
 172
 173                 if(!do_open)
 174                 {
 175                         cs_log("PTI: %s skipped", dp->d_name);
 176                         continue;
 177                 }
 178
 179                 ErrorCode = oscam_stapi_Open(dp->d_name, &dev_list[i].SessionHandle);
 180                 if(ErrorCode != 0)
 181                 {
 182                         cs_log("STPTI_Open ErrorCode: %d", ErrorCode);
 183                         continue;
 184                 }
 185
 186                 //debug
 187                 //oscam_stapi_Capability(dp->d_name);
 188
 189                 cs_strncpy(dev_list[i].name, dp->d_name, sizeof(dev_list[i].name));
 190                 cs_log("PTI: %s open %d", dp->d_name, i);
 191
 192                 ErrorCode = oscam_stapi_SignalAllocate(dev_list[i].SessionHandle, &dev_list[i].SignalHandle);
 193                 if(ErrorCode != 0)
 194                         { cs_log("SignalAllocate: ErrorCode: %d SignalHandle: %x", ErrorCode, dev_list[i].SignalHandle); }
 195
 196                 i++;
 197                 if(i >= PTINUM) { break; }
 198         }
 199         closedir(dirp);
 200
 201         if(i == 0) { return 0; }
 202
 203         SAFE_MUTEX_INIT(&filter_lock, NULL);
 204
 205         for(i = 0; i < PTINUM; i++)
 206         {
 207                 if(dev_list[i].SessionHandle == 0)
 208                         { continue; }
 209
 210                 struct read_thread_param *para;
 211                 if(!cs_malloc(&para, sizeof(struct read_thread_param)))
 212                         { return 0; }
 213                 para->id = i;
 214                 para->cli = cur_client();
 215
 216                 int32_t ret = start_thread("stapi read", stapi_read_thread, (void *)para, &dev_list[i].thread, 1, 0);
 217                 if(ret)
 218                 {
 219                         return 0;
 220                 }
 221         }
 222
 223         atexit(stapi_off);
 224
 225         cs_log("liboscam_stapi v.%s initialized", oscam_stapi_LibVersion());
 226         return 1;
 227 }
 228
 229 int32_t stapi_activate_section_filter(int32_t fd, uchar *filter, uchar *mask)
 230 {
 231         int n=0, ret=852049;
 232         while (n<3 && ret==852049) {
 233                 ret = oscam_stapi_FilterSet(fd, filter, mask);
 234                 if(ret) {
 235                         cs_log_dbg(D_DVBAPI, "Error: oscam_stapi_FilterSet; %d", ret);
 236                         cs_sleepms(50);
 237                         n++;
 238                 }
 239         }
 240         if(ret) {
 241                 cs_log("Error: stapi_activate_section_filter: %d", ret);
 242                 ret = -1;
 243         }
 244         return ret;
 245 }
 246
 247 int32_t stapi_set_filter(int32_t demux_id, uint16_t pid, uchar *filter, uchar *mask, int32_t num, char *pmtfile)
 248 {
 249         int32_t i;
 250         int32_t ret = -1;
 251         char dest[1024];
 252         uint16_t pids[1] = { pid };
 253         struct s_dvbapi_priority *p;
 254
 255         if(!pmtfile)
 256         {
 257                 cs_log_dbg(D_DVBAPI, "No valid pmtfile!");
 258                 return -1;
 259         }
 260
 261         cs_log_dbg(D_DVBAPI, "pmt file %s demux_id %d", pmtfile, demux_id);
 262
 263         for(p = dvbapi_priority; p != NULL; p = p->next)
 264         {
 265                 if(p->type != 's') { continue; }  // stapi rule?
 266                 if(strcmp(pmtfile, p->pmtfile) != 0) { continue; }  // same file?
 267
 268                 for(i = 0; i < PTINUM; i++)
 269                 {
 270                         if(strcmp(dev_list[i].name, p->devname) == 0 && p->disablefilter == 0)  // check device name and if filtering is enabled!
 271                         {
 272                                 cs_log_dbg(D_DVBAPI, "set stapi filter on %s for pid %04X", dev_list[i].name, pids[0]);
 273                                 ret = stapi_do_set_filter(demux_id, &dev_list[i].demux_fd[demux_id][num], pids, 1, filter, mask, i);
 274                                 if(ret > 0)    // success
 275                                 {
 276                                         cs_log_dbg(D_DVBAPI, "%s filter %d set (pid %04X)", dev_list[i].name, num, pid);
 277                                         return ret; // return filternumber
 278                                 }
 279                                 else   // failure
 280                                 {
 281                                         cs_log_dbg(D_DVBAPI, "Error setting new filter for pid %04X on %s!", pid, dev_list[i].name);
 282                                         return -1; // set return to error
 283                                 }
 284                         }
 285                 }
 286         }
 287
 288         if(p == NULL)
 289         {
 290                 cs_log_dbg(D_DVBAPI, "No matching S: line in oscam.dvbapi for pmtfile %s -> stop descrambling!", pmtfile);
 291                 snprintf(dest, sizeof(dest), "%s%s", TMPDIR, demux[demux_id].pmt_file);
 292                 unlink(dest); // remove obsolete pmt file
 293                 dvbapi_stop_descrambling(demux_id, 0);
 294         }
 295         return ret;
 296 }
 297
 298 int32_t stapi_remove_filter(int32_t demux_id, int32_t num, char *pmtfile)
 299 {
 300         int32_t i, ret = 0;
 301         struct s_dvbapi_priority *p;
 302
 303         if(!pmtfile) { return 0; }
 304
 305         for(p = dvbapi_priority; p != NULL; p = p->next)
 306         {
 307                 if(p->type != 's') { continue; }
 308                 if(strcmp(pmtfile, p->pmtfile) != 0)
 309                         { continue; }
 310
 311                 for(i = 0; i < PTINUM; i++)
 312                 {
 313                         if(strcmp(dev_list[i].name, p->devname) == 0 && p->disablefilter == 0)
 314                         {
 315                                 ret = stapi_do_remove_filter(demux_id, &dev_list[i].demux_fd[demux_id][num], i);
 316                         }
 317                 }
 318         }
 319         if(ret == 1)
 320         {
 321                 cs_log_dbg(D_DVBAPI, "filter %d removed", num);
 322         }
 323         else
 324         {
 325                 cs_log_dbg(D_DVBAPI, "Error: filter %d was not removed!", num);
 326         }
 327         return ret;
 328 }
 329
 330 static uint32_t check_slot(int32_t dev_id, uint32_t checkslot, FILTERTYPE *skipfilter)
 331 {
 332         int32_t d, f, l;
 333         for(d = 0; d < MAX_DEMUX; d++)
 334         {
 335                 for(f = 0; f < MAX_FILTER; f++)
 336                 {
 337                         if(skipfilter && &dev_list[dev_id].demux_fd[d][f] == skipfilter)
 338                                 { continue; }
 339                         for(l = 0; l < dev_list[dev_id].demux_fd[d][f].NumSlots; l++)
 340                         {
 341                                 if(checkslot == dev_list[dev_id].demux_fd[d][f].SlotHandle[l])
 342                                 {
 343                                         return dev_list[dev_id].demux_fd[d][f].BufferHandle[l];
 344                                 }
 345                         }
 346                 }
 347         }
 348         return 0;
 349 }
 350
 351
 352 static int32_t stapi_do_set_filter(int32_t demux_id, FILTERTYPE *filter, uint16_t *pids, int32_t pidcount, uchar *filt, uchar *mask, int32_t dev_id)
 353 {
 354         uint32_t FilterAssociateError = 0;
 355         int32_t k, ret = 0;
 356
 357         filter->fd          = 0;
 358         filter->BufferHandle[0]     = 0;
 359         filter->SlotHandle[0]   = 0;
 360
 361         if(dev_list[dev_id].SessionHandle == 0) { return 0; }
 362
 363         uint32_t FilterAllocateError = oscam_stapi_FilterAllocate(dev_list[dev_id].SessionHandle, &filter->fd);
 364
 365         if(FilterAllocateError != 0)
 366         {
 367                 cs_log("FilterAllocate problem");
 368                 filter->fd = 0;
 369                 return 0;
 370         }
 371
 372         for(k = 0; k < pidcount; k++)
 373         {
 374                 uint16_t pid = pids[k];
 375
 376                 uint32_t QuerySlot = oscam_stapi_PidQuery(dev_list[dev_id].name, pid);
 377                 int32_t SlotInit = 1;
 378
 379                 if(QuerySlot != 0)
 380                 {
 381                         uint32_t checkslot = check_slot(dev_id, QuerySlot, NULL);
 382                         if(checkslot > 0)
 383                         {
 384                                 filter->SlotHandle[k] = QuerySlot;
 385                                 filter->BufferHandle[k] = checkslot;
 386                                 SlotInit = 0;
 387                         }
 388                         else
 389                         {
 390                                 cs_log("overtake: clear pid: %d", oscam_stapi_SlotClearPid(QuerySlot));
 391                                 SlotInit = 1;
 392                         }
 393                 }
 394
 395                 if(SlotInit == 1)
 396                 {
 397                         ret = oscam_stapi_SlotInit(dev_list[dev_id].SessionHandle, dev_list[dev_id].SignalHandle, &filter->BufferHandle[k], &filter->SlotHandle[k], pid);
 398                 }
 399
 400                 FilterAssociateError = oscam_stapi_FilterAssociate(filter->fd, filter->SlotHandle[k]);
 401                 filter->NumSlots++;
 402         }
 403
 404         uint32_t FilterSetError         = oscam_stapi_FilterSet(filter->fd, filt, mask);
 405
 406         if(ret || FilterAllocateError || FilterAssociateError || FilterSetError)
 407         {
 408                 cs_log("set_filter: dev: %d FAl: %d FAs: %d FS: %d",
 409                            dev_id, FilterAllocateError, FilterAssociateError, FilterSetError);
 410                 stapi_do_remove_filter(demux_id, filter, dev_id);
 411                 return 0;
 412         }
 413         else
 414         {
 415                 return filter->fd; // return fd of filter
 416         }
 417 }
 418
 419 static int32_t stapi_do_remove_filter(int32_t UNUSED(demux_id), FILTERTYPE *filter, int32_t dev_id)
 420 {
 421         if(filter->fd == 0) { return 0; }
 422
 423         uint32_t BufferDeallocateError = 0, SlotDeallocateError = 0;
 424
 425         if(dev_list[dev_id].SessionHandle == 0) { return 0; }
 426
 427         int32_t k;
 428         for(k = 0; k < filter->NumSlots; k++)
 429         {
 430                 uint32_t checkslot = check_slot(dev_id, filter->SlotHandle[k], filter);
 431
 432                 if(checkslot == 0)
 433                 {
 434                         BufferDeallocateError   = oscam_stapi_BufferDeallocate(filter->BufferHandle[k]);
 435                         SlotDeallocateError     = oscam_stapi_SlotDeallocate(filter->SlotHandle[k]);
 436                 }
 437         }
 438         uint32_t FilterDeallocateError      = oscam_stapi_FilterDeallocate(filter->fd);
 439
 440         memset(filter, 0, sizeof(FILTERTYPE));
 441
 442         if(BufferDeallocateError || SlotDeallocateError || FilterDeallocateError)
 443         {
 444                 cs_log("remove_filter: dev: %d BD: %d SD: %d FDe: %d",
 445                            dev_id, BufferDeallocateError, SlotDeallocateError, FilterDeallocateError);
 446                 return 0;
 447         }
 448         else
 449         {
 450                 return 1;
 451         }
 452 }
 453
 454 static void stapi_cleanup_thread(void *dev)
 455 {
 456         int32_t dev_index = (int)dev;
 457
 458         int32_t ErrorCode;
 459         ErrorCode = oscam_stapi_Close(dev_list[dev_index].SessionHandle);
 460
 461         cs_log("liboscam_stapi: PTI %s closed - %d\n", dev_list[dev_index].name, ErrorCode);
 462         dev_list[dev_index].SessionHandle = 0;
 463 }
 464
 465 static void *stapi_read_thread(void *sparam)
 466 {
 467         int32_t dev_index, ErrorCode, i, j, CRCValid;
 468         uint32_t QueryBufferHandle = 0, DataSize = 0;
 469         uchar buf[BUFFLEN];
 470
 471         struct read_thread_param *para = sparam;
 472         dev_index = para->id;
 473
 474         SAFE_SETSPECIFIC(getclient, para->cli);
 475         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 476         pthread_cleanup_push(stapi_cleanup_thread, (void *) dev_index);
 477
 478         int32_t error_count = 0;
 479
 480         while(!exit_oscam)
 481         {
 482                 QueryBufferHandle = 0;
 483                 ErrorCode = oscam_stapi_SignalWaitBuffer(dev_list[dev_index].SignalHandle, &QueryBufferHandle, 1000);
 484
 485                 switch(ErrorCode)
 486                 {
 487                 case 0: // NO_ERROR:
 488                         break;
 489                 case 852042: // ERROR_SIGNAL_ABORTED
 490                         cs_log("Caught abort signal");
 491                         pthread_exit(NULL);
 492                         break;
 493                 case 11: // ERROR_TIMEOUT:
 494                         //cs_log("timeout %d", dev_index);
 495                         //TODO: if pidindex == -1 try next
 496                         continue;
 497                         break;
 498                 default:
 499                         if(QueryBufferHandle != 0)
 500                         {
 501                                 cs_log("SignalWaitBuffer error: %d", ErrorCode);
 502                                 oscam_stapi_BufferFlush(QueryBufferHandle);
 503                                 continue;
 504                         }
 505                         cs_log("SignalWaitBuffer: index %d ErrorCode: %d - QueryBuffer: %x", dev_index, ErrorCode, QueryBufferHandle);
 506                         error_count++;
 507                         if(error_count > 10)
 508                         {
 509                                 cs_log("Too many errors in reader thread %d, quitting.", dev_index);
 510                                 pthread_exit(NULL);
 511                         }
 512                         continue;
 513                         break;
 514                 }
 515
 516                 uint32_t NumFilterMatches = 0;
 517                 int32_t demux_id = 0, filter_num = 0;
 518                 DataSize = 0;
 519                 uint32_t k;
 520
 521                 uint32_t MatchedFilterList[10];
 522                 ErrorCode = oscam_stapi_BufferReadSection(QueryBufferHandle, MatchedFilterList, 10, &NumFilterMatches, &CRCValid, buf, BUFFLEN, &DataSize);
 523
 524                 if(ErrorCode != 0)
 525                 {
 526                         cs_log("BufferRead: index: %d ErrorCode: %d", dev_index, ErrorCode);
 527                         cs_sleepms(1000);
 528                         continue;
 529                 }
 530
 531                 if(DataSize <= 0)
 532                         { continue; }
 533
 534                 SAFE_MUTEX_LOCK(&filter_lock); // don't use cs_lock() here; multiple threads using same s_client struct
 535                 for(k = 0; k < NumFilterMatches; k++)
 536                 {
 537                         for(i = 0; i < MAX_DEMUX; i++)
 538                         {
 539                                 for(j = 0; j < MAX_FILTER; j++)
 540                                 {
 541                                         if(dev_list[dev_index].demux_fd[i][j].fd == MatchedFilterList[k])
 542                                         {
 543                                                 demux_id = i;
 544                                                 filter_num = j;
 545
 546                                                 dvbapi_process_input(demux_id, filter_num, buf, DataSize, 0);
 547                                         }
 548                                 }
 549                         }
 550                 }
 551                 SAFE_MUTEX_UNLOCK(&filter_lock);
 552         }
 553
 554         pthread_cleanup_pop(0);
 555
 556         return NULL;
 557 }
 558
 559 #define ASSOCIATE 1
 560 #define DISASSOCIATE 0
 561
 562 #define DE_START 0
 563 #define DE_STOP 1
 564
 565 static void stapi_DescramblerAssociate(int32_t demux_id, uint16_t pid, int32_t mode, int32_t n)
 566 {
 567         uint32_t Slot = 0;
 568         int32_t ErrorCode = 0;
 569
 570         if(dev_list[n].SessionHandle == 0) { return; }
 571
 572         Slot = oscam_stapi_PidQuery(dev_list[n].name, pid);
 573         if(!Slot) { return; }
 574
 575         if(demux[demux_id].DescramblerHandle[n] == 0) { return; }
 576
 577         if(mode == ASSOCIATE)
 578         {
 579                 int32_t k;
 580                 for(k = 0; k < SLOTNUM; k++)
 581                 {
 582                         if(demux[demux_id].slot_assc[n][k] == Slot)
 583                         {
 584                                 return;
 585                         }
 586                 }
 587
 588                 ErrorCode = oscam_stapi_DescramblerAssociate(demux[demux_id].DescramblerHandle[n], Slot);
 589                 cs_log_dbg(D_DVBAPI, "set pid %04x on %s", pid, dev_list[n].name);
 590
 591                 if(ErrorCode != 0)
 592                         { cs_log("DescramblerAssociate %d", ErrorCode); }
 593
 594                 for(k = 0; k < SLOTNUM; k++)
 595                 {
 596                         if(demux[demux_id].slot_assc[n][k] == 0)
 597                         {
 598                                 demux[demux_id].slot_assc[n][k] = Slot;
 599                                 break;
 600                         }
 601                 }
 602         }
 603         else
 604         {
 605                 ErrorCode = oscam_stapi_DescramblerDisassociate(demux[demux_id].DescramblerHandle[n], Slot);
 606                 if(ErrorCode != 0)
 607                         { cs_log_dbg(D_DVBAPI, "DescramblerDisassociate %d", ErrorCode); }
 608
 609                 cs_log_dbg(D_DVBAPI, "unset pid %04x on %s", pid, dev_list[n].name);
 610
 611                 int32_t k;
 612                 for(k = 0; k < SLOTNUM; k++)
 613                 {
 614                         if(demux[demux_id].slot_assc[n][k] == Slot)
 615                         {
 616                                 demux[demux_id].slot_assc[n][k] = 0;
 617                                 return;
 618                         }
 619                 }
 620         }
 621
 622         return;
 623 }
 624
 625 static void stapi_startdescrambler(int32_t demux_id, int32_t dev_index, int32_t mode)
 626 {
 627         int32_t ErrorCode;
 628
 629         if(mode == DE_START && demux[demux_id].DescramblerHandle[dev_index] == 0)
 630         {
 631                 uint32_t DescramblerHandle = 0;
 632                 ErrorCode = oscam_stapi_DescramblerAllocate(dev_list[dev_index].SessionHandle, &DescramblerHandle);
 633                 if(ErrorCode != 0)
 634                 {
 635                         cs_log("DescramblerAllocate: ErrorCode: %d SignalHandle: %x", ErrorCode, dev_list[dev_index].SignalHandle);
 636                         return;
 637                 }
 638
 639                 demux[demux_id].DescramblerHandle[dev_index] = DescramblerHandle;
 640         }
 641
 642         if(mode == DE_STOP && demux[demux_id].DescramblerHandle[dev_index] > 0)
 643         {
 644                 ErrorCode = oscam_stapi_DescramblerDeallocate(demux[demux_id].DescramblerHandle[dev_index]);
 645
 646                 if(ErrorCode != 0)
 647                         { cs_log("DescramblerDeallocate: ErrorCode: %d", ErrorCode); }
 648
 649                 demux[demux_id].DescramblerHandle[dev_index] = 0;
 650         }
 651
 652         return;
 653 }
 654
 655 int32_t stapi_set_pid(int32_t demux_id, int32_t UNUSED(num), ca_index_t idx, uint16_t UNUSED(pid), char *UNUSED(pmtfile))
 656 {
 657         int32_t n;
 658
 659         if(idx == INDEX_INVALID)
 660         {
 661                 for(n = 0; n < PTINUM; n++)
 662                 {
 663                         if(demux[demux_id].DescramblerHandle[n] == 0) { continue; }
 664
 665                         cs_log_dbg(D_DVBAPI, "stop descrambling PTI: %s", dev_list[n].name);
 666                         stapi_startdescrambler(demux_id, n, DE_STOP);
 667                         memset(demux[demux_id].slot_assc[n], 0, sizeof(demux[demux_id].slot_assc[n]));
 668                 }
 669         }
 670
 671         return 1;
 672 }
 673
 674 int32_t stapi_write_cw(int32_t demux_id, uchar *cw, uint16_t *STREAMpids, int32_t STREAMpidcount, char *pmtfile)
 675 {
 676         int32_t ErrorCode, l, n, k;
 677         unsigned char nullcw[8];
 678         memset(nullcw, 0, 8);
 679         char *text[] = { "even", "odd" };
 680
 681         if(!pmtfile) { return 0; }
 682
 683         for(n = 0; n < PTINUM; n++)
 684         {
 685                 if(dev_list[n].SessionHandle == 0) { continue; }
 686                 if(demux[demux_id].DescramblerHandle[n] == 0)
 687                 {
 688                         struct s_dvbapi_priority *p;
 689
 690                         for(p = dvbapi_priority; p != NULL; p = p->next)
 691                         {
 692                                 if(p->type != 's') { continue; }
 693                                 if(strcmp(pmtfile, p->pmtfile) != 0)
 694                                         { continue; }
 695
 696                                 if(strcmp(dev_list[n].name, p->devname) == 0)
 697                                 {
 698                                         cs_log_dbg(D_DVBAPI, "start descrambling PTI: %s", dev_list[n].name);
 699                                         stapi_startdescrambler(demux_id, n, DE_START);
 700                                 }
 701                         }
 702                 }
 703
 704                 if(demux[demux_id].DescramblerHandle[n] == 0) { continue; }
 705
 706                 for(k = 0; k < STREAMpidcount; k++)
 707                 {
 708                         stapi_DescramblerAssociate(demux_id, STREAMpids[k], ASSOCIATE, n);
 709                 }
 710         }
 711
 712         int32_t pidnum = demux[demux_id].pidindex; // get current pidindex used for descrambling
 713         ca_index_t idx = demux[demux_id].ECMpids[pidnum].index[0];
 714
 715         if(idx == INDEX_INVALID)   // if no indexer for this pid get one!
 716         {
 717                 idx = dvbapi_get_descindex(demux_id, pidnum, 0);
 718                 cs_log_dbg(D_DVBAPI, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X is using index %d", demux_id, pidnum,
 719                         demux[demux_id].ECMpids[pidnum].CAID, demux[demux_id].ECMpids[pidnum].ECM_PID, idx);
 720         }
 721
 722         for(l = 0; l < 2; l++)
 723         {
 724                 if(memcmp(cw + (l * 8), demux[demux_id].lastcw[l], 8) != 0 && (memcmp(cw + (l * 8), nullcw, 8) != 0 || demux[demux_id].ECMpids[pidnum].CAID == 0x2600))
 725                 {
 726                         for(n = 0; n < PTINUM; n++)
 727                         {
 728                                 if(demux[demux_id].DescramblerHandle[n] == 0) { continue; }
 729
 730                                 ErrorCode = oscam_stapi_DescramblerSet(demux[demux_id].DescramblerHandle[n], l, cw + (l * 8));
 731                                 if(ErrorCode != 0)
 732                                         { cs_log("DescramblerSet: ErrorCode: %d", ErrorCode); }
 733
 734                                 memcpy(demux[demux_id].lastcw[l], cw + (l * 8), 8);
 735                                 cs_log_dbg(D_DVBAPI, "write cw %s index: %d %s", text[l], demux_id, dev_list[n].name);
 736                         }
 737                 }
 738         }
 739
 740         return 1;
 741 }
 742
 743 // Needed for compatability with liboscam_stapi.a
 744 #undef cs_log
 745 void cs_log(const char *fmt, ...)
 746 {
 747         va_list params;
 748         char log_txt[512];
 749
 750         va_start(params, fmt);
 751         vsnprintf(log_txt, sizeof(log_txt), fmt, params);
 752         va_end(params);
 753
 754         cs_log_txt(MODULE_LOG_PREFIX, "%s", log_txt);
 755 }
 756
 757 #endif