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, uint8_t *filt, uint8_t *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, uint8_t *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, uint8_t *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, uint8_t *filt, uint8_t *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, uint8_t *filter, uint8_t *mask)
 230 {
 231         int n = 0, ret = 852049;
 232         while(n < 3 && ret == 852049)
 233         {
 234                 ret = oscam_stapi_FilterSet(fd, filter, mask);
 235                 if(ret)
 236                 {
 237                         cs_log_dbg(D_DVBAPI, "Error: oscam_stapi_FilterSet; %d", ret);
 238                         cs_sleepms(50);
 239                         n++;
 240                 }
 241         }
 242
 243         if(ret)
 244         {
 245                 cs_log("Error: stapi_activate_section_filter: %d", ret);
 246                 ret = -1;
 247         }
 248         return ret;
 249 }
 250
 251 int32_t stapi_set_filter(int32_t demux_id, uint16_t pid, uint8_t *filter, uint8_t *mask, int32_t num, char *pmtfile)
 252 {
 253         int32_t i;
 254         int32_t ret = -1;
 255         char dest[1024];
 256         uint16_t pids[1] = { pid };
 257         struct s_dvbapi_priority *p;
 258
 259         if(!pmtfile)
 260         {
 261                 cs_log_dbg(D_DVBAPI, "No valid pmtfile!");
 262                 return -1;
 263         }
 264
 265         cs_log_dbg(D_DVBAPI, "pmt file %s demux_id %d", pmtfile, demux_id);
 266
 267         for(p = dvbapi_priority; p != NULL; p = p->next)
 268         {
 269                 if(p->type != 's') { continue; } // stapi rule?
 270                 if(strcmp(pmtfile, p->pmtfile) != 0) { continue; } // same file?
 271
 272                 for(i = 0; i < PTINUM; i++)
 273                 {
 274                         if(strcmp(dev_list[i].name, p->devname) == 0 && p->disablefilter == 0) // check device name and if filtering is enabled!
 275                         {
 276                                 cs_log_dbg(D_DVBAPI, "set stapi filter on %s for pid %04X", dev_list[i].name, pids[0]);
 277                                 ret = stapi_do_set_filter(demux_id, &dev_list[i].demux_fd[demux_id][num], pids, 1, filter, mask, i);
 278                                 if(ret > 0) // success
 279                                 {
 280                                         cs_log_dbg(D_DVBAPI, "%s filter %d set (pid %04X)", dev_list[i].name, num, pid);
 281                                         return ret; // return filternumber
 282                                 }
 283                                 else // failure
 284                                 {
 285                                         cs_log_dbg(D_DVBAPI, "Error setting new filter for pid %04X on %s!", pid, dev_list[i].name);
 286                                         return -1; // set return to error
 287                                 }
 288                         }
 289                 }
 290         }
 291
 292         if(p == NULL)
 293         {
 294                 cs_log_dbg(D_DVBAPI, "No matching S: line in oscam.dvbapi for pmtfile %s -> stop descrambling!", pmtfile);
 295                 snprintf(dest, sizeof(dest), "%s%s", TMPDIR, demux[demux_id].pmt_file);
 296                 unlink(dest); // remove obsolete pmt file
 297                 dvbapi_stop_descrambling(demux_id, 0);
 298         }
 299         return ret;
 300 }
 301
 302 int32_t stapi_remove_filter(int32_t demux_id, int32_t num, char *pmtfile)
 303 {
 304         int32_t i, ret = 0;
 305         struct s_dvbapi_priority *p;
 306
 307         if(!pmtfile) { return 0; }
 308
 309         for(p = dvbapi_priority; p != NULL; p = p->next)
 310         {
 311                 if(p->type != 's') { continue; }
 312                 if(strcmp(pmtfile, p->pmtfile) != 0)
 313                         { continue; }
 314
 315                 for(i = 0; i < PTINUM; i++)
 316                 {
 317                         if(strcmp(dev_list[i].name, p->devname) == 0 && p->disablefilter == 0)
 318                         {
 319                                 ret = stapi_do_remove_filter(demux_id, &dev_list[i].demux_fd[demux_id][num], i);
 320                         }
 321                 }
 322         }
 323         if(ret == 1)
 324         {
 325                 cs_log_dbg(D_DVBAPI, "filter %d removed", num);
 326         }
 327         else
 328         {
 329                 cs_log_dbg(D_DVBAPI, "Error: filter %d was not removed!", num);
 330         }
 331         return ret;
 332 }
 333
 334 static uint32_t check_slot(int32_t dev_id, uint32_t checkslot, FILTERTYPE *skipfilter)
 335 {
 336         int32_t d, f, l;
 337         for(d = 0; d < MAX_DEMUX; d++)
 338         {
 339                 for(f = 0; f < MAX_FILTER; f++)
 340                 {
 341                         if(skipfilter && &dev_list[dev_id].demux_fd[d][f] == skipfilter)
 342                                 { continue; }
 343                         for(l = 0; l < dev_list[dev_id].demux_fd[d][f].NumSlots; l++)
 344                         {
 345                                 if(checkslot == dev_list[dev_id].demux_fd[d][f].SlotHandle[l])
 346                                 {
 347                                         return dev_list[dev_id].demux_fd[d][f].BufferHandle[l];
 348                                 }
 349                         }
 350                 }
 351         }
 352         return 0;
 353 }
 354
 355
 356 static int32_t stapi_do_set_filter(int32_t demux_id, FILTERTYPE *filter, uint16_t *pids, int32_t pidcount, uint8_t *filt, uint8_t *mask, int32_t dev_id)
 357 {
 358         uint32_t FilterAssociateError = 0;
 359         int32_t k, ret = 0;
 360
 361         filter->fd = 0;
 362         filter->BufferHandle[0] = 0;
 363         filter->SlotHandle[0] = 0;
 364
 365         if(dev_list[dev_id].SessionHandle == 0) { return 0; }
 366
 367         uint32_t FilterAllocateError = oscam_stapi_FilterAllocate(dev_list[dev_id].SessionHandle, &filter->fd);
 368
 369         if(FilterAllocateError != 0)
 370         {
 371                 cs_log("FilterAllocate problem");
 372                 filter->fd = 0;
 373                 return 0;
 374         }
 375
 376         for(k = 0; k < pidcount; k++)
 377         {
 378                 uint16_t pid = pids[k];
 379
 380                 uint32_t QuerySlot = oscam_stapi_PidQuery(dev_list[dev_id].name, pid);
 381                 int32_t SlotInit = 1;
 382
 383                 if(QuerySlot != 0)
 384                 {
 385                         uint32_t checkslot = check_slot(dev_id, QuerySlot, NULL);
 386                         if(checkslot > 0)
 387                         {
 388                                 filter->SlotHandle[k] = QuerySlot;
 389                                 filter->BufferHandle[k] = checkslot;
 390                                 SlotInit = 0;
 391                         }
 392                         else
 393                         {
 394                                 cs_log("overtake: clear pid: %d", oscam_stapi_SlotClearPid(QuerySlot));
 395                                 SlotInit = 1;
 396                         }
 397                 }
 398
 399                 if(SlotInit == 1)
 400                 {
 401                         ret = oscam_stapi_SlotInit(dev_list[dev_id].SessionHandle, dev_list[dev_id].SignalHandle, &filter->BufferHandle[k], &filter->SlotHandle[k], pid);
 402                 }
 403
 404                 FilterAssociateError = oscam_stapi_FilterAssociate(filter->fd, filter->SlotHandle[k]);
 405                 filter->NumSlots++;
 406         }
 407
 408         uint32_t FilterSetError = oscam_stapi_FilterSet(filter->fd, filt, mask);
 409
 410         if(ret || FilterAllocateError || FilterAssociateError || FilterSetError)
 411         {
 412                 cs_log("set_filter: dev: %d FAl: %d FAs: %d FS: %d",
 413                                 dev_id, FilterAllocateError, FilterAssociateError, FilterSetError);
 414                 stapi_do_remove_filter(demux_id, filter, dev_id);
 415                 return 0;
 416         }
 417         else
 418         {
 419                 return filter->fd; // return fd of filter
 420         }
 421 }
 422
 423 static int32_t stapi_do_remove_filter(int32_t UNUSED(demux_id), FILTERTYPE *filter, int32_t dev_id)
 424 {
 425         if(filter->fd == 0) { return 0; }
 426
 427         uint32_t BufferDeallocateError = 0, SlotDeallocateError = 0;
 428
 429         if(dev_list[dev_id].SessionHandle == 0) { return 0; }
 430
 431         int32_t k;
 432         for(k = 0; k < filter->NumSlots; k++)
 433         {
 434                 uint32_t checkslot = check_slot(dev_id, filter->SlotHandle[k], filter);
 435
 436                 if(checkslot == 0)
 437                 {
 438                         BufferDeallocateError = oscam_stapi_BufferDeallocate(filter->BufferHandle[k]);
 439                         SlotDeallocateError = oscam_stapi_SlotDeallocate(filter->SlotHandle[k]);
 440                 }
 441         }
 442         uint32_t FilterDeallocateError = oscam_stapi_FilterDeallocate(filter->fd);
 443
 444         memset(filter, 0, sizeof(FILTERTYPE));
 445
 446         if(BufferDeallocateError || SlotDeallocateError || FilterDeallocateError)
 447         {
 448                 cs_log("remove_filter: dev: %d BD: %d SD: %d FDe: %d",
 449                                 dev_id, BufferDeallocateError, SlotDeallocateError, FilterDeallocateError);
 450                 return 0;
 451         }
 452         else
 453         {
 454                 return 1;
 455         }
 456 }
 457
 458 static void stapi_cleanup_thread(void *dev)
 459 {
 460         int32_t dev_index = (int)dev;
 461
 462         int32_t ErrorCode;
 463         ErrorCode = oscam_stapi_Close(dev_list[dev_index].SessionHandle);
 464
 465         cs_log("liboscam_stapi: PTI %s closed - %d\n", dev_list[dev_index].name, ErrorCode);
 466         dev_list[dev_index].SessionHandle = 0;
 467 }
 468
 469 static void *stapi_read_thread(void *sparam)
 470 {
 471         int32_t dev_index, ErrorCode, i, j, CRCValid;
 472         uint32_t QueryBufferHandle = 0, DataSize = 0;
 473         uint8_t buf[BUFFLEN];
 474
 475         struct read_thread_param *para = sparam;
 476         dev_index = para->id;
 477
 478         SAFE_SETSPECIFIC(getclient, para->cli);
 479         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 480         pthread_cleanup_push(stapi_cleanup_thread, (void *) dev_index);
 481
 482         int32_t error_count = 0;
 483
 484         while(!exit_oscam)
 485         {
 486                 QueryBufferHandle = 0;
 487                 ErrorCode = oscam_stapi_SignalWaitBuffer(dev_list[dev_index].SignalHandle, &QueryBufferHandle, 1000);
 488
 489                 switch(ErrorCode)
 490                 {
 491                 case 0: // NO_ERROR:
 492                         break;
 493                 case 852042: // ERROR_SIGNAL_ABORTED
 494                         cs_log("Caught abort signal");
 495                         pthread_exit(NULL);
 496                         break;
 497                 case 11: // ERROR_TIMEOUT:
 498                         //cs_log("timeout %d", dev_index);
 499                         //TODO: if pidindex == -1 try next
 500                         continue;
 501                         break;
 502                 default:
 503                         if(QueryBufferHandle != 0)
 504                         {
 505                                 cs_log("SignalWaitBuffer error: %d", ErrorCode);
 506                                 oscam_stapi_BufferFlush(QueryBufferHandle);
 507                                 continue;
 508                         }
 509                         cs_log("SignalWaitBuffer: index %d ErrorCode: %d - QueryBuffer: %x", dev_index, ErrorCode, QueryBufferHandle);
 510                         error_count++;
 511                         if(error_count > 10)
 512                         {
 513                                 cs_log("Too many errors in reader thread %d, quitting.", dev_index);
 514                                 pthread_exit(NULL);
 515                         }
 516                         continue;
 517                         break;
 518                 }
 519
 520                 uint32_t NumFilterMatches = 0;
 521                 int32_t demux_id = 0, filter_num = 0;
 522                 DataSize = 0;
 523                 uint32_t k;
 524
 525                 uint32_t MatchedFilterList[10];
 526                 ErrorCode = oscam_stapi_BufferReadSection(QueryBufferHandle, MatchedFilterList, 10, &NumFilterMatches, &CRCValid, buf, BUFFLEN, &DataSize);
 527
 528                 if(ErrorCode != 0)
 529                 {
 530                         cs_log("BufferRead: index: %d ErrorCode: %d", dev_index, ErrorCode);
 531                         cs_sleepms(1000);
 532                         continue;
 533                 }
 534
 535                 if(DataSize <= 0)
 536                         { continue; }
 537
 538                 SAFE_MUTEX_LOCK(&filter_lock); // don't use cs_lock() here; multiple threads using same s_client struct
 539                 for(k = 0; k < NumFilterMatches; k++)
 540                 {
 541                         for(i = 0; i < MAX_DEMUX; i++)
 542                         {
 543                                 for(j = 0; j < MAX_FILTER; j++)
 544                                 {
 545                                         if(dev_list[dev_index].demux_fd[i][j].fd == MatchedFilterList[k])
 546                                         {
 547                                                 demux_id = i;
 548                                                 filter_num = j;
 549
 550                                                 dvbapi_process_input(demux_id, filter_num, buf, DataSize, 0);
 551                                         }
 552                                 }
 553                         }
 554                 }
 555                 SAFE_MUTEX_UNLOCK(&filter_lock);
 556         }
 557
 558         pthread_cleanup_pop(0);
 559
 560         return NULL;
 561 }
 562
 563 #define ASSOCIATE 1
 564 #define DISASSOCIATE 0
 565
 566 #define DE_START 0
 567 #define DE_STOP 1
 568
 569 static void stapi_DescramblerAssociate(int32_t demux_id, uint16_t pid, int32_t mode, int32_t n)
 570 {
 571         uint32_t Slot = 0;
 572         int32_t ErrorCode = 0;
 573
 574         if(dev_list[n].SessionHandle == 0) { return; }
 575
 576         Slot = oscam_stapi_PidQuery(dev_list[n].name, pid);
 577         if(!Slot) { return; }
 578
 579         if(demux[demux_id].DescramblerHandle[n] == 0) { return; }
 580
 581         if(mode == ASSOCIATE)
 582         {
 583                 int32_t k;
 584                 for(k = 0; k < SLOTNUM; k++)
 585                 {
 586                         if(demux[demux_id].slot_assc[n][k] == Slot)
 587                         {
 588                                 return;
 589                         }
 590                 }
 591
 592                 ErrorCode = oscam_stapi_DescramblerAssociate(demux[demux_id].DescramblerHandle[n], Slot);
 593                 cs_log_dbg(D_DVBAPI, "set pid %04x on %s", pid, dev_list[n].name);
 594
 595                 if(ErrorCode != 0)
 596                         { cs_log("DescramblerAssociate %d", ErrorCode); }
 597
 598                 for(k = 0; k < SLOTNUM; k++)
 599                 {
 600                         if(demux[demux_id].slot_assc[n][k] == 0)
 601                         {
 602                                 demux[demux_id].slot_assc[n][k] = Slot;
 603                                 break;
 604                         }
 605                 }
 606         }
 607         else
 608         {
 609                 ErrorCode = oscam_stapi_DescramblerDisassociate(demux[demux_id].DescramblerHandle[n], Slot);
 610                 if(ErrorCode != 0)
 611                         { cs_log_dbg(D_DVBAPI, "DescramblerDisassociate %d", ErrorCode); }
 612
 613                 cs_log_dbg(D_DVBAPI, "unset pid %04x on %s", pid, dev_list[n].name);
 614
 615                 int32_t k;
 616                 for(k = 0; k < SLOTNUM; k++)
 617                 {
 618                         if(demux[demux_id].slot_assc[n][k] == Slot)
 619                         {
 620                                 demux[demux_id].slot_assc[n][k] = 0;
 621                                 return;
 622                         }
 623                 }
 624         }
 625
 626         return;
 627 }
 628
 629 static void stapi_startdescrambler(int32_t demux_id, int32_t dev_index, int32_t mode)
 630 {
 631         int32_t ErrorCode;
 632
 633         if(mode == DE_START && demux[demux_id].DescramblerHandle[dev_index] == 0)
 634         {
 635                 uint32_t DescramblerHandle = 0;
 636                 ErrorCode = oscam_stapi_DescramblerAllocate(dev_list[dev_index].SessionHandle, &DescramblerHandle);
 637                 if(ErrorCode != 0)
 638                 {
 639                         cs_log("DescramblerAllocate: ErrorCode: %d SignalHandle: %x", ErrorCode, dev_list[dev_index].SignalHandle);
 640                         return;
 641                 }
 642
 643                 demux[demux_id].DescramblerHandle[dev_index] = DescramblerHandle;
 644         }
 645
 646         if(mode == DE_STOP && demux[demux_id].DescramblerHandle[dev_index] > 0)
 647         {
 648                 ErrorCode = oscam_stapi_DescramblerDeallocate(demux[demux_id].DescramblerHandle[dev_index]);
 649
 650                 if(ErrorCode != 0)
 651                         { cs_log("DescramblerDeallocate: ErrorCode: %d", ErrorCode); }
 652
 653                 demux[demux_id].DescramblerHandle[dev_index] = 0;
 654         }
 655
 656         return;
 657 }
 658
 659 int32_t stapi_set_pid(int32_t demux_id, int32_t UNUSED(num), uint32_t idx, uint16_t UNUSED(pid), char *UNUSED(pmtfile))
 660 {
 661         int32_t n;
 662
 663         if(idx == INDEX_INVALID)
 664         {
 665                 for(n = 0; n < PTINUM; n++)
 666                 {
 667                         if(demux[demux_id].DescramblerHandle[n] == 0) { continue; }
 668
 669                         cs_log_dbg(D_DVBAPI, "stop descrambling PTI: %s", dev_list[n].name);
 670                         stapi_startdescrambler(demux_id, n, DE_STOP);
 671                         memset(demux[demux_id].slot_assc[n], 0, sizeof(demux[demux_id].slot_assc[n]));
 672                 }
 673         }
 674
 675         return 1;
 676 }
 677
 678 int32_t stapi_write_cw(int32_t demux_id, uint8_t *cw, uint16_t *STREAMpids, int32_t STREAMpidcount, char *pmtfile)
 679 {
 680         int32_t ErrorCode, l, n, k;
 681         uint8_t nullcw[8];
 682         memset(nullcw, 0, 8);
 683         char *text[] = { "even", "odd" };
 684
 685         if(!pmtfile) { return 0; }
 686
 687         for(n = 0; n < PTINUM; n++)
 688         {
 689                 if(dev_list[n].SessionHandle == 0) { continue; }
 690                 if(demux[demux_id].DescramblerHandle[n] == 0)
 691                 {
 692                         struct s_dvbapi_priority *p;
 693
 694                         for(p = dvbapi_priority; p != NULL; p = p->next)
 695                         {
 696                                 if(p->type != 's') { continue; }
 697                                 if(strcmp(pmtfile, p->pmtfile) != 0)
 698                                         { continue; }
 699
 700                                 if(strcmp(dev_list[n].name, p->devname) == 0)
 701                                 {
 702                                         cs_log_dbg(D_DVBAPI, "start descrambling PTI: %s", dev_list[n].name);
 703                                         stapi_startdescrambler(demux_id, n, DE_START);
 704                                 }
 705                         }
 706                 }
 707
 708                 if(demux[demux_id].DescramblerHandle[n] == 0) { continue; }
 709
 710                 for(k = 0; k < STREAMpidcount; k++)
 711                 {
 712                         stapi_DescramblerAssociate(demux_id, STREAMpids[k], ASSOCIATE, n);
 713                 }
 714         }
 715
 716         int32_t pidnum = demux[demux_id].pidindex; // get current pidindex used for descrambling
 717         uint32_t idx = demux[demux_id].ECMpids[pidnum].index[0];
 718
 719         if(idx == INDEX_INVALID) // if no indexer for this pid get one!
 720         {
 721                 idx = dvbapi_get_desc_index(demux_id, pidnum, 0);
 722                 cs_log_dbg(D_DVBAPI, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X is using index %d", demux_id, pidnum,
 723                         demux[demux_id].ECMpids[pidnum].CAID, demux[demux_id].ECMpids[pidnum].ECM_PID, idx);
 724         }
 725
 726         for(l = 0; l < 2; l++)
 727         {
 728                 // Skip check for BISS1 - cw could be indeed zero
 729                 // Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
 730                 if(memcmp(cw + (l * 8), demux[demux_id].last_cw[0][l], 8) != 0
 731                         && (memcmp(cw + (l * 8), nullcw, 8) != 0 || caid_is_biss(demux[demux_id].ECMpids[pidnum].CAID)))
 732                 {
 733                         for(n = 0; n < PTINUM; n++)
 734                         {
 735                                 if(demux[demux_id].DescramblerHandle[n] == 0) { continue; }
 736
 737                                 ErrorCode = oscam_stapi_DescramblerSet(demux[demux_id].DescramblerHandle[n], l, cw + (l * 8));
 738                                 if(ErrorCode != 0)
 739                                         { cs_log("DescramblerSet: ErrorCode: %d", ErrorCode); }
 740
 741                                 memcpy(demux[demux_id].last_cw[0][l], cw + (l * 8), 8);
 742                                 cs_log_dbg(D_DVBAPI, "write cw %s index: %d %s", text[l], demux_id, dev_list[n].name);
 743                         }
 744                 }
 745         }
 746
 747         return 1;
 748 }
 749
 750 // Needed for compatability with liboscam_stapi.a
 751 #undef cs_log
 752 void cs_log(const char *fmt, ...)
 753 {
 754         va_list params;
 755         char log_txt[512];
 756
 757         va_start(params, fmt);
 758         vsnprintf(log_txt, sizeof(log_txt), fmt, params);
 759         va_end(params);
 760
 761         cs_log_txt(MODULE_LOG_PREFIX, "%s", log_txt);
 762 }
 763
 764 #endif