?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Fix for descramblers used not 100% fixed but it is more accurate than before
[oscam.git] / module-dvbapi.c
blob319621e496ef893a8b8420f75f05c3b1120f98b1
1 #define MODULE_LOG_PREFIX "dvbapi"
2
3 #include "globals.h"
4
5 #ifdef HAVE_DVBAPI
6
7 #include "module-dvbapi.h"
8 #include "module-cacheex.h"
9 #include "module-dvbapi-azbox.h"
10 #include "module-dvbapi-mca.h"
11 #include "module-dvbapi-coolapi.h"
12 #include "module-dvbapi-stapi.h"
13 #include "module-dvbapi-chancache.h"
14 #include "module-stat.h"
15 #include "oscam-chk.h"
16 #include "oscam-client.h"
17 #include "oscam-config.h"
18 #include "oscam-ecm.h"
19 #include "oscam-emm.h"
20 #include "oscam-files.h"
21 #include "oscam-net.h"
22 #include "oscam-reader.h"
23 #include "oscam-string.h"
24 #include "oscam-time.h"
25 #include "oscam-work.h"
26 #include "reader-irdeto.h"
27 #include "cscrypt/md5.h"
28
29 extern int32_t exit_oscam;
30
31 #if defined (__CYGWIN__)
32 #define F_NOTIFY 0
33 #define F_SETSIG 0
34 #define DN_MODIFY 0
35 #define DN_CREATE 0
36 #define DN_DELETE 0
37 #define DN_MULTISHOT 0
38 #endif
39
40 static const char *get_stream_type_txt(uint8_t stream_type)
41 {
42 switch(stream_type)
43 {
44 case 0x00: return "invalid";
45 case 0x01: return "MPEG-1 video";
46 case 0x02: return "MPEG-2 video"; // MPEG-1 (constrained parameter) or MPEG-2 video
47 case 0x03: return "MPEG-1 audio"; // MP1, MP2, MP3
48 case 0x04: return "MPEG-2 audio"; // MP1, MP2, MP3
49 case 0x05: return "MPEG-2 private sections";
50 case 0x06: return "MPEG-2 PES private data"; // AC-3, Enhanced AC-3, AC-4, DTS(-HD) audio, subtitles, etc (DVB) (depends on descriptor)
51 case 0x07: return "MHEG data";
52 case 0x08: return "DSM-CC data";
53 case 0x09: return "MPEG-2 over ATM data";
54 case 0x0A: return "DSM-CC data";
55 case 0x0B: return "DSM-CC data";
56 case 0x0C: return "DSM-CC data";
57 case 0x0D: return "DSM-CC data";
58 case 0x0E: return "MPEG-2 auxiliary data";
59 case 0x0F: return "MPEG-2 audio"; // AAC
60 case 0x10: return "MPEG-4 video";
61 case 0x11: return "MPEG-4 audio"; // AAC, HE AAC and AAC v2
62 case 0x12: return "MPEG-4 PES data";
63 case 0x13: return "MPEG-4 data";
64 case 0x14: return "DSM-CC data";
65 case 0x15: return "MPEG-7 MetaData";
66 case 0x16: return "MPEG-7 MetaData";
67 case 0x17: return "MPEG-7 MetaData";
68 case 0x18: return "MPEG-7 MetaData";
69 case 0x19: return "MPEG-7 MetaData";
70 case 0x1A: return "MPEG-2 IPMP data";
71 case 0x1B: return "AVC video";
72 case 0x1C: return "MPEG-4 audio"; // DST, ALS, SLS
73 case 0x24: return "HEVC video";
74 case 0x25: return "HEVC subset video";
75 case 0x2D: return "MPEG-H 3D audio"; // main stream
76 case 0x2E: return "MPEG-H 3D audio"; // auxiliary stream
77 case 0x42: return "Chinese video";
78 case 0x7F: return "IPMP data";
79 case 0x81: return "AC-3 audio (ATSC)"; // with descriptor tag 0x81
80 case 0x86: return "SCTE 35 data";
81 case 0x87: return "enhanced AC-3 audio (ATSC)";
82 //case 0x88: return "DTS-HD audio (ATSC 2.0)"; // fixme: has ATSC 2.0 ever been used?
83 //case 0x??: return "AC-4 audio (ATSC 3.0)"; // fixme: add the actual value when it gets published
84 //case 0x??: return "MPEG-H 3D audio (ATSC 3.0)"; // fixme: add the actual value when it gets published
85 case 0xD1: return "BBC Dirac video";
86 case 0xEA: return "VC-1 video";
87 default: return "user private";
88 }
89 }
90
91 static const char *get_descriptor_tag_txt(uint8_t descriptor_tag)
92 {
93 switch(descriptor_tag)
94 {
95 // Valid in all MPEG contexts:
96 case 0x00: return "reserved";
97 case 0x01: return "forbidden";
98 case 0x02: return "video stream";
99 case 0x03: return "audio stream";
100 case 0x04: return "hierarchy";
101 case 0x05: return "registration";
102 case 0x06: return "data stream alignment";
103 case 0x07: return "target background grid";
104 case 0x08: return "video window";
105 case 0x09: return "CA";
106 case 0x0A: return "ISO 639 language";
107 case 0x0B: return "system clock";
108 case 0x0C: return "multiplex buffer utilization";
109 case 0x0D: return "copyright";
110 case 0x0E: return "maximum bitrate";
111 case 0x0F: return "private data indicator";
112 case 0x10: return "smoothing buffer";
113 case 0x11: return "STD";
114 case 0x12: return "IBP";
115 case 0x13: return "DSM-CC carousel identifier";
116 case 0x14: return "DSM-CC association tag";
117 case 0x15: return "DSM-CC deferred association tags";
118 case 0x17: return "DSM-CC NPT reference";
119 case 0x18: return "DSM-CC NPT endpoint";
120 case 0x19: return "DSM-CC stream mode";
121 case 0x1A: return "DSM-CC stream event";
122 case 0x1B: return "MPEG-4 video";
123 case 0x1C: return "MPEG-4 audio";
124 case 0x1D: return "IOD";
125 case 0x1E: return "SL";
126 case 0x1F: return "FMC";
127 case 0x20: return "External ES id";
128 case 0x21: return "MuxCode";
129 case 0x22: return "FmxBufferSize";
130 case 0x23: return "MultiplexBuffer";
131 case 0x24: return "Content labeling";
132 case 0x25: return "Metadata association";
133 case 0x26: return "Metadata";
134 case 0x27: return "Metadata STD";
135 case 0x28: return "AVC video";
136 case 0x29: return "MPEG-2 IPMP";
137 case 0x2A: return "AVC timing and HRD";
138 case 0x2B: return "MPEG-2 AAC Audio";
139 case 0x2C: return "FlexMuxTiming";
140 case 0x2D: return "MPEG-4 Text";
141 case 0x2E: return "MPEG-4 Audio Extension";
142 case 0x2F: return "Auxiliary Video Stream";
143 case 0x30: return "SVC Extension";
144 case 0x31: return "MVC Extension";
145 case 0x32: return "J2K Video";
146 case 0x33: return "MVC Operation Point";
147 case 0x34: return "MPEG-2 Stereoscopic Video Format";
148 case 0x35: return "Stereoscopic Program Info";
149 case 0x36: return "Stereoscopic Video Info";
150 case 0x37: return "Transport Profile";
151 case 0x38: return "HEVC Video";
152 case 0x3F: return "MPEG-2 Extension";
153 // Valid in DVB context:
154 case 0x45: return "VBI data";
155 case 0x46: return "VBI teletext";
156 case 0x51: return "mosaic";
157 case 0x52: return "stream identifier";
158 case 0x56: return "teletext";
159 case 0x59: return "subtitling"; // with stream type 0x06
160 case 0x5F: return "private data specifier";
161 case 0x60: return "service move";
162 case 0x65: return "scrambling";
163 case 0x66: return "data broadcast id";
164 case 0x6A: return "AC-3"; // with stream type 0x06
165 case 0x6B: return "ancillary data";
166 case 0x6F: return "application signalling";
167 case 0x70: return "adaptation field data";
168 case 0x74: return "related content";
169 case 0x78: return "ECM repetition rate";
170 case 0x7A: return "enhanced AC-3"; // with stream type 0x06
171 case 0x7B: return "DTS"; // with stream type 0x06
172 case 0x7C: return "AAC"; // with stream type 0x06
173 case 0x7D: return "XAIT location";
174 case 0x7F: return "DVB extension";
175 // Valid in ATSC context:
176 case 0x81: return "AC-3"; // with stream type 0x81
177 case 0xCC: return "enhanced AC-3"; // with stream type 0x87
178 default: return "user private";
179 }
180 }
181
182 static const char *get_extension_descriptor_txt(uint8_t extension_tag)
183 {
184 switch(extension_tag)
185 {
186 case 0x02: return "CP";
187 case 0x06: return "supplementary audio";
188 case 0x0E: return "DTS-HD"; // with stream type 0x06
189 case 0x0F: return "DTS Neural"; // with stream type 0x06
190 case 0x11: return "T2MI";
191 case 0x13: return "URI linkage";
192 case 0x15: return "AC-4"; // with stream type 0x06
193 case 0x18: return "protection message";
194 case 0x19: return "audio preselection";
195 case 0x20: return "TTML subtitling"; // (could become 0x1A, value in A038 draft seems weird)
196 case 0x21: return "DTS-UHD"; // with stream type 0x06 (could become 0x1B, value in A038 draft seems weird)
197 default: return "Undefined";
198 }
199 }
200
201 void flush_read_fd(int32_t demux_id, int32_t num, int fd)
202 {
203 if(!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX)
204 {
205 cs_log_dbg(D_DVBAPI,"Demuxer %d flushing stale input data of filter %d (fd:%d)", demux_id, num + 1, fd);
206
207 fd_set rd;
208 struct timeval t;
209 char buff[100];
210
211 t.tv_sec = 0;
212 t.tv_usec = 0;
213
214 FD_ZERO(&rd);
215 FD_SET(fd, &rd);
216
217 while(select(fd + 1, &rd, NULL, NULL, &t) > 0)
218 {
219 if(read(fd, buff, 100)) { ; }
220 }
221 }
222 }
223
224 static int dvbapi_ioctl(int fd, uint32_t request, ...)
225 {
226 int ret = 0;
227 va_list args;
228 va_start(args, request);
229 if(!(cfg.dvbapi_boxtype == BOXTYPE_SAMYGO))
230 {
231 void *param = va_arg(args, void *);
232 ret = ioctl(fd, request, param);
233 }
234 else
235 {
236 switch(request)
237 {
238 case DMX_SET_FILTER:
239 {
240 struct dmx_sct_filter_params *sFP = va_arg(args, struct dmx_sct_filter_params *);
241 //fix filter for samygo
242 //note: we only have 14 available filter bytes (instead of 16) on samygo
243 memmove(&sFP->filter.filter[3], &sFP->filter.filter[1], 13);
244 memset(&sFP->filter.filter[1], 0, 2);
245 memmove(&sFP->filter.mask[3], &sFP->filter.mask[1], 13);
246 memset(&sFP->filter.mask[1], 0, 2);
247 // prepare packet
248 uint8_t packet[sizeof(request) + sizeof(struct dmx_sct_filter_params)];
249 memcpy(&packet, &request, sizeof(request));
250 memcpy(&packet[sizeof(request)], sFP, sizeof(struct dmx_sct_filter_params));
251 ret = send(fd, packet, sizeof(packet), 0);
252 break;
253 }
254
255 case DMX_SET_FILTER1:
256 {
257 cs_log("error: samygo does not support DMX_SET_FILTER1");
258 ret = -1;
259 break;
260 }
261
262 case DMX_STOP:
263 {
264 ret = send(fd, &request, sizeof(request), 0);
265 ret = 1;
266 break;
267 }
268
269 case CA_GET_DESCR_INFO:
270 {
271 ca_descr_info_t *ca_descr_info = va_arg(args, ca_descr_info_t *);
272 // preparing packet
273 uint8_t packet[sizeof(request) + sizeof(ca_descr_info_t)];
274 memcpy(&packet[0], &request, sizeof(request));
275 memcpy(&packet[sizeof(request)], ca_descr_info, sizeof(ca_descr_info_t));
276 // sending data to UDP
277 ret = send(fd, &packet[0], sizeof(packet), 0);
278 break;
279 }
280
281 case CA_SET_DESCR:
282 {
283 ca_descr_t *ca_descr = va_arg(args, ca_descr_t *);
284 // preparing packet
285 uint8_t packet[sizeof(request) + sizeof(ca_descr_t)];
286 memcpy(&packet[0], &request, sizeof(request));
287 memcpy(&packet[sizeof(request)], ca_descr, sizeof(ca_descr_t));
288 // sending data to UDP
289 ret = send(fd, &packet[0], sizeof(packet), 0);
290 break;
291 }
292
293 case CA_SET_PID:
294 {
295 ca_pid_t *ca_pid2 = va_arg(args, ca_pid_t *);
296 // preparing packet
297 uint8_t packet[sizeof(request) + sizeof(ca_pid_t)];
298 memcpy(&packet[0], &request, sizeof(request));
299 memcpy(&packet[sizeof(request)], ca_pid2, sizeof(ca_pid_t));
300 // sending data to UDP
301 ret = send(fd, &packet[0], sizeof(packet), 0);
302 break;
303 }
304
305 case CA_SET_DESCR_MODE:
306 {
307 cs_log("error: samygo does not support CA_SET_DESCR_MODE");
308 ret = -1;
309 break;
310 }
311
312 case CA_SET_DESCR_DATA:
313 {
314 cs_log("error: samygo does not support CA_SET_DESCR_DATA");
315 ret = -1;
316 break;
317 }
318 }
319
320 if(ret > 0) // send() may return larger than 1
321 {
322 ret = 1;
323 }
324 }
325 #if defined(__powerpc__)
326 // Old dm500 boxes (ppc old) are using broken kernel, se we need some fixups
327 switch (request)
328 {
329 case DMX_STOP:
330 case CA_SET_DESCR:
331 case CA_SET_PID:
332 ret = 1;
333 }
334 #endif
335 // FIXME: Workaround for su980 bug
336 // See: http://www.streamboard.tv/wbb2/thread.php?postid=533940
337 if(boxtype_is("su980"))
338 {
339 ret = 1;
340 }
341 va_end(args);
342 return ret;
343 }
344
345 // tunemm_caid_map
346 #define FROM_TO 0
347 #define TO_FROM 1
348
349 int32_t pausecam = 0, disable_pmt_files = 0;
350
351 DEMUXTYPE demux[MAX_DEMUX];
352 struct s_dvbapi_priority *dvbapi_priority;
353 struct s_client *dvbapi_client;
354
355 const char *boxdesc[] = { "none", "dreambox", "duckbox", "ufs910", "dbox2", "ipbox", "ipbox-pmt",
356 "dm7000", "qboxhd", "coolstream", "neumo", "pc", "pc-nodmx", "samygo" };
357
358 // when updating devices[BOX_COUNT] make sure to update these index defines
359 #define BOX_INDEX_QBOXHD 0
360 #define BOX_INDEX_DREAMBOX_DVBAPI3 1
361 #define BOX_INDEX_COOLSTREAM 6
362
363 static const struct box_devices devices[BOX_COUNT] =
364 {
365 /* QboxHD (dvb-api-3)*/ { "/tmp/virtual_adapter/", "ca%d", "demux%d", "/tmp/camd.socket", DVBAPI_3 },
366 /* dreambox (dvb-api-3)*/ { "/dev/dvb/adapter%d/", "ca%d", "demux%d", "/tmp/camd.socket", DVBAPI_3 },
367 /* wetek (dvb-api-3)*/ { "/dev/dvb%d.", "ca%d", "demux%d", "/tmp/camd.socket", DVBAPI_3 },
368 /* dreambox (dvb-api-1)*/ { "/dev/dvb/card%d/", "ca%d", "demux%d", "/tmp/camd.socket", DVBAPI_1 },
369 /* neumo (dvb-api-1)*/ { "/dev/", "demuxapi", "demuxapi", "/tmp/camd.socket", DVBAPI_1 },
370 #ifdef WITH_STAPI5
371 /* sh4 (stapi5)*/ { "/dev/stapi/", "stpti5_ioctl", "stpti5_ioctl", "/tmp/camd.socket", STAPI },
372 #else
373 /* sh4 (stapi)*/ { "/dev/stapi/", "stpti4_ioctl", "stpti4_ioctl", "/tmp/camd.socket", STAPI },
374 #endif
375 /* coolstream*/ { "/dev/cnxt/", "null", "null", "/tmp/camd.socket", COOLAPI },
376 };
377
378 static int32_t selected_box = -1;
379 static int32_t selected_api = -1;
380 static int32_t maxfilter = MAX_FILTER;
381 static int32_t dir_fd = -1;
382 static uint16_t last_client_proto_version = 0;
383 static char *last_client_name = NULL;
384 static uint32_t ca_descramblers_total = 0; // total number of available descramblers in box
385 static uint32_t ca_descramblers_used = 0; // total number of used descramblers during decoding
386 static int32_t ca_fd[CA_MAX]; // holds fd handle of all ca devices (0 not in use)
387 static LLIST *ll_activestreampids; // list of all enabled streampids on ca devices
388 static int32_t unassoc_fd[MAX_DEMUX];
389
390 bool is_dvbapi_usr(char *usr)
391 {
392 return streq(cfg.dvbapi_usr, usr);
393 }
394
395 struct s_emm_filter
396 {
397 int32_t demux_id;
398 uint8_t filter[32];
399 uint16_t caid;
400 uint32_t provid;
401 uint16_t pid;
402 uint32_t num;
403 struct timeb time_started;
404 };
405
406 static LLIST *ll_emm_active_filter;
407 static LLIST *ll_emm_inactive_filter;
408 static LLIST *ll_emm_pending_filter;
409
410 int32_t add_emmfilter_to_list(int32_t demux_id, uint8_t *filter, uint16_t caid, uint32_t provid, uint16_t emmpid, int32_t num, bool enable)
411 {
412 if(!ll_emm_active_filter)
413 {
414 ll_emm_active_filter = ll_create("ll_emm_active_filter");
415 }
416
417 if(!ll_emm_inactive_filter)
418 {
419 ll_emm_inactive_filter = ll_create("ll_emm_inactive_filter");
420 }
421
422 if(!ll_emm_pending_filter)
423 {
424 ll_emm_pending_filter = ll_create("ll_emm_pending_filter");
425 }
426
427 struct s_emm_filter *filter_item;
428 if(!cs_malloc(&filter_item, sizeof(struct s_emm_filter)))
429 {
430 return 0;
431 }
432
433 filter_item->demux_id = demux_id;
434 memcpy(filter_item->filter, filter, 32);
435 filter_item->caid = caid;
436 filter_item->provid = provid;
437 filter_item->pid = emmpid;
438 filter_item->num = num;
439
440 if(enable)
441 {
442 cs_ftime(&filter_item->time_started);
443 }
444 else
445 {
446 memset(&filter_item->time_started, 0, sizeof(filter_item->time_started));
447 }
448
449 if(num > 0)
450 {
451 ll_append(ll_emm_active_filter, filter_item);
452 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d added to active emmfilters (CAID %04X PROVID %06X EMMPID %04X)",
453 filter_item->demux_id, filter_item->num, filter_item->caid, filter_item->provid, filter_item->pid);
454 }
455 else if(num < 0)
456 {
457 ll_append(ll_emm_pending_filter, filter_item);
458 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter added to pending emmfilters (CAID %04X PROVID %06X EMMPID %04X)",
459 filter_item->demux_id, filter_item->caid, filter_item->provid, filter_item->pid);
460 }
461 else
462 {
463 ll_append(ll_emm_inactive_filter, filter_item);
464 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter added to inactive emmfilters (CAID %04X PROVID %06X EMMPID %04X)",
465 filter_item->demux_id, filter_item->caid, filter_item->provid, filter_item->pid);
466 }
467 return 1;
468 }
469
470 int32_t is_emmfilter_in_list_internal(LLIST *ll, uint8_t *filter, uint16_t emmpid, uint32_t provid, uint16_t caid)
471 {
472 struct s_emm_filter *filter_item;
473 LL_ITER itr;
474 if(ll_count(ll) > 0)
475 {
476 itr = ll_iter_create(ll);
477 while((filter_item = ll_iter_next(&itr)) != NULL)
478 {
479 if(!memcmp(filter_item->filter, filter, 32) && (filter_item->pid == emmpid)
480 && (filter_item->provid == provid) && (filter_item->caid == caid))
481 {
482 return 1;
483 }
484 }
485 }
486 return 0;
487 }
488
489 int32_t is_emmfilter_in_list(uint8_t *filter, uint16_t emmpid, uint32_t provid, uint16_t caid)
490 {
491 if(!ll_emm_active_filter)
492 {
493 ll_emm_active_filter = ll_create("ll_emm_active_filter");
494 }
495
496 if(!ll_emm_inactive_filter)
497 {
498 ll_emm_inactive_filter = ll_create("ll_emm_inactive_filter");
499 }
500
501 if(!ll_emm_pending_filter)
502 {
503 ll_emm_pending_filter = ll_create("ll_emm_pending_filter");
504 }
505
506 if(is_emmfilter_in_list_internal(ll_emm_active_filter, filter, emmpid, provid, caid)
507 || is_emmfilter_in_list_internal(ll_emm_inactive_filter, filter, emmpid, provid, caid)
508 || is_emmfilter_in_list_internal(ll_emm_pending_filter, filter, emmpid, provid, caid))
509 {
510 return 1;
511 }
512 return 0;
513 }
514
515 struct s_emm_filter *get_emmfilter_by_filternum_internal(LLIST *ll, int32_t demux_id, uint32_t num)
516 {
517 struct s_emm_filter *filter;
518 LL_ITER itr;
519 if(ll_count(ll) > 0)
520 {
521 itr = ll_iter_create(ll);
522 while((filter = ll_iter_next(&itr)))
523 {
524 if(filter->demux_id == demux_id && filter->num == num)
525 {
526 return filter;
527 }
528 }
529 }
530 return NULL;
531 }
532
533 struct s_emm_filter *get_emmfilter_by_filternum(int32_t demux_id, uint32_t num)
534 {
535 if(!ll_emm_active_filter)
536 {
537 ll_emm_active_filter = ll_create("ll_emm_active_filter");
538 }
539
540 if(!ll_emm_inactive_filter)
541 {
542 ll_emm_inactive_filter = ll_create("ll_emm_inactive_filter");
543 }
544
545 if(!ll_emm_pending_filter)
546 {
547 ll_emm_pending_filter = ll_create("ll_emm_pending_filter");
548 }
549
550 struct s_emm_filter *emm_filter = NULL;
551
552 emm_filter = get_emmfilter_by_filternum_internal(ll_emm_active_filter, demux_id, num);
553 if(emm_filter)
554 {
555 return emm_filter;
556 }
557
558 emm_filter = get_emmfilter_by_filternum_internal(ll_emm_inactive_filter, demux_id, num);
559 if(emm_filter)
560 {
561 return emm_filter;
562 }
563
564 emm_filter = get_emmfilter_by_filternum_internal(ll_emm_pending_filter, demux_id, num);
565 if(emm_filter)
566 {
567 return emm_filter;
568 }
569
570 return NULL;
571 }
572
573 int8_t remove_emmfilter_from_list_internal(LLIST *ll, int32_t demux_id, uint16_t caid, uint32_t provid, uint16_t pid, uint32_t num)
574 {
575 struct s_emm_filter *filter;
576 LL_ITER itr;
577
578 if(ll_count(ll) > 0)
579 {
580 itr = ll_iter_create(ll);
581 while((filter = ll_iter_next(&itr)))
582 {
583 if(filter->demux_id == demux_id && filter->caid == caid && filter->provid == provid && filter->pid == pid && filter->num == num)
584 {
585 ll_iter_remove_data(&itr);
586 return 1;
587 }
588 }
589 }
590 return 0;
591 }
592
593 void remove_emmfilter_from_list(int32_t demux_id, uint16_t caid, uint32_t provid, uint16_t pid, uint32_t num)
594 {
595 if((ll_emm_active_filter && remove_emmfilter_from_list_internal(ll_emm_active_filter, demux_id, caid, provid, pid, num))
596 || (ll_emm_inactive_filter && remove_emmfilter_from_list_internal(ll_emm_inactive_filter, demux_id, caid, provid, pid, num))
597 || (ll_emm_pending_filter && remove_emmfilter_from_list_internal(ll_emm_pending_filter, demux_id, caid, provid, pid, num)))
598 {
599 return;
600 }
601 }
602
603 void dvbapi_net_add_str(uint8_t *packet, int *size, const char *str)
604 {
605 uint8_t *str_len = &packet[*size]; // string length
606 *size += 1;
607 *str_len = snprintf((char *) &packet[*size], DVBAPI_MAX_PACKET_SIZE - *size, "%s", str);
608 *size += *str_len;
609 }
610
611 int32_t dvbapi_net_send(uint32_t request, int32_t socket_fd, uint32_t msgid, int32_t demux_id,
612 uint32_t filter_number, uint8_t *data, struct s_client *client, ECM_REQUEST *er, uint16_t client_proto_version)
613 {
614 uint8_t packet[DVBAPI_MAX_PACKET_SIZE]; // maximum possible packet size
615 int32_t size = 0;
616 uint32_t u32;
617
618 // not connected?
619 if(socket_fd <= 0)
620 {
621 return 0;
622 }
623
624 // preparing packet - header
625 // in old protocol client expect this first byte as adapter index,
626 // changed in the new protocol to be always after request type (opcode)
627 if(client_proto_version <= 0)
628 {
629 packet[size++] = demux[demux_id].adapter_index; // adapter index - 1 byte
630 }
631 else if(client_proto_version >= 3)
632 {
633 packet[size++] = 0xa5; // message start
634 u32 = htonl(msgid);
635 memcpy(&packet[size], &u32, 4);
636 size += 4;
637 }
638
639 // type of request
640 u32 = request;
641 if(client_proto_version >= 1)
642 {
643 u32 = htonl(u32);
644 }
645 memcpy(&packet[size], &u32, 4);
646 size += 4;
647
648 // preparing packet - adapter index for proto >= 1
649 if((request != DVBAPI_SERVER_INFO) && client_proto_version >= 1)
650 {
651 packet[size++] = demux[demux_id].adapter_index; // adapter index - 1 byte
652 }
653
654 // struct with data
655 switch(request)
656 {
657 case DVBAPI_SERVER_INFO:
658 {
659 int16_t proto_version = htons(DVBAPI_PROTOCOL_VERSION); // our protocol version
660 char capabilities[128] = "\x00"; // two zero characters
661 memcpy(&packet[size], &proto_version, 2);
662 size += 2;
663 uint8_t *info_len = &packet[size]; // info string length
664 size += 1;
665
666 if(cfg.dvbapi_extended_cw_api == 1)
667 {
668 strcat(capabilities, ",e1mk"); // extended cw, key follows mode - supports CSA, DES, AES128
669 }
670
671 if(cfg.dvbapi_extended_cw_api == 2)
672 {
673 strcat(capabilities, ",e2"); // usage of DES algo signalled through PID index - CSA and DES only
674 }
675
676 *info_len = snprintf((char *) &packet[size], sizeof(packet) - size, "OSCam v%s, build r%s (%s); %s",
677 CS_VERSION, CS_SVN_VERSION, CS_TARGET, capabilities + 1);
678
679 size += *info_len;
680 break;
681 }
682
683 case DVBAPI_ECM_INFO:
684 {
685 if(er->rc >= E_NOTFOUND)
686 {
687 return 0;
688 }
689
690 int8_t hops = 0;
691
692 uint16_t sid = htons(er->srvid); // service ID (program number)
693 memcpy(&packet[size], &sid, 2);
694 size += 2;
695
696 uint16_t caid = htons(er->caid); // CAID
697 memcpy(&packet[size], &caid, 2);
698 size += 2;
699
700 uint16_t pid = htons(er->pid); // PID
701 memcpy(&packet[size], &pid, 2);
702 size += 2;
703
704 uint32_t prid = htonl(er->prid); // Provider ID
705 memcpy(&packet[size], &prid, 4);
706 size += 4;
707
708 uint32_t ecmtime = htonl(client->cwlastresptime); // ECM time
709 memcpy(&packet[size], &ecmtime, 4);
710 size += 4;
711
712 dvbapi_net_add_str(packet, &size, get_cardsystem_desc_by_caid(er->caid)); // cardsystem name
713
714 switch (er->rc)
715 {
716 case E_FOUND:
717 if(er->selected_reader)
718 {
719 dvbapi_net_add_str(packet, &size, er->selected_reader->label); // reader
720 if(is_network_reader(er->selected_reader))
721 {
722 dvbapi_net_add_str(packet, &size, er->selected_reader->device); // from
723 }
724 else
725 {
726 dvbapi_net_add_str(packet, &size, "local"); // from
727 }
728 dvbapi_net_add_str(packet, &size, reader_get_type_desc(er->selected_reader, 1)); // protocol
729 hops = er->selected_reader->currenthops;
730 }
731 break;
732
733 case E_CACHE1:
734 dvbapi_net_add_str(packet, &size, "Cache"); // reader
735 dvbapi_net_add_str(packet, &size, "cache1"); // from
736 dvbapi_net_add_str(packet, &size, "none"); // protocol
737 break;
738
739 case E_CACHE2:
740 dvbapi_net_add_str(packet, &size, "Cache"); // reader
741 dvbapi_net_add_str(packet, &size, "cache2"); // from
742 dvbapi_net_add_str(packet, &size, "none"); // protocol
743 break;
744
745 case E_CACHEEX:
746 dvbapi_net_add_str(packet, &size, "Cache"); // reader
747 dvbapi_net_add_str(packet, &size, "cache3"); // from
748 dvbapi_net_add_str(packet, &size, "none"); // protocol
749 break;
750 }
751 packet[size++] = hops; // hops
752 break;
753 }
754
755 case DVBAPI_CA_GET_DESCR_INFO:
756 {
757 int sct_cadescr_info_size = sizeof(ca_descr_info_t);
758 if(client_proto_version >= 1)
759 {
760 ca_descr_info_t *cadescr_info = (ca_descr_info_t *) data;
761 cadescr_info->num = htonl(cadescr_info->num);
762 cadescr_info->type = htonl(cadescr_info->type);
763 }
764 memcpy(&packet[size], data, sct_cadescr_info_size);
765 size += sct_cadescr_info_size;
766 break;
767 }
768
769 case DVBAPI_CA_SET_DESCR:
770 {
771 int sct_cadescr_size = sizeof(ca_descr_t);
772 if(client_proto_version >= 1)
773 {
774 ca_descr_t *cadesc = (ca_descr_t *) data;
775 cadesc->index = htonl(cadesc->index);
776 cadesc->parity = htonl(cadesc->parity);
777 }
778 memcpy(&packet[size], data, sct_cadescr_size);
779 size += sct_cadescr_size;
780 break;
781 }
782
783 case DVBAPI_CA_SET_PID:
784 {
785 int sct_capid_size = sizeof(ca_pid_t);
786 if(client_proto_version >= 1)
787 {
788 ca_pid_t *capid = (ca_pid_t *) data;
789 capid->pid = htonl(capid->pid);
790 capid->index = htonl(capid->index);
791 }
792 memcpy(&packet[size], data, sct_capid_size);
793 size += sct_capid_size;
794 break;
795 }
796
797 case DVBAPI_CA_SET_DESCR_MODE:
798 {
799 int sct_cadescr_mode_size = sizeof(ca_descr_mode_t);
800 if(client_proto_version >= 1)
801 {
802 ca_descr_mode_t *cadesc_mode = (ca_descr_mode_t *) data;
803 cadesc_mode->index = htonl(cadesc_mode->index);
804 cadesc_mode->algo = htonl(cadesc_mode->algo);
805 cadesc_mode->cipher_mode = htonl(cadesc_mode->cipher_mode);
806 }
807 memcpy(&packet[size], data, sct_cadescr_mode_size);
808 size += sct_cadescr_mode_size;
809 break;
810 }
811
812 case DVBAPI_CA_SET_DESCR_DATA:
813 {
814 ca_descr_data_t *cadesc_data = (ca_descr_data_t *) data;
815 uint32_t length = cadesc_data->length;
816 if(client_proto_version >= 1)
817 {
818 cadesc_data->index = htonl(cadesc_data->index);
819 cadesc_data->parity = htonl(cadesc_data->parity);
820 cadesc_data->data_type = htonl(cadesc_data->data_type);
821 cadesc_data->length = htonl(cadesc_data->length);
822 }
823 memcpy(&packet[size], &cadesc_data->index, 4);
824 memcpy(&packet[size + 4], &cadesc_data->parity, 4);
825 memcpy(&packet[size + 8], &cadesc_data->data_type, 4);
826 memcpy(&packet[size + 12], &cadesc_data->length, 4);
827 memcpy(&packet[size + 16], cadesc_data->data, length);
828 size += 16 + length;
829 break;
830 }
831
832 case DVBAPI_DMX_SET_FILTER:
833 case DVBAPI_DMX_STOP:
834 {
835 int32_t sct_filter_size = sizeof(struct dmx_sct_filter_params);
836 packet[size++] = demux_id; // demux id - 1 byte
837 packet[size++] = filter_number; // filter number - 1 byte
838 if(data) // filter data when starting
839 {
840 if(client_proto_version >= 1)
841 {
842 struct dmx_sct_filter_params *fp = (struct dmx_sct_filter_params *)data;
843 // adding all dmx_sct_filter_params structure fields
844 // one by one to avoid padding problems
845 uint16_t pid = htons(fp->pid);
846 memcpy(&packet[size], &pid, 2);
847 size += 2;
848 memcpy(&packet[size], fp->filter.filter, 16);
849 size += 16;
850 memcpy(&packet[size], fp->filter.mask, 16);
851 size += 16;
852 memcpy(&packet[size], fp->filter.mode, 16);
853 size += 16;
854 uint32_t timeout = htonl(fp->timeout);
855 memcpy(&packet[size], &timeout, 4);
856 size += 4;
857 uint32_t flags = htonl(fp->flags);
858 memcpy(&packet[size], &flags, 4);
859 size += 4;
860 }
861 else
862 {
863 memcpy(&packet[size], data, sct_filter_size); // dmx_sct_filter_params struct
864 size += sct_filter_size;
865 }
866 }
867 else // pid when stopping
868 {
869 if(client_proto_version >= 1)
870 {
871 uint16_t pid = htons(demux[demux_id].demux_fd[filter_number].pid);
872 memcpy(&packet[size], &pid, 2);
873 size += 2;
874 }
875 else
876 {
877 uint16_t pid = demux[demux_id].demux_fd[filter_number].pid;
878 packet[size++] = pid >> 8;
879 packet[size++] = pid & 0xff;
880 }
881 }
882 break;
883 }
884
885 default: // unknown request
886 {
887 cs_log("ERROR: dvbapi_net_send: invalid request");
888 return 0;
889 }
890 }
891 // sending
892 cs_log_dump_dbg(D_DVBAPI, packet, size, "Sending packet to dvbapi client (fd=%d):", socket_fd);
893 send(socket_fd, &packet, size, MSG_DONTWAIT);
894 // always returning success as the client could close socket
895 return 0;
896 }
897
898 int32_t dvbapi_set_filter(int32_t demux_id, int32_t api, uint16_t pid, uint16_t caid, uint32_t provid,
899 uint8_t *filt, uint8_t *mask, int32_t timeout, int32_t pidindex, int32_t type, int8_t add_to_emm_list)
900 {
901 int32_t ret = -1, n = -1, i, filterfd = -1;
902
903 for(i = 0; i < maxfilter && demux[demux_id].demux_fd[i].fd > 0; i++) { ; }
904
905 if(i >= maxfilter)
906 {
907 cs_log_dbg(D_DVBAPI, "no free filter");
908 return -1;
909 }
910 n = i;
911
912 if(USE_OPENXCAS)
913 {
914 if(type == TYPE_ECM)
915 {
916 openxcas_set_caid(demux[demux_id].ECMpids[pidindex].CAID);
917 openxcas_set_ecm_pid(pid);
918 }
919
920 demux[demux_id].demux_fd[n].fd = DUMMY_FD;
921 demux[demux_id].demux_fd[n].pidindex = pidindex;
922 demux[demux_id].demux_fd[n].pid = pid;
923 demux[demux_id].demux_fd[n].caid = caid;
924 demux[demux_id].demux_fd[n].provid = provid;
925 demux[demux_id].demux_fd[n].type = type;
926 memcpy(demux[demux_id].demux_fd[n].filter, filt, 16); // copy filter to check later on if receiver delivered accordingly
927 memcpy(demux[demux_id].demux_fd[n].mask, mask, 16); // copy mask to check later on if receiver delivered accordingly
928 return 1;
929 }
930
931 switch(api)
932 {
933 case DVBAPI_3:
934 {
935 if(cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
936 {
937 ret = filterfd = DUMMY_FD;
938 }
939 else
940 {
941 ret = filterfd = dvbapi_open_device(0, demux[demux_id].demux_index, demux[demux_id].adapter_index);
942 }
943
944 if(ret < 0)
945 {
946 return ret; // return if device cant be opened!
947 }
948
949 struct dmx_sct_filter_params sFP2;
950 memset(&sFP2, 0, sizeof(sFP2));
951 sFP2.pid = pid;
952 sFP2.timeout = timeout;
953 sFP2.flags = DMX_IMMEDIATE_START;
954
955 if(cfg.dvbapi_boxtype == BOXTYPE_NEUMO)
956 {
957 //DeepThought: on dgs/cubestation and neumo images, perhaps others
958 //the following code is needed to descramble
959 sFP2.filter.filter[0] = filt[0];
960 sFP2.filter.mask[0] = mask[0];
961 sFP2.filter.filter[1] = 0;
962 sFP2.filter.mask[1] = 0;
963 sFP2.filter.filter[2] = 0;
964 sFP2.filter.mask[2] = 0;
965 memcpy(sFP2.filter.filter + 3, filt + 1, 16 - 3);
966 memcpy(sFP2.filter.mask + 3, mask + 1, 16 - 3);
967
968 //DeepThought: in the drivers of the dgs/cubestation and neumo images,
969 //dvbapi 1 and 3 are somehow mixed. In the kernel drivers, the DMX_SET_FILTER
970 //ioctl expects to receive a dmx_sct_filter_params structure (DVBAPI 3) but
971 //due to a bug its sets the "positive mask" wrongly (they should be all 0).
972 //On the other hand, the DMX_SET_FILTER1 ioctl also uses the dmx_sct_filter_params
973 //structure, which is incorrect (it should be dmxSctFilterParams).
974 //The only way to get it right is to call DMX_SET_FILTER1 with the argument
975 //expected by DMX_SET_FILTER. Otherwise, the timeout parameter is not passed correctly.
976 ret = dvbapi_ioctl(filterfd, DMX_SET_FILTER1, &sFP2);
977 }
978 else
979 {
980 memcpy(sFP2.filter.filter, filt, 16);
981 memcpy(sFP2.filter.mask, mask, 16);
982 if(cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
983 {
984 ret = dvbapi_net_send(DVBAPI_DMX_SET_FILTER,
985 demux[demux_id].socket_fd,
986 0,
987 demux_id,
988 n,
989 (uint8_t *) &sFP2,
990 NULL,
991 NULL,
992 demux[demux_id].client_proto_version);
993 }
994 else
995 {
996 ret = dvbapi_ioctl(filterfd, DMX_SET_FILTER, &sFP2);
997 }
998 }
999 break;
1000 }
1001
1002 case DVBAPI_1:
1003 {
1004 ret = filterfd = dvbapi_open_device(0, demux[demux_id].demux_index, demux[demux_id].adapter_index);
1005 if(ret < 0) { return ret; } // return if device cant be opened!
1006
1007 struct dmxSctFilterParams sFP1;
1008 memset(&sFP1, 0, sizeof(sFP1));
1009 sFP1.pid = pid;
1010 sFP1.timeout = timeout;
1011 sFP1.flags = DMX_IMMEDIATE_START;
1012 memcpy(sFP1.filter.filter, filt, 16);
1013 memcpy(sFP1.filter.mask, mask, 16);
1014 ret = dvbapi_ioctl(filterfd, DMX_SET_FILTER1, &sFP1);
1015 break;
1016 }
1017
1018 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
1019 case STAPI:
1020 {
1021 ret = filterfd = stapi_set_filter(demux_id, pid, filt, mask, n, demux[demux_id].pmt_file);
1022 if(ret <= 0)
1023 {
1024 ret = -1; // error setting filter!
1025 }
1026 break;
1027 }
1028 #endif
1029
1030 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
1031 case COOLAPI:
1032 {
1033 ret = filterfd = coolapi_open_device(demux[demux_id].demux_index, demux_id);
1034 if(ret > 0)
1035 {
1036 ret = coolapi_set_filter(filterfd, n, pid, filt, mask, type);
1037 }
1038 else
1039 {
1040 ret = -1; // fail
1041 }
1042 break;
1043 }
1044 #endif
1045
1046 default:
1047 break;
1048 }
1049
1050 if(ret != -1) // filter set successful
1051 {
1052 // only register if filter was set successful
1053 demux[demux_id].demux_fd[n].fd = filterfd;
1054 demux[demux_id].demux_fd[n].pidindex = pidindex;
1055 demux[demux_id].demux_fd[n].pid = pid;
1056 demux[demux_id].demux_fd[n].caid = caid;
1057 demux[demux_id].demux_fd[n].provid = provid;
1058 demux[demux_id].demux_fd[n].type = type;
1059
1060 // copy filter and mask to check later on if receiver delivered accordingly
1061 memcpy(demux[demux_id].demux_fd[n].filter, filt, 16);
1062 memcpy(demux[demux_id].demux_fd[n].mask, mask, 16);
1063
1064 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d started successfully (caid %04X provid %06X pid %04X)",
1065 demux_id, n + 1, caid, provid, pid);
1066
1067 if(type == TYPE_EMM && add_to_emm_list)
1068 {
1069 add_emmfilter_to_list(demux_id, filt, caid, provid, pid, n + 1, true);
1070 }
1071 }
1072 else
1073 {
1074 cs_log("ERROR: Could not start demux filter (api: %d errno=%d %s)", selected_api, errno, strerror(errno));
1075 }
1076 return ret;
1077 }
1078
1079 /*
1080 * Get number of available descramblers from box. On success, it stores result on
1081 * global variable "ca_descramblers_total". On failure, it uses a safe default value.
1082 */
1083 static int32_t dvbapi_get_descrambler_info(void)
1084 {
1085 // In enigma2 all ca devices are listed under adapter0. In addition we only
1086 // need to ask one ca device to get the total number of descramblers. In
1087 // PC installations, there are no ca devices, so we use a predefined value.
1088
1089 if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
1090 {
1091 ca_descramblers_total = INDEX_MAX_NET;
1092 return 1; // nothing else to do for PCs
1093 }
1094
1095 int32_t fd = 0, ca_offset = 0;
1096 char device_path[128], device_path2[128];
1097 struct ca_descr_info descr_info;
1098 memset(&descr_info, 0, sizeof(descr_info));
1099
1100 // Use a safe default in case we fail to get the exact number
1101 ca_descramblers_total = INDEX_MAX_LOCAL;
1102
1103 if(cfg.dvbapi_boxtype == BOXTYPE_DUCKBOX ||
1104 cfg.dvbapi_boxtype == BOXTYPE_DBOX2 ||
1105 cfg.dvbapi_boxtype == BOXTYPE_UFS910)
1106 {
1107 ca_offset = 1;
1108 }
1109
1110 // Ask device for exact number of ca descramblers
1111 snprintf(device_path2, sizeof(device_path2), devices[selected_box].ca_device, ca_offset);
1112 snprintf(device_path, sizeof(device_path), devices[selected_box].path, 0);
1113 strncat(device_path, device_path2, sizeof(device_path) - strlen(device_path));
1114
1115 if((fd = open(device_path, O_RDWR | O_NONBLOCK)) < 0)
1116 {
1117 cs_log("ERROR: Can't open device %s (errno=%d %s)", device_path, errno, strerror(errno));
1118 return 0;
1119 }
1120
1121 if(dvbapi_ioctl(fd, CA_GET_DESCR_INFO, &descr_info) < 0)
1122 {
1123 cs_log("ERROR: ioctl(CA_GET_DESCR_INFO): %s", strerror(errno));
1124 }
1125
1126 if(close(fd) < 0)
1127 {
1128 cs_log("ERROR: Can't close device %s (errno=%d %s)", device_path, errno, strerror(errno));
1129 }
1130
1131 // We got a valid response from device (count the ECD type only)
1132 if(descr_info.num > 0 && (descr_info.type & 1))
1133 {
1134 ca_descramblers_total = descr_info.num;
1135 cs_log("Detected %s device, total available descramblers: %d", device_path, ca_descramblers_total);
1136 return 1;
1137 }
1138
1139 return 0;
1140 }
1141
1142 static int32_t dvbapi_detect_api(void)
1143 {
1144 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
1145 selected_api = COOLAPI;
1146 selected_box = BOX_INDEX_COOLSTREAM;
1147 disable_pmt_files = 1;
1148 cfg.dvbapi_listenport = 0;
1149 cs_log("Detected Coolstream API");
1150 return 1;
1151 #else
1152 if(cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX || cfg.dvbapi_boxtype == BOXTYPE_PC)
1153 {
1154 selected_api = DVBAPI_3;
1155 selected_box = BOX_INDEX_DREAMBOX_DVBAPI3;
1156 if(cfg.dvbapi_listenport)
1157 {
1158 cs_log("Using TCP listen socket, API forced to DVBAPIv3 (%d), userconfig boxtype: %d",
1159 selected_api, cfg.dvbapi_boxtype);
1160 }
1161 else
1162 {
1163 cs_log("Using %s listen socket, API forced to DVBAPIv3 (%d), userconfig boxtype: %d",
1164 devices[selected_box].cam_socket_path, selected_api, cfg.dvbapi_boxtype);
1165 }
1166 return 1;
1167 }
1168 else if(cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
1169 {
1170 selected_api = DVBAPI_3;
1171 selected_box = BOX_INDEX_QBOXHD;
1172 cfg.dvbapi_listenport = 0;
1173 disable_pmt_files = 1;
1174 cs_log("Using SamyGO dvbapi v0.1");
1175 return 1;
1176 }
1177 else
1178 {
1179 cfg.dvbapi_listenport = 0;
1180 }
1181
1182 int32_t i = 0, n = 0, devnum = -1, dmx_fd = 0, filtercount = 0;
1183 char device_path[128], device_path2[128];
1184 static LLIST *ll_max_fd;
1185 ll_max_fd = ll_create("ll_max_fd");
1186 LL_ITER itr;
1187
1188 struct s_open_fd
1189 {
1190 uint32_t fd;
1191 };
1192 struct s_open_fd *open_fd;
1193
1194 while(i < BOX_COUNT)
1195 {
1196 do
1197 {
1198 snprintf(device_path2, sizeof(device_path2), devices[i].demux_device, 0);
1199 snprintf(device_path, sizeof(device_path), devices[i].path, n);
1200 strncat(device_path, device_path2, sizeof(device_path) - strlen(device_path));
1201
1202 filtercount = 0;
1203 while((dmx_fd = open(device_path, O_RDWR | O_NONBLOCK)) > 0 && filtercount < MAX_FILTER)
1204 {
1205 filtercount++;
1206 if(!cs_malloc(&open_fd, sizeof(struct s_open_fd)))
1207 {
1208 close(dmx_fd);
1209 break;
1210 }
1211 open_fd->fd = dmx_fd;
1212 ll_append(ll_max_fd, open_fd);
1213 }
1214
1215 if(filtercount > 0)
1216 {
1217 itr = ll_iter_create(ll_max_fd);
1218 while((open_fd = ll_iter_next(&itr)))
1219 {
1220 dmx_fd = open_fd->fd;
1221 do
1222 {
1223 ;
1224 }
1225 while(close(dmx_fd) < 0);
1226 ll_iter_remove_data(&itr);
1227 }
1228 devnum = i;
1229 selected_api = devices[devnum].api;
1230 selected_box = devnum;
1231
1232 if(cfg.dvbapi_boxtype == BOXTYPE_NEUMO)
1233 {
1234 selected_api = DVBAPI_3; //DeepThought
1235 }
1236
1237 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
1238 if(selected_api == STAPI && stapi_open() == 0)
1239 {
1240 cs_log("ERROR: stapi: setting up stapi failed.");
1241 return 0;
1242 }
1243 #endif
1244 maxfilter = filtercount;
1245 cs_log("Detected %s Api: %d, userconfig boxtype: %d maximum number of filters is %d (oscam limit is %d)",
1246 device_path, selected_api, cfg.dvbapi_boxtype, filtercount, MAX_FILTER);
1247 }
1248
1249 // try at least 8 adapters
1250 if((strchr(devices[i].path, '%') != NULL) && (n < 8))
1251 {
1252 n++;
1253 }
1254 else
1255 {
1256 n = 0; i++;
1257 }
1258
1259 } while(n != 0); // n is set to 0 again if 8 adapters are tried!
1260
1261 if(devnum != -1)
1262 {
1263 break; // check if box detected
1264 }
1265 }
1266
1267 ll_destroy(&ll_max_fd);
1268 if(devnum == -1)
1269 {
1270 return 0;
1271 }
1272 #endif
1273
1274 return 1;
1275 }
1276
1277 static int32_t dvbapi_read_device(int32_t dmx_fd, uint8_t *buf, uint32_t length)
1278 {
1279 int32_t readed;
1280 uint32_t count = 0;
1281 struct pollfd pfd[1];
1282
1283 pfd[0].fd = dmx_fd;
1284 pfd[0].events = (POLLIN | POLLPRI);
1285
1286 while(count < length)
1287 {
1288 if(poll(pfd, 1, 0)) // fd ready for reading?
1289 {
1290 if(pfd[0].revents & (POLLIN | POLLPRI)) // is there data to read?
1291 {
1292 readed = read(dmx_fd, &buf[count], length-count);
1293 if(readed < 0) // error occured while reading
1294 {
1295 if(errno == EINTR || errno == EAGAIN) // try again in case of interrupt
1296 {
1297 continue;
1298 }
1299
1300 cs_log("ERROR: Read error on fd %d (errno=%d %s)", dmx_fd, errno, strerror(errno));
1301 return (errno == EOVERFLOW ? 0 : -1);
1302 }
1303
1304 if(readed > 0) // succesfull read
1305 {
1306 count += readed;
1307 }
1308
1309 if(readed == 0 && count > 0) // nothing to read left
1310 {
1311 break;
1312 }
1313 }
1314 else
1315 {
1316 return -1; // other events than pollin/pri means bad news -> abort!
1317 }
1318 }
1319 else
1320 {
1321 break;
1322 }
1323 }
1324 cs_log_dump_dbg(D_TRACE, buf, count, "Received:");
1325 return count;
1326 }
1327
1328 int32_t dvbapi_open_device(int32_t type, int32_t num, int32_t adapter)
1329 {
1330 int32_t dmx_fd, ret;
1331 int32_t ca_offset = 0;
1332 char device_path[128], device_path2[128];
1333
1334 if(cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
1335 {
1336 return DUMMY_FD;
1337 }
1338
1339 if(type == 0)
1340 {
1341 snprintf(device_path2, sizeof(device_path2), devices[selected_box].demux_device, num);
1342 snprintf(device_path, sizeof(device_path), devices[selected_box].path, adapter);
1343 strncat(device_path, device_path2, sizeof(device_path) - strlen(device_path));
1344 }
1345 else
1346 {
1347 if(cfg.dvbapi_boxtype == BOXTYPE_DUCKBOX
1348 || cfg.dvbapi_boxtype == BOXTYPE_DBOX2
1349 || cfg.dvbapi_boxtype == BOXTYPE_UFS910)
1350 {
1351 ca_offset = 1;
1352 }
1353
1354 if(cfg.dvbapi_boxtype == BOXTYPE_QBOXHD
1355 || cfg.dvbapi_boxtype == BOXTYPE_PC
1356 || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
1357 {
1358 num = 0;
1359 }
1360
1361 snprintf(device_path2, sizeof(device_path2), devices[selected_box].ca_device, num + ca_offset);
1362 snprintf(device_path, sizeof(device_path), devices[selected_box].path, adapter);
1363 strncat(device_path, device_path2, sizeof(device_path) - strlen(device_path));
1364 }
1365
1366 if(cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
1367 {
1368 if(type == 0)
1369 {
1370 struct sockaddr_un saddr;
1371 memset(&saddr, 0, sizeof(saddr));
1372 saddr.sun_family = AF_UNIX;
1373 cs_strncpy(saddr.sun_path, device_path, sizeof(saddr.sun_path));
1374 dmx_fd = socket(AF_UNIX, SOCK_STREAM, 0);
1375 ret = connect(dmx_fd, (struct sockaddr *)&saddr, sizeof(saddr));
1376 if(ret < 0)
1377 {
1378 close(dmx_fd);
1379 }
1380 }
1381 else if(type == 1)
1382 {
1383 int32_t udp_port = 9000;
1384 struct sockaddr_in saddr;
1385 memset(&saddr, 0, sizeof(saddr));
1386 saddr.sin_family = AF_INET;
1387 saddr.sin_port = htons(udp_port + adapter);
1388 saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
1389 dmx_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
1390 set_nonblock(dmx_fd, true);
1391 ret = connect(dmx_fd, (struct sockaddr *) &saddr, sizeof(saddr));
1392 if(ret < 0)
1393 {
1394 close(dmx_fd);
1395 }
1396 cs_log_dbg(D_DVBAPI, "NET DEVICE open (port = %d) fd %d", udp_port + adapter, dmx_fd);
1397 }
1398 else
1399 {
1400 ret = -1;
1401 }
1402 }
1403 else
1404 {
1405 dmx_fd = ret = open(device_path, O_RDWR | O_NONBLOCK);
1406 }
1407
1408 if(ret < 0)
1409 {
1410 cs_log("ERROR: Can't open device %s (errno=%d %s)", device_path, errno, strerror(errno));
1411 return -1;
1412 }
1413 cs_log_dbg(D_DVBAPI, "Open device %s (fd %d)", device_path, dmx_fd);
1414 return dmx_fd;
1415 }
1416
1417 uint16_t tunemm_caid_map(uint8_t direct, uint16_t caid, uint16_t srvid)
1418 {
1419 int32_t i;
1420 struct s_client *cl = cur_client();
1421 TUNTAB *ttab = &cl->ttab;
1422
1423 if(!ttab->ttnum)
1424 {
1425 return caid;
1426 }
1427
1428 if(direct)
1429 {
1430 for(i = 0; i < ttab->ttnum; i++)
1431 {
1432 if(caid == ttab->ttdata[i].bt_caidto &&
1433 (srvid == ttab->ttdata[i].bt_srvid || ttab->ttdata[i].bt_srvid == 0xFFFF || !ttab->ttdata[i].bt_srvid))
1434 {
1435 return ttab->ttdata[i].bt_caidfrom;
1436 }
1437 }
1438 }
1439 else
1440 {
1441 for(i = 0; i < ttab->ttnum; i++)
1442 {
1443 if(caid == ttab->ttdata[i].bt_caidfrom &&
1444 (srvid == ttab->ttdata[i].bt_srvid || ttab->ttdata[i].bt_srvid == 0xFFFF || !ttab->ttdata[i].bt_srvid))
1445 {
1446 return ttab->ttdata[i].bt_caidto;
1447 }
1448 }
1449 }
1450 return caid;
1451 }
1452
1453 int32_t dvbapi_stop_filter(int32_t demux_id, int32_t type, uint32_t msgid)
1454 {
1455 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
1456 // We prevented PAT and PMT from starting, so lets don't close them either.
1457 if(type == TYPE_PAT || type == TYPE_PMT)
1458 {
1459 return 1;
1460 }
1461 #endif
1462
1463 int32_t g, error = 0;
1464
1465 // just stop them all, we don't want to risk leaving
1466 // any stale filter running due to lowering of maxfilters
1467 for(g = 0; g < MAX_FILTER; g++)
1468 {
1469 if(demux[demux_id].demux_fd[g].type == type)
1470 {
1471 if(dvbapi_stop_filternum(demux_id, g, msgid) == -1)
1472 {
1473 error = 1;
1474 }
1475 }
1476 }
1477 return !error; // on error return 0, all ok 1
1478 }
1479
1480 int32_t dvbapi_stop_filternum(int32_t demux_id, int32_t num, uint32_t msgid)
1481 {
1482 int32_t retfilter = -1, retfd = -1, fd = demux[demux_id].demux_fd[num].fd, try = 0;
1483
1484 if(USE_OPENXCAS)
1485 {
1486 demux[demux_id].demux_fd[num].type = 0;
1487 demux[demux_id].demux_fd[num].fd = 0;
1488 return 1; // all ok!
1489 }
1490
1491 if(fd > 0)
1492 {
1493 do
1494 {
1495 errno = 0;
1496 if(try)
1497 {
1498 cs_sleepms(50);
1499 }
1500 try++;
1501
1502 cs_log_dbg(D_DVBAPI, "Demuxer %d stop filter %d try %d (fd: %d api: %d, caid: %04X, provid: %06X, %spid: %04X)",
1503 demux_id,
1504 num + 1,
1505 try,
1506 fd,
1507 selected_api,
1508 demux[demux_id].demux_fd[num].caid,
1509 demux[demux_id].demux_fd[num].provid,
1510 demux[demux_id].demux_fd[num].type == TYPE_ECM ? "ecm" : "emm",
1511 demux[demux_id].demux_fd[num].pid);
1512
1513 switch(selected_api)
1514 {
1515 case DVBAPI_3:
1516 {
1517 if(cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
1518 {
1519 retfilter = dvbapi_net_send(DVBAPI_DMX_STOP,
1520 demux[demux_id].socket_fd,
1521 msgid,
1522 demux_id,
1523 num,
1524 NULL,
1525 NULL,
1526 NULL,
1527 demux[demux_id].client_proto_version);
1528 }
1529 else
1530 {
1531 retfilter = dvbapi_ioctl(fd, DMX_STOP, NULL);
1532 }
1533 break;
1534 }
1535
1536 case DVBAPI_1:
1537 {
1538 retfilter = dvbapi_ioctl(fd, DMX_STOP, NULL);
1539 break;
1540 }
1541
1542 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
1543 case STAPI:
1544 {
1545 retfilter = stapi_remove_filter(demux_id, num, demux[demux_id].pmt_file);
1546 if(retfilter != 1) // stapi returns 0 for error, 1 for all ok
1547 {
1548 retfilter = -1;
1549 }
1550 break;
1551 }
1552 #endif
1553 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
1554 case COOLAPI:
1555 {
1556 retfilter = coolapi_remove_filter(fd, num);
1557 if(retfilter >= 0)
1558 {
1559 retfd = coolapi_close_device(fd);
1560 }
1561 break;
1562 }
1563 #endif
1564 default:
1565 break;
1566 }
1567
1568 if(errno == 9) // no error on bad file descriptor
1569 {
1570 retfilter = 0;
1571 }
1572 } while(retfilter < 0 && try < 10);
1573
1574 #if !defined WITH_COOLAPI && !defined WITH_COOLAPI2 // no fd close for coolapi and stapi, all others do close fd!
1575 try = 0;
1576 do
1577 {
1578 if(try)
1579 {
1580 errno = 0;
1581 cs_sleepms(50);
1582 }
1583 try++;
1584
1585 // on bad filterfd dont try to close!
1586 if(!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX && errno != 9)
1587 {
1588 if(selected_api == STAPI)
1589 {
1590 retfd = 0; // stapi closes its own filter fd!
1591 }
1592 else
1593 {
1594 // flush filter input buffer in attempt to avoid overflow receivers internal buffer
1595 flush_read_fd(demux_id, num, fd);
1596 retfd = close(fd);
1597 if(errno == 9)
1598 {
1599 retfd = 0; // no error on bad file descriptor
1600 }
1601 }
1602 }
1603 else
1604 {
1605 retfd = 0;
1606 }
1607
1608 } while(retfd < 0 && try < 10);
1609 #endif
1610 }
1611 else // fd <=0
1612 {
1613 return 1; // filter was already killed!
1614 }
1615
1616 if(retfilter < 0) // error on remove filter
1617 {
1618 cs_log("ERROR: Demuxer %d could not stop Filter %d (fd:%d api:%d errno=%d %s)",
1619 demux_id, num + 1, fd, selected_api, errno, strerror(errno));
1620 return retfilter;
1621 }
1622
1623 if(retfd < 0) // error on close filter fd
1624 {
1625 cs_log("ERROR: Demuxer %d could not close fd of Filter %d (fd=%d api:%d errno=%d %s)",
1626 demux_id, num + 1, fd, selected_api, errno, strerror(errno));
1627 return retfd;
1628 }
1629
1630 // code below runs only if nothing has gone wrong
1631 if(demux[demux_id].demux_fd[num].type == TYPE_ECM) // ecm filter stopped: reset index!
1632 {
1633 int32_t oldpid = demux[demux_id].demux_fd[num].pidindex;
1634 int32_t curpid = demux[demux_id].pidindex;
1635
1636 // workaround: below dont run on stapi since it handles it own pids...
1637 // stapi need to be better integrated in oscam dvbapi.
1638 if(selected_api != STAPI)
1639 {
1640 int32_t z;
1641 for(z = 0; z < MAX_STREAM_INDICES; z++)
1642 {
1643 uint32_t idx = demux[demux_id].ECMpids[oldpid].index[z];
1644 demux[demux_id].ECMpids[oldpid].index[z] = INDEX_INVALID;
1645
1646 if(idx != INDEX_INVALID) // if in use
1647 {
1648 int32_t i;
1649 for(i = 0; i < demux[demux_id].STREAMpidcount; i++)
1650 {
1651 int8_t match = 0;
1652
1653 // check streams of old disabled ecmpid
1654 if(!demux[demux_id].ECMpids[oldpid].streams
1655 || ((demux[demux_id].ECMpids[oldpid].streams & (1 << i)) == (uint) (1 << i)))
1656 {
1657 // check if new ecmpid is using same streams
1658 if(curpid != -1 && (!demux[demux_id].ECMpids[curpid].streams
1659 || ((demux[demux_id].ECMpids[curpid].streams & (1 << i)) == (uint) (1 << i))))
1660 {
1661 continue; // found same stream on old and new ecmpid -> skip! (and leave it enabled!)
1662 }
1663 int32_t pidtobestopped = demux[demux_id].STREAMpids[i];
1664 int32_t j, k, otherdemuxpid;
1665 uint32_t otherdemuxidx;
1666
1667 for(j = 0; j < MAX_DEMUX; j++) // check other demuxers for same streampid with same index
1668 {
1669 if(demux[j].program_number == 0 || demux_id == j || demux[j].ca_mask != demux[demux_id].ca_mask)
1670 {
1671 continue;
1672 // skip empty demuxers
1673 // skip same demuxer
1674 // skip streampid running on other ca device
1675 }
1676
1677 otherdemuxpid = demux[j].pidindex;
1678 if(otherdemuxpid == -1)
1679 {
1680 continue; // Other demuxer not descrambling yet
1681 }
1682
1683 int32_t y;
1684 for(y = 0; y < MAX_STREAM_INDICES; y++)
1685 {
1686 otherdemuxidx = demux[j].ECMpids[otherdemuxpid].index[y];
1687 if(otherdemuxidx == INDEX_INVALID || otherdemuxidx != idx)
1688 {
1689 continue; // Other demuxer has no index yet, or index is different
1690 }
1691
1692 for(k = 0; k < demux[j].STREAMpidcount; k++)
1693 {
1694 if(!demux[j].ECMpids[otherdemuxpid].streams
1695 || ((demux[j].ECMpids[otherdemuxpid].streams & (1 << k)) == (uint) (1 << k)))
1696 {
1697 if(demux[j].STREAMpids[k] == pidtobestopped)
1698 {
1699 continue; // found same streampid enabled with same index
1700 // on one or more other demuxers -> skip! (and leave it enabled!)
1701 }
1702 }
1703 match = 1; // matching stream found
1704 }
1705 }
1706 }
1707
1708 if(!match)
1709 {
1710 for(j = 0; j < CA_MAX; j++)
1711 {
1712 if(((demux[demux_id].ca_mask & (1 << j)) == (uint32_t) (1 << j)))
1713 {
1714 remove_streampid_from_list(j, pidtobestopped, idx);
1715 break;
1716 }
1717 }
1718 }
1719 }
1720 }
1721 }
1722 }
1723 }
1724 }
1725
1726 if(demux[demux_id].demux_fd[num].type == TYPE_EMM) // If emm type remove from emm filterlist
1727 {
1728 remove_emmfilter_from_list(demux_id,
1729 demux[demux_id].demux_fd[num].caid,
1730 demux[demux_id].demux_fd[num].provid,
1731 demux[demux_id].demux_fd[num].pid,
1732 num + 1);
1733 }
1734 demux[demux_id].demux_fd[num].type = 0;
1735 demux[demux_id].demux_fd[num].fd = 0;
1736 return 1; // all ok!
1737 }
1738
1739 void dvbapi_start_filter(int32_t demux_id, int32_t pidindex, uint16_t pid, uint16_t caid,
1740 uint32_t provid, uint8_t table, uint8_t mask, int32_t timeout, int32_t type)
1741 {
1742 int32_t i;
1743 for(i = 0; i < maxfilter; i++) // check if filter is present
1744 {
1745 if(demux[demux_id].demux_fd[i].fd > 0 &&
1746 demux[demux_id].demux_fd[i].pid == pid &&
1747 demux[demux_id].demux_fd[i].type == type &&
1748 demux[demux_id].demux_fd[i].filter[0] == table &&
1749 demux[demux_id].demux_fd[i].mask[0] == mask)
1750 {
1751 return;
1752 }
1753 }
1754
1755 uint8_t filter[32];
1756 memset(filter, 0, 32);
1757 filter[0] = table;
1758 filter[16] = mask;
1759
1760 cs_log_dbg(D_DVBAPI, "Demuxer %d try to start new filter for caid: %04X, provid: %06X, pid: %04X",
1761 demux_id, caid, provid, pid);
1762
1763 dvbapi_set_filter(demux_id, selected_api, pid, caid, provid, filter, filter + 16, timeout, pidindex, type, 0);
1764 }
1765
1766 void dvbapi_start_sdt_filter(int32_t demux_id)
1767 {
1768 dvbapi_start_filter(demux_id, demux[demux_id].pidindex, 0x0011, 0x001, 0x01, 0x42, 0xFF, 0, TYPE_SDT);
1769 demux[demux_id].sdt_filter = 0;
1770 }
1771
1772 void dvbapi_start_pat_filter(int32_t demux_id)
1773 {
1774 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
1775 // PAT-Filter breaks API and OSCAM for Coolstream.
1776 // Don't use it
1777 return;
1778 #endif
1779 dvbapi_start_filter(demux_id, demux[demux_id].pidindex, 0x0000, 0x001, 0x01, 0x00, 0xFF, 0, TYPE_PAT);
1780 }
1781
1782 void dvbapi_start_pmt_filter(int32_t demux_id)
1783 {
1784 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
1785 // PMT-Filter breaks API and OSCAM for Coolstream.
1786 // Don't use it
1787 return;
1788 #endif
1789 uint8_t filter[16], mask[16];
1790 memset(filter, 0, 16);
1791 memset(mask, 0, 16);
1792
1793 filter[0] = 0x02;
1794 i2b_buf(2, demux[demux_id].program_number, filter + 1); // add srvid to filter since the pid can deliver pmt for multiple srvid
1795 mask[0] = 0xFF;
1796 mask[1] = 0xFF;
1797 mask[2] = 0xFF;
1798
1799 dvbapi_set_filter(demux_id, selected_api, demux[demux_id].pmtpid, 0x001, 0x01, filter, mask, 0, 0, TYPE_PMT, 0);
1800 }
1801
1802 void dvbapi_start_cat_filter(int32_t demux_id)
1803 {
1804 dvbapi_start_filter(demux_id, demux[demux_id].pidindex, 0x0001, 0x001, 0x01, 0x01, 0xFF, 0, TYPE_CAT);
1805 demux[demux_id].emm_filter = 0;
1806 }
1807
1808 void dvbapi_start_emm_filter(int32_t demux_id)
1809 {
1810 unsigned int j;
1811 if(!demux[demux_id].EMMpidcount)
1812 {
1813 return;
1814 }
1815
1816 struct s_csystem_emm_filter *dmx_filter = NULL;
1817 unsigned int filter_count = 0;
1818 uint16_t caid, ncaid;
1819 uint32_t provid;
1820 struct s_reader *rdr = NULL;
1821 struct s_client *cl = cur_client();
1822
1823 if(!cl || !cl->aureader_list)
1824 {
1825 return;
1826 }
1827
1828 LL_ITER itr = ll_iter_create(cl->aureader_list);
1829 while((rdr = ll_iter_next(&itr)))
1830 {
1831 if(!(rdr->grp & cl->grp))
1832 {
1833 continue;
1834 }
1835
1836 if(rdr->audisabled || !rdr->enable || (!is_network_reader(rdr) && rdr->card_status != CARD_INSERTED))
1837 {
1838 continue;
1839 }
1840
1841 const struct s_cardsystem *csystem;
1842 uint16_t c, match;
1843 cs_log_dbg(D_DVBAPI, "Demuxer %d matching reader %s against available emmpids -> START!", demux_id, rdr->label);
1844
1845 for(c = 0; c < demux[demux_id].EMMpidcount; c++)
1846 {
1847 caid = ncaid = demux[demux_id].EMMpids[c].CAID;
1848 if(!caid) continue;
1849
1850 if(chk_is_betatunnel_caid(caid) == 2)
1851 {
1852 ncaid = tunemm_caid_map(FROM_TO, caid, demux[demux_id].program_number);
1853 }
1854 provid = demux[demux_id].EMMpids[c].PROVID;
1855
1856 if(caid == ncaid)
1857 {
1858 match = emm_reader_match(rdr, caid, provid);
1859 }
1860 else
1861 {
1862 match = emm_reader_match(rdr, ncaid, provid);
1863 }
1864
1865 if(match)
1866 {
1867 if(rdr->typ == R_EMU)
1868 {
1869 csystem = rdr->csystem;
1870 }
1871 else
1872 {
1873 csystem = get_cardsystem_by_caid(caid);
1874 }
1875 if(csystem)
1876 {
1877 if(caid != ncaid)
1878 {
1879 csystem = get_cardsystem_by_caid(ncaid);
1880 if(csystem && csystem->get_tunemm_filter)
1881 {
1882 csystem->get_tunemm_filter(rdr, &dmx_filter, &filter_count);
1883 cs_log_dbg(D_DVBAPI, "Demuxer %d setting emm filter for betatunnel: %04X -> %04X",
1884 demux_id, ncaid, caid);
1885 }
1886 else
1887 {
1888 cs_log_dbg(D_DVBAPI, "Demuxer %d cardsystem for emm filter for caid %04X of reader %s not found",
1889 demux_id, ncaid, rdr->label);
1890 continue;
1891 }
1892 }
1893 else if(csystem->get_emm_filter)
1894 {
1895 if(rdr->typ == R_EMU)
1896 {
1897 csystem->get_emm_filter_adv(rdr, &dmx_filter, &filter_count, caid, provid, demux[demux_id].program_number,
1898 demux[demux_id].tsid, demux[demux_id].onid, demux[demux_id].ens);
1899 }
1900 else
1901 {
1902 csystem->get_emm_filter(rdr, &dmx_filter, &filter_count);
1903 }
1904 }
1905 }
1906 else
1907 {
1908 cs_log_dbg(D_DVBAPI, "Demuxer %d cardsystem for emm filter for caid %04X of reader %s not found",
1909 demux_id, caid, rdr->label);
1910 continue;
1911 }
1912
1913 for(j = 0; j < filter_count ; j++)
1914 {
1915 if(dmx_filter[j].enabled == 0)
1916 {
1917 continue;
1918 }
1919
1920 uint8_t filter[32];
1921 memset(filter, 0, sizeof(filter)); // reset filter
1922 uint32_t usefilterbytes = 16; // default use all filters
1923 memcpy(filter, dmx_filter[j].filter, usefilterbytes);
1924 memcpy(filter + 16, dmx_filter[j].mask, usefilterbytes);
1925 int32_t emmtype = dmx_filter[j].type;
1926
1927 if(filter[0] && (((1 << (filter[0] % 0x80)) & rdr->b_nano) && !((1 << (filter[0] % 0x80)) & rdr->s_nano)))
1928 {
1929 cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d blocked by userconfig -> SKIP!",
1930 demux_id, rdr->label, j + 1, filter_count);
1931 continue;
1932 }
1933
1934 if((rdr->blockemm & emmtype) && !(((1 << (filter[0] % 0x80)) & rdr->s_nano) || (rdr->saveemm & emmtype)))
1935 {
1936 cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d blocked by userconfig -> SKIP!",
1937 demux_id, rdr->label, j + 1, filter_count);
1938 continue;
1939 }
1940
1941 if(demux[demux_id].EMMpids[c].type & emmtype)
1942 {
1943 cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d type match -> ENABLE!",
1944 demux_id, rdr->label, j + 1, filter_count);
1945 check_add_emmpid(demux_id, filter, c, emmtype);
1946 }
1947 else
1948 {
1949 cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d type mismatch -> SKIP!",
1950 demux_id, rdr->label, j + 1, filter_count);
1951 }
1952 }
1953 // dmx_filter not use below this point;
1954 NULLFREE(dmx_filter);
1955 filter_count = 0;
1956 }
1957 }
1958 cs_log_dbg(D_DVBAPI, "Demuxer %d matching reader %s against available emmpids -> DONE!", demux_id, rdr->label);
1959 }
1960
1961 if(demux[demux_id].emm_filter == -1) // first run -1
1962 {
1963 demux[demux_id].emm_filter = 0;
1964 }
1965 cs_log_dbg(D_DVBAPI, "Demuxer %d handles %i emm filters", demux_id, demux[demux_id].emm_filter);
1966 }
1967
1968 void dvbapi_add_ecmpid_int(int32_t demux_id, uint16_t caid, uint16_t ecmpid, uint32_t provid, uint32_t cadata, char *txt)
1969 {
1970 int32_t n, added = 0;
1971 int32_t stream = demux[demux_id].STREAMpidcount - 1;
1972
1973 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
1974 {
1975 if(demux[demux_id].ECMpids[n].CAID == caid && demux[demux_id].ECMpids[n].ECM_PID == ecmpid
1976 && (!provid || (provid && demux[demux_id].ECMpids[n].PROVID == provid)))
1977 {
1978 added = 1;
1979 if(stream > -1)
1980 {
1981 if(!demux[demux_id].ECMpids[n].streams)
1982 {
1983 // we already got this caid/ecmpid as global, no need to add the single stream
1984 cs_log_dbg(D_DVBAPI, "Demuxer %d skipped stream CAID: %04X ECM_PID: %04X PROVID: %06X (Same as ECMPID %d)",
1985 demux_id, caid, ecmpid, provid, n);
1986 continue;
1987 }
1988 demux[demux_id].ECMpids[n].streams |= (1 << stream);
1989 cs_log("Demuxer %d added stream to ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X",
1990 demux_id, n, caid, ecmpid, provid);
1991 }
1992 }
1993 }
1994
1995 if(added == 1)
1996 {
1997 return;
1998 }
1999
2000 if(demux[demux_id].ECMpidcount >= MAX_ECM_PIDS)
2001 {
2002 cs_log("We reached maximum ECMpids: unable to add to demuxer %d ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X %s",
2003 demux_id, demux[demux_id].ECMpidcount, caid, ecmpid, provid, txt);
2004 return;
2005 }
2006
2007 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].ECM_PID = ecmpid;
2008 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].CAID = caid;
2009 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].PROVID = provid;
2010 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].CHID = 0x10000; // reset CHID
2011 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].checked = 0;
2012 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].status = 0;
2013 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].tries = 0xFE;
2014 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].streams = 0; // reset streams!
2015 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].irdeto_curindex = 0xFE; // reset
2016 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].irdeto_maxindex = 0; // reset
2017 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].irdeto_cycle = 0xFE; // reset
2018 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].table = 0;
2019 demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].cadata = cadata;
2020
2021 cs_log("Demuxer %d ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X %s",
2022 demux_id, demux[demux_id].ECMpidcount, caid, ecmpid, provid, txt);
2023
2024 // marker to fetch emms early irdeto needs them!
2025 if(caid_is_irdeto(caid) || (caid_is_dre(caid) && (provid == 0x11 || provid == 0xFE)))
2026 {
2027 demux[demux_id].emmstart.time = 1;
2028 }
2029 demux[demux_id].ECMpidcount++;
2030 }
2031
2032 void dvbapi_add_ecmpid(int32_t demux_id, uint16_t caid, uint16_t ecmpid, uint32_t provid, uint32_t cadata, char *txt)
2033 {
2034 dvbapi_add_ecmpid_int(demux_id, caid, ecmpid, provid, cadata, txt);
2035 struct s_dvbapi_priority *joinentry;
2036
2037 for(joinentry = dvbapi_priority; joinentry != NULL; joinentry = joinentry->next)
2038 {
2039 if((joinentry->type != 'j')
2040 || (joinentry->caid && joinentry->caid != caid)
2041 || (joinentry->provid && joinentry->provid != provid)
2042 || (joinentry->ecmpid && joinentry->ecmpid != ecmpid)
2043 || (joinentry->srvid && joinentry->srvid != demux[demux_id].program_number))
2044 {
2045 continue;
2046 }
2047
2048 cs_log_dbg(D_DVBAPI, "Join ecmpid %04X@%06X:%04X to %04X@%06X:%04X",
2049 caid, provid, ecmpid, joinentry->mapcaid, joinentry->mapprovid, joinentry->mapecmpid);
2050 dvbapi_add_ecmpid_int(demux_id, joinentry->mapcaid, joinentry->mapecmpid, joinentry->mapprovid, 0, txt);
2051 }
2052 }
2053
2054 void dvbapi_add_emmpid(int32_t demux_id, uint16_t caid, uint16_t emmpid, uint32_t provid, uint32_t cadata, uint8_t type)
2055 {
2056 char typetext[40];
2057 char cadatatext[40];
2058 cs_strncpy(typetext, ":", sizeof(typetext));
2059
2060 if(type & 0x01) { strcat(typetext, "UNIQUE:"); }
2061 if(type & 0x02) { strcat(typetext, "SHARED:"); }
2062 if(type & 0x04) { strcat(typetext, "GLOBAL:"); }
2063 if(type & 0xF8) { strcat(typetext, "UNKNOWN:"); }
2064
2065 if(cadata > 0)
2066 {
2067 snprintf(cadatatext, 40, " CA DATA %X ", cadata);
2068 }
2069 else
2070 {
2071 cadatatext[0] = '\t'; cadatatext[1] = '\0';
2072 }
2073
2074 if(caid == 0x4AE1 && provid == 0x11 && cadata == 0)
2075 {
2076 return;
2077 }
2078
2079 uint16_t i;
2080 for(i = 0; i < demux[demux_id].EMMpidcount; i++)
2081 {
2082 if(demux[demux_id].EMMpids[i].PID == emmpid && demux[demux_id].EMMpids[i].CAID == caid &&
2083 demux[demux_id].EMMpids[i].PROVID == provid && demux[demux_id].EMMpids[i].cadata == cadata)
2084 {
2085 if(!(demux[demux_id].EMMpids[i].type & type))
2086 {
2087 demux[demux_id].EMMpids[i].type |= type; // register this emm kind to this emmpid
2088 cs_log_dbg(D_DVBAPI, "Added to existing emmpid %d additional emmtype %s",
2089 demux[demux_id].EMMpidcount - 1, typetext);
2090 }
2091 return;
2092 }
2093 }
2094
2095 if(i < MAX_EMM_PIDS)
2096 {
2097 demux[demux_id].EMMpids[demux[demux_id].EMMpidcount].PID = emmpid;
2098 demux[demux_id].EMMpids[demux[demux_id].EMMpidcount].CAID = caid;
2099 demux[demux_id].EMMpids[demux[demux_id].EMMpidcount].PROVID = provid;
2100 demux[demux_id].EMMpids[demux[demux_id].EMMpidcount].type = type;
2101 demux[demux_id].EMMpids[demux[demux_id].EMMpidcount++].cadata = cadata;
2102 cs_log_dbg(D_DVBAPI, "Added new emmpid %d CAID: %04X EMM_PID: %04X PROVID: %06X%sTYPE %s",
2103 demux[demux_id].EMMpidcount - 1, caid, emmpid, provid, cadatatext, typetext);
2104 }
2105 else
2106 {
2107 cs_log_dbg(D_DVBAPI, "We reached max emmpids: unable to add new emmpid %d CAID: %04X EMM_PID: %04X PROVID: %06X%sTYPE %s",
2108 demux[demux_id].EMMpidcount - 1, caid, emmpid, provid, cadatatext, typetext);
2109 }
2110 }
2111
2112 static void dvbapi_parse_cat_ca_descriptor(int32_t demux_id, const uint8_t *buffer, uint8_t descriptor_length)
2113 {
2114 uint16_t i, ca_system_id, ca_pid;
2115 uint32_t ca_provider = 0, ca_data = 0;
2116
2117 if(descriptor_length < 4)
2118 {
2119 return; // CA descriptor has a minimum length of 4 bytes
2120 }
2121
2122 ca_system_id = b2i(2, buffer);
2123 ca_pid = b2i(2, buffer + 2) & 0x1FFF;
2124
2125 switch(ca_system_id >> 8)
2126 {
2127 case 0x01:
2128 {
2129 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, 0, 0, EMM_UNIQUE | EMM_GLOBAL);
2130
2131 for(i = 5; i < descriptor_length; i += 4)
2132 {
2133 ca_pid = b2i(2, buffer + i) & 0x1FFF;
2134 ca_provider = b2i(2, buffer + i + 2);
2135
2136 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, ca_provider, 0, EMM_SHARED);
2137 }
2138 break;
2139 }
2140
2141 case 0x05:
2142 {
2143 for(i = 4; i < descriptor_length; i += 2 + buffer[i + 1])
2144 {
2145 if(buffer[i] == 0x14)
2146 {
2147 ca_provider = (b2i(3, buffer + i + 2) & 0xFFFFF0); // viaccess fixup: don't care about last digit
2148 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, ca_provider, 0, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
2149 }
2150 }
2151 break;
2152 }
2153
2154 case 0x18:
2155 {
2156 if(descriptor_length == 0x07 || descriptor_length == 0x0B)
2157 {
2158 for(i = 5; i < 5 + buffer[4]; i += 2)
2159 {
2160 ca_provider = b2i(2, buffer + i);
2161 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, ca_provider, 0, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
2162 }
2163 }
2164 else
2165 {
2166 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, ca_provider, 0, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
2167 }
2168 break;
2169 }
2170
2171 case 0x27:
2172 case 0x4A:
2173 {
2174 if(caid_is_bulcrypt(ca_system_id))
2175 {
2176 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, 0, 0, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
2177 break;
2178 }
2179
2180 ca_provider = buffer[4];
2181
2182 if(buffer[4] == 0xFE)
2183 {
2184 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, ca_provider, 0x102, EMM_GLOBAL);
2185 }
2186 else
2187 {
2188 if(descriptor_length == 0x0A)
2189 {
2190 ca_data = b2i(4, buffer + 6);
2191 }
2192
2193 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, ca_provider, ca_data, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
2194 }
2195 break;
2196 }
2197
2198 default:
2199 dvbapi_add_emmpid(demux_id, ca_system_id, ca_pid, 0, 0, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
2200 break;
2201 }
2202 }
2203
2204 static void dvbapi_parse_cat(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint32_t msgid)
2205 {
2206 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
2207 // driver sometimes reports error if too many emm filter
2208 // but adding more ecm filter is no problem
2209 // ... so ifdef here instead of limiting MAX_FILTER
2210 demux[demux_id].max_emm_filter = 14;
2211 #else
2212 if(cfg.dvbapi_requestmode == 1)
2213 {
2214 uint16_t ecm_filter_needed = 0, n;
2215 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
2216 {
2217 if(demux[demux_id].ECMpids[n].status > -1)
2218 {
2219 ecm_filter_needed++;
2220 }
2221 }
2222
2223 if(maxfilter - ecm_filter_needed <= 0)
2224 {
2225 demux[demux_id].max_emm_filter = 0;
2226 }
2227 else
2228 {
2229 demux[demux_id].max_emm_filter = maxfilter - ecm_filter_needed;
2230 }
2231 }
2232 else
2233 {
2234 demux[demux_id].max_emm_filter = maxfilter - 1;
2235 }
2236 #endif
2237
2238 uint16_t i;
2239 uint8_t descriptor_tag, descriptor_length;
2240
2241 dvbapi_stop_filter(demux_id, TYPE_CAT, msgid);
2242
2243 for(i = 8; i + 1 < length; i += 2 + descriptor_length)
2244 {
2245 descriptor_tag = buffer[i];
2246 descriptor_length = buffer[i + 1];
2247
2248 if(descriptor_tag == 0x09) // There should be only CA descriptors here
2249 {
2250 dvbapi_parse_cat_ca_descriptor(demux_id, buffer + i + 2, descriptor_length);
2251 }
2252 }
2253 }
2254
2255 static pthread_mutex_t lockindex = PTHREAD_MUTEX_INITIALIZER;
2256
2257 uint32_t dvbapi_get_desc_index(int32_t demux_id, int32_t pid, int32_t stream_id)
2258 {
2259 int32_t i, j, k, fail = 1;
2260 uint32_t idx = 0;
2261
2262 if(cfg.dvbapi_boxtype == BOXTYPE_NEUMO)
2263 {
2264 sscanf(demux[demux_id].pmt_file, "pmt%3d.tmp", &idx);
2265 return idx;
2266 }
2267
2268 SAFE_MUTEX_LOCK(&lockindex); // to avoid race when readers become responsive!
2269 while(fail && idx <= INDEX_MAX)
2270 {
2271 fail = 0;
2272 for(i = 0; i < MAX_DEMUX && !fail && idx < INDEX_MAX; i++)
2273 {
2274 if(demux[i].program_number == 0)
2275 {
2276 continue; // skip empty demuxers
2277 }
2278
2279 if(demux[i].ca_mask != demux[demux_id].ca_mask
2280 && (!(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)))
2281 {
2282 continue; // skip demuxer using other ca device
2283 }
2284
2285 for(j = 0; j < demux[i].ECMpidcount && !fail; j++) // search for new unique index
2286 {
2287 for(k = 0; k < MAX_STREAM_INDICES; k++)
2288 {
2289 if(demux[i].ECMpids[j].index[k] == idx)
2290 {
2291 fail = 1;
2292 idx++;
2293 }
2294 }
2295 }
2296 }
2297 }
2298
2299 if(selected_api == DVBAPI_3 || selected_api == DVBAPI_1)
2300 {
2301 // make sure we haven't run out of descramblers
2302 if(ca_descramblers_used < ca_descramblers_total)
2303 {
2304 ca_descramblers_used++; // increase number of descramblers used
2305 }
2306 else
2307 {
2308 idx = INDEX_INVALID; // we don't have any descramblers left
2309 }
2310 }
2311 else // old style check for STAPI, COOLAPI, etc
2312 {
2313 if(idx > ca_descramblers_total)
2314 {
2315 idx = INDEX_INVALID; // we don't have any descramblers left
2316 }
2317 }
2318
2319 demux[demux_id].ECMpids[pid].index[stream_id] = idx;
2320 SAFE_MUTEX_UNLOCK(&lockindex); // and release it!
2321
2322 return idx;
2323 }
2324
2325 void dvbapi_set_pid(int32_t demux_id, int32_t num, uint32_t idx, bool enable, bool use_des, uint32_t msgid)
2326 {
2327 int32_t i, currentfd;
2328 uint16_t streampid = demux[demux_id].STREAMpids[num];
2329 uint32_t newidx = 0, curidx;
2330 ca_pid_t ca_pid2;
2331
2332 if(demux[demux_id].pidindex == -1 && enable)
2333 {
2334 return; // no current pid on enable? --> exit
2335 }
2336
2337 switch(selected_api)
2338 {
2339 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
2340 case STAPI:
2341 if(!enable) idx = INDEX_INVALID;
2342 stapi_set_pid(demux_id, num, idx, streampid, demux[demux_id].pmt_file); // only used to disable pids!!!
2343 break;
2344 #endif
2345
2346 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
2347 case COOLAPI:
2348 break;
2349 #endif
2350
2351 default:
2352 for(i = 0; i < CA_MAX; i++)
2353 {
2354 newidx = INDEX_INVALID;
2355 curidx = idx;
2356
2357 if(((demux[demux_id].ca_mask & (1 << i)) == (uint32_t) (1 << i)))
2358 {
2359 uint32_t action = 0;
2360 if(enable)
2361 {
2362 action = update_streampid_list(i, streampid, curidx, use_des);
2363 }
2364
2365 if(!enable)
2366 {
2367 action = remove_streampid_from_list(i, streampid, curidx);
2368 }
2369
2370 if(action != NO_STREAMPID_LISTED && action != INVALID_STREAMPID_INDEX &&
2371 action != FOUND_STREAMPID_INDEX && action != ADDED_STREAMPID_INDEX &&
2372 action != REMOVED_STREAMPID_INDEX)
2373 {
2374 // removed last index of this streampid on ca? -> disable this pid with -1 on this ca
2375 if((action == REMOVED_STREAMPID_LASTINDEX || action == FIRST_STREAMPID_INDEX)
2376 && (is_ca_used(i, streampid) == INDEX_INVALID))
2377 {
2378 curidx = DVBAPI_INDEX_DISABLE;
2379 }
2380
2381 // removed index of streampid that is used to decode on ca -> get a fresh one
2382 if(action == REMOVED_DECODING_STREAMPID_INDEX || action == FIRST_STREAMPID_INDEX)
2383 {
2384 newidx = is_ca_used(i, streampid); // get an active index for this pid and enable it on ca device
2385 curidx = DVBAPI_INDEX_DISABLE;
2386 }
2387
2388 while(curidx != INDEX_INVALID || newidx != INDEX_INVALID)
2389 {
2390 memset(&ca_pid2, 0, sizeof(ca_pid2));
2391 ca_pid2.pid = streampid;
2392 if(curidx != INDEX_INVALID)
2393 {
2394 (curidx == DVBAPI_INDEX_DISABLE) ? (ca_pid2.index = -1) : (ca_pid2.index = curidx);
2395 cs_log_dbg(D_DVBAPI, "Demuxer %d %s stream %d pid=0x%04x index=%d on ca%d",
2396 demux_id,
2397 ((enable && curidx != DVBAPI_INDEX_DISABLE) ? "enable" : "disable"),
2398 num + 1,
2399 ca_pid2.pid,
2400 ca_pid2.index,
2401 i);
2402 curidx = INDEX_INVALID; // flag this index as handled
2403 }
2404 else if(newidx != INDEX_INVALID)
2405 {
2406 (newidx == DVBAPI_INDEX_DISABLE) ? (ca_pid2.index = -1) : (ca_pid2.index = newidx);
2407 cs_log_dbg(D_DVBAPI, "Demuxer %d %s stream %d pid=0x%04x by index=%d on ca%d",
2408 demux_id,
2409 ((enable && action == FIRST_STREAMPID_INDEX) ? "enable" : "takeover"),
2410 num + 1,
2411 ca_pid2.pid,
2412 ca_pid2.index,
2413 i);
2414 newidx = INDEX_INVALID; // flag this takeover / new index as handled
2415 }
2416
2417 if(use_des && cfg.dvbapi_extended_cw_api == 2 && ca_pid2.index != -1)
2418 {
2419 ca_pid2.index |= 0x100; // flag DES algo through pid index
2420 }
2421
2422 if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
2423 {
2424 dvbapi_net_send(DVBAPI_CA_SET_PID, demux[demux_id].socket_fd,
2425 msgid,
2426 demux_id,
2427 -1 /*unused*/,
2428 (uint8_t *) &ca_pid2,
2429 NULL,
2430 NULL,
2431 demux[demux_id].client_proto_version);
2432 }
2433 else
2434 {
2435 currentfd = ca_fd[i];
2436 if(currentfd <= 0)
2437 {
2438 currentfd = dvbapi_open_device(1, i, demux[demux_id].adapter_index);
2439 ca_fd[i] = currentfd; // save fd of this ca
2440 }
2441
2442 if(currentfd > 0)
2443 {
2444 if(dvbapi_ioctl(currentfd, CA_SET_PID, &ca_pid2) == -1)
2445 {
2446 cs_log_dbg(D_TRACE | D_DVBAPI,"CA_SET_PID ioctl error (errno=%d %s)", errno, strerror(errno));
2447 remove_streampid_from_list(i, ca_pid2.pid, INDEX_DISABLE_ALL);
2448 }
2449
2450 uint32_t result = is_ca_used(i, 0); // check if in use by any pid
2451 if(result == INDEX_INVALID)
2452 {
2453 cs_log_dbg(D_DVBAPI, "Demuxer %d close now unused CA%d device", demux_id, i);
2454 int32_t ret = close(currentfd);
2455 if(ret < 0)
2456 {
2457 cs_log("ERROR: Could not close demuxer fd (errno=%d %s)", errno, strerror(errno));
2458 }
2459 currentfd = ca_fd[i] = 0;
2460 }
2461 }
2462 }
2463 }
2464 }
2465 }
2466 }
2467 break;
2468 }
2469 return;
2470 }
2471
2472 void dvbapi_stop_all_descrambling(uint32_t msgid)
2473 {
2474 int32_t j;
2475
2476 for(j = 0; j < MAX_DEMUX; j++)
2477 {
2478 if(demux[j].program_number == 0)
2479 {
2480 continue;
2481 }
2482
2483 dvbapi_stop_descrambling(j, msgid);
2484 }
2485 }
2486
2487 void dvbapi_stop_all_cat_emm_sdt_filtering(uint32_t msgid)
2488 {
2489 int32_t j;
2490
2491 for(j = 0; j < MAX_DEMUX; j++)
2492 {
2493 if(demux[j].program_number == 0)
2494 {
2495 continue;
2496 }
2497
2498 dvbapi_stop_filter(j, TYPE_EMM, msgid);
2499 dvbapi_stop_filter(j, TYPE_SDT, msgid);
2500 dvbapi_stop_filter(j, TYPE_CAT, msgid);
2501 demux[j].emm_filter = -1;
2502 }
2503 }
2504
2505 void dvbapi_stop_descrambling(int32_t demux_id, uint32_t msgid)
2506 {
2507 int32_t i, j, z;
2508 if(demux[demux_id].program_number == 0) { return; }
2509 char channame[CS_SERVICENAME_SIZE];
2510
2511 i = demux[demux_id].pidindex;
2512 if(i < 0)
2513 {
2514 i = 0;
2515 }
2516
2517 demux[demux_id].pidindex = -1; // no ecmpid is to be descrambling since we start stop descrambling!
2518
2519 get_servicename(dvbapi_client, demux[demux_id].program_number,
2520 demux[demux_id].ECMpidcount > 0 ? demux[demux_id].ECMpids[i].PROVID : NO_PROVID_VALUE,
2521 demux[demux_id].ECMpidcount > 0 ? demux[demux_id].ECMpids[i].CAID : NO_CAID_VALUE,
2522 channame, sizeof(channame));
2523
2524 cs_log("Demuxer %d stopped descrambling for program %04X (%s)",
2525 demux_id, demux[demux_id].program_number, channame);
2526
2527 dvbapi_stop_filter(demux_id, TYPE_EMM, msgid);
2528 dvbapi_stop_filter(demux_id, TYPE_SDT, msgid);
2529 dvbapi_stop_filter(demux_id, TYPE_PAT, msgid);
2530 dvbapi_stop_filter(demux_id, TYPE_PMT, msgid);
2531 dvbapi_stop_filter(demux_id, TYPE_CAT, msgid);
2532
2533 for(i = 0; i < demux[demux_id].ECMpidcount && demux[demux_id].ECMpidcount > 0; i++)
2534 {
2535 for(j = 0; j < MAX_STREAM_INDICES; j++)
2536 {
2537 if(demux[demux_id].ECMpids[i].index[j] == INDEX_INVALID)
2538 {
2539 continue;
2540 }
2541
2542 // disable streams!
2543 for(z = 0; z < demux[demux_id].STREAMpidcount; z++)
2544 {
2545 dvbapi_set_pid(demux_id, z, demux[demux_id].ECMpids[i].index[j], false, false, msgid); // disable streampid
2546 }
2547 demux[demux_id].ECMpids[i].index[j] = INDEX_INVALID;
2548 }
2549 }
2550 dvbapi_stop_filter(demux_id, TYPE_ECM, msgid);
2551
2552 pthread_mutex_destroy(&demux[demux_id].answerlock);
2553 memset(&demux[demux_id], 0 , sizeof(DEMUXTYPE));
2554
2555 SAFE_MUTEX_INIT(&demux[demux_id].answerlock, NULL);
2556 for(i = 0; i < MAX_ECM_PIDS; i++)
2557 {
2558 for(j = 0; j < MAX_STREAM_INDICES; j++)
2559 {
2560 demux[demux_id].ECMpids[i].index[j] = INDEX_INVALID;
2561 }
2562 }
2563 demux[demux_id].pidindex = -1;
2564 demux[demux_id].curindex = -1;
2565 if(ca_descramblers_used > 0) // it should never go below 0, but you never know
2566 {
2567 ca_descramblers_used--; // decrease number of used descramblers
2568 }
2569
2570 if(!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX)
2571 {
2572 unlink(ECMINFO_FILE);
2573 }
2574 return;
2575 }
2576
2577 int32_t dvbapi_start_descrambling(int32_t demux_id, int32_t pid, int8_t checked, uint32_t msgid)
2578 {
2579 int32_t started = 0; // in case ecmfilter started = 1
2580 int32_t fake_ecm = 0;
2581 ECM_REQUEST *er;
2582 struct s_reader *rdr;
2583
2584 if(!(er = get_ecmtask()))
2585 {
2586 return started;
2587 }
2588 demux[demux_id].ECMpids[pid].checked = checked + 1; // mark this pid as checked!
2589
2590 struct s_dvbapi_priority *p;
2591 for(p = dvbapi_priority; p != NULL ; p = p->next)
2592 {
2593 if((p->type != 'p')
2594 || (p->caid && p->caid != demux[demux_id].ECMpids[pid].CAID)
2595 || (p->provid && p->provid != demux[demux_id].ECMpids[pid].PROVID)
2596 || (p->ecmpid && p->ecmpid != demux[demux_id].ECMpids[pid].ECM_PID)
2597 || (p->srvid && p->srvid != demux[demux_id].program_number)
2598 || (p->pidx && p->pidx-1 != pid)
2599 || (p->cadata && p->cadata != demux[demux_id].ECMpids[pid].cadata))
2600 {
2601 continue;
2602 }
2603
2604 // if found chid and first run apply chid filter, on forced pids always apply!
2605 if(p->type == 'p' && p->chid < 0x10000 && (demux[demux_id].ECMpids[pid].checked == 1 || (p && p->force)))
2606 {
2607 if(demux[demux_id].ECMpids[pid].CHID < 0x10000) // channelcache delivered chid
2608 {
2609 er->chid = demux[demux_id].ECMpids[pid].CHID;
2610 }
2611 else
2612 {
2613 er->chid = p->chid; // no channelcache or no chid in use, so use prio chid
2614 demux[demux_id].ECMpids[pid].CHID = p->chid;
2615 }
2616 //cs_log("********* CHID %04X **************", demux[demux_id].ECMpids[pid].CHID);
2617 break; // we only accept one!
2618 }
2619 else
2620 {
2621 if(demux[demux_id].ECMpids[pid].CHID < 0x10000) // channelcache delivered chid
2622 {
2623 er->chid = demux[demux_id].ECMpids[pid].CHID;
2624 }
2625 else // no channelcache or no chid in use
2626 {
2627 er->chid = 0;
2628 demux[demux_id].ECMpids[pid].CHID = 0x10000;
2629 }
2630 }
2631 }
2632
2633 er->srvid = demux[demux_id].program_number;
2634 er->caid = demux[demux_id].ECMpids[pid].CAID;
2635 er->pid = demux[demux_id].ECMpids[pid].ECM_PID;
2636 er->prid = demux[demux_id].ECMpids[pid].PROVID;
2637 er->vpid = demux[demux_id].ECMpids[pid].VPID;
2638 er->pmtpid = demux[demux_id].pmtpid;
2639 er->onid = demux[demux_id].onid;
2640 er->msgid = msgid;
2641
2642 #ifdef WITH_STAPI5
2643 cs_strncpy(er->dev_name, dev_list[demux[demux_id].dev_index].name, sizeof(dev_list[demux[demux_id].dev_index].name));
2644 #endif
2645 struct timeb now;
2646 cs_ftime(&now);
2647
2648 for(rdr = first_active_reader; rdr != NULL ; rdr = rdr->next)
2649 {
2650 int8_t match = matching_reader(er, rdr); // check for matching reader
2651 int64_t gone = comp_timeb(&now, &rdr->emm_last);
2652 if(gone > 3600*1000 && rdr->needsemmfirst && caid_is_irdeto(er->caid))
2653 {
2654 cs_log("Warning reader %s received no emms for the last %d seconds -> skip, this reader needs emms first!",
2655 rdr->label, (int)(gone / 1000));
2656 continue; // skip this card needs to process emms first before it can be used for descramble
2657 }
2658
2659 if(p && p->force)
2660 {
2661 match = 1; // forced pid always started!
2662 }
2663
2664 if(!match) // if this reader does not match, check betatunnel for it
2665 {
2666 match = lb_check_auto_betatunnel(er, rdr);
2667 }
2668
2669 if(!match && chk_is_betatunnel_caid(er->caid)) // these caids might be tunneled invisible by peers
2670 {
2671 match = 1; // so make it a match to try it!
2672 }
2673
2674 // check if cache-ex is matching
2675 if(config_enabled(CS_CACHEEX) && (!match && (cacheex_is_match_alias(dvbapi_client, er))))
2676 {
2677 match = 1; // so make it a match to try it!
2678 }
2679
2680 // BISS1 and BISS2 mode 1/E or FAKE caid
2681 // ecm pid is fake, so send out one fake ecm request
2682 // special treatment: if we asked the cw first without starting a filter,
2683 // the cw request will be killed due to no ecmfilter started
2684 if(caid_is_fake(demux[demux_id].ECMpids[pid].CAID) || caid_is_biss_fixed(demux[demux_id].ECMpids[pid].CAID))
2685 {
2686 int32_t j, n;
2687 er->ecmlen = 5;
2688 er->ecm[0] = 0x80; // to pass the cache check it must be 0x80 or 0x81
2689 er->ecm[1] = 0x00;
2690 er->ecm[2] = 0x02;
2691 i2b_buf(2, er->srvid, er->ecm + 3);
2692
2693 for(j = 0, n = 5; j < demux[demux_id].STREAMpidcount; j++, n += 2)
2694 {
2695 i2b_buf(2, demux[demux_id].STREAMpids[j], er->ecm + n);
2696 er->ecm[2] += 2;
2697 er->ecmlen += 2;
2698 }
2699
2700 cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X ANY CHID PMTPID %04X VPID %04X",
2701 demux_id,
2702 pid,
2703 demux[demux_id].ECMpids[pid].CAID,
2704 demux[demux_id].ECMpids[pid].PROVID,
2705 demux[demux_id].ECMpids[pid].ECM_PID,
2706 demux[demux_id].pmtpid,
2707 demux[demux_id].ECMpids[pid].VPID);
2708
2709 demux[demux_id].curindex = pid; // set current pid to the fresh started one
2710 dvbapi_start_filter(demux_id,
2711 pid,
2712 demux[demux_id].ECMpids[pid].ECM_PID,
2713 demux[demux_id].ECMpids[pid].CAID,
2714 demux[demux_id].ECMpids[pid].PROVID,
2715 0x80,
2716 0xF0,
2717 3000,
2718 TYPE_ECM);
2719
2720 started = 1;
2721 request_cw(dvbapi_client, er, demux_id, 0); // do not register ecm since this try!
2722 fake_ecm = 1;
2723 break; // we started an ecmfilter so stop looking for next matching reader!
2724 }
2725
2726 if(match) // if matching reader found check for irdeto cas if local irdeto card check if it received emms in last 60 minutes
2727 {
2728 if(caid_is_irdeto(er->caid)) // irdeto cas init irdeto_curindex to wait for first index (00)
2729 {
2730 if(demux[demux_id].ECMpids[pid].irdeto_curindex == 0xFE)
2731 {
2732 demux[demux_id].ECMpids[pid].irdeto_curindex = 0x00;
2733 }
2734 }
2735
2736 if(p && p->chid < 0x10000) // do we prio a certain chid?
2737 {
2738 cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X CHID %04X PMTPID %04X VPID %04X",
2739 demux_id, pid,
2740 demux[demux_id].ECMpids[pid].CAID,
2741 demux[demux_id].ECMpids[pid].PROVID,
2742 demux[demux_id].ECMpids[pid].ECM_PID,
2743 demux[demux_id].ECMpids[pid].CHID,
2744 demux[demux_id].pmtpid,
2745 demux[demux_id].ECMpids[pid].VPID);
2746 }
2747 else
2748 {
2749 cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X ANY CHID PMTPID %04X VPID %04X",
2750 demux_id, pid,
2751 demux[demux_id].ECMpids[pid].CAID,
2752 demux[demux_id].ECMpids[pid].PROVID,
2753 demux[demux_id].ECMpids[pid].ECM_PID,
2754 demux[demux_id].pmtpid,
2755 demux[demux_id].ECMpids[pid].VPID);
2756 }
2757
2758 demux[demux_id].curindex = pid; // set current pid to the fresh started one
2759 dvbapi_start_filter(demux_id,
2760 pid,
2761 demux[demux_id].ECMpids[pid].ECM_PID,
2762 demux[demux_id].ECMpids[pid].CAID,
2763 demux[demux_id].ECMpids[pid].PROVID,
2764 0x80,
2765 0xF0,
2766 3000,
2767 TYPE_ECM);
2768
2769 started = 1;
2770 break; // we started an ecmfilter so stop looking for next matching reader!
2771 }
2772 }
2773
2774 if(demux[demux_id].curindex != pid)
2775 {
2776 cs_log("Demuxer %d impossible to descramble PID %d CAID %04X PROVID %06X ECMPID %04X PMTPID %04X (NO MATCHING READER)",
2777 demux_id, pid,
2778 demux[demux_id].ECMpids[pid].CAID,
2779 demux[demux_id].ECMpids[pid].PROVID,
2780 demux[demux_id].ECMpids[pid].ECM_PID,
2781 demux[demux_id].pmtpid);
2782
2783 demux[demux_id].ECMpids[pid].checked = 4; // flag this pid as checked
2784 demux[demux_id].ECMpids[pid].status = -1; // flag this pid as unusable
2785 dvbapi_edit_channel_cache(demux_id, pid, 0); // remove this pid from channelcache
2786 }
2787
2788 if(!fake_ecm)
2789 {
2790 NULLFREE(er);
2791 }
2792 return started;
2793 }
2794
2795 struct s_dvbapi_priority *dvbapi_check_prio_match_emmpid(int32_t demux_id, uint16_t caid, uint32_t provid, char type)
2796 {
2797 struct s_dvbapi_priority *p;
2798 int32_t i;
2799 uint16_t ecm_pid = 0;
2800
2801 for(i = 0; i < demux[demux_id].ECMpidcount; i++)
2802 {
2803 if((demux[demux_id].ECMpids[i].CAID == caid) && (demux[demux_id].ECMpids[i].PROVID == provid))
2804 {
2805 ecm_pid = demux[demux_id].ECMpids[i].ECM_PID;
2806 break;
2807 }
2808 }
2809
2810 if(!ecm_pid)
2811 {
2812 return NULL;
2813 }
2814
2815 for(p = dvbapi_priority; p != NULL; p = p->next)
2816 {
2817 if(p->type != type
2818 || (p->caid && p->caid != caid)
2819 || (p->provid && p->provid != provid)
2820 || (p->ecmpid && p->ecmpid != ecm_pid)
2821 || (p->srvid && p->srvid != demux[demux_id].program_number)
2822 || (p->pidx && p->pidx-1 !=i)
2823 || (p->type == 'i' && (p->chid < 0x10000)))
2824 {
2825 continue;
2826 }
2827
2828 return p;
2829 }
2830 return NULL;
2831 }
2832
2833 struct s_dvbapi_priority *dvbapi_check_prio_match(int32_t demux_id, int32_t pidindex, char type)
2834 {
2835 if(!dvbapi_priority)
2836 {
2837 return NULL;
2838 }
2839
2840 struct s_dvbapi_priority *p;
2841 struct s_ecmpid *ecmpid = &demux[demux_id].ECMpids[pidindex];
2842
2843 for(p = dvbapi_priority; p != NULL; p = p->next)
2844 {
2845 if(p->type != type
2846 || (p->caid && p->caid != ecmpid->CAID)
2847 || (p->provid && p->provid != ecmpid->PROVID)
2848 || (p->ecmpid && p->ecmpid != ecmpid->ECM_PID)
2849 || (p->srvid && p->srvid != demux[demux_id].program_number)
2850 || (p->pidx && p->pidx-1 != pidindex)
2851 || (p->chid < 0x10000 && p->chid != ecmpid->CHID))
2852 {
2853 continue;
2854 }
2855
2856 return p;
2857 }
2858 return NULL;
2859 }
2860
2861 void dvbapi_process_emm(int32_t demux_id, int32_t filter_num, uint8_t *buffer, uint32_t len)
2862 {
2863 EMM_PACKET epg;
2864
2865 struct s_emm_filter *filter = get_emmfilter_by_filternum(demux_id, filter_num + 1); // 0 is used for pending emmfilters, so everything increase 1
2866 if(!filter)
2867 {
2868 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d no filter matches -> SKIP!", demux_id, filter_num + 1);
2869 return;
2870 }
2871
2872 uint32_t provider = filter->provid;
2873 uint16_t caid = filter->caid;
2874 struct s_dvbapi_priority *mapentry = dvbapi_check_prio_match_emmpid(filter->demux_id, filter->caid, filter->provid, 'm');
2875 if(mapentry)
2876 {
2877 cs_log_dbg(D_DVBAPI, "Demuxer %d mapping EMM from %04X@%06X to %04X@%06X",
2878 demux_id, caid, provider, mapentry->mapcaid, mapentry->mapprovid);
2879
2880 caid = mapentry->mapcaid;
2881 provider = mapentry->mapprovid;
2882 }
2883
2884 memset(&epg, 0, sizeof(epg));
2885 i2b_buf(2, caid, epg.caid);
2886 i2b_buf(4, provider, epg.provid);
2887 epg.emmlen = len > sizeof(epg.emm) ? sizeof(epg.emm) : len;
2888 memcpy(epg.emm, buffer, epg.emmlen);
2889
2890 if(config_enabled(READER_IRDETO) && chk_is_betatunnel_caid(caid) == 2)
2891 {
2892 uint16_t ncaid = tunemm_caid_map(FROM_TO, caid, demux[demux_id].program_number);
2893 if(caid != ncaid)
2894 {
2895 irdeto_add_emm_header(&epg);
2896 i2b_buf(2, ncaid, epg.caid);
2897 }
2898 }
2899 do_emm(dvbapi_client, &epg);
2900 }
2901
2902 void dvbapi_read_priority(void)
2903 {
2904 FILE *fp;
2905 char token[128], str1[128];
2906 char type;
2907 int32_t i, ret, count = 0;
2908 const char *cs_prio = "oscam.dvbapi";
2909
2910 fp = fopen(get_config_filename(token, sizeof(token), cs_prio), "r");
2911 if(!fp)
2912 {
2913 cs_log_dbg(D_DVBAPI, "ERROR: Can't open priority file %s", token);
2914 return;
2915 }
2916
2917 if(dvbapi_priority)
2918 {
2919 cs_log_dbg(D_DVBAPI, "reread priority file %s", cs_prio);
2920 struct s_dvbapi_priority *o, *p;
2921 for(p = dvbapi_priority; p != NULL; p = o)
2922 {
2923 o = p->next;
2924 NULLFREE(p);
2925 }
2926 dvbapi_priority = NULL;
2927 }
2928
2929 while(fgets(token, sizeof(token), fp))
2930 {
2931 // Ignore comments and empty lines
2932 if(token[0] == '#' || token[0] == '/' || token[0] == '\n' || token[0] == '\r' || token[0] == '\0' || strlen(token) > 100)
2933 {
2934 continue;
2935 }
2936 memset(str1, 0, 128);
2937
2938 for(i = 0; i < (int)strlen(token) && token[i] == ' '; i++) { ; }
2939
2940 if(i == (int)strlen(token) - 1) // empty line or all spaces
2941 {
2942 continue;
2943 }
2944
2945 for(i = 0; i < (int)strlen(token); i++)
2946 {
2947 if(token[i] == '@')
2948 {
2949 token[i] = ':';
2950 }
2951 }
2952
2953 for(i = 0; i < (int)strlen(token); i++)
2954 {
2955 if((token[i] == ':' || token[i] == ' ') && token[i + 1] == ':') // if "::" or " :"
2956 {
2957 memmove(token + i + 2, token + i + 1, strlen(token) - i + 1); // insert extra position
2958 token[i + 1] = '0'; // and fill it with NULL
2959 }
2960
2961 if(token[i] == '#' || token[i] == '/')
2962 {
2963 token[i] = '\0';
2964 break;
2965 }
2966 }
2967
2968 type = 0;
2969 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
2970 uint32_t disablefilter = 0;
2971 ret = sscanf(trim(token), "%c: %63s %63s %d", &type, str1, str1 + 64, &disablefilter);
2972 #else
2973 ret = sscanf(trim(token), "%c: %63s %63s", &type, str1, str1 + 64);
2974 #endif
2975 type = tolower((uint8_t)type);
2976
2977 if(ret < 1 || (type != 'p' && type != 'i' && type != 'm' && type != 'd' &&
2978 type != 's' && type != 'l' && type != 'j' && type != 'a' && type != 'x'))
2979 {
2980 //fprintf(stderr, "Warning: line containing %s in %s not recognized, ignoring line\n", token, cs_prio);
2981 // fprintf would issue the warning to the command line, which is more consistent with other config warnings
2982 // however it takes OSCam a long time (>4 seconds) to reach this part of the program, so the warnings are
2983 // reaching tty rather late which leads to confusion. So send the warnings to log file instead
2984 cs_log_dbg(D_DVBAPI, "WARN: line containing %s in %s not recognized, ignoring...", token, cs_prio);
2985 continue;
2986 }
2987
2988 struct s_dvbapi_priority *entry;
2989 if(!cs_malloc(&entry, sizeof(struct s_dvbapi_priority)))
2990 {
2991 ret = fclose(fp);
2992 if(ret < 0)
2993 {
2994 cs_log("ERROR: Could not close oscam.dvbapi fd (errno=%d %s)", errno, strerror(errno));
2995 }
2996 return;
2997 }
2998
2999 entry->type = type;
3000 entry->next = NULL;
3001 count++;
3002
3003 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
3004 if(type == 's')
3005 {
3006 cs_strncpy(entry->devname, str1, sizeof(entry->devname));
3007 cs_strncpy(entry->pmtfile, str1 + 64, sizeof(entry->pmtfile));
3008 entry->disablefilter = disablefilter;
3009 cs_log_dbg(D_DVBAPI, "stapi prio: ret=%d | %c: %s %s | disable %d",
3010 ret, type, entry->devname, entry->pmtfile, disablefilter);
3011
3012 if(!dvbapi_priority)
3013 {
3014 dvbapi_priority = entry;
3015 }
3016 else
3017 {
3018 struct s_dvbapi_priority *p;
3019 for(p = dvbapi_priority; p->next != NULL; p = p->next) { ; }
3020 p->next = entry;
3021 }
3022 continue;
3023 }
3024 #endif
3025 char c_srvid[34];
3026 c_srvid[0] = '\0';
3027 uint32_t caid = 0, provid = 0, srvid = 0, ecmpid = 0, cadata = 0;;
3028 uint32_t chid = 0x10000; //chid=0 is a valid chid
3029
3030 ret = sscanf(str1, "%4x:%6x:%33[^:]:%4x:%4x:%8x"SCNx16, &caid, &provid, c_srvid, &ecmpid, &chid, &cadata);
3031 if(ret < 1)
3032 {
3033 cs_log("Error in oscam.dvbapi: ret=%d | %c: %04X %06X %s %04X %04X",
3034 ret, type, caid, provid, c_srvid, ecmpid, chid);
3035 continue; // skip this entry!
3036 }
3037 else
3038 {
3039 cs_log_dbg(D_DVBAPI, "Parsing rule: ret=%d | %c: %04X %06X %s %04X %04X %04X",
3040 ret, type, caid, provid, c_srvid, ecmpid, chid, cadata);
3041 }
3042
3043 entry->caid = caid;
3044 entry->provid = provid;
3045 entry->ecmpid = ecmpid;
3046 entry->chid = chid;
3047 entry->cadata = cadata;
3048 uint32_t delay = 0, force = 0, mapcaid = 0, mapprovid = 0, mapecmpid = 0, pidx = 0;
3049
3050 switch(type)
3051 {
3052 case 'i':
3053 ret = sscanf(str1 + 64, "%1d", &pidx);
3054 entry->pidx = pidx + 1;
3055 if(ret < 1) entry->pidx = 0;
3056 break;
3057
3058 case 'd':
3059 sscanf(str1 + 64, "%4d", &delay);
3060 entry->delay = delay;
3061 break;
3062
3063 case 'l':
3064 entry->delay = dyn_word_atob(str1 + 64);
3065 if(entry->delay == -1) { entry->delay = 0; }
3066 break;
3067
3068 case 'p':
3069 ret = sscanf(str1 + 64, "%1d:%1d", &force, &pidx);
3070 entry->force = force;
3071 entry->pidx = pidx + 1;
3072 if(ret < 2) entry->pidx = 0;
3073 break;
3074
3075 case 'm':
3076 sscanf(str1 + 64, "%4x:%6x", &mapcaid, &mapprovid);
3077 if(!mapcaid) { mapcaid = 0xFFFF; }
3078 entry->mapcaid = mapcaid;
3079 entry->mapprovid = mapprovid;
3080 break;
3081
3082 case 'a':
3083 case 'j':
3084 sscanf(str1 + 64, "%4x:%6x:%4x", &mapcaid, &mapprovid, &mapecmpid);
3085 if(!mapcaid) { mapcaid = 0xFFFF; }
3086 entry->mapcaid = mapcaid;
3087 entry->mapprovid = mapprovid;
3088 entry->mapecmpid = mapecmpid;
3089 break;
3090 }
3091
3092 if(c_srvid[0] == '=')
3093 {
3094 struct s_srvid *this;
3095 for(i = 0; i < 16; i++)
3096 {
3097 for(this = cfg.srvid[i]; this != NULL; this = this->next)
3098 {
3099 if(this->name && strcmp(this->name, c_srvid + 1) == 0)
3100 {
3101 struct s_dvbapi_priority *entry2;
3102 if(!cs_malloc(&entry2, sizeof(struct s_dvbapi_priority)))
3103 {
3104 continue;
3105 }
3106
3107 memcpy(entry2, entry, sizeof(struct s_dvbapi_priority));
3108 entry2->srvid = this->srvid;
3109 cs_log_dbg(D_DVBAPI, "prio srvid: ret=%d | %c: %04X %06X %04X %04X %04X -> map %04X %06X %04X | prio %d | delay %d",
3110 ret,
3111 entry2->type,
3112 entry2->caid,
3113 entry2->provid,
3114 entry2->srvid,
3115 entry2->ecmpid,
3116 entry2->chid,
3117 entry2->mapcaid,
3118 entry2->mapprovid,
3119 entry2->mapecmpid,
3120 entry2->force,
3121 entry2->delay);
3122
3123 if(!dvbapi_priority)
3124 {
3125 dvbapi_priority = entry2;
3126 }
3127 else
3128 {
3129 struct s_dvbapi_priority *p;
3130 for(p = dvbapi_priority; p->next != NULL; p = p->next) { ; }
3131 p->next = entry2;
3132 }
3133 }
3134 }
3135 }
3136 NULLFREE(entry);
3137 continue;
3138 }
3139 else
3140 {
3141 sscanf(c_srvid, "%4x", &srvid);
3142 entry->srvid = srvid;
3143 }
3144 cs_log_dbg(D_DVBAPI, "prio: ret=%d | %c: %04X %06X %04X %04X %04X -> map %04X %06X %04X | prio %d | delay %d",
3145 ret,
3146 entry->type,
3147 entry->caid,
3148 entry->provid,
3149 entry->srvid,
3150 entry->ecmpid,
3151 entry->chid,
3152 entry->mapcaid,
3153 entry->mapprovid,
3154 entry->mapecmpid,
3155 entry->force,
3156 entry->delay);
3157
3158 if(!dvbapi_priority)
3159 {
3160 dvbapi_priority = entry;
3161 }
3162 else
3163 {
3164 struct s_dvbapi_priority *p;
3165 for(p = dvbapi_priority; p->next != NULL; p = p->next) { ; }
3166 p->next = entry;
3167 }
3168 }
3169 cs_log_dbg(D_DVBAPI, "Read %d entries from %s", count, cs_prio);
3170
3171 ret = fclose(fp);
3172 if(ret < 0)
3173 {
3174 cs_log("ERROR: Could not close oscam.dvbapi fd (errno=%d %s)", errno, strerror(errno));
3175 }
3176 return;
3177 }
3178
3179 void dvbapi_resort_ecmpids(int32_t demux_id)
3180 {
3181 int32_t n, cache = 0, matching_done = 0, found = -1, match_reader_count = 0, total_reader = 0;
3182 uint16_t btun_caid = 0;
3183 struct timeb start,end;
3184 cs_ftime(&start);
3185
3186 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
3187 {
3188 demux[demux_id].ECMpids[n].status = 0;
3189 demux[demux_id].ECMpids[n].checked = 0;
3190 demux[demux_id].ECMpids[n].irdeto_curindex = 0xFE;
3191 demux[demux_id].ECMpids[n].irdeto_maxindex = 0;
3192 demux[demux_id].ECMpids[n].irdeto_cycle = 0xFE;
3193 demux[demux_id].ECMpids[n].tries = 0xFE;
3194 demux[demux_id].ECMpids[n].table = 0;
3195 }
3196
3197 demux[demux_id].max_status = 0;
3198 demux[demux_id].curindex = -1;
3199 demux[demux_id].pidindex = -1;
3200
3201 struct s_reader *rdr;
3202 int32_t p_order = demux[demux_id].ECMpidcount + 1;
3203 struct s_dvbapi_priority *prio;
3204
3205 // handle prio order in oscam.dvbapi + ignore all chids
3206 for(rdr = first_active_reader; rdr ; rdr = rdr->next)
3207 {
3208 total_reader++; // only need to calculate once!
3209 }
3210
3211 ECM_REQUEST *er;
3212 if(!cs_malloc(&er, sizeof(ECM_REQUEST)))
3213 {
3214 return;
3215 }
3216
3217 for(prio = dvbapi_priority; prio != NULL; prio = prio->next)
3218 {
3219 if(prio->type != 'p' && prio->type != 'i')
3220 {
3221 continue;
3222 }
3223
3224 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
3225 {
3226 if(demux[demux_id].ECMpids[n].status == -1) continue; // skip ignores!
3227
3228 er->caid = er->ocaid = demux[demux_id].ECMpids[n].CAID;
3229 er->prid = demux[demux_id].ECMpids[n].PROVID;
3230 er->pid = demux[demux_id].ECMpids[n].ECM_PID;
3231 er->srvid = demux[demux_id].program_number;
3232 er->client = cur_client();
3233 btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
3234
3235 if(prio->type == 'p' && btun_caid)
3236 {
3237 er->caid = btun_caid;
3238 }
3239
3240 if((prio->caid && (prio->caid != er->caid && prio->caid != er->ocaid))
3241 || (prio->provid && prio->provid != er->prid)
3242 || (prio->srvid && prio->srvid != er->srvid)
3243 || (prio->ecmpid && prio->ecmpid != er->pid)
3244 || (prio->pidx && prio->pidx - 1 != n))
3245 {
3246 continue;
3247 }
3248
3249 if(prio->type == 'p') // check for prio
3250 {
3251 if(prio->cadata != 0 && prio->cadata != demux[demux_id].ECMpids[n].cadata)
3252 {
3253 continue;
3254 }
3255
3256 if(prio->chid < 0x10000)
3257 {
3258 demux[demux_id].ECMpids[n].CHID = prio->chid;
3259 }
3260
3261 if(prio->force)
3262 {
3263 int32_t j;
3264 for(j = 0; j < demux[demux_id].ECMpidcount; j++)
3265 {
3266 demux[demux_id].ECMpids[j].status = -1;
3267 }
3268
3269 demux[demux_id].ECMpids[n].status = 1;
3270 demux[demux_id].ECMpids[n].checked = 0;
3271 demux[demux_id].max_status = 1;
3272 demux[demux_id].max_emm_filter = maxfilter - 1;
3273
3274 cs_log_dbg(D_DVBAPI, "Demuxer %d prio forced%s ecmpid %d %04X@%06X:%04X:%04X (file)",
3275 demux_id,
3276 ((prio->caid == er->caid && prio->caid != er->ocaid) ? " betatunneled" : ""),
3277 n,
3278 demux[demux_id].ECMpids[n].CAID,
3279 demux[demux_id].ECMpids[n].PROVID,
3280 demux[demux_id].ECMpids[n].ECM_PID,
3281 (uint16_t) prio->chid);
3282 NULLFREE(er);
3283 return; // go start descrambling since its forced by user!
3284 }
3285 else
3286 {
3287 if(!demux[demux_id].ECMpids[n].status) // only accept first matching prio from oscam.dvbapi
3288 {
3289 demux[demux_id].ECMpids[n].status = total_reader + p_order--;
3290 matching_done = 1;
3291 cs_log_dbg(D_DVBAPI, "Demuxer %d prio%s ecmpid %d %04X@%06X:%04X:%04X weight: %d (file)",
3292 demux_id,
3293 ((prio->caid == er->caid && prio->caid != er->ocaid) ? " betatunneled" : ""),
3294 n,
3295 demux[demux_id].ECMpids[n].CAID,
3296 demux[demux_id].ECMpids[n].PROVID,
3297 demux[demux_id].ECMpids[n].ECM_PID,
3298 (uint16_t) prio->chid,
3299 demux[demux_id].ECMpids[n].status);
3300 }
3301 continue; // evaluate next ecmpid
3302 }
3303 }
3304
3305 // check for ignore all chids
3306 if(prio->type == 'i' && prio->chid == 0x10000 && demux[demux_id].ECMpids[n].status == 0)
3307 {
3308 cs_log_dbg(D_DVBAPI, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X all chids (file)",
3309 demux_id,
3310 n,
3311 demux[demux_id].ECMpids[n].CAID,
3312 demux[demux_id].ECMpids[n].PROVID,
3313 demux[demux_id].ECMpids[n].ECM_PID);
3314 demux[demux_id].ECMpids[n].status = -1;
3315 continue; // evaluate next ecmpid
3316 }
3317 }
3318 }
3319 p_order = demux[demux_id].ECMpidcount + 1;
3320
3321 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
3322 {
3323 if(demux[demux_id].ECMpids[n].status == -1)
3324 {
3325 continue; // skip ignores!
3326 }
3327
3328 int32_t nr;
3329 SIDTAB *sidtab;
3330
3331 er->caid = er->ocaid = demux[demux_id].ECMpids[n].CAID;
3332 er->prid = demux[demux_id].ECMpids[n].PROVID;
3333 er->pid = demux[demux_id].ECMpids[n].ECM_PID;
3334 er->srvid = demux[demux_id].program_number;
3335 er->client = cur_client();
3336
3337 btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
3338 if(btun_caid)
3339 {
3340 er->caid = btun_caid;
3341 }
3342
3343 match_reader_count = 0;
3344
3345 for(rdr = first_active_reader; rdr ; rdr = rdr->next)
3346 {
3347 if(matching_reader(er, rdr))
3348 {
3349 match_reader_count++;
3350 }
3351 }
3352
3353 if(match_reader_count == 0)
3354 {
3355 cs_log_dbg(D_DVBAPI, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X:%04X (no matching reader)",
3356 demux_id,
3357 n,
3358 demux[demux_id].ECMpids[n].CAID,
3359 demux[demux_id].ECMpids[n].PROVID,
3360 demux[demux_id].ECMpids[n].ECM_PID,
3361 demux[demux_id].ECMpids[n].CHID);
3362 demux[demux_id].ECMpids[n].status = -1;
3363 continue; // evaluate next ecmpid
3364 }
3365 else // ecmpids with no matching readers are disabled and matching sidtabbits have now highest status
3366 {
3367 for(nr = 0, sidtab = cfg.sidtab; sidtab; sidtab = sidtab->next, nr++)
3368 {
3369 if(sidtab->num_caid | sidtab->num_provid | sidtab->num_srvid)
3370 {
3371 if((cfg.dvbapi_sidtabs.no & ((SIDTABBITS)1 << nr)) && (chk_srvid_match(er, sidtab)))
3372 {
3373 demux[demux_id].ECMpids[n].status = -1; //ignore
3374 cs_log_dbg(D_DVBAPI, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X (service %s pos %d)",
3375 demux_id,
3376 n,
3377 demux[demux_id].ECMpids[n].CAID,
3378 demux[demux_id].ECMpids[n].PROVID,
3379 demux[demux_id].ECMpids[n].ECM_PID,
3380 sidtab->label,
3381 nr);
3382 continue; // evaluate next ecmpid
3383 }
3384 if((cfg.dvbapi_sidtabs.ok & ((SIDTABBITS) 1 << nr)) && (chk_srvid_match(er, sidtab)))
3385 {
3386 demux[demux_id].ECMpids[n].status++; // priority
3387 cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (service %s pos %d)",
3388 demux_id,
3389 n,
3390 demux[demux_id].ECMpids[n].CAID,
3391 demux[demux_id].ECMpids[n].PROVID,
3392 demux[demux_id].ECMpids[n].ECM_PID,
3393 demux[demux_id].ECMpids[n].status,
3394 sidtab->label,
3395 nr);
3396 }
3397 }
3398 }
3399 }
3400 }
3401
3402 // ecmpid with highest prio from oscam.dvbapi has now highest status
3403 // check all ecmpids and get the highest amount cache-ex and local readers
3404 int32_t max_local_matching_reader = 0, max_cacheex_reader = 0;
3405
3406 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
3407 {
3408 int32_t count_matching_cacheex_reader = 0, count_matching_local_reader = 0;
3409 if(demux[demux_id].ECMpids[n].status == -1)
3410 {
3411 continue; // skip ignores!
3412 }
3413
3414 er->caid = er->ocaid = demux[demux_id].ECMpids[n].CAID;
3415 er->prid = demux[demux_id].ECMpids[n].PROVID;
3416 er->pid = demux[demux_id].ECMpids[n].ECM_PID;
3417 er->srvid = demux[demux_id].program_number;
3418 er->client = cur_client();
3419
3420 btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
3421 if(btun_caid)
3422 {
3423 er->caid = btun_caid;
3424 }
3425
3426 for(rdr = first_active_reader; rdr ; rdr = rdr->next)
3427 {
3428 if(matching_reader(er, rdr))
3429 {
3430 if(cacheex_reader(rdr))
3431 {
3432 count_matching_cacheex_reader++;
3433 }
3434 else if(is_localreader(rdr, er))
3435 {
3436 count_matching_local_reader++;
3437 }
3438 }
3439 }
3440
3441 if(max_local_matching_reader < count_matching_local_reader)
3442 {
3443 max_local_matching_reader = count_matching_local_reader;
3444 }
3445
3446 if(max_cacheex_reader < count_matching_cacheex_reader)
3447 {
3448 max_cacheex_reader = count_matching_cacheex_reader;
3449 }
3450 }
3451
3452 if(max_local_matching_reader != 0 || max_cacheex_reader != 0)
3453 {
3454 p_order = demux[demux_id].ECMpidcount * 2;
3455 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
3456 {
3457 int32_t count_matching_cacheex_reader = 0, count_matching_local_reader = 0;
3458 int32_t localprio = 1, cacheexprio = 1;
3459
3460 if(demux[demux_id].ECMpids[n].status == -1)
3461 {
3462 continue; // skip ignores!
3463 }
3464
3465 if(cfg.preferlocalcards == 2) // ecmpids with local reader get highest prio
3466 {
3467 localprio = max_cacheex_reader + p_order + 1;
3468 }
3469 else if(cfg.preferlocalcards == 1) // ecmpids with cacheex reader get highest prio
3470 {
3471 cacheexprio = max_local_matching_reader + p_order + 1;
3472 }
3473
3474 er->caid = er->ocaid = demux[demux_id].ECMpids[n].CAID;
3475 er->prid = demux[demux_id].ECMpids[n].PROVID;
3476 er->pid = demux[demux_id].ECMpids[n].ECM_PID;
3477 er->srvid = demux[demux_id].program_number;
3478 er->client = cur_client();
3479
3480 btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
3481 if(btun_caid)
3482 {
3483 er->caid = btun_caid;
3484 }
3485
3486 int32_t oldstatus = demux[demux_id].ECMpids[n].status;
3487 int32_t anyreader = 0;
3488
3489 for(rdr = first_active_reader; rdr; rdr = rdr->next)
3490 {
3491 if(matching_reader(er, rdr))
3492 {
3493 if(cfg.preferlocalcards == 0)
3494 {
3495 if(!matching_done)
3496 {
3497 demux[demux_id].ECMpids[n].status++;
3498 }
3499 anyreader++;
3500 continue;
3501 }
3502
3503 if(cacheex_reader(rdr))
3504 {
3505 demux[demux_id].ECMpids[n].status += cacheexprio;
3506 count_matching_cacheex_reader++;
3507 cacheexprio = 1;
3508 }
3509
3510 if(is_localreader(rdr, er))
3511 {
3512 demux[demux_id].ECMpids[n].status += localprio;
3513 count_matching_local_reader++;
3514 localprio = 1;
3515 }
3516 }
3517 }
3518
3519 if(oldstatus != demux[demux_id].ECMpids[n].status)
3520 {
3521 if(anyreader)
3522 {
3523 cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X:%04X weight: %d (%d readers)",
3524 demux_id,
3525 n,
3526 demux[demux_id].ECMpids[n].CAID,
3527 demux[demux_id].ECMpids[n].PROVID,
3528 demux[demux_id].ECMpids[n].ECM_PID,
3529 demux[demux_id].ECMpids[n].CHID,
3530 demux[demux_id].ECMpids[n].status,
3531 anyreader);
3532 }
3533 else
3534 {
3535 cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X:%04X weight: %d (%d local and %d cacheex readers)",
3536 demux_id,
3537 n,
3538 demux[demux_id].ECMpids[n].CAID,
3539 demux[demux_id].ECMpids[n].PROVID,
3540 demux[demux_id].ECMpids[n].ECM_PID,
3541 demux[demux_id].ECMpids[n].CHID,
3542 demux[demux_id].ECMpids[n].status,
3543 count_matching_local_reader,
3544 count_matching_cacheex_reader);
3545 }
3546 }
3547 }
3548 }
3549
3550 struct s_channel_cache *c = NULL;
3551
3552 for(n = 0; n < demux[demux_id].ECMpidcount && matching_done == 0; n++)
3553 {
3554 if(demux[demux_id].ECMpids[n].status == -1)
3555 {
3556 continue; // skip ignores!
3557 }
3558
3559 c = dvbapi_find_channel_cache(demux_id, n, 0); // find exact channel match
3560 if(c != NULL)
3561 {
3562 found = n;
3563 cache = 2; // found cache entry with higher priority
3564 demux[demux_id].ECMpids[n].status++; // prioritize CAIDs which already decoded same caid:provid:srvid
3565
3566 if(c->chid < 0x10000)
3567 {
3568 demux[demux_id].ECMpids[n].CHID = c->chid; // if chid registered in cache -> use it!
3569 }
3570 cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (found caid/provid/srvid in cache)",
3571 demux_id,
3572 n,
3573 demux[demux_id].ECMpids[n].CAID,
3574 demux[demux_id].ECMpids[n].PROVID,
3575 demux[demux_id].ECMpids[n].ECM_PID,
3576 demux[demux_id].ECMpids[n].status);
3577 break;
3578 }
3579 }
3580
3581 if(found == -1)
3582 {
3583 // prioritize CAIDs which already decoded same caid:provid
3584 for(n = 0; n < demux[demux_id].ECMpidcount && matching_done == 0; n++)
3585 {
3586 if(demux[demux_id].ECMpids[n].status == -1) continue; // skip ignores!
3587
3588 c = dvbapi_find_channel_cache(demux_id, n, 1);
3589 if(c != NULL)
3590 {
3591 cache = 1; //found cache entry
3592 demux[demux_id].ECMpids[n].status++;
3593 cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (found caid/provid in cache)",
3594 demux_id,
3595 n,
3596 demux[demux_id].ECMpids[n].CAID,
3597 demux[demux_id].ECMpids[n].PROVID,
3598 demux[demux_id].ECMpids[n].ECM_PID,
3599 demux[demux_id].ECMpids[n].status);
3600 }
3601 }
3602 }
3603
3604 int32_t max_status = 0;
3605 int32_t highest_priopid = -1;
3606
3607 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
3608 {
3609 if(demux[demux_id].ECMpids[n].status == -1)
3610 {
3611 continue; // skip ignores!
3612 }
3613
3614 if(demux[demux_id].ECMpids[n].status > max_status) // find highest prio pid
3615 {
3616 max_status = demux[demux_id].ECMpids[n].status;
3617 highest_priopid = n;
3618 }
3619
3620 if(!USE_OPENXCAS) // openxcas doesnt use prio and non-prio run: all are equal!
3621 {
3622 if(demux[demux_id].ECMpids[n].status == 0)
3623 {
3624 demux[demux_id].ECMpids[n].checked = 2; // set pids with no status to no prio run
3625 }
3626 }
3627 }
3628
3629 demux[demux_id].max_status = max_status; // register maxstatus
3630
3631 // Found entry in channelcache that is valid and has exact match on srvid
3632 if(highest_priopid != -1 && found == highest_priopid && cache == 2)
3633 {
3634 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
3635 {
3636 if(demux[demux_id].ECMpids[n].status == -1)
3637 {
3638 continue; // skip ignores!
3639 }
3640
3641 if(n != found)
3642 {
3643 // disable non matching pid
3644 demux[demux_id].ECMpids[n].status = -1;
3645 }
3646 else
3647 {
3648 demux[demux_id].ECMpids[n].status = 1;
3649 }
3650 }
3651 demux[demux_id].max_emm_filter = maxfilter - 1;
3652 demux[demux_id].max_status = 1;
3653 cs_log("Demuxer %d found channel in cache and matching prio -> start descrambling ecmpid %d ", demux_id, found);
3654 }
3655
3656 NULLFREE(er);
3657 cs_ftime(&end);
3658 int64_t gone = comp_timeb(&end, &start);
3659 cs_log_dbg(D_DVBAPI, "Demuxer %d sorting the ecmpids took %"PRId64" ms", demux_id, gone);
3660 return;
3661 }
3662
3663 static void dvbapi_priority_read_entry_add(int32_t demux_id, uint16_t video_pid)
3664 {
3665 struct s_dvbapi_priority *add_entry;
3666
3667 for(add_entry = dvbapi_priority; add_entry != NULL; add_entry = add_entry->next)
3668 {
3669 // ECM pid is misused to hold PMT pid in case of 'A' rule.
3670 // Some receivers don't forward the PMT pid, so use the video pid instead
3671 if(add_entry->type != 'a' || add_entry->srvid != demux[demux_id].program_number
3672 || (add_entry->ecmpid && demux[demux_id].pmtpid && add_entry->ecmpid != demux[demux_id].pmtpid)
3673 || (add_entry->ecmpid && !demux[demux_id].pmtpid && add_entry->ecmpid != video_pid))
3674 {
3675 continue;
3676 }
3677
3678 dvbapi_add_ecmpid(demux_id, add_entry->mapcaid, add_entry->mapecmpid, add_entry->mapprovid, 0, "(fake ecm pid)");
3679
3680 cs_log_dbg(D_DVBAPI, "Demuxer %d added fake ecm pid %04X@%06X:%04X for program %04X", demux_id,
3681 add_entry->mapcaid, add_entry->mapprovid, add_entry->mapecmpid, demux[demux_id].program_number);
3682 break;
3683 }
3684 }
3685
3686 static void dvbapi_priority_read_entry_map(int32_t demux_id)
3687 {
3688 int32_t j;
3689 struct s_dvbapi_priority *map_entry;
3690
3691 for(j = 0; j < demux[demux_id].ECMpidcount; j++)
3692 {
3693 map_entry = dvbapi_check_prio_match(demux_id, j, 'm');
3694 if(map_entry)
3695 {
3696 cs_log_dbg(D_DVBAPI, "Demuxer %d mapping ecm pid %d from %04X@%06X to %04X@%06X",
3697 demux_id, j, demux[demux_id].ECMpids[j].CAID, demux[demux_id].ECMpids[j].PROVID,
3698 map_entry->mapcaid, map_entry->mapprovid);
3699
3700 demux[demux_id].ECMpids[j].CAID = map_entry->mapcaid;
3701 demux[demux_id].ECMpids[j].PROVID = map_entry->mapprovid;
3702 }
3703 }
3704 }
3705
3706 static void dvbapi_priority_read_entry_extra(int32_t demux_id)
3707 {
3708 struct s_dvbapi_priority *extra_entry;
3709 int32_t j, k, l, m, extra_demux_id;
3710
3711 for(extra_entry = dvbapi_priority; extra_entry != NULL; extra_entry = extra_entry->next)
3712 {
3713 if(extra_entry->type != 'x')
3714 {
3715 continue;
3716 }
3717
3718 for(j = 0; j <= demux[demux_id].ECMpidcount; ++j)
3719 {
3720 if((extra_entry->caid && extra_entry->caid != demux[demux_id].ECMpids[j].CAID)
3721 || (extra_entry->provid && extra_entry->provid != demux[demux_id].ECMpids[j].PROVID)
3722 || (extra_entry->ecmpid && extra_entry->ecmpid != demux[demux_id].ECMpids[j].ECM_PID)
3723 || (extra_entry->srvid && extra_entry->srvid != demux[demux_id].program_number))
3724 {
3725 continue;
3726 }
3727
3728 cs_log("Mapping ecm pid %04X@%06X:%04X:%04X to extra demuxer",
3729 extra_entry->caid, extra_entry->provid, extra_entry->ecmpid, extra_entry->srvid);
3730
3731 for(extra_demux_id = 0; extra_demux_id < MAX_DEMUX; extra_demux_id++)
3732 {
3733 if(demux[extra_demux_id].program_number != 0)
3734 {
3735 continue; // Skip occupied demuxers
3736 }
3737 }
3738
3739 if(extra_demux_id >= MAX_DEMUX)
3740 {
3741 cs_log("There is no free demuxer for extra streams");
3742 continue;
3743 }
3744
3745 demux[extra_demux_id].ECMpids[0] = demux[demux_id].ECMpids[j];
3746 demux[extra_demux_id].ECMpidcount = 1;
3747 demux[extra_demux_id].STREAMpidcount = 0;
3748 demux[extra_demux_id].program_number = demux[demux_id].program_number;
3749 demux[extra_demux_id].pmtpid = demux[demux_id].pmtpid;
3750 demux[extra_demux_id].demux_index = demux[demux_id].demux_index;
3751 demux[extra_demux_id].adapter_index = demux[demux_id].adapter_index;
3752 demux[extra_demux_id].ca_mask = demux[demux_id].ca_mask;
3753 demux[extra_demux_id].socket_fd = demux[demux_id].socket_fd;
3754 demux[extra_demux_id].stop_descrambling = false;
3755 demux[extra_demux_id].rdr = NULL;
3756 demux[extra_demux_id].curindex = -1;
3757
3758 // Add streams to extra demux
3759 for(k = 0; k < demux[demux_id].STREAMpidcount; ++k)
3760 {
3761 if(!demux[demux_id].ECMpids[j].streams || (demux[demux_id].ECMpids[j].streams & (1 << k)))
3762 {
3763 demux[extra_demux_id].ECMpids[0].streams |= (1 << demux[extra_demux_id].STREAMpidcount);
3764 demux[extra_demux_id].STREAMpids[demux[extra_demux_id].STREAMpidcount] = demux[demux_id].STREAMpids[k];
3765 demux[extra_demux_id].STREAMpidsType[demux[extra_demux_id].STREAMpidcount] = demux[demux_id].STREAMpidsType[k];
3766 ++demux[extra_demux_id].STREAMpidcount;
3767
3768 // Shift stream associations in normal demux because we will remove the stream entirely
3769 for(l = 0; l < demux[demux_id].ECMpidcount; ++l)
3770 {
3771 for(m = k; m < demux[demux_id].STREAMpidcount - 1; ++m)
3772 {
3773 if(demux[demux_id].ECMpids[l].streams & (1 << (m + 1)))
3774 {
3775 demux[demux_id].ECMpids[l].streams |= (1 << m);
3776 }
3777 else
3778 {
3779 demux[demux_id].ECMpids[l].streams &= ~(1 << m);
3780 }
3781 }
3782 }
3783
3784 // Remove stream association from normal demux device
3785 for(l = k; l < demux[demux_id].STREAMpidcount - 1; ++l)
3786 {
3787 demux[demux_id].STREAMpids[l] = demux[demux_id].STREAMpids[l + 1];
3788 demux[demux_id].STREAMpidsType[l] = demux[demux_id].STREAMpidsType[l + 1];
3789 }
3790
3791 --demux[demux_id].STREAMpidcount;
3792 --k;
3793 }
3794 }
3795
3796 // Remove ecm pid from normal demuxer
3797 for(k = j; k < demux[demux_id].ECMpidcount; ++k)
3798 {
3799 demux[demux_id].ECMpids[k] = demux[demux_id].ECMpids[k + 1];
3800 }
3801
3802 --demux[demux_id].ECMpidcount;
3803 --j;
3804
3805 if(demux[extra_demux_id].STREAMpidcount <= 0)
3806 {
3807 cs_log("Found no streams for extra demuxer. Not starting additional decoding on it.");
3808
3809 demux[extra_demux_id].program_number = 0;
3810 demux[extra_demux_id].stop_descrambling = true;
3811 }
3812
3813 if(demux[demux_id].STREAMpidcount < 1)
3814 {
3815 cs_log("Found no streams for normal demuxer. Not starting additional decoding on it.");
3816 }
3817 }
3818 }
3819 }
3820
3821 static void dvbapi_parse_pmt_ca_descriptor(int32_t demux_id, const uint8_t *buffer, uint8_t descriptor_length)
3822 {
3823 uint16_t i, ca_system_id, ca_pid;
3824 uint32_t ca_provider = 0, ca_data = 0;
3825 char txt[40]; // room for PBM: 8 byte pbm and DATE: date
3826 memset(txt, 0x00, sizeof(txt));
3827
3828 if(descriptor_length < 4)
3829 {
3830 return; // CA descriptor has a minimum length of 4 bytes
3831 }
3832
3833 ca_system_id = b2i(2, buffer);
3834 ca_pid = b2i(2, buffer + 2) & 0x1FFF;
3835
3836 if(caid_is_seca(ca_system_id))
3837 {
3838 for(i = 2; i < descriptor_length; i += 15)
3839 {
3840 ca_pid = b2i(2, buffer + i) & 0x1FFF;
3841 ca_provider = b2i(2, buffer + i + 2);
3842
3843 int8_t year = buffer[i + 13] >> 1;
3844 int8_t month = (((buffer[i + 13] & 0x01) << 3) | (buffer[i + 14] >> 5));
3845 int8_t day = buffer[i + 14] & 0x1F;
3846
3847 snprintf(txt, sizeof(txt), "PBM: ");
3848 cs_hexdump(0, buffer + i + 5, 8, txt + 5, (2 * 8) + 1); // hexdump 8 byte pbm
3849 snprintf(txt + 20, sizeof(txt) - 20, " DATE: %d-%d-%d", day, month, year + 1990);
3850
3851 dvbapi_add_ecmpid(demux_id, ca_system_id, ca_pid, ca_provider, 0, txt);
3852 }
3853 }
3854 else
3855 {
3856 if(caid_is_viaccess(ca_system_id) && descriptor_length == 0x0F && buffer[10] == 0x14)
3857 {
3858 ca_provider = b2i(3, buffer + 12) & 0xFFFFF0;
3859 }
3860 else if(caid_is_nagra(ca_system_id) && descriptor_length == 0x07)
3861 {
3862 ca_provider = b2i(2, buffer + 5);
3863 }
3864 else if((ca_system_id >> 8 == 0x4A || ca_system_id == 0x2710) && descriptor_length > 0x04)
3865 {
3866 ca_provider = buffer[4];
3867
3868 if(caid_is_dre(ca_system_id) && descriptor_length == 0x0A)
3869 {
3870 ca_data = b2i(4, buffer + 6);
3871 snprintf(txt, 40, "CA DATA: %X", ca_data);
3872 }
3873 }
3874
3875 dvbapi_add_ecmpid(demux_id, ca_system_id, ca_pid, ca_provider, ca_data, txt);
3876 }
3877 }
3878
3879 static void dvbapi_parse_pmt_descriptors(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint8_t *type)
3880 {
3881 uint16_t i, j;
3882 uint8_t descriptor_tag, descriptor_length;
3883
3884 for(i = 0; i + 1 < length; i += 2 + descriptor_length)
3885 {
3886 descriptor_tag = buffer[i];
3887 descriptor_length = buffer[i + 1];
3888
3889 cs_log_dbg(D_DVBAPI, "Demuxer %d found %s descriptor (tag: %02X length: %02X)",
3890 demux_id, get_descriptor_tag_txt(descriptor_tag), descriptor_tag, descriptor_length);
3891
3892 switch(descriptor_tag)
3893 {
3894 case 0x05: // Registration descriptor
3895 {
3896 // "HDMV" format identifier is removed
3897 // OSCam does not need to know about Blu-ray
3898 const char format_identifiers_audio[10][5] =
3899 {
3900 "AC-3", "BSSD", "dmat", "DRA1", "DTS1",
3901 "DTS2", "DTS3", "EAC3", "mlpa", "Opus",
3902 };
3903
3904 for(j = 0; j < 10; j++)
3905 {
3906 if(memcmp(buffer + i + 2, format_identifiers_audio[j], 4) == 0)
3907 {
3908 *type = STREAM_AUDIO;
3909 break;
3910 }
3911 }
3912 break;
3913 }
3914
3915 case 0x09: // CA descriptor
3916 {
3917 dvbapi_parse_pmt_ca_descriptor(demux_id, buffer + i + 2, descriptor_length);
3918 break;
3919 }
3920
3921 case 0x59: // Subtitling descriptor (DVB)
3922 {
3923 *type = STREAM_SUBTITLE;
3924 break;
3925 }
3926
3927 case 0x6A: // AC-3 descriptor (DVB)
3928 case 0x7A: // Enhanced AC-3 descriptor (DVB)
3929 case 0x7B: // DTS descriptor (DVB)
3930 case 0x7C: // AAC descriptor (DVB)
3931 case 0x81: // AC-3 descriptor (ATSC)
3932 case 0xCC: // Enhanced AC-3 descriptor (ATSC)
3933 {
3934 *type = STREAM_AUDIO;
3935 break;
3936 }
3937
3938 case 0x7F: // Extension descriptor (DVB)
3939 {
3940 uint8_t extension_descriptor_tag = buffer[i + 2];
3941
3942 cs_log_dbg(D_DVBAPI, "Demuxer %d found %s descriptor (extension tag: %02X)",
3943 demux_id, get_extension_descriptor_txt(extension_descriptor_tag), extension_descriptor_tag);
3944
3945 switch(extension_descriptor_tag)
3946 {
3947 case 0x0E: // DTS-HD descriptor (DVB)
3948 case 0x0F: // DTS Neural descriptor (DVB)
3949 case 0x15: // AC-4 descriptor (DVB)
3950 case 0x21: // DTS-UHD descriptor (DVB)
3951 *type = STREAM_AUDIO;
3952 break;
3953
3954 default:
3955 *type = STREAM_UNDEFINED;
3956 break;
3957 }
3958 break;
3959 }
3960
3961 default:
3962 break;
3963 }
3964 }
3965 }
3966
3967 void request_cw(struct s_client *client, ECM_REQUEST *er, int32_t demux_id, uint8_t delayed_ecm_check)
3968 {
3969 if(!er) { return; }
3970
3971 int32_t filternum = dvbapi_set_section_filter(demux_id, er, -1); // set ecm filter to odd -> even and visaversa
3972 if(filternum < 0)
3973 {
3974 cs_log_dbg(D_DVBAPI, "Demuxer %d not requesting cw -> ecm filter was killed!", demux_id);
3975 NULLFREE(er);
3976 return;
3977 }
3978
3979 if(!delayed_ecm_check) // no delayed ecm check for this filter
3980 {
3981 memset(demux[demux_id].demux_fd[filternum].lastecmd5, 0, CS_ECMSTORESIZE); // no ecm delay check: zero it!
3982 }
3983 else
3984 {
3985 uint8_t md5tmp[MD5_DIGEST_LENGTH];
3986 MD5(er->ecm, er->ecmlen, md5tmp);
3987
3988 if(!memcmp(demux[demux_id].demux_fd[filternum].prevecmd5, md5tmp, CS_ECMSTORESIZE))
3989 {
3990 if(demux[demux_id].demux_fd[filternum].prevresult < E_NOTFOUND)
3991 {
3992 cs_log_dbg(D_DVBAPI, "Demuxer %d not requesting same ecm again! -> SKIP!", demux_id);
3993 NULLFREE(er);
3994 return;
3995 }
3996 else
3997 {
3998 cs_log_dbg(D_DVBAPI, "Demuxer %d requesting same ecm again (previous result was not found!)", demux_id);
3999 }
4000 }
4001 else if(!memcmp(demux[demux_id].demux_fd[filternum].lastecmd5, md5tmp, CS_ECMSTORESIZE))
4002 {
4003 if(demux[demux_id].demux_fd[filternum].lastresult < E_NOTFOUND)
4004 {
4005 cs_log_dbg(D_DVBAPI, "Demuxer %d not requesting same ecm again! -> SKIP!", demux_id);
4006 NULLFREE(er);
4007 return;
4008 }
4009 else
4010 {
4011 cs_log_dbg(D_DVBAPI, "Demuxer %d requesting same ecm again (previous result was not found!)", demux_id);
4012 }
4013 }
4014
4015 memcpy(demux[demux_id].demux_fd[filternum].prevecmd5, demux[demux_id].demux_fd[filternum].lastecmd5, CS_ECMSTORESIZE);
4016 demux[demux_id].demux_fd[filternum].prevresult = demux[demux_id].demux_fd[filternum].lastresult;
4017 memcpy(demux[demux_id].demux_fd[filternum].lastecmd5, md5tmp, CS_ECMSTORESIZE);
4018 demux[demux_id].demux_fd[filternum].lastresult = 0xFF;
4019 }
4020
4021 er->adapter_index = demux[demux_id].adapter_index;
4022 get_cw(client, er);
4023
4024 #ifdef WITH_DEBUG
4025 char buf[ECM_FMT_LEN];
4026 format_ecm(er, buf, ECM_FMT_LEN);
4027 cs_log_dbg(D_DVBAPI, "Demuxer %d request controlword for ecm %s", demux_id, buf);
4028 #endif
4029 }
4030
4031 void dvbapi_try_next_caid(int32_t demux_id, int8_t checked, uint32_t msgid)
4032 {
4033 int32_t n, j, found = -1, started = 0;
4034 int32_t status = demux[demux_id].max_status;
4035
4036 for(j = status; j >= 0; j--) // largest status first!
4037 {
4038 for(n = 0; n < demux[demux_id].ECMpidcount; n++)
4039 {
4040 //cs_log_dbg(D_DVBAPI,"Demuxer %d PID %d checked = %d status = %d (searching for pid with status = %d)",
4041 // demux_id, n, demux[demux_id].ECMpids[n].checked, demux[demux_id].ECMpids[n].status, j);
4042
4043 if(demux[demux_id].ECMpids[n].checked == checked && demux[demux_id].ECMpids[n].status == j)
4044 {
4045 found = n;
4046 openxcas_set_provid(demux[demux_id].ECMpids[found].PROVID);
4047 openxcas_set_caid(demux[demux_id].ECMpids[found].CAID);
4048 openxcas_set_ecm_pid(demux[demux_id].ECMpids[found].ECM_PID);
4049
4050 // fixup for cas that need emm first!
4051 if(caid_is_irdeto(demux[demux_id].ECMpids[found].CAID) || (caid_is_dre(demux[demux_id].ECMpids[found].CAID)
4052 && ((demux[demux_id].ECMpids[found].PROVID == 0x11 || demux[demux_id].ECMpids[found].PROVID == 0xFE))))
4053 {
4054 demux[demux_id].emmstart.time = 0;
4055 }
4056
4057 started = dvbapi_start_descrambling(demux_id, found, checked, msgid);
4058 if(cfg.dvbapi_requestmode == 0 && started == 1)
4059 {
4060 return; // in requestmode 0 we only start 1 ecm request at the time
4061 }
4062 }
4063 }
4064 }
4065
4066 if(found == -1 && demux[demux_id].pidindex == -1)
4067 {
4068 cs_log("Demuxer %d no suitable readers found that can be used for decoding!", demux_id);
4069 return;
4070 }
4071 }
4072
4073 static void dvbapi_parse_pmt_program_info(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint8_t *ca_pmt_cmd_id)
4074 {
4075 uint16_t i, offset = 0;
4076 uint8_t descriptor_tag, descriptor_length;
4077
4078 if(ca_pmt_cmd_id != NULL) // We are on CA PMT parsing
4079 {
4080 *ca_pmt_cmd_id = buffer[0];
4081 offset = 1;
4082 }
4083
4084 for(i = offset; i + 1 < length; i += 2 + descriptor_length)
4085 {
4086 descriptor_tag = buffer[i];
4087 descriptor_length = buffer[i + 1];
4088
4089 if(descriptor_tag == 0x09) // We only care about CA descriptors at program level
4090 {
4091 dvbapi_parse_pmt_ca_descriptor(demux_id, buffer + i + 2, descriptor_length);
4092 }
4093 }
4094 }
4095
4096 static void dvbapi_parse_pmt_es_info(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint8_t *ca_pmt_cmd_id, uint16_t *video_pid)
4097 {
4098 uint16_t i, elementary_pid, es_info_length, offset = 0;
4099 uint8_t stream_type, type;
4100
4101 for(i = 0; i + 4 < length; i += 5 + es_info_length)
4102 {
4103 if(demux[demux_id].STREAMpidcount >= MAX_STREAM_PIDS)
4104 {
4105 cs_log("Demuxer %d reached maximum number of elementary streams", demux_id);
4106 break;
4107 }
4108
4109 type = STREAM_UNDEFINED;
4110 stream_type = buffer[i];
4111 elementary_pid = b2i(2, buffer + i + 1) & 0x1FFF;
4112 es_info_length = b2i(2, buffer + i + 3) & 0x0FFF;
4113
4114 cs_log_dbg(D_DVBAPI,"Demuxer %d found %s stream (type: %02X pid: %04X)",
4115 demux_id, get_stream_type_txt(stream_type), stream_type, elementary_pid);
4116
4117 if(es_info_length != 0 && es_info_length < length)
4118 {
4119 if(ca_pmt_cmd_id != NULL) // We are on CA PMT parsing
4120 {
4121 // Only enigma2, Spark and VDR follow the CA PMT specification ("ca_pmt_cmd_id"
4122 // shall be present in the ES info loop). For the first two, checking for boxtype
4123 // "dreambox" is sufficient, but for VDR this is not enough, because it shares
4124 // the same boxtype with tvheadend. So, for every other box (including VDR and
4125 // tvheadend), we stick to the old style check based on the value (descriptors
4126 // with tag 0x00 or 0x01 are not allowed, so this works), while for enigma2 we
4127 // do a proper check, because the "ca_pmt_cmd_id" can also take greater values.
4128 if(cfg.dvbapi_boxtype == BOXTYPE_DREAMBOX)
4129 {
4130 *ca_pmt_cmd_id = buffer[i + 5]; // It should be identical for all ES and the same as in program info
4131 offset = 1;
4132 }
4133 else
4134 {
4135 offset = (buffer[i + 5] <= 0x01) ? 1 : 0;
4136 }
4137 }
4138
4139 // Parse descriptors at ES level
4140 dvbapi_parse_pmt_descriptors(demux_id, buffer + i + 5 + offset, es_info_length, &type);
4141 }
4142
4143 // Get basic stream type (video, audio, subtitle) for each ES pid
4144 switch(stream_type)
4145 {
4146 case 0x01:
4147 case 0x02:
4148 case 0x10:
4149 case 0x1B:
4150 case 0x20:
4151 case 0x24:
4152 case 0x25:
4153 case 0x42:
4154 case 0xD1:
4155 case 0xEA:
4156 if(*video_pid == 0)
4157 {
4158 *video_pid = elementary_pid;
4159 }
4160 demux[demux_id].STREAMpidsType[demux[demux_id].STREAMpidcount] = STREAM_VIDEO;
4161 break;
4162
4163 case 0x03:
4164 case 0x04:
4165 case 0x0F:
4166 case 0x11:
4167 case 0x1C:
4168 case 0x2D:
4169 case 0x2E:
4170 case 0x81:
4171 demux[demux_id].STREAMpidsType[demux[demux_id].STREAMpidcount] = STREAM_AUDIO;
4172 break;
4173
4174 case 0x06:
4175 //case 0x81: some ATSC AC-3 streams do not contain the AC-3 descriptor!
4176 case 0x87:
4177 // Set the type based on the descriptors for these stream types
4178 demux[demux_id].STREAMpidsType[demux[demux_id].STREAMpidcount] = type;
4179 break;
4180
4181 default:
4182 demux[demux_id].STREAMpidsType[demux[demux_id].STREAMpidcount] = STREAM_UNDEFINED;
4183 break;
4184 }
4185
4186 demux[demux_id].STREAMpids[demux[demux_id].STREAMpidcount] = elementary_pid;
4187 demux[demux_id].STREAMpidcount++;
4188 }
4189 }
4190
4191 static void dvbapi_parse_pmt_info(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint8_t *ca_pmt_cmd_id)
4192 {
4193 uint16_t i, program_info_length, video_pid = 0;
4194
4195 // Cleanout demuxer from possible stale info
4196 // (reset ECM pids and streams)
4197 if(demux[demux_id].running == false)
4198 {
4199 demux[demux_id].ECMpidcount = 0;
4200 }
4201
4202 for(i = 0; i < demux[demux_id].ECMpidcount; i++)
4203 {
4204 demux[demux_id].ECMpids[i].streams = 0;
4205 }
4206
4207 demux[demux_id].STREAMpidcount = 0;
4208
4209 // Parse program info
4210 // In case of CA PMT, read the ca_pmt_cmd_id as well
4211 program_info_length = b2i(2, buffer) & 0x0FFF;
4212 if(program_info_length != 0 && program_info_length < length)
4213 {
4214 dvbapi_parse_pmt_program_info(demux_id, buffer + 2, program_info_length, ca_pmt_cmd_id);
4215 }
4216
4217 // Parse elementary stream info
4218 // In case of CA PMT, read the ca_pmt_cmd_id for each stream as well
4219 dvbapi_parse_pmt_es_info(demux_id, buffer + 2 + program_info_length, length - 2 - program_info_length, ca_pmt_cmd_id, &video_pid);
4220
4221 cs_log("Demuxer %d found %d ECM pids and %d STREAM pids in %sPMT", demux_id,
4222 demux[demux_id].ECMpidcount, demux[demux_id].STREAMpidcount, ca_pmt_cmd_id != NULL ? "CA " : "");
4223
4224 // Various retarded boxes misuse the "ca_pmt_cmd_id" value,
4225 // usually by setting it to zero. If we are on CA PMT parsing,
4226 // make sure we pass a value we can work with later on.
4227 if(ca_pmt_cmd_id != NULL)
4228 {
4229 *ca_pmt_cmd_id = (*ca_pmt_cmd_id < CA_PMT_CMD_OK_DESCRAMBLING) ? CA_PMT_CMD_OK_DESCRAMBLING : *ca_pmt_cmd_id;
4230 }
4231
4232 // If no elementary streams are available, set the PMT pid as the
4233 // first stream (PMT cannot be encrypted, like it was mentioned
4234 // in the old comment, so not sure why this is needed...)
4235 if(demux[demux_id].STREAMpidcount == 0)
4236 {
4237 demux[demux_id].STREAMpids[0] = demux[demux_id].pmtpid;
4238 demux[demux_id].STREAMpidsType[0] = STREAM_VIDEO;
4239 demux[demux_id].STREAMpidcount++;
4240 video_pid = demux[demux_id].pmtpid;
4241 }
4242
4243 // Register found video pid on all ECM pids of this demuxer
4244 for(i = 0; i < demux[demux_id].ECMpidcount; i++)
4245 {
4246 demux[demux_id].ECMpids[i].VPID = video_pid;
4247 }
4248
4249 // Search for dvbapi priority entries for this program
4250 if(dvbapi_priority != NULL)
4251 {
4252 dvbapi_priority_read_entry_add(demux_id, video_pid);
4253 dvbapi_priority_read_entry_map(demux_id);
4254 dvbapi_priority_read_entry_extra(demux_id);
4255 }
4256 }
4257
4258 typedef struct demux_parameters
4259 {
4260 uint8_t demux_index;
4261 uint8_t adapter_index;
4262 uint32_t ca_mask;
4263 uint16_t program_number;
4264 uint16_t pmtpid;
4265 uint16_t onid;
4266 uint16_t tsid;
4267 uint32_t ens;
4268 } demux_parameters_t;
4269
4270 static void get_demux_parameters(const uint8_t *buffer, demux_parameters_t *parameters)
4271 {
4272 parameters->ca_mask = 1;
4273 parameters->demux_index = 0;
4274 parameters->adapter_index = 0;
4275 parameters->pmtpid = 0;
4276 parameters->program_number = b2i(2, buffer + 1);
4277
4278 uint16_t program_info_length = b2i(2, buffer + 4) & 0x0FFF;
4279 uint16_t pos = 7; // 4 + 2 (program_info_length) + 1 (ca_pmt_cmd_id)
4280
4281 while(pos + 1 < 5 + program_info_length)
4282 {
4283 uint8_t descriptor_tag = buffer[pos];
4284 uint8_t descriptor_length = buffer[pos + 1];
4285
4286 switch(descriptor_tag)
4287 {
4288 case CA:
4289 {
4290 break;
4291 }
4292
4293 case ENIGMA_NAMESPACE:
4294 {
4295 if(descriptor_length == 0x08)
4296 {
4297 parameters->ens = b2i(4, buffer + pos + 2);
4298 parameters->tsid = b2i(2, buffer + pos + 6);
4299 parameters->onid = b2i(2, buffer + pos + 8);
4300 }
4301 break;
4302 }
4303
4304 case DEMUX_CA_MASK_ADAPTER:
4305 {
4306 if(descriptor_length == 0x02 && (cfg.dvbapi_boxtype == BOXTYPE_PC ||
4307 cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO))
4308 {
4309 parameters->demux_index = buffer[pos + 2]; // Usually 0, but not always
4310 parameters->adapter_index = buffer[pos + 3]; // Can be 0, 1, 2, ...
4311 parameters->ca_mask = (1 << parameters->adapter_index); // use adapter_index as ca_mask
4312 }
4313 else if(descriptor_length == 0x03 && cfg.dvbapi_boxtype == BOXTYPE_QBOXHD)
4314 {
4315 // ca_mask = buffer[pos + 2]; // with STONE 1.0.4 always 0x01
4316 parameters->demux_index = buffer[pos + 3]; // with STONE 1.0.4 always 0x00
4317 parameters->adapter_index = buffer[pos + 4]; // with STONE 1.0.4 adapter index can be 0, 1, 2
4318 parameters->ca_mask = (1 << parameters->adapter_index); // use adapter_index as ca_mask
4319 }
4320 else if(descriptor_length == 0x02) // enigma2
4321 {
4322 parameters->ca_mask = buffer[pos + 2];
4323 uint8_t demux_tmp = buffer[pos + 3];
4324
4325 if(demux_tmp >= 8 && parameters->ca_mask == 0) // openpli based images
4326 {
4327 parameters->ca_mask = 1 << demux_tmp;
4328 }
4329
4330 if(demux_tmp == 0xFF) // tryfix prismcube (0xFF -> "demux-1" = error!)
4331 {
4332 demux_tmp = 0;
4333 }
4334 parameters->demux_index = demux_tmp;
4335 }
4336 break;
4337 }
4338
4339 case ADAPTER_DEVICE:
4340 {
4341 if(descriptor_length == 0x01)
4342 {
4343 parameters->adapter_index = buffer[pos + 2];
4344 }
4345 break;
4346 }
4347
4348 case PMT_PID:
4349 {
4350 if(descriptor_length == 0x02)
4351 {
4352 parameters->pmtpid = b2i(2, buffer + pos + 2);
4353 }
4354 break;
4355 }
4356
4357 case SERVICE_TYPE_MASK:
4358 break;
4359
4360 case DEMUX_DEVICE:
4361 {
4362 if(descriptor_length == 0x01)
4363 {
4364 parameters->demux_index = buffer[pos + 2];
4365 parameters->ca_mask = 1 << parameters->demux_index;
4366 }
4367 break;
4368 }
4369
4370 case CA_DEVICE:
4371 {
4372 if(descriptor_length == 0x01)
4373 {
4374 parameters->ca_mask = 1 << buffer[pos + 2];
4375 }
4376 break;
4377 }
4378
4379 default:
4380 {
4381 cs_log_dbg(D_DVBAPI, "Skipped unsupported or CA PMT irrelevant descriptor (tag: %02X length: %02X)", descriptor_tag, descriptor_length);
4382 break;
4383 }
4384 }
4385
4386 pos += 2 + descriptor_length;
4387 }
4388 }
4389
4390 static void dvbapi_capmt_notify(struct demux_s *dmx)
4391 {
4392 struct s_client *cl;
4393 for(cl = first_client->next; cl; cl = cl->next)
4394 {
4395 if((cl->typ == 'p' || cl->typ == 'r') && cl->reader && cl->reader->ph.c_capmt)
4396 {
4397 struct demux_s *curdemux;
4398 if(cs_malloc(&curdemux, sizeof(struct demux_s)))
4399 {
4400 memcpy(curdemux, dmx, sizeof(struct demux_s));
4401 add_job(cl, ACTION_READER_CAPMT_NOTIFY, curdemux, sizeof(struct demux_s));
4402 }
4403 }
4404 }
4405 }
4406
4407 static void dvbapi_prepare_descrambling(int32_t demux_id, uint32_t msgid)
4408 {
4409 bool is_powervu = false, start_emm = true;
4410 char service_name[CS_SERVICENAME_SIZE];
4411
4412 // The CA PMT should have given us enough info to determine if descrambling
4413 // is possible. Parsing the (real) PMT is not necessary, unless we have a
4414 // PowerVu encrypted channel or (for some weird reason) no stream pids at all.
4415 // Actually, when no streams are available, we set the PMT pid as the 1st
4416 // stream pid, so we have to check against that. Finally, if the PMT pid is
4417 // not included in the CA PMT, we start the PAT filter instead.
4418
4419 #ifdef WITH_EXTENDED_CW
4420 uint8_t i;
4421 for(i = 0; i < demux[demux_id].ECMpidcount; i++)
4422 {
4423 if(caid_is_powervu(demux[demux_id].ECMpids[i].CAID))
4424 {
4425 is_powervu = true;
4426 break;
4427 }
4428 }
4429 #endif
4430
4431 if(demux[demux_id].pmtpid == 0)
4432 {
4433 dvbapi_start_pat_filter(demux_id);
4434 }
4435 else if(demux[demux_id].STREAMpids[0] == demux[demux_id].pmtpid || is_powervu)
4436 {
4437 dvbapi_start_pmt_filter(demux_id);
4438 }
4439
4440 if(demux[demux_id].running)
4441 {
4442 disable_unused_streampids(demux_id); // disable all streampids not in use anymore
4443 }
4444
4445 if(!demux[demux_id].running && demux[demux_id].ECMpidcount != 0) // only start demuxer if it wasn't running
4446 {
4447 // remove all non important filtering
4448 // (there are images with limited amount of filters available!)
4449 dvbapi_stop_all_cat_emm_sdt_filtering(msgid);
4450
4451 get_servicename(dvbapi_client, demux[demux_id].program_number, demux[demux_id].ECMpids[0].PROVID,
4452 demux[demux_id].ECMpids[0].CAID, service_name, sizeof(service_name));
4453
4454 cs_log_dbg(D_DVBAPI, "Demuxer %d started descrambling for program %04X (%s) (fd: %d)",
4455 demux_id, demux[demux_id].program_number, service_name, demux[demux_id].socket_fd);
4456
4457 demux[demux_id].running = true; // mark channel as running
4458 openxcas_set_sid(demux[demux_id].program_number);
4459 demux[demux_id].decodingtries = -1;
4460 dvbapi_resort_ecmpids(demux_id);
4461 dvbapi_try_next_caid(demux_id, 0, msgid);
4462 cs_sleepms(1);
4463 }
4464 else if(demux[demux_id].ECMpidcount == 0) // FTA: do logging and part of ecm handler
4465 {
4466 get_servicename(dvbapi_client, demux[demux_id].program_number, NO_PROVID_VALUE, NO_CAID_VALUE,
4467 service_name, sizeof(service_name));
4468
4469 cs_log_dbg(D_DVBAPI, "Demuxer %d no descrambling needed for FTA program %04X (%s) (fd: %d)",
4470 demux_id, demux[demux_id].program_number, service_name, demux[demux_id].socket_fd);
4471
4472 demux[demux_id].running = false; // reset running flag
4473 demux[demux_id].pidindex = -1; // reset ecmpid used for descrambling
4474 dvbapi_stop_filter(demux_id, TYPE_ECM, msgid);
4475
4476 if(cfg.usrfileflag) // add to user log previous channel + time on channel
4477 {
4478 cs_statistics(dvbapi_client);
4479 }
4480
4481 dvbapi_client->last_srvid = demux[demux_id].program_number; // set new channel srvid
4482 dvbapi_client->last_caid = NO_CAID_VALUE; // FTA channels have no caid!
4483 dvbapi_client->last_provid = NO_PROVID_VALUE; // FTA channels have no provid!
4484 dvbapi_client->lastswitch = dvbapi_client->last = time((time_t *)0); // reset idle-Time & last switch
4485 }
4486
4487 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
4488 // Don't start and Stop EMM Filters over and over again if we are on FTA
4489 if(dvbapi_client->last_caid == NO_CAID_VALUE)
4490 {
4491 start_emm = false;
4492 }
4493 #endif
4494
4495 // only do emm setup if au enabled and not running!
4496 if(cfg.dvbapi_au > 0 && demux[demux_id].EMMpidcount == 0 && start_emm == true)
4497 {
4498 demux[demux_id].emm_filter = -1; // to register first run emmfilter start
4499
4500 if(demux[demux_id].emmstart.time == 1) // irdeto fetch emm cat direct!
4501 {
4502 // trick to let emm fetching start after 30 seconds to speed up zapping
4503 cs_ftime(&demux[demux_id].emmstart);
4504
4505 dvbapi_start_cat_filter(demux_id);
4506 }
4507 else
4508 {
4509 cs_ftime(&demux[demux_id].emmstart); // for all other caids delayed start!
4510 }
4511 }
4512 }
4513
4514 int32_t dvbapi_parse_capmt(const uint8_t *buffer, uint32_t length, int32_t connfd, char *pmtfile, uint16_t client_proto_version, uint32_t msgid)
4515 {
4516 int32_t i, demux_id = -1;
4517 uint8_t ca_pmt_list_management, ca_pmt_cmd_id;
4518 bool is_update = false;
4519 demux_parameters_t parameters;
4520 memset(&parameters, 0, sizeof(parameters));
4521
4522 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
4523 ca_pmt_list_management = CA_PMT_LIST_ONLY;
4524 #else
4525 ca_pmt_list_management = buffer[0];
4526 #endif
4527
4528 // We received a new list of CA PMT objects.
4529 // Mark all demuxers to stop descrambling, but do not actually stop any of them,
4530 // until we verify the new list does not contain any previously selected program.
4531 if(ca_pmt_list_management == CA_PMT_LIST_FIRST || ca_pmt_list_management == CA_PMT_LIST_ONLY)
4532 {
4533 for(i = 0; i < MAX_DEMUX; i++)
4534 {
4535 // Skip empty demuxers, demuxers belonging to different
4536 // CA PMT connections or handled by different PMT files.
4537 if(demux[i].program_number == 0 || demux[i].socket_fd != connfd ||
4538 (demux[i].socket_fd == -1 && pmtfile && strcmp(demux[i].pmt_file, pmtfile) != 0))
4539 {
4540 continue;
4541 }
4542
4543 demux[i].stop_descrambling = true; // Mark for deletion if not used again by following CA PMT objects
4544
4545 cs_log_dbg(D_DVBAPI, "Demuxer %d marked to stop descrambling for program %04X (fd: %d)",
4546 i, demux[i].program_number, connfd);
4547 }
4548 }
4549
4550 // Read private descriptors inside the CA PMT message
4551 // in order to get adapter, demux, ca, pmt pid and more.
4552 get_demux_parameters(buffer, &parameters);
4553
4554 cs_log_dbg(D_DVBAPI, "Received CA PMT list management %d for program %04X (pmt pid: %04X adapter: %d demux: %d camask: %d)",
4555 ca_pmt_list_management, parameters.program_number, parameters.pmtpid, parameters.adapter_index,
4556 parameters.demux_index, parameters.ca_mask);
4557
4558 // Search current demuxers for having the same program
4559 // as the one we received in this CA PMT object.
4560 for(i = 0; i < MAX_DEMUX; i++)
4561 {
4562 if(demux[i].program_number == 0)
4563 {
4564 continue;
4565 }
4566
4567 if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX_PMT)
4568 {
4569 parameters.demux_index = i; // fixup for ipbox
4570 }
4571
4572 bool full_check = true, matched = false;
4573
4574 if(config_enabled(WITH_COOLAPI) || config_enabled(WITH_COOLAPI2) || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
4575 {
4576 full_check = false;
4577 }
4578
4579 if(full_check)
4580 {
4581 matched = (connfd > 0 && demux[i].socket_fd == connfd) && demux[i].program_number == parameters.program_number;
4582 }
4583 else
4584 {
4585 matched = connfd > 0 && demux[i].program_number == parameters.program_number;
4586 }
4587
4588 if(matched)
4589 {
4590 if(full_check)
4591 {
4592 // In PMT mode 6, when zapping between channels with the same program number and PMT pid
4593 // (sometimes the case with satellite feeds), as all hardware parameters being the same
4594 // (adapter, demux, ca_mask, connfd), the new program is considered an existing one (matched).
4595 // The only reliable way to determine whether we actually have a new program is to compare
4596 // the enigma namespace, tsid and onid as well.
4597 if(demux[i].demux_index != parameters.demux_index || demux[i].ca_mask != parameters.ca_mask ||
4598 demux[i].adapter_index != parameters.adapter_index || demux[i].pmtpid != parameters.pmtpid ||
4599 demux[i].ens != parameters.ens || demux[i].tsid != parameters.tsid || demux[i].onid != parameters.onid)
4600 {
4601 continue;
4602 }
4603 }
4604
4605 // A program update is normally signaled by either a list management:
4606 // 1. UPDATE for an existing program
4607 // 2. ADD for an existing program (which according to the specifications should be treated as an UPDATE)
4608 // 3. ONLY for an existing program (with broken clients, in pmt modes other than 6)
4609 if(ca_pmt_list_management == CA_PMT_LIST_UPDATE || ca_pmt_list_management == CA_PMT_LIST_ADD
4610 || (cfg.dvbapi_pmtmode != 6 && ca_pmt_list_management == CA_PMT_LIST_ONLY))
4611 {
4612 is_update = true;
4613 cs_log("Demuxer %d received updated CA PMT for program %04X", i, parameters.program_number);
4614 }
4615
4616 cs_log("Demuxer %d continues descrambling for program %04X", i, demux[i].program_number);
4617 openxcas_set_sid(parameters.program_number);
4618 demux[i].stop_descrambling = false; // don't stop current demuxer!
4619 demux_id = i;
4620 break; // no need to explore other demuxers since we have a match!
4621 }
4622 }
4623
4624 // We are currently processing the last object of the CA PMT list.
4625 // We should now stop descrambling all programs not included in this list.
4626 if(ca_pmt_list_management != CA_PMT_LIST_FIRST && ca_pmt_list_management != CA_PMT_LIST_MORE)
4627 {
4628 for(i = 0; i < MAX_DEMUX; i++)
4629 {
4630 if(demux[i].program_number == 0)
4631 {
4632 continue;
4633 }
4634
4635 if(demux[i].stop_descrambling)
4636 {
4637 dvbapi_stop_descrambling(i, msgid);
4638 }
4639 }
4640 }
4641
4642 // We continue reading the CA PMT object only when we get
4643 // a new program (demux_id == -1) or an updated program.
4644 if(!(demux_id == -1 || is_update))
4645 {
4646 return demux_id;
4647 }
4648
4649 // We received a CA PMT object for a new program.
4650 // Let's find an empty demuxer for it.
4651 if(demux_id == -1)
4652 {
4653 if(ca_pmt_list_management == CA_PMT_LIST_UPDATE)
4654 {
4655 cs_log("ERROR: Received CA PMT list update for unknown program");
4656 return -1;
4657 }
4658
4659 for(demux_id = 0; demux_id < MAX_DEMUX; demux_id++)
4660 {
4661 if(demux[demux_id].program_number != 0)
4662 {
4663 continue; // Skip occupied demuxers
4664 }
4665
4666 // Probably this box doesn't send any private descriptor in the
4667 // CA PMT, so we have to improvise before saving to the demuxer.
4668 if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX_PMT)
4669 {
4670 parameters.ca_mask = demux_id + 1;
4671 parameters.demux_index = demux_id;
4672 }
4673
4674 demux[demux_id].demux_index = parameters.demux_index;
4675 demux[demux_id].adapter_index = parameters.adapter_index;
4676 demux[demux_id].ca_mask = parameters.ca_mask;
4677 demux[demux_id].socket_fd = connfd;
4678 demux[demux_id].client_proto_version = client_proto_version;
4679 demux[demux_id].program_number = parameters.program_number;
4680 demux[demux_id].pmtpid = parameters.pmtpid;
4681 demux[demux_id].ens = parameters.ens;
4682 demux[demux_id].tsid = parameters.tsid;
4683 demux[demux_id].onid = parameters.onid;
4684 demux[demux_id].stop_descrambling = false;
4685 demux[demux_id].running = false;
4686 demux[demux_id].sdt_filter = -1;
4687 demux[demux_id].rdr = NULL;
4688
4689 if(pmtfile)
4690 {
4691 cs_strncpy(demux[demux_id].pmt_file, pmtfile, sizeof(demux[demux_id].pmt_file));
4692 }
4693
4694 break;
4695 }
4696
4697 if(demux_id >= MAX_DEMUX)
4698 {
4699 cs_log("There is no free demuxer for the new program! Aborting...");
4700 return -1;
4701 }
4702 }
4703
4704 // We continue parsing the CA PMT info for new or updated programs.
4705 // For updated programs, we just delete all previous stream pids and
4706 // ECM pids and start parsing the fresh data.
4707 dvbapi_parse_pmt_info(demux_id, buffer + 4, length - 4, &ca_pmt_cmd_id);
4708
4709 // Finally, evaluate what response the host requires from OSCam.
4710 // This allows multiple CA applications to run at the host simultaneously.
4711 // "OK query" will be implemented at a later stage, when support is first
4712 // added in enigma2.
4713 switch(ca_pmt_cmd_id)
4714 {
4715 case CA_PMT_CMD_OK_DESCRAMBLING:
4716 {
4717 // remove from unassoc_fd when necessary
4718 for(i = 0; i < MAX_DEMUX; i++)
4719 {
4720 if(unassoc_fd[i] == connfd)
4721 {
4722 unassoc_fd[i] = 0;
4723 }
4724 }
4725
4726 dvbapi_capmt_notify(&demux[demux_id]);
4727 dvbapi_prepare_descrambling(demux_id, msgid);
4728 return demux_id;
4729 }
4730
4731 case CA_PMT_CMD_QUERY:
4732 {
4733 cs_log("Received unsupported CA PMT command ID 'query' for program %04X", demux[demux_id].program_number);
4734 dvbapi_stop_descrambling(demux_id, msgid); // Clear all data from this demuxer
4735 return -1;
4736 }
4737
4738 case CA_PMT_CMD_NOT_SELECTED:
4739 {
4740 cs_log("Program %04X is not selected for descrambling", demux[demux_id].program_number);
4741 dvbapi_stop_descrambling(demux_id, msgid); // Clear all data from this demuxer
4742 return -1;
4743 }
4744
4745 default:
4746 {
4747 cs_log("Received unknown or unsupported CA PMT command ID %02X from host", ca_pmt_cmd_id);
4748 dvbapi_stop_descrambling(demux_id, msgid);
4749 return -1;
4750 }
4751 }
4752 }
4753
4754 static void dvbapi_parse_pmt(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint32_t msgid)
4755 {
4756 uint16_t program_number = b2i(2, buffer + 3);
4757 if(program_number != demux[demux_id].program_number)
4758 {
4759 cs_log("Demuxer %d received PMT for undefined program %04X", demux_id, program_number);
4760 return;
4761 }
4762
4763 dvbapi_stop_filter(demux_id, TYPE_PMT, msgid);
4764 dvbapi_parse_pmt_info(demux_id, buffer + 10, length - 10 - 4, NULL); // last 4 bytes are the CRC-32
4765 }
4766
4767 static void dvbapi_create_srvid_line(int32_t demux_id, char *buffer, uint32_t buflen)
4768 {
4769 int32_t i, j, pos = 0;
4770 uint16_t caid_done[32], cur_caid;
4771 uint8_t caid_done_count = 0, skip_caid;
4772
4773 if(demux[demux_id].ECMpidcount == 0)
4774 {
4775 snprintf(buffer, buflen, "%04X@%06X", NO_CAID_VALUE, NO_PROVID_VALUE);
4776 return;
4777 }
4778
4779 for(i = 0; i < demux[demux_id].ECMpidcount && i < 32; i++)
4780 {
4781 skip_caid = 0;
4782 for(j = 0; j < caid_done_count; j++)
4783 {
4784 if(caid_done[j] == demux[demux_id].ECMpids[i].CAID)
4785 {
4786 skip_caid = 1;
4787 break;
4788 }
4789 }
4790
4791 if(skip_caid)
4792 {
4793 continue;
4794 }
4795
4796 cur_caid = demux[demux_id].ECMpids[i].CAID;
4797 pos += snprintf(buffer + pos, buflen - pos, "%s%04X", caid_done_count > 0 ? "," : "", cur_caid == 0 ? NO_CAID_VALUE : cur_caid);
4798
4799 for(j = i; j < demux[demux_id].ECMpidcount; j++)
4800 {
4801 if(demux[demux_id].ECMpids[j].PROVID == 0)
4802 {
4803 continue;
4804 }
4805
4806 if(cur_caid == demux[demux_id].ECMpids[j].CAID)
4807 {
4808 pos += snprintf(buffer + pos, buflen - pos, "@%06X", demux[demux_id].ECMpids[j].PROVID);
4809 }
4810 }
4811
4812 caid_done[caid_done_count] = demux[demux_id].ECMpids[i].CAID;
4813 caid_done_count++;
4814 }
4815 }
4816
4817 static void dvbapi_write_sdt_info(int32_t demux_id, const char *provider_name, const char* service_name, const char *service_type)
4818 {
4819 int8_t did_save_srvid = 0;
4820 int32_t provid, caid, pidindex;
4821 char tmp[256], srvid_line[1024];
4822 FILE *fpsave = NULL;
4823
4824 pidindex = demux[demux_id].pidindex;
4825 if(pidindex != -1)
4826 {
4827 caid = demux[demux_id].ECMpids[pidindex].CAID;
4828 provid = demux[demux_id].ECMpids[pidindex].PROVID;
4829 }
4830 else
4831 {
4832 if(demux[demux_id].ECMpidcount == 0 || demux[demux_id].ECMpids[0].CAID == 0)
4833 {
4834 caid = NO_CAID_VALUE;
4835 provid = NO_PROVID_VALUE;
4836 }
4837 else
4838 {
4839 caid = demux[demux_id].ECMpids[0].CAID;
4840 provid = demux[demux_id].ECMpids[0].PROVID;
4841 }
4842 }
4843
4844 if(strlen(provider_name) && caid != NO_CAID_VALUE)
4845 {
4846 get_providername_or_null(provid, caid, tmp, sizeof(tmp));
4847
4848 if(tmp[0] == '\0')
4849 {
4850 get_config_filename(tmp, sizeof(tmp), "oscam.provid");
4851
4852 if((fpsave = fopen(tmp, "a")))
4853 {
4854 fprintf(fpsave, "\n%04X@%06X|%s|", caid, provid, provider_name);
4855 fclose(fpsave);
4856 init_provid();
4857 }
4858 }
4859 }
4860
4861 if(strlen(service_name))
4862 {
4863 get_servicename_or_null(cur_client(), demux[demux_id].program_number, provid, caid, tmp, sizeof(tmp));
4864
4865 if(tmp[0] == '\0')
4866 {
4867 get_config_filename(tmp, sizeof(tmp), "oscam.srvid2");
4868
4869 if(!access(tmp, F_OK) && (fpsave = fopen(tmp, "a")))
4870 {
4871 if((caid != NO_CAID_VALUE) || (cfg.dvbapi_read_sdt > 1))
4872 {
4873 dvbapi_create_srvid_line(demux_id, srvid_line, sizeof(srvid_line));
4874
4875 if(cfg.dvbapi_write_sdt_prov)
4876 {
4877 fprintf(fpsave, "\n%04X:%s|%s|%s||%s", demux[demux_id].program_number, srvid_line, service_name, service_type, provider_name);
4878 }
4879 else
4880 {
4881 fprintf(fpsave, "\n%04X:%s|%s|%s", demux[demux_id].program_number, srvid_line, service_name, service_type);
4882 }
4883
4884 did_save_srvid = 1;
4885 }
4886 }
4887 else
4888 {
4889 get_config_filename(tmp, sizeof(tmp), "oscam.srvid");
4890
4891 if((fpsave = fopen(tmp, "a")))
4892 {
4893 if((caid != NO_CAID_VALUE) || (cfg.dvbapi_read_sdt > 1))
4894 {
4895 dvbapi_create_srvid_line(demux_id, srvid_line, sizeof(srvid_line));
4896
4897 if(cfg.dvbapi_write_sdt_prov)
4898 {
4899 fprintf(fpsave, "\n%s:%04X|%s|%s|%s", srvid_line, demux[demux_id].program_number, provider_name, service_name, service_type);
4900 }
4901 else
4902 {
4903 fprintf(fpsave, "\n%s:%04X||%s|%s", srvid_line, demux[demux_id].program_number, service_name, service_type);
4904 }
4905
4906 did_save_srvid = 1;
4907 }
4908 }
4909 }
4910
4911 if(fpsave)
4912 {
4913 fclose(fpsave);
4914 }
4915
4916 if(did_save_srvid)
4917 {
4918 init_srvid();
4919 }
4920 }
4921 }
4922 }
4923
4924 static uint32_t dvbapi_extract_sdt_string(char *buf, uint32_t buflen, const uint8_t *source, uint8_t sourcelen)
4925 {
4926 uint32_t i, j, offset = 0;
4927 int8_t iso_mode = -1;
4928 char *tmpbuf;
4929 const uint8_t *ptr_in;
4930 uint8_t *ptr_out;
4931 size_t in_bytes, out_bytes;
4932
4933 if(sourcelen == 0)
4934 {
4935 buf[0] = '\0';
4936 return 1;
4937 }
4938
4939 if(!cs_malloc(&tmpbuf, buflen))
4940 {
4941 return 0;
4942 }
4943
4944 if(sourcelen > buflen - 1)
4945 {
4946 sourcelen = buflen - 1;
4947 }
4948
4949 if(sourcelen > 0 && source[0] < 0x20)
4950 {
4951 if(source[0] >= 0x01 && source[0] <= 0x0B && source[0] != 0x08) // ISO/IEC 8859
4952 {
4953 offset = 1;
4954 iso_mode = 4 + source[0];
4955 }
4956 else if(source[0] == 0x10) // Dynamically selected part of ISO/IEC 8859
4957 {
4958 if(source[1] == 0x00 && source[2] >= 0x01 && source[2] <= 0x0F && source[2] != 0x0C)
4959 {
4960 offset = 3;
4961 iso_mode = source[2];
4962 }
4963 }
4964 else if(source[0] == 0x11) // ISO/IEC 10646
4965 {
4966 offset = 1;
4967 iso_mode = -2;
4968 }
4969 // missing: 0x12 KSX1001-2004 (Korean Character Set)
4970 // missing: 0x13 GB-2312-1980 (Simplified Chinese Character Set)
4971 // missing: 0x14 Big5 subset of ISO/IEC 10646 (Traditional Chinese)
4972 else if(source[0] == 0x15) // UTF-8 encoding of ISO/IEC 10646
4973 {
4974 offset = 1;
4975 iso_mode = -3;
4976 }
4977 // missing: 0x1F Described by encoding_type_id
4978 else
4979 {
4980 NULLFREE(tmpbuf);
4981 return 0;
4982 }
4983 }
4984
4985 if(offset >= sourcelen)
4986 {
4987 NULLFREE(tmpbuf);
4988 return 0;
4989 }
4990
4991 if(iso_mode >= -1)
4992 {
4993 for(i = 0, j = 0; i < sourcelen - offset; i++)
4994 {
4995 if(source[offset + i] >= 0x80 && source[offset + i] <= 0x9F)
4996 {
4997 continue;
4998 }
4999
5000 tmpbuf[j] = source[offset + i];
5001 j++;
5002 }
5003
5004 tmpbuf[j] = '\0';
5005 }
5006
5007 ptr_in = (const uint8_t *)tmpbuf;
5008 in_bytes = strlen(tmpbuf);
5009 ptr_out = (uint8_t *)buf;
5010 out_bytes = buflen;
5011
5012 #ifdef READ_SDT_CHARSETS
5013 if(iso_mode >= -1)
5014 {
5015 memset(buf, 0, buflen);
5016 cs_log_dbg(D_DVBAPI, "sdt-info dbg: iso_mode: %d offset: %u", iso_mode, offset);
5017 cs_log_dump_dbg(D_DVBAPI, (uint8_t *)tmpbuf, in_bytes, "sdt-info dbg: raw string:");
5018
5019 if(iso_mode == -1)
5020 {
5021 if(ISO6937toUTF8(&ptr_in, &in_bytes, &ptr_out, &out_bytes) == (size_t)(-1))
5022 {
5023 cs_log_dbg(D_DVBAPI, "sdt-info error: ISO6937toUTF8 failed");
5024 NULLFREE(tmpbuf);
5025 return 0;
5026 }
5027 }
5028 else
5029 {
5030 if(ISO8859toUTF8(iso_mode, &ptr_in, &in_bytes, &ptr_out, &out_bytes) == (size_t)(-1))
5031 {
5032 cs_log_dbg(D_DVBAPI, "sdt-info error: ISO8859toUTF8 failed");
5033 NULLFREE(tmpbuf);
5034 return 0;
5035 }
5036 }
5037 }
5038 #else
5039 if(iso_mode >= -1)
5040 {
5041 cs_strncpy(buf, tmpbuf, buflen);
5042 cs_log_dbg(D_DVBAPI, "sdt-info warning: your build of oscam does not support iso-to-utf8 conversion, special chars may be corrupted!");
5043 }
5044 #endif
5045 else if(iso_mode == -2)
5046 {
5047 memset(buf, 0, buflen);
5048 cs_log_dbg(D_DVBAPI, "sdt-info dbg: iso_mode: %d offset: %u", iso_mode, offset);
5049
5050 if(UnicodetoUTF8(&ptr_in, &in_bytes, &ptr_out, &out_bytes) == (size_t)(-1))
5051 {
5052 cs_log_dbg(D_DVBAPI, "sdt-info error: UnicodetoUTF8 failed");
5053 NULLFREE(tmpbuf);
5054 return 0;
5055 }
5056 }
5057 else if(iso_mode == -3) // No conversion, already in UTF-8
5058 {
5059 memcpy(buf, source + offset, sourcelen - offset);
5060 buf[sourcelen - offset] = '\0';
5061 cs_log_dbg(D_DVBAPI, "sdt-info dbg: iso_mode: -3 offset: %u", offset);
5062 }
5063
5064 cs_log_dump_dbg(D_DVBAPI, (uint8_t *)buf, strlen(buf), "sdt-info dbg: encoded string:");
5065 NULLFREE(tmpbuf);
5066 return 1;
5067 }
5068
5069 static const char *dvbapi_get_service_type(uint8_t service_type)
5070 {
5071 switch(service_type)
5072 {
5073 case 0x01:
5074 case 0x0B:
5075 case 0x11:
5076 case 0x16:
5077 case 0x17:
5078 case 0x18:
5079 case 0x19:
5080 case 0x1A:
5081 case 0x1B:
5082 case 0x1C:
5083 case 0x1D:
5084 case 0x1E:
5085 case 0x1F:
5086 case 0x20:
5087 return "TV";
5088
5089 case 0x02:
5090 case 0x07:
5091 case 0x0A:
5092 return "Radio";
5093
5094 case 0x03:
5095 return "Teletext";
5096
5097 case 0x0C:
5098 return "Data";
5099
5100 default:
5101 return "unknown";
5102 }
5103 }
5104
5105 static void dvbapi_parse_service_descriptor(int32_t demux_id, const uint8_t *buffer, uint8_t descriptor_length)
5106 {
5107 uint8_t service_provider_name_length, service_name_length;
5108 char service_provider_name[64], service_name[64];
5109 const char *service_type;
5110
5111 if(descriptor_length < 3)
5112 {
5113 return; // Service descriptor has a minimum length of 3 bytes
5114 }
5115
5116 service_type = dvbapi_get_service_type(buffer[0]);
5117
5118 service_provider_name_length = buffer[1];
5119 if(2 + service_provider_name_length + 1 > descriptor_length)
5120 {
5121 return;
5122 }
5123
5124 service_name_length = buffer[2 + service_provider_name_length];
5125 if(2 + service_provider_name_length + 1 + service_name_length > descriptor_length)
5126 {
5127 return;
5128 }
5129
5130 if(!dvbapi_extract_sdt_string(service_provider_name, sizeof(service_provider_name), buffer + 2, service_provider_name_length) ||
5131 !dvbapi_extract_sdt_string(service_name, sizeof(service_name), buffer + 2 + service_provider_name_length + 1, service_name_length))
5132 {
5133 return;
5134 }
5135
5136 cs_log_dbg(D_DVBAPI, "Demuxer %d got service info (provider: %s - name: %s - type: %s)",
5137 demux_id, service_provider_name, service_name, service_type);
5138
5139 dvbapi_write_sdt_info(demux_id, service_provider_name, service_name, service_type);
5140 }
5141
5142 static void dvbapi_parse_sdt(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint32_t msgid)
5143 {
5144 uint8_t descriptor_tag, descriptor_length;
5145 uint16_t service_id, descriptors_loop_length, i, j;
5146
5147 if(buffer[0] != 0x42) // SDT sections with table_id value 0x42 describe the actual TS
5148 {
5149 return;
5150 }
5151
5152 // Get the tsid and onid (in enigma2 STBs we have
5153 // already received them in the CA PMT message)
5154 demux[demux_id].tsid = b2i(2, buffer + 3);
5155 demux[demux_id].onid = b2i(2, buffer + 8);
5156
5157 for(i = 11; i + 5 < length; i += 5 + descriptors_loop_length)
5158 {
5159 service_id = b2i(2, buffer + i);
5160 descriptors_loop_length = b2i(2, buffer + i + 3) & 0x0FFF;
5161
5162 if(service_id != demux[demux_id].program_number)
5163 {
5164 continue;
5165 }
5166
5167 for(j = 0; j + 1 < descriptors_loop_length; j += 2 + descriptor_length)
5168 {
5169 descriptor_tag = buffer[i + 5 + j];
5170 descriptor_length = buffer[i + 5 + j + 1];
5171
5172 if(descriptor_tag == 0x48)
5173 {
5174 dvbapi_parse_service_descriptor(demux_id, buffer + i + 5 + j + 2, descriptor_length);
5175 }
5176 }
5177
5178 dvbapi_stop_filter(demux_id, TYPE_SDT, msgid);
5179 break;
5180 }
5181 }
5182
5183 static void dvbapi_parse_pat(int32_t demux_id, const uint8_t *buffer, uint16_t length, uint32_t msgid)
5184 {
5185 uint16_t i, srvid;
5186
5187 dvbapi_stop_filter(demux_id, TYPE_PAT, msgid);
5188
5189 for(i = 8; i + 7 < length; i += 4)
5190 {
5191 srvid = b2i(2, buffer + i);
5192 if(srvid == 0)
5193 {
5194 continue;
5195 }
5196
5197 if(demux[demux_id].program_number == srvid)
5198 {
5199 demux[demux_id].pmtpid = b2i(2, buffer + i + 2) & 0x1FFF;
5200 dvbapi_start_pmt_filter(demux_id);
5201 break;
5202 }
5203 }
5204 }
5205
5206 int32_t dvbapi_init_listenfd(void)
5207 {
5208 int32_t clilen, listenfd;
5209 struct sockaddr_un servaddr;
5210
5211 memset(&servaddr, 0, sizeof(struct sockaddr_un));
5212 servaddr.sun_family = AF_UNIX;
5213 cs_strncpy(servaddr.sun_path, devices[selected_box].cam_socket_path, sizeof(servaddr.sun_path));
5214 clilen = sizeof(servaddr.sun_family) + strlen(servaddr.sun_path);
5215
5216 if(((unlink(devices[selected_box].cam_socket_path) < 0) && (errno != ENOENT))
5217 || ((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
5218 || (bind(listenfd, (struct sockaddr *)&servaddr, clilen) < 0)
5219 || (listen(listenfd, 5) < 0))
5220 {
5221 return 0;
5222 }
5223
5224 // change the access right on the camd.socket
5225 // this will allow oscam to run as root if needed
5226 // and still allow non root client to connect to the socket
5227 chmod(devices[selected_box].cam_socket_path, S_IRWXU | S_IRWXG | S_IRWXO);
5228 return listenfd;
5229 }
5230
5231 int32_t dvbapi_net_init_listenfd(void)
5232 {
5233 int32_t listenfd;
5234 struct SOCKADDR servaddr;
5235
5236 memset(&servaddr, 0, sizeof(servaddr));
5237 SIN_GET_FAMILY(servaddr) = DEFAULT_AF;
5238 SIN_GET_ADDR(servaddr) = ADDR_ANY;
5239 SIN_GET_PORT(servaddr) = htons((uint16_t)cfg.dvbapi_listenport);
5240
5241 if((listenfd = socket(DEFAULT_AF, SOCK_STREAM, 0)) < 0)
5242 {
5243 return 0;
5244 }
5245 int32_t opt = 0;
5246
5247 #ifdef IPV6SUPPORT
5248 // azbox toolchain do not have this define
5249 #ifndef IPV6_V6ONLY
5250 #define IPV6_V6ONLY 26
5251 #endif
5252 // set the server socket option to listen on IPv4 and IPv6 simultaneously
5253 setsockopt(listenfd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&opt, sizeof(opt));
5254 #endif
5255
5256 opt = 1;
5257 setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (void *)&opt, sizeof(opt));
5258 set_so_reuseport(listenfd);
5259
5260 if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
5261 {
5262 return 0;
5263 }
5264
5265 if(listen(listenfd, 5) < 0)
5266 {
5267 return 0;
5268 }
5269 return listenfd;
5270 }
5271
5272 static pthread_mutex_t event_handler_lock = PTHREAD_MUTEX_INITIALIZER;
5273
5274 void event_handler(int32_t UNUSED(signal))
5275 {
5276 struct stat pmt_info;
5277 char dest[1024];
5278 DIR *dirp;
5279 struct dirent entry, *dp = NULL;
5280 int32_t i, pmt_fd;
5281 uint8_t mbuf[2048]; // dirty fix: larger buffer needed for CA PMT mode 6 with many parallel channels to decode
5282
5283 if(dvbapi_client != cur_client())
5284 {
5285 return;
5286 }
5287
5288 SAFE_MUTEX_LOCK(&event_handler_lock);
5289 if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
5290 {
5291 pausecam = 0;
5292 }
5293 else
5294 {
5295 int32_t standby_fd = open(STANDBY_FILE, O_RDONLY);
5296 pausecam = (standby_fd > 0) ? 1 : 0;
5297 if(standby_fd > 0)
5298 {
5299 int32_t ret = close(standby_fd);
5300 if(ret < 0)
5301 {
5302 cs_log("ERROR: Could not close standby fd (errno=%d %s)", errno, strerror(errno));
5303 }
5304 }
5305 }
5306
5307 if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX || cfg.dvbapi_pmtmode == 1)
5308 {
5309 SAFE_MUTEX_UNLOCK(&event_handler_lock);
5310 return;
5311 }
5312
5313 for(i = 0; i < MAX_DEMUX; i++)
5314 {
5315 if(demux[i].pmt_file[0] != 0)
5316 {
5317 snprintf(dest, sizeof(dest), "%s%s", TMPDIR, demux[i].pmt_file);
5318 pmt_fd = open(dest, O_RDONLY);
5319 if(pmt_fd > 0)
5320 {
5321 if(fstat(pmt_fd, &pmt_info) != 0)
5322 {
5323 int32_t ret = close(pmt_fd);
5324 if(ret < 0)
5325 {
5326 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno));
5327 }
5328 continue;
5329 }
5330
5331 if((time_t)pmt_info.st_mtime != demux[i].pmt_time)
5332 {
5333 dvbapi_stop_descrambling(i, 0);
5334 }
5335
5336 int32_t ret = close(pmt_fd);
5337 if(ret < 0)
5338 {
5339 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno));
5340 }
5341 continue;
5342 }
5343 else
5344 {
5345 cs_log("Demuxer %d Unable to open PMT file %s -> stop descrambling!", i, dest);
5346 dvbapi_stop_descrambling(i, 0);
5347 }
5348 }
5349 }
5350
5351 if(disable_pmt_files)
5352 {
5353 SAFE_MUTEX_UNLOCK(&event_handler_lock);
5354 return;
5355 }
5356
5357 dirp = opendir(TMPDIR);
5358 if(!dirp)
5359 {
5360 cs_log_dbg(D_DVBAPI, "opendir failed (errno=%d %s)", errno, strerror(errno));
5361 SAFE_MUTEX_UNLOCK(&event_handler_lock);
5362 return;
5363 }
5364
5365 while(!cs_readdir_r(dirp, &entry, &dp))
5366 {
5367 if(!dp)
5368 {
5369 break;
5370 }
5371
5372 if(strlen(dp->d_name) < 7)
5373 {
5374 continue;
5375 }
5376
5377 if(strncmp(dp->d_name, "pmt", 3) != 0 || strncmp(dp->d_name + strlen(dp->d_name) - 4, ".tmp", 4) != 0)
5378 {
5379 continue;
5380 }
5381
5382 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
5383 struct s_dvbapi_priority *p;
5384 for(p = dvbapi_priority; p != NULL; p = p->next) // stapi: check if there is a device connected to this pmt file!
5385 {
5386 if(p->type != 's') { continue; } // stapi rule?
5387 if(strcmp(dp->d_name, p->pmtfile) != 0) { continue; } // same file?
5388 break; // found match!
5389 }
5390
5391 if(p == NULL)
5392 {
5393 cs_log_dbg(D_DVBAPI, "No matching S: line in oscam.dvbapi for pmtfile %s -> skip!", dp->d_name);
5394 continue;
5395 }
5396 #endif
5397 snprintf(dest, sizeof(dest), "%s%s", TMPDIR, dp->d_name);
5398 pmt_fd = open(dest, O_RDONLY);
5399 if(pmt_fd < 0)
5400 {
5401 continue;
5402 }
5403
5404 if(fstat(pmt_fd, &pmt_info) != 0)
5405 {
5406 int32_t ret = close(pmt_fd);
5407 if(ret < 0)
5408 {
5409 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno));
5410 }
5411 continue;
5412 }
5413
5414 int32_t found = 0;
5415
5416 for(i = 0; i < MAX_DEMUX; i++)
5417 {
5418 if(strcmp(demux[i].pmt_file, dp->d_name) == 0)
5419 {
5420 if((time_t)pmt_info.st_mtime == demux[i].pmt_time)
5421 {
5422 found = 1;
5423 break;
5424 }
5425 }
5426 }
5427
5428 if(found)
5429 {
5430 int32_t ret = close(pmt_fd);
5431 if(ret < 0)
5432 {
5433 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno));
5434 }
5435 continue;
5436 }
5437 cs_log_dbg(D_DVBAPI, "found pmt file %s", dest);
5438 cs_sleepms(100);
5439
5440 uint32_t len = read(pmt_fd, mbuf, sizeof(mbuf));
5441 int32_t ret = close(pmt_fd);
5442
5443 if(ret < 0)
5444 {
5445 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno));
5446 }
5447
5448 if(len < 1)
5449 {
5450 cs_log_dbg(D_DVBAPI, "pmt file %s have invalid len!", dest);
5451 continue;
5452 }
5453
5454 int32_t demux_id;
5455 #ifdef QBOXHD
5456 uint32_t j1, j2;
5457
5458 // QboxHD pmt.tmp is the full capmt written as a string of hex values
5459 // pmt.tmp must be longer than 3 bytes (6 hex chars) and even length
5460 if((len < 6) || ((len % 2) != 0) || ((len / 2) > sizeof(dest)))
5461 {
5462 cs_log_dbg(D_DVBAPI, "error parsing QboxHD pmt.tmp, incorrect length");
5463 continue;
5464 }
5465
5466 for(j2 = 0, j1 = 0; j2 < len; j2 += 2, j1++)
5467 {
5468 unsigned int tmp;
5469 if(sscanf((char *)mbuf + j2, "%02X", &tmp) != 1)
5470 {
5471 cs_log_dbg(D_DVBAPI, "error parsing QboxHD pmt.tmp, data not valid in position %d", j2);
5472 SAFE_MUTEX_UNLOCK(&event_handler_lock);
5473 return;
5474 }
5475 else
5476 {
5477 memcpy(dest + j1, &tmp, 4);
5478 }
5479 }
5480
5481 cs_log_dump_dbg(D_DVBAPI, (uint8_t *)dest, len / 2, "QboxHD pmt.tmp:");
5482 demux_id = dvbapi_parse_capmt((uint8_t *)dest + 4, (len / 2) - 4, -1, dp->d_name, 0, 0);
5483 #else
5484 if(len > sizeof(dest))
5485 {
5486 cs_log_dbg(D_DVBAPI, "event_handler() dest buffer is to small for pmt data!");
5487 continue;
5488 }
5489
5490 if(len < 16)
5491 {
5492 cs_log_dbg(D_DVBAPI, "event_handler() received pmt is too small! (%d < 16 bytes!)", len);
5493 continue;
5494 }
5495
5496 cs_log_dump_dbg(D_DVBAPI, mbuf, len, "PMT file:"); // Original PMT file
5497
5498 // Do some tidying on the PMT file to make it compatible with the CA PMT parser
5499 dest[0] = CA_PMT_LIST_ONLY;
5500 memcpy(dest + 1, mbuf + 3, 2); // program_number
5501 uint16_t pmt_program_info_length = b2i(2, mbuf + 10) & 0x0FFF;
5502 i2b_buf(2, pmt_program_info_length + 1, (uint8_t *)dest + 4);
5503 dest[6] = CA_PMT_CMD_OK_DESCRAMBLING;
5504 memcpy(dest + 7, mbuf + 12, len - 12 - 4);
5505
5506 cs_log_dump_dbg(D_DVBAPI, (uint8_t *)dest, 7 + len - 12 - 4, "CA PMT:"); // Actual CA PMT message
5507 demux_id = dvbapi_parse_capmt((uint8_t *)dest, 7 + len - 12 - 4, -1, dp->d_name, 0, 0);
5508 #endif
5509
5510 if(demux_id >= 0)
5511 {
5512 cs_strncpy(demux[demux_id].pmt_file, dp->d_name, sizeof(demux[demux_id].pmt_file));
5513 demux[demux_id].pmt_time = (time_t)pmt_info.st_mtime;
5514 }
5515
5516 if(cfg.dvbapi_pmtmode == 3)
5517 {
5518 disable_pmt_files = 1;
5519 break;
5520 }
5521 }
5522 closedir(dirp);
5523 SAFE_MUTEX_UNLOCK(&event_handler_lock);
5524 }
5525
5526 void *dvbapi_event_thread(void *cli)
5527 {
5528 struct s_client *client = (struct s_client *) cli;
5529 SAFE_SETSPECIFIC(getclient, client);
5530 set_thread_name(__func__);
5531
5532 while(!exit_oscam)
5533 {
5534 cs_sleepms(750);
5535 event_handler(0);
5536 }
5537 return NULL;
5538 }
5539
5540 void dvbapi_process_input(int32_t demux_id, int32_t filter_num, uint8_t *buffer, int32_t len, uint32_t msgid)
5541 {
5542 struct s_ecmpid *curpid = NULL;
5543 int32_t pid = demux[demux_id].demux_fd[filter_num].pidindex;
5544 uint16_t filtertype = demux[demux_id].demux_fd[filter_num].type;
5545 uint16_t sctlen = SCT_LEN(buffer);
5546
5547 if(sctlen < 4)
5548 {
5549 cs_log_dbg(D_DVBAPI, "Received filter data with invalid section length!");
5550 return;
5551 }
5552
5553 if(len < sctlen)
5554 {
5555 cs_log_dbg(D_DVBAPI, "Received filter data with total length 0x%03X but section length is 0x%03X -> invalid length!", len, sctlen);
5556 return;
5557 }
5558
5559 if(demux_id < 0 || demux_id >= MAX_DEMUX)
5560 {
5561 cs_log("dvbapi_process_input(): error - received invalid demux_id (%d)", demux_id);
5562 return;
5563 }
5564
5565 if(filter_num < 0 || filter_num >= MAX_FILTER)
5566 {
5567 cs_log("dvbapi_process_input(): error - received invalid filter_num (%d)", filter_num);
5568 return;
5569 }
5570
5571 if(pid != -1 && filtertype == TYPE_ECM)
5572 {
5573 curpid = &demux[demux_id].ECMpids[pid];
5574 }
5575
5576 int32_t filt_match = filtermatch(buffer, filter_num, demux_id, sctlen); // acts on all filters (sdt/emm/ecm)
5577 if(!filt_match)
5578 {
5579 cs_log_dbg(D_DVBAPI,"Demuxer %d receiver returned data not matching the filter -> delivered filter data discarded!", demux_id);
5580 return;
5581 }
5582
5583 if(curpid && curpid->tries <= 0xF0 && filtertype == TYPE_ECM)
5584 {
5585 curpid->irdeto_maxindex = 0;
5586 curpid->irdeto_curindex = 0xFE;
5587 curpid->tries = 0xFE; // reset timeout retry flag
5588 curpid->irdeto_cycle = 0xFE; // reset irdetocycle
5589 curpid->table = 0;
5590 curpid->checked = 4; // flag ecmpid as checked
5591 curpid->status = -1; // flag ecmpid as unusable
5592
5593 if(pid == demux[demux_id].pidindex)
5594 {
5595 // current pid delivered problems so this pid isn't
5596 // being used to descramble any longer -> clear pidindex
5597 demux[demux_id].pidindex = -1;
5598
5599 // remove this pid from channel cache since we had no founds on any ecmpid!
5600 dvbapi_edit_channel_cache(demux_id, pid, 0);
5601 }
5602
5603 dvbapi_stop_filternum(demux_id, filter_num, msgid); // stop this ecm filter!
5604 return;
5605 }
5606
5607 if(filtertype == TYPE_ECM)
5608 {
5609 uint32_t chid = 0x10000;
5610 int8_t pvu_skip = 0;
5611 ECM_REQUEST *er;
5612
5613 if(len != 0) // len = 0 receiver encountered an internal bufferoverflow!
5614 {
5615 cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d filter %d fetched ECM data (length = 0x%03X):",
5616 demux_id, filter_num + 1, sctlen);
5617
5618 if(sctlen > MAX_ECM_SIZE) // ecm too long to handle!
5619 {
5620 cs_log_dbg(D_DVBAPI, "Received data with total length 0x%03X but max supported ECM length is 0x%03X -> Please report!",
5621 sctlen, MAX_ECM_SIZE);
5622
5623 if(curpid)
5624 {
5625 curpid->tries -= 0x0E;
5626 }
5627 return;
5628 }
5629
5630 if(!(buffer[0] == 0x80 || buffer[0] == 0x81))
5631 {
5632 cs_log_dbg(D_DVBAPI, "Received an ECM with invalid ecmtable ID %02X -> ignoring!", buffer[0]);
5633 if(curpid)
5634 {
5635 curpid->tries--;
5636 }
5637 return;
5638 }
5639
5640 #ifdef WITH_EMU
5641 if(caid_is_powervu(curpid->CAID)) // ecm counter for powervu
5642 {
5643 pvu_skip = 1;
5644
5645 if(sctlen - 11 > buffer[9])
5646 {
5647 if(buffer[11 + buffer[9]] > curpid->pvu_counter
5648 || (curpid->pvu_counter == 255 && buffer[11 + buffer[9]] == 0)
5649 || ((curpid->pvu_counter - buffer[11 + buffer[9]]) > 5))
5650 {
5651 curpid->pvu_counter = buffer[11 + buffer[9]];
5652 pvu_skip = 0;
5653 }
5654 }
5655 }
5656 #endif
5657 // wait for odd / even ecm change (only not for irdeto!)
5658 if((curpid->table == buffer[0] && !caid_is_irdeto(curpid->CAID)) || pvu_skip)
5659 {
5660 if(!(er = get_ecmtask()))
5661 {
5662 return;
5663 }
5664 er->srvid = demux[demux_id].program_number;
5665
5666 #ifdef WITH_STAPI5
5667 cs_strncpy(er->dev_name, dev_list[demux[demux_id].dev_index].name, sizeof(dev_list[demux[demux_id].dev_index].name));
5668 #endif
5669 er->tsid = demux[demux_id].tsid;
5670 er->onid = demux[demux_id].onid;
5671 er->pmtpid = demux[demux_id].pmtpid;
5672 er->ens = demux[demux_id].ens;
5673 er->caid = curpid->CAID;
5674 er->pid = curpid->ECM_PID;
5675 er->prid = curpid->PROVID;
5676 er->vpid = curpid->VPID;
5677 er->ecmlen = sctlen;
5678 memcpy(er->ecm, buffer, er->ecmlen);
5679 chid = get_subid(er); // fetch chid or fake chid
5680 er->chid = chid;
5681 er->msgid = msgid;
5682 dvbapi_set_section_filter(demux_id, er, filter_num);
5683 NULLFREE(er);
5684 return;
5685 }
5686
5687 if(caid_is_irdeto(curpid->CAID))
5688 {
5689 // 80 70 39 53 04 05 00 88
5690 // 81 70 41 41 01 06 00 13 00 06 80 38 1F 52 93 D2
5691 //if(buffer[5]>20) return;
5692 if(curpid->irdeto_maxindex != buffer[5]) // 6, register max irdeto index
5693 {
5694 cs_log_dbg(D_DVBAPI, "Found %d IRDETO ECM CHIDs", buffer[5] + 1);
5695 curpid->irdeto_maxindex = buffer[5]; // numchids = 7 (0..6)
5696 }
5697 }
5698 }
5699
5700 if(!(er = get_ecmtask()))
5701 {
5702 return;
5703 }
5704 er->srvid = demux[demux_id].program_number;
5705
5706 #ifdef WITH_STAPI5
5707 cs_strncpy(er->dev_name, dev_list[demux[demux_id].dev_index].name, sizeof(dev_list[demux[demux_id].dev_index].name));
5708 #endif
5709
5710 er->tsid = demux[demux_id].tsid;
5711 er->onid = demux[demux_id].onid;
5712 er->pmtpid = demux[demux_id].pmtpid;
5713 er->ens = demux[demux_id].ens;
5714 er->caid = curpid->CAID;
5715 er->pid = curpid->ECM_PID;
5716 er->prid = curpid->PROVID;
5717 er->vpid = curpid->VPID;
5718 er->ecmlen = sctlen;
5719 memcpy(er->ecm, buffer, er->ecmlen);
5720 er->msgid = msgid;
5721 chid = get_subid(er); // fetch chid or fake chid
5722 uint32_t fixedprovid = chk_provid(er->ecm, er->caid);
5723
5724 if(fixedprovid && fixedprovid != er->prid)
5725 {
5726 cs_log_dbg(D_DVBAPI, "Fixing provid ecmpid %d from %06X -> %06X", pid, curpid->PROVID, fixedprovid);
5727 curpid->PROVID = fixedprovid;
5728
5729 if(!USE_OPENXCAS)
5730 {
5731 cs_log_dbg(D_DVBAPI, "Fixing provid filter %d from %06X -> %06X",
5732 filter_num + 1, demux[demux_id].demux_fd[filter_num].provid, fixedprovid);
5733
5734 demux[demux_id].demux_fd[filter_num].provid = fixedprovid;
5735 }
5736 cs_log_dbg(D_DVBAPI, "Fixing provid ecmrequest from %06X -> %06X", er->prid, fixedprovid);
5737 er->prid = fixedprovid;
5738 }
5739 er->chid = chid;
5740
5741 // only used on receiver internal buffer overflow
5742 // to get quickly fresh ecm filterdata otherwise freezing!
5743 if(len == 0)
5744 {
5745 curpid->table = 0;
5746 dvbapi_set_section_filter(demux_id, er, filter_num);
5747 NULLFREE(er);
5748 return;
5749 }
5750
5751 if(caid_is_irdeto(curpid->CAID))
5752 {
5753 if(curpid->irdeto_curindex != buffer[4]) // old style wrong irdeto index
5754 {
5755 if(curpid->irdeto_curindex == 0xFE) // check if this ecmfilter just started up
5756 {
5757 // on startup set the current index to the irdeto index of the ecm
5758 curpid->irdeto_curindex = buffer[4];
5759 }
5760 else // we are already running and not interested in this ecm
5761 {
5762 if(curpid->table != buffer[0]) // fix for receivers not supporting section filtering
5763 {
5764 curpid->table = 0;
5765 }
5766
5767 // set ecm filter to odd + even since
5768 // this ecm doesn't match with current irdeto index
5769 dvbapi_set_section_filter(demux_id, er, filter_num);
5770
5771 NULLFREE(er);
5772 return;
5773 }
5774 }
5775 else // fix for receivers not supporting section filtering
5776 {
5777 if(curpid->table == buffer[0])
5778 {
5779 NULLFREE(er);
5780 return;
5781 }
5782 }
5783 cs_log_dbg(D_DVBAPI, "Demuxer %d ECMTYPE %02X CAID %04X PROVID %06X ECMPID %04X IRDETO INDEX %02X MAX INDEX %02X CHID %04X CYCLE %02X VPID %04X",
5784 demux_id, er->ecm[0], er->caid, er->prid, er->pid, er->ecm[4], er->ecm[5], er->chid, curpid->irdeto_cycle, er->vpid);
5785 }
5786 else
5787 {
5788 cs_log_dbg(D_DVBAPI, "Demuxer %d ECMTYPE %02X CAID %04X PROVID %06X ECMPID %04X FAKECHID %04X (unique part in ecm)",
5789 demux_id, er->ecm[0], er->caid, er->prid, er->pid, er->chid);
5790 }
5791
5792 // check for matching chid (unique ecm part in case of non-irdeto cas)
5793 // plus added fix for seca2 monthly changing fakechid
5794 if((curpid->CHID < 0x10000) && !((chid == curpid->CHID) || ((curpid->CAID >> 8 == 0x01) && (chid & 0xF0FF) == (curpid->CHID & 0xF0FF))))
5795 {
5796 if(caid_is_irdeto(curpid->CAID))
5797 {
5798 // if same: we cycled all indexes but no luck!
5799 if((curpid->irdeto_cycle < 0xFE) && (curpid->irdeto_cycle == curpid->irdeto_curindex))
5800 {
5801 struct s_dvbapi_priority *forceentry = dvbapi_check_prio_match(demux_id, pid, 'p');
5802
5803 // forced pid? keep trying the forced ecmpid, no force kill ecm filter
5804 if(!forceentry || !forceentry->force)
5805 {
5806 if(curpid->checked == 2)
5807 {
5808 curpid->checked = 4;
5809 }
5810
5811 if(curpid->checked == 1)
5812 {
5813 curpid->checked = 2;
5814 curpid->CHID = 0x10000;
5815 }
5816
5817 dvbapi_stop_filternum(demux_id, filter_num, msgid); // stop this ecm filter!
5818 NULLFREE(er);
5819 return;
5820 }
5821 }
5822 curpid->irdeto_curindex++; // set check on next index
5823
5824 if(curpid->irdeto_cycle == 0xFE)
5825 {
5826 curpid->irdeto_cycle = buffer[4]; // on startup set to current irdeto index
5827 }
5828
5829 if(curpid->irdeto_curindex > curpid->irdeto_maxindex)
5830 {
5831 curpid->irdeto_curindex = 0; // check if we reached max irdeto index, if so reset to 0
5832 }
5833 curpid->table = 0;
5834
5835 // set ecm filter to odd + even since
5836 // this ecm doesn't match with current irdeto index
5837 dvbapi_set_section_filter(demux_id, er, filter_num);
5838
5839 NULLFREE(er);
5840 return;
5841 }
5842 else // all non irdeto cas systems
5843 {
5844 struct s_dvbapi_priority *forceentry = dvbapi_check_prio_match(demux_id, pid, 'p');
5845 curpid->table = 0;
5846
5847 // set ecm filter to odd + even since
5848 // this ecm doesn't match with current irdeto index
5849 dvbapi_set_section_filter(demux_id, er, filter_num);
5850
5851 if(forceentry && forceentry->force)
5852 {
5853 NULLFREE(er);
5854 return; // forced pid? keep trying the forced ecmpid!
5855 }
5856
5857 if(curpid->checked == 2)
5858 {
5859 curpid->checked = 4;
5860 }
5861
5862 if(curpid->checked == 1)
5863 {
5864 curpid->checked = 2;
5865 curpid->CHID = 0x10000;
5866 }
5867
5868 dvbapi_stop_filternum(demux_id, filter_num, msgid); // stop this ecm filter!
5869 NULLFREE(er);
5870 return;
5871 }
5872 }
5873
5874 struct s_dvbapi_priority *p;
5875 for(p = dvbapi_priority; p != NULL; p = p->next)
5876 {
5877 if(p->type != 'l'
5878 || (p->caid && p->caid != curpid->CAID)
5879 || (p->provid && p->provid != curpid->PROVID)
5880 || (p->ecmpid && p->ecmpid != curpid->ECM_PID)
5881 || (p->srvid && p->srvid != demux[demux_id].program_number))
5882 {
5883 continue;
5884 }
5885
5886 if((uint)p->delay == sctlen && p->force < 6)
5887 {
5888 p->force++;
5889 NULLFREE(er);
5890 return;
5891 }
5892
5893 if(p->force >= 6)
5894 {
5895 p->force = 0;
5896 }
5897 }
5898
5899 if(!curpid->PROVID)
5900 {
5901 curpid->PROVID = chk_provid(buffer, curpid->CAID);
5902 }
5903
5904 if(caid_is_irdeto(curpid->CAID)) // irdeto: wait for the correct index
5905 {
5906 if(buffer[4] != curpid->irdeto_curindex)
5907 {
5908 curpid->table = 0;
5909
5910 // set ecm filter to odd + even since
5911 // this ecm doesn't match with current irdeto index
5912 dvbapi_set_section_filter(demux_id, er, filter_num);
5913
5914 NULLFREE(er);
5915 return;
5916 }
5917 }
5918
5919 // we have an ecm with the correct irdeto index (or fakechid)
5920 for(p = dvbapi_priority; p != NULL ; p = p->next) // check for ignore!
5921 {
5922 if((p->type != 'i')
5923 || (p->caid && p->caid != curpid->CAID)
5924 || (p->provid && p->provid != curpid->PROVID)
5925 || (p->ecmpid && p->ecmpid != curpid->ECM_PID)
5926 || (p->pidx && p->pidx - 1 != pid)
5927 || (p->srvid && p->srvid != demux[demux_id].program_number))
5928 {
5929 continue;
5930 }
5931
5932 // found an ignore chid match with current ecm -> ignoring this irdeto index
5933 if(p->type == 'i' && (p->chid < 0x10000 && p->chid == chid))
5934 {
5935 curpid->irdeto_curindex++;
5936 if(curpid->irdeto_cycle == 0xFE)
5937 {
5938 curpid->irdeto_cycle = buffer[4]; // on startup set to current irdeto index
5939 }
5940
5941 if(curpid->irdeto_curindex > curpid->irdeto_maxindex) // check if curindex is over the max
5942 {
5943 curpid->irdeto_curindex = 0;
5944 }
5945 curpid->table = 0;
5946
5947 // irdeto: wait for the correct index + check if we cycled all
5948 if(caid_is_irdeto(curpid->CAID) && (curpid->irdeto_cycle != curpid->irdeto_curindex))
5949 {
5950 // set ecm filter to odd + even since this chid has to be ignored!
5951 dvbapi_set_section_filter(demux_id, er, filter_num);
5952 }
5953 else // this fakechid has to be ignored, kill this filter!
5954 {
5955 if(curpid->checked == 2)
5956 {
5957 curpid->checked = 4;
5958 }
5959
5960 if(curpid->checked == 1)
5961 {
5962 curpid->checked = 2;
5963 curpid->CHID = 0x10000;
5964 }
5965
5966 dvbapi_stop_filternum(demux_id, filter_num, msgid); // stop this ecm filter!
5967 }
5968 NULLFREE(er);
5969 return;
5970 }
5971 }
5972
5973 if(er)
5974 {
5975 curpid->table = er->ecm[0];
5976 }
5977
5978 request_cw(dvbapi_client, er, demux_id, 1); // register this ecm for delayed ecm response check
5979 return; // end of ecm filterhandling!
5980 }
5981
5982 if(filtertype == TYPE_EMM)
5983 {
5984 if(len != 0) // len = 0 receiver encountered an internal buffer overflow!
5985 {
5986 cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d filter %d fetched EMM data (length = 0x%03X):",
5987 demux_id, filter_num + 1, sctlen);
5988
5989 if(sctlen > MAX_EMM_SIZE) // emm too long to handle!
5990 {
5991 cs_log_dbg(D_DVBAPI, "Received data with total length 0x%03X but max supported EMM length is 0x%03X -> Please report!",
5992 sctlen, MAX_EMM_SIZE);
5993
5994 return;
5995 }
5996 }
5997 else
5998 {
5999 return; // just skip on internal buffer overflow
6000 }
6001
6002 #ifdef WITH_EMU
6003 if(caid_is_director(demux[demux_id].demux_fd[filter_num].caid))
6004 {
6005 uint32_t i;
6006 uint32_t emmhash;
6007
6008 if(sctlen < 4)
6009 {
6010 return;
6011 }
6012
6013 for(i = 0; i + 2 < sctlen; i++)
6014 {
6015 if(buffer[i] == 0xF0 && (buffer[i + 2] == 0xE1 || buffer[i + 2] == 0xE4))
6016 {
6017 emmhash = (buffer[3] << 8) | buffer[sctlen - 2];
6018 if(demux[demux_id].demux_fd[filter_num].cadata == emmhash)
6019 {
6020 return;
6021 }
6022
6023 demux[demux_id].demux_fd[filter_num].cadata = emmhash;
6024 dvbapi_process_emm(demux_id, filter_num, buffer, sctlen);
6025 return;
6026 }
6027 }
6028 return;
6029 }
6030 #endif
6031 // fix to handle more than one irdeto emm packet
6032 uint8_t *pbuf = buffer;
6033 int32_t done = 0;
6034 int32_t unhandled = len;
6035
6036 while(len > done)
6037 {
6038 pbuf += done;
6039 sctlen = SCT_LEN(pbuf);
6040
6041 if(unhandled < 4 || (int32_t)sctlen > unhandled || sctlen > MAX_EMM_SIZE || sctlen < 4)
6042 {
6043 break;
6044 }
6045
6046 dvbapi_process_emm(demux_id, filter_num, pbuf, sctlen);
6047 done += sctlen;
6048 unhandled -= sctlen;
6049 }
6050 }
6051
6052 if(filtertype == TYPE_SDT)
6053 {
6054 cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d filter %d fetched SDT data (length = 0x%03X):",
6055 demux_id, filter_num + 1, sctlen);
6056
6057 dvbapi_parse_sdt(demux_id, buffer, sctlen, msgid);
6058 }
6059
6060 if(filtertype == TYPE_PAT)
6061 {
6062 cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d filter %d fetched PAT data (length = 0x%03X):",
6063 demux_id, filter_num + 1, sctlen);
6064
6065 dvbapi_parse_pat(demux_id, buffer, sctlen, msgid);
6066 }
6067
6068 if(filtertype == TYPE_PMT)
6069 {
6070 cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d filter %d fetched PMT data (length = 0x%03X):",
6071 demux_id, filter_num + 1, sctlen);
6072
6073 dvbapi_parse_pmt(demux_id, buffer, sctlen, msgid);
6074 }
6075
6076 if(filtertype == TYPE_CAT)
6077 {
6078 cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d filter %d fetched CAT data (length = 0x%03X):",
6079 demux_id, filter_num + 1, sctlen);
6080
6081 dvbapi_parse_cat(demux_id, buffer, sctlen, msgid);
6082 }
6083 }
6084
6085 static int32_t dvbapi_recv(int32_t connfd, uint8_t *mbuf, size_t rlen)
6086 {
6087 ssize_t len = cs_recv(connfd, mbuf, rlen, MSG_DONTWAIT);
6088
6089 if((len == -1 && (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)) || (len == 0))
6090 {
6091 return -1;
6092 }
6093
6094 if(len == -1)
6095 {
6096 return 0;
6097 }
6098
6099 return len;
6100 }
6101
6102 static uint16_t dvbapi_get_nbof_missing_header_bytes(uint8_t *mbuf, uint16_t mbuf_len, uint32_t msgid_size)
6103 {
6104 uint16_t commandsize = 4;
6105 commandsize += msgid_size;
6106 if(mbuf_len < commandsize)
6107 {
6108 return commandsize - mbuf_len;
6109 }
6110 else
6111 {
6112 mbuf += msgid_size;
6113 uint32_t opcode = b2i(4, mbuf);
6114
6115 if((opcode & 0xFFFFF000) == DVBAPI_AOT_CA)
6116 {
6117 if(mbuf[3] & 0x80)
6118 {
6119 uint32_t size = mbuf[3] & 0x7F;
6120 if(mbuf_len < (commandsize + size))
6121 {
6122 return (commandsize + size) - mbuf_len;
6123 }
6124 }
6125 return 0;
6126 }
6127 else
6128 {
6129 switch (opcode)
6130 {
6131 case DVBAPI_FILTER_DATA:
6132 commandsize = 9;
6133 commandsize += msgid_size;
6134 if(mbuf_len < commandsize)
6135 {
6136 return commandsize - mbuf_len;
6137 }
6138 return 0;
6139
6140 case DVBAPI_CLIENT_INFO:
6141 commandsize = 7;
6142 commandsize += msgid_size;
6143 if(mbuf_len < commandsize)
6144 {
6145 return commandsize - mbuf_len;
6146 }
6147 return 0;
6148
6149 default:
6150 return 0;
6151 }
6152 }
6153 }
6154 }
6155
6156 static void set_chunksize_data_len_to_invalid(uint16_t *chunksize, uint16_t *data_len)
6157 {
6158 (*chunksize) = 1;
6159 (*data_len) = 1;
6160 }
6161
6162 static void log_packeterror(uint16_t mbuf_len, const char* command)
6163 {
6164 cs_log("dvbapi_get_packet_size(): error - buffer length (%" PRIu16 ") too short for %s", mbuf_len, command);
6165 }
6166
6167 static bool is_commandsize_valid(uint32_t commandsize, uint16_t mbuf_len, const char* command)
6168 {
6169 bool isValid = mbuf_len >= commandsize;
6170 if(!isValid)
6171 {
6172 log_packeterror(mbuf_len, command);
6173 }
6174 return isValid;
6175 }
6176
6177 static uint8_t get_asn1packetsize(uint8_t *mbuf, uint16_t mbuf_len, const char *command, uint32_t *tmp_data_len)
6178 {
6179 uint8_t sizebytes = 0;
6180 uint8_t commandsize = 4;
6181 *tmp_data_len = mbuf[3] & 0x7F;
6182 if(mbuf[3] & 0x80)
6183 {
6184 sizebytes = *tmp_data_len;
6185 if(is_commandsize_valid(3 + sizebytes, mbuf_len, command))
6186 {
6187 *tmp_data_len = b2i(sizebytes, mbuf + 4);
6188 }
6189 else
6190 {
6191 return 0;
6192 }
6193 }
6194 return commandsize + sizebytes;
6195 }
6196
6197 static void dvbapi_get_packet_size(uint8_t *mbuf, uint16_t mbuf_len, uint16_t *chunksize, uint16_t *data_len)
6198 {
6199 //chunksize: size of complete chunk in the buffer (an opcode with the data)
6200 //data_len: variable for internal data length (eg. for the filter data size, PMT len)
6201 (*chunksize) = 0;
6202 (*data_len) = 0;
6203
6204 if(mbuf_len < 4)
6205 {
6206 cs_log("dvbapi_get_packet_size(): error - buffer length (%" PRIu16 ") too short", mbuf_len);
6207 set_chunksize_data_len_to_invalid(chunksize, data_len);
6208 return;
6209 }
6210
6211 int32_t commandsize = 0;
6212 char* command = "DVBAPI_UNKNOWN_COMMAND";
6213 uint32_t tmp_data_len = 0;
6214 uint32_t opcode = b2i(4, mbuf);
6215
6216
6217 switch (opcode)
6218 {
6219 case DVBAPI_AOT_CA_STOP:
6220 {
6221 command = "DVBAPI_AOT_CA_STOP";
6222 commandsize = get_asn1packetsize(mbuf, mbuf_len, command, &tmp_data_len);
6223 break;
6224 }
6225 case DVBAPI_FILTER_DATA:
6226 {
6227 command = "DVBAPI_FILTER_DATA";
6228 commandsize = 9;
6229 if(is_commandsize_valid(commandsize, mbuf_len, command))
6230 {
6231 tmp_data_len = b2i(2, mbuf + 7) & 0x0FFF;
6232 }
6233 break;
6234 }
6235
6236 case DVBAPI_CLIENT_INFO:
6237 {
6238 command = "DVBAPI_CLIENT_INFO";
6239 commandsize = 7;
6240 if(is_commandsize_valid(commandsize, mbuf_len, command))
6241 {
6242 tmp_data_len = mbuf[6];
6243 }
6244 break;
6245 }
6246
6247 default:
6248 {
6249 if((opcode & 0xFFFFFF00) == DVBAPI_AOT_CA_PMT)
6250 {
6251 command = "DVBAPI_AOT_CA_PMT";
6252 commandsize = get_asn1packetsize(mbuf, mbuf_len, command, &tmp_data_len);
6253 break;
6254 }
6255 else
6256 {
6257 cs_log("Unknown socket command received: 0x%08X", opcode);
6258 }
6259 break;
6260 }
6261 }
6262
6263 if(tmp_data_len == 0 || commandsize == 0)
6264 {
6265 set_chunksize_data_len_to_invalid(chunksize, data_len);
6266 return;
6267 }
6268
6269 if(tmp_data_len + commandsize > 0xFFFF)
6270 {
6271 cs_log("This packet is too big: %d bytes => truncated!", tmp_data_len);
6272 tmp_data_len = 0xFFFF - commandsize;
6273 }
6274
6275 (*data_len) = tmp_data_len;
6276 (*chunksize) += commandsize + tmp_data_len;
6277
6278 if(*chunksize > mbuf_len)
6279 {
6280 cs_log_dbg(D_DVBAPI, "This %s packet is incomplete => command length is (%" PRIu16 ")", command, *chunksize);
6281 }
6282 else
6283 {
6284 cs_log_dbg(D_DVBAPI, "This is a %s packet with size %d => lets process it!", command, (*chunksize));
6285 }
6286 }
6287
6288 static void dvbapi_handlesockmsg(uint8_t *mbuf, uint16_t chunksize, uint16_t data_len, uint8_t *add_to_poll, int32_t connfd, uint16_t *client_proto_version)
6289 {
6290 uint32_t msgid = 0;
6291 if(*client_proto_version >= 3)
6292 {
6293 if(mbuf[0] != 0xa5)
6294 {
6295 cs_log("Error: network packet malformed! (no start)");
6296 return;
6297 }
6298 msgid = b2i(4, mbuf + 1);
6299 mbuf += 5;
6300 }
6301
6302 uint32_t opcode = b2i(4, mbuf);
6303
6304 switch(opcode)
6305 {
6306 case DVBAPI_FILTER_DATA:
6307 {
6308 int32_t demux_id = mbuf[4];
6309 int32_t filter_num = mbuf[5];
6310
6311 if(demux_id < 0 || demux_id >= MAX_DEMUX)
6312 {
6313 cs_log("dvbapi_handlesockmsg(): error - received invalid demux_id (%d)", demux_id);
6314 break;
6315 }
6316
6317 if(filter_num < 0 || filter_num >= MAX_FILTER)
6318 {
6319 cs_log("dvbapi_handlesockmsg(): error - received invalid filter_num (%d)", filter_num);
6320 break;
6321 }
6322 dvbapi_process_input(demux_id, filter_num, mbuf + 6, data_len + 3, msgid);
6323 break;
6324 }
6325
6326 case DVBAPI_CLIENT_INFO:
6327 {
6328 uint16_t client_proto = b2i(2, mbuf + 4);
6329 NULLFREE(last_client_name);
6330
6331 if(cs_malloc(&last_client_name, data_len + 1))
6332 {
6333 memcpy(last_client_name, &mbuf[7], data_len);
6334 last_client_name[data_len] = 0;
6335 cs_log("Client connected: '%s' (protocol version = %" PRIu16 ")", last_client_name, client_proto);
6336 }
6337 dvbapi_net_send(DVBAPI_SERVER_INFO, connfd, msgid, -1, -1, NULL, NULL, NULL, client_proto);
6338
6339 // now the protocol handshake is complete set correct version so all further packets are sent with correct message id.
6340 (*client_proto_version) = client_proto;
6341
6342 // setting the global var according to the client
6343 last_client_proto_version = client_proto;
6344 break;
6345 }
6346
6347 case DVBAPI_AOT_CA_PMT:
6348 {
6349 cs_log_dbg(D_DVBAPI,"Received DVBAPI_AOT_CA_PMT object on socket %d:", connfd);
6350 dvbapi_parse_capmt(mbuf + (chunksize - data_len), data_len, connfd, NULL, *client_proto_version, msgid);
6351 (*add_to_poll) = 0;
6352 break;
6353 }
6354
6355 case (DVBAPI_AOT_CA_STOP):
6356 {
6357 cs_log_dbg(D_DVBAPI, "Received DVBAPI_AOT_CA_STOP object on socket %d:", connfd);
6358 if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX || cfg.dvbapi_listenport)
6359 {
6360 int32_t i;
6361 int32_t demux_index = mbuf[7];
6362 for(i = 0; i < MAX_DEMUX; i++)
6363 {
6364 // 0xff demux_index is a wildcard => close all related demuxers
6365 if(demux_index == 0xff)
6366 {
6367 if(demux[i].socket_fd == connfd)
6368 {
6369 dvbapi_stop_descrambling(i, msgid);
6370 }
6371 }
6372 else if(demux[i].demux_index == demux_index)
6373 {
6374 dvbapi_stop_descrambling(i, msgid);
6375 break;
6376 }
6377 }
6378
6379 // ipbox fix
6380 if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX)
6381 {
6382 // check do we have any demux running on this fd
6383 int16_t execlose = 1;
6384 for(i = 0; i < MAX_DEMUX; i++)
6385 {
6386 if(demux[i].socket_fd == connfd)
6387 {
6388 execlose = 0;
6389 break;
6390 }
6391 }
6392 if(execlose)
6393 {
6394 int32_t ret = close(connfd);
6395 if(ret < 0)
6396 {
6397 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno));
6398 }
6399 }
6400 }
6401
6402 if(cfg.dvbapi_listenport)
6403 {
6404 (*add_to_poll) = 1;
6405 break;
6406 }
6407 }
6408 else if(cfg.dvbapi_pmtmode != 6)
6409 {
6410 int32_t ret = close(connfd);
6411 if(ret < 0)
6412 {
6413 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno));
6414 }
6415 }
6416 (*add_to_poll) = 0;
6417 break;
6418 }
6419 default:
6420 {
6421 if((opcode & 0xFFFFFF00) == DVBAPI_AOT_CA_PMT)
6422 {
6423 cs_log_dbg(D_DVBAPI, "Received DVBAPI_AOT_CA_PMT object on socket %d:", connfd);
6424 dvbapi_parse_capmt(mbuf + (chunksize - data_len), data_len, connfd, NULL, *client_proto_version, msgid);
6425 }
6426 else
6427 {
6428 cs_log("Unknown socket command received: 0x%08X", opcode);
6429 }
6430 break;
6431 }
6432 }
6433 }
6434
6435 static bool dvbapi_handlesockdata(int32_t connfd, uint8_t *mbuf, uint16_t mbuf_size, uint16_t unhandled_len,
6436 uint8_t *add_to_poll, uint16_t *new_unhandled_len, uint16_t *client_proto_version)
6437 {
6438 int32_t recv_result;
6439 uint16_t chunksize = 1, data_len = 1;
6440 uint8_t packet_count = 1;
6441 uint32_t msgid_size = 0;
6442 uint16_t missing_header_bytes = 0;
6443 if(*client_proto_version >= 3)
6444 {
6445 msgid_size = 5;
6446 }
6447
6448 do
6449 {
6450 missing_header_bytes = dvbapi_get_nbof_missing_header_bytes(mbuf, unhandled_len, msgid_size);
6451
6452 if(missing_header_bytes != 0)
6453 {
6454 // read first few bytes so we know packet type and length
6455 cs_log_dbg(D_TRACE, "%s reading %" PRIu16 " bytes from connection fd %d", (unhandled_len == 0) ? "Try" : "Continue", missing_header_bytes, connfd);
6456
6457 recv_result = dvbapi_recv(connfd, mbuf + unhandled_len, mbuf_size - unhandled_len);
6458 if(recv_result < 1)
6459 {
6460 (*new_unhandled_len) = unhandled_len;
6461 return (recv_result != -1);
6462 }
6463 else
6464 {
6465 unhandled_len += recv_result;
6466 if(unhandled_len < missing_header_bytes)
6467 {
6468 (*new_unhandled_len) = unhandled_len;
6469 return true;
6470 }
6471 }
6472 }
6473
6474 cs_log_dump_dbg(D_DVBAPI, mbuf, unhandled_len, "Got packetdata (msgid size: %d, clientprotocol: %d)", msgid_size, *client_proto_version);
6475 dvbapi_get_packet_size(mbuf+msgid_size, unhandled_len-msgid_size, &chunksize, &data_len);
6476
6477 chunksize+=msgid_size;
6478 if(chunksize > mbuf_size)
6479 {
6480 cs_log("***** WARNING: SOCKET DATA BUFFER OVERFLOW (%" PRIu16 " bytes), PLEASE REPORT! ****** ", chunksize);
6481 (*new_unhandled_len) = 0;
6482 return true;
6483 }
6484
6485 if(unhandled_len < chunksize) // we are missing some bytes, try to read them
6486 {
6487 cs_log_dbg(D_TRACE, "Continue to read the missing %d bytes from connection fd %d", chunksize - unhandled_len, connfd);
6488 recv_result = dvbapi_recv(connfd, mbuf + unhandled_len, mbuf_size - unhandled_len);
6489 if(recv_result < 1)
6490 {
6491 (*new_unhandled_len) = unhandled_len;
6492 return (recv_result != -1);
6493 }
6494 else
6495 {
6496 unhandled_len += recv_result;
6497 if(unhandled_len < chunksize)
6498 {
6499 (*new_unhandled_len) = unhandled_len;
6500 return true;
6501 }
6502 }
6503 }
6504
6505 dvbapi_handlesockmsg(mbuf, chunksize-msgid_size, data_len, add_to_poll, connfd, client_proto_version);
6506
6507 unhandled_len -= chunksize;
6508 if(unhandled_len > 0)
6509 {
6510 memmove(mbuf, mbuf + chunksize, unhandled_len);
6511 }
6512 } while(unhandled_len != 0 && packet_count++ < 8);
6513
6514 cs_log_dbg(D_DVBAPI, "Processing socketdata completed after %d packets with %d bytes left unprocessed", packet_count, unhandled_len);
6515
6516 (*new_unhandled_len) = unhandled_len;
6517 return true;
6518 }
6519
6520 static void *dvbapi_main_local(void *cli)
6521 {
6522 int32_t i, j, l;
6523 struct s_client *client = (struct s_client *)cli;
6524 client->thread = pthread_self();
6525 SAFE_SETSPECIFIC(getclient, cli);
6526 dvbapi_client = cli;
6527 int32_t maxpfdsize = (MAX_DEMUX * maxfilter) + MAX_DEMUX + 2;
6528 struct pollfd pfd2[maxpfdsize];
6529 struct timeb start, end; // start time poll, end time poll
6530 #define PMT_SERVER_SOCKET "/tmp/.listen.camd.socket"
6531 struct sockaddr_un saddr;
6532 saddr.sun_family = AF_UNIX;
6533 cs_strncpy(saddr.sun_path, PMT_SERVER_SOCKET, sizeof(saddr.sun_path));
6534 int32_t rc, pfdcount, g, connfd, clilen;
6535 int32_t ids[maxpfdsize], fdn[maxpfdsize], type[maxpfdsize];
6536 struct SOCKADDR servaddr;
6537 ssize_t len = 0;
6538 static const uint16_t mbuf_size = 2048;
6539 uint8_t *mbuf;
6540 uint16_t unhandled_buf_len[maxpfdsize], unhandled_buf_used[maxpfdsize];
6541 uint8_t *unhandled_buf[maxpfdsize];
6542 struct s_auth *account;
6543 int32_t ok = 0;
6544 uint16_t client_proto_version[maxpfdsize];
6545
6546 if(!cs_malloc(&mbuf, sizeof(uint8_t) * mbuf_size))
6547 {
6548 return NULL;
6549 }
6550
6551 for(i = 0; i < maxpfdsize; i++)
6552 {
6553 unhandled_buf[i] = NULL;
6554 unhandled_buf_len[i] = 0;
6555 unhandled_buf_used[i] = 0;
6556 client_proto_version[i] = 0;
6557 }
6558
6559 for(account = cfg.account; account != NULL; account = account->next)
6560 {
6561 if((ok = is_dvbapi_usr(account->usr)))
6562 {
6563 break;
6564 }
6565 }
6566
6567 cs_auth_client(client, ok ? account : (struct s_auth *)(-1), "dvbapi");
6568 memset(demux, 0, sizeof(demux));
6569
6570 for(i = 0; i < MAX_DEMUX; i++)
6571 {
6572 SAFE_MUTEX_INIT(&demux[i].answerlock, NULL);
6573 for(j = 0; j < MAX_ECM_PIDS; j++)
6574 {
6575 for(l = 0; l < MAX_STREAM_INDICES; l++)
6576 {
6577 demux[i].ECMpids[j].index[l] = INDEX_INVALID;
6578 }
6579 }
6580 demux[i].pidindex = -1;
6581 demux[i].curindex = -1;
6582 }
6583
6584 memset(ca_fd, 0, sizeof(ca_fd));
6585 memset(unassoc_fd, 0, sizeof(unassoc_fd));
6586 dvbapi_read_priority();
6587 dvbapi_load_channel_cache();
6588 dvbapi_detect_api();
6589
6590 if(selected_box == -1 || selected_api == -1)
6591 {
6592 cs_log("ERROR: Could not detect DVBAPI version.");
6593 free(mbuf);
6594 return NULL;
6595 }
6596
6597 // detect box type first and then get descrambler info
6598 dvbapi_get_descrambler_info();
6599
6600 if(cfg.dvbapi_pmtmode == 1)
6601 {
6602 disable_pmt_files = 1;
6603 }
6604
6605 int32_t listenfd = -1;
6606 if(cfg.dvbapi_boxtype != BOXTYPE_IPBOX_PMT &&
6607 cfg.dvbapi_pmtmode != 2 && cfg.dvbapi_pmtmode != 5 && cfg.dvbapi_pmtmode != 6)
6608 {
6609 if(!cfg.dvbapi_listenport)
6610 {
6611 listenfd = dvbapi_init_listenfd();
6612 }
6613 else
6614 {
6615 listenfd = dvbapi_net_init_listenfd();
6616 }
6617
6618 if(listenfd < 1)
6619 {
6620 cs_log("ERROR: Could not init socket: (errno=%d: %s)", errno, strerror(errno));
6621 free(mbuf);
6622 return NULL;
6623 }
6624 }
6625
6626 for(i = 0; i < MAX_DEMUX; i++) // init all demuxers!
6627 {
6628 demux[i].pidindex = -1;
6629 demux[i].curindex = -1;
6630 }
6631
6632 if(cfg.dvbapi_pmtmode != 4 && cfg.dvbapi_pmtmode != 5 && cfg.dvbapi_pmtmode != 6)
6633 {
6634 struct sigaction signal_action;
6635 signal_action.sa_handler = event_handler;
6636 sigemptyset(&signal_action.sa_mask);
6637 signal_action.sa_flags = SA_RESTART;
6638 sigaction(SIGRTMIN + 1, &signal_action, NULL);
6639
6640 dir_fd = open(TMPDIR, O_RDONLY);
6641 if(dir_fd >= 0)
6642 {
6643 fcntl(dir_fd, F_SETSIG, SIGRTMIN + 1);
6644 fcntl(dir_fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_DELETE | DN_MULTISHOT);
6645 event_handler(SIGRTMIN + 1);
6646 }
6647 }
6648 else
6649 {
6650 int32_t ret = start_thread("dvbapi event", dvbapi_event_thread, (void *) dvbapi_client, NULL, 1, 0);
6651 if(ret)
6652 {
6653 free(mbuf);
6654 return NULL;
6655 }
6656 }
6657
6658 if(listenfd != -1)
6659 {
6660 pfd2[0].fd = listenfd;
6661 pfd2[0].events = (POLLIN | POLLPRI);
6662 type[0] = 1;
6663 }
6664
6665 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 || defined WITH_NEUTRINO
6666 system("pzapit -rz");
6667 #endif
6668 cs_ftime(&start); // register start time
6669
6670 while(!exit_oscam)
6671 {
6672 if(pausecam) // for dbox2, STAPI or PC in standby mode don't parse any ecm/emm or try to start next filter
6673 {
6674 continue;
6675 }
6676
6677 if(cfg.dvbapi_pmtmode == 6)
6678 {
6679 if(listenfd < 0)
6680 {
6681 cs_log("PMT mode 6: Connecting to enigma CA PMT listen socket...");
6682
6683 // socket init
6684 if((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
6685 {
6686 cs_log("socket error (errno=%d %s)", errno, strerror(errno));
6687 listenfd = -1;
6688 }
6689 else if(connect(listenfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
6690 {
6691 cs_log("socket connect error (errno=%d %s)", errno, strerror(errno));
6692 close(listenfd);
6693 listenfd = -1;
6694 }
6695 else
6696 {
6697 pfd2[0].fd = listenfd;
6698 pfd2[0].events = (POLLIN | POLLPRI);
6699 type[0] = 1;
6700 cs_log("PMT mode 6: Successfully connected to CA PMT server (fd %d)", listenfd);
6701 }
6702 }
6703
6704 if(listenfd == -1) // not connected!
6705 {
6706 cs_sleepms(1000);
6707 continue; // start fresh connect attempt!
6708 }
6709 }
6710
6711 pfdcount = (listenfd > -1) ? 1 : 0;
6712 for(i = 0; i < MAX_DEMUX; i++)
6713 {
6714 // add client fd's which are not yet associated
6715 // with the demux but needs to be polled for data
6716 if(unassoc_fd[i])
6717 {
6718 pfd2[pfdcount].fd = unassoc_fd[i];
6719 pfd2[pfdcount].events = (POLLIN | POLLPRI);
6720 client_proto_version[pfdcount] = last_client_proto_version;
6721 type[pfdcount++] = 1;
6722 }
6723
6724 if(demux[i].program_number == 0)
6725 {
6726 continue; // only evalutate demuxers that have channels assigned
6727 }
6728
6729 uint32_t ecmcounter = 0, emmcounter = 0;
6730 for(g = 0; g < maxfilter; g++)
6731 {
6732 if(demux[i].demux_fd[g].fd <= 0)
6733 {
6734 continue; // deny obvious invalid fd!
6735 }
6736
6737 if(!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX
6738 && selected_api != STAPI && selected_api != COOLAPI)
6739 {
6740 pfd2[pfdcount].fd = demux[i].demux_fd[g].fd;
6741 pfd2[pfdcount].events = (POLLIN | POLLPRI);
6742 ids[pfdcount] = i;
6743 fdn[pfdcount] = g;
6744 type[pfdcount++] = 0;
6745 }
6746
6747 // count ecm filters to see if demuxing is possible anyway
6748 if(demux[i].demux_fd[g].type == TYPE_ECM)
6749 {
6750 ecmcounter++;
6751 }
6752
6753 // count emm filters also
6754 if(demux[i].demux_fd[g].type == TYPE_EMM)
6755 {
6756 emmcounter++;
6757 }
6758 }
6759
6760 // only produce log if something changed
6761 if(ecmcounter != demux[i].old_ecmfiltercount || emmcounter != demux[i].old_emmfiltercount)
6762 {
6763 cs_log_dbg(D_DVBAPI, "Demuxer %d has %d ecmpids, %d streampids, %d ecmfilters and %d of max %d emmfilters",
6764 i, demux[i].ECMpidcount, demux[i].STREAMpidcount, ecmcounter, emmcounter, demux[i].max_emm_filter);
6765
6766 demux[i].old_ecmfiltercount = ecmcounter; // save new amount of ecm filters
6767 demux[i].old_emmfiltercount = emmcounter; // save new amount of emm filters
6768 }
6769
6770 // delayed emm start for non irdeto caids,
6771 // start emm cat if not already done for this demuxer!
6772 struct timeb now;
6773 cs_ftime(&now);
6774 int64_t gone;
6775 int8_t do_emm_start = (cfg.dvbapi_au > 0 && demux[i].emm_filter == -1 && demux[i].EMMpidcount == 0 && emmcounter == 0);
6776 int8_t do_sdt_start = (cfg.dvbapi_read_sdt && demux[i].sdt_filter == -1 && cfg.dvbapi_boxtype != BOXTYPE_SAMYGO);
6777
6778 if(do_emm_start || do_sdt_start)
6779 {
6780 gone = comp_timeb(&now, &demux[i].emmstart);
6781 if(gone > 20 * 1000)
6782 {
6783 if(do_emm_start)
6784 {
6785 cs_ftime(&demux[i].emmstart); // trick to let emm fetching start after 30 seconds to speed up zapping
6786 dvbapi_start_cat_filter(i);
6787 }
6788 }
6789
6790 if(gone > 5 * 1000)
6791 {
6792 if(do_sdt_start)
6793 {
6794 dvbapi_start_sdt_filter(i);
6795 }
6796 }
6797 }
6798
6799 // early start for irdeto since they need emm before ecm
6800 // (pmt emmstart = 1 if detected caid 0x06)
6801 int32_t emmstarted = demux[i].emm_filter;
6802
6803 // check every time since share readers might
6804 // give us new filters due to hexserial change
6805 if(cfg.dvbapi_au && demux[i].EMMpidcount > 0)
6806 {
6807 if(!emmcounter && emmstarted == -1)
6808 {
6809 demux[i].emmstart = now;
6810 dvbapi_start_emm_filter(i); // start emm filtering if emm pids are found
6811 }
6812 else
6813 {
6814 gone = comp_timeb(&now, &demux[i].emmstart);
6815 if(gone > 30 * 1000)
6816 {
6817 demux[i].emmstart = now;
6818 dvbapi_start_emm_filter(i); // start emm filtering delayed if filters already were running
6819 rotate_emmfilter(i); // rotate active emm filters
6820 }
6821 }
6822 }
6823
6824 // Restart decoding all caids we have ecmpids but no ecm filters!
6825 if(ecmcounter == 0 && demux[i].ECMpidcount > 0)
6826 {
6827 int32_t started = 0;
6828
6829 // avoid race: not all pids are asked and checked out yet!
6830 for(g = 0; g < demux[i].ECMpidcount; g++)
6831 {
6832 // check if prio run is done
6833 if(demux[i].ECMpids[g].checked == 0 && demux[i].ECMpids[g].status >= 0)
6834 {
6835 dvbapi_try_next_caid(i, 0, 0); // not done, so start next prio pid
6836 started = 1;
6837 break;
6838 }
6839 }
6840
6841 if(started)
6842 {
6843 continue; // if started a filter proceed with next demuxer
6844 }
6845
6846 // all usable pids (with prio) are tried, lets start over again without prio!
6847 if(g == demux[i].ECMpidcount)
6848 {
6849 // avoid race: not all pids are asked and checked out yet!
6850 for(g = 0; g < demux[i].ECMpidcount; g++)
6851 {
6852 // check if noprio run is done
6853 if(demux[i].ECMpids[g].checked == 2 && demux[i].ECMpids[g].status >= 0)
6854 {
6855 demux[i].ECMpids[g].irdeto_curindex = 0xFE;
6856 demux[i].ECMpids[g].irdeto_maxindex = 0;
6857 demux[i].ECMpids[g].irdeto_cycle = 0xFE;
6858 demux[i].ECMpids[g].tries = 0xFE;
6859 demux[i].ECMpids[g].table = 0;
6860 demux[i].ECMpids[g].CHID = 0x10000; // remove chid prio
6861
6862 dvbapi_try_next_caid(i, 2, 0); // not done, so start next no prio pid
6863 started = 1;
6864 break;
6865 }
6866 }
6867 }
6868
6869 if(started)
6870 {
6871 continue; // if started a filter proceed with next demuxer
6872 }
6873
6874 if(g == demux[i].ECMpidcount) // all usable pids are tried, lets start over again!
6875 {
6876 if(demux[i].decodingtries == -1) // first redecoding attempt?
6877 {
6878 cs_ftime(&demux[i].decstart);
6879
6880 // re-init some used things from second run (without prio)
6881 for(g = 0; g < demux[i].ECMpidcount; g++)
6882 {
6883 demux[i].ECMpids[g].checked = 0;
6884 demux[i].ECMpids[g].irdeto_curindex = 0xFE;
6885 demux[i].ECMpids[g].irdeto_maxindex = 0;
6886 demux[i].ECMpids[g].irdeto_cycle = 0xFE;
6887 demux[i].ECMpids[g].table = 0;
6888 demux[i].decodingtries = 0;
6889
6890 // remove this pid from channel cache since we had no founds on any ecmpid!
6891 dvbapi_edit_channel_cache(i, g, 0);
6892 }
6893 }
6894
6895 uint8_t number_of_enabled_pids = 0;
6896 demux[i].decodingtries++;
6897 dvbapi_resort_ecmpids(i);
6898
6899 for(g = 0; g < demux[i].ECMpidcount; g++) // count number of enabled pids!
6900 {
6901 if(demux[i].ECMpids[g].status >= 0) number_of_enabled_pids++;
6902 }
6903
6904 if(!number_of_enabled_pids)
6905 {
6906 if(demux[i].decodingtries == 10)
6907 {
6908 demux[i].decodingtries = 0;
6909 cs_log("Demuxer %d no enabled matching ecmpids -> decoding is waiting for matching readers!",i);
6910 }
6911 }
6912 else
6913 {
6914 cs_ftime(&demux[i].decend);
6915 demux[i].decodingtries = -1; // reset to first run again!
6916 gone = comp_timeb(&demux[i].decend, &demux[i].decstart);
6917
6918 cs_log("Demuxer %d restarting decoding requests after %"PRId64" ms with %d enabled and %d disabled ecmpids!",
6919 i, gone, number_of_enabled_pids, (demux[i].ECMpidcount-number_of_enabled_pids));
6920
6921 dvbapi_try_next_caid(i, 0, 0);
6922 }
6923 }
6924 }
6925
6926 if(demux[i].socket_fd > 0 && cfg.dvbapi_pmtmode != 6)
6927 {
6928 rc = 0;
6929 for(j = 0; j < pfdcount; j++)
6930 {
6931 if(pfd2[j].fd == demux[i].socket_fd)
6932 {
6933 rc = 1;
6934 break;
6935 }
6936 }
6937
6938 if(rc == 1)
6939 {
6940 continue;
6941 }
6942
6943 pfd2[pfdcount].fd = demux[i].socket_fd;
6944 pfd2[pfdcount].events = (POLLIN | POLLPRI);
6945 ids[pfdcount] = i;
6946 type[pfdcount++] = 1;
6947 }
6948 }
6949
6950 rc = 0;
6951 while(!(listenfd == -1 && cfg.dvbapi_pmtmode == 6))
6952 {
6953 rc = poll(pfd2, pfdcount, 500);
6954 if(rc < 0) // error occured while polling for fd's with fresh data
6955 {
6956 if(errno == EINTR || errno == EAGAIN) // try again in case of interrupt
6957 {
6958 continue;
6959 }
6960 cs_log("ERROR: error on poll of %d fd's (errno=%d %s)", pfdcount, errno, strerror(errno));
6961 break;
6962 }
6963 else
6964 {
6965 break;
6966 }
6967 }
6968
6969 if(rc > 0)
6970 {
6971 cs_ftime(&end); // register end time
6972 int64_t timeout = comp_timeb(&end, &start);
6973 if(timeout < 0)
6974 {
6975 cs_log("*** WARNING: BAD TIME AFFECTING WHOLE OSCAM ECM HANDLING ****");
6976 }
6977 cs_log_dbg(D_TRACE, "New events occurred on %d of %d handlers after %"PRId64" ms inactivity", rc, pfdcount, timeout);
6978 cs_ftime(&start); // register new start time for next poll
6979 }
6980
6981 for(i = 0; i < pfdcount && rc > 0; i++)
6982 {
6983 if(pfd2[i].revents == 0) { continue; } // skip sockets with no changes
6984 rc--; //event handled!
6985 cs_log_dbg(D_TRACE, "Now handling fd %d that reported event %d", pfd2[i].fd, pfd2[i].revents);
6986
6987 if(pfd2[i].revents & (POLLHUP | POLLNVAL | POLLERR))
6988 {
6989 if(type[i] == 1)
6990 {
6991 for(j = 0; j < MAX_DEMUX; j++)
6992 {
6993 // if listenfd closes stop all assigned decoding!
6994 if(demux[j].socket_fd == pfd2[i].fd)
6995 {
6996 dvbapi_stop_descrambling(j, 0);
6997 }
6998
6999 // remove from unassoc_fd when necessary
7000 if(unassoc_fd[j] == pfd2[i].fd)
7001 {
7002 unassoc_fd[j] = 0;
7003 }
7004 }
7005
7006 int32_t ret = close(pfd2[i].fd);
7007 if(ret < 0 && errno != 9)
7008 {
7009 cs_log("ERROR: Could not close demuxer socket fd (errno=%d %s)", errno, strerror(errno));
7010 }
7011
7012 if(pfd2[i].fd == listenfd && cfg.dvbapi_pmtmode == 6)
7013 {
7014 listenfd = -1;
7015 }
7016 cs_log_dbg(D_DVBAPI, "Socket %d reported hard connection close", pfd2[i].fd);
7017 }
7018 else // type = 0
7019 {
7020 int32_t demux_id = ids[i];
7021 int32_t n = fdn[i];
7022
7023 if(cfg.dvbapi_boxtype != BOXTYPE_SAMYGO)
7024 {
7025 // stop filter since its giving errors and wont return anything good
7026 dvbapi_stop_filternum(demux_id, n, 0);
7027 }
7028 else
7029 {
7030 int32_t ret, pid;
7031 uint8_t filter[32];
7032 struct dmx_sct_filter_params sFP;
7033 cs_log_dbg(D_DVBAPI, "re-opening connection to demux socket");
7034 close(demux[demux_id].demux_fd[n].fd);
7035 demux[demux_id].demux_fd[n].fd = -1;
7036
7037 ret = dvbapi_open_device(0, demux[demux_id].demux_index, demux[demux_id].adapter_index);
7038 if(ret != -1)
7039 {
7040 demux[demux_id].demux_fd[n].fd = ret;
7041 pid = demux[demux_id].curindex;
7042 memset(filter, 0, 32);
7043 memset(&sFP, 0, sizeof(sFP));
7044 filter[0] = 0x80;
7045 filter[16] = 0xF0;
7046 sFP.pid = demux[demux_id].ECMpids[pid].ECM_PID;
7047 sFP.timeout = 3000;
7048 sFP.flags = DMX_IMMEDIATE_START;
7049 memcpy(sFP.filter.filter, filter, 16);
7050 memcpy(sFP.filter.mask, filter + 16, 16);
7051 ret = dvbapi_ioctl(demux[demux_id].demux_fd[n].fd, DMX_SET_FILTER, &sFP);
7052 }
7053
7054 if(ret == -1)
7055 {
7056 // stop filter since it's giving errors and wont return anything good
7057 dvbapi_stop_filternum(demux_id, n, 0);
7058 }
7059 }
7060 }
7061 continue; // continue with other events
7062 }
7063
7064 if(pfd2[i].revents & (POLLIN | POLLPRI))
7065 {
7066 if(type[i] == 1)
7067 {
7068 connfd = -1; // initially no socket to read from
7069 uint8_t add_to_poll = 0; // we may need to additionally poll this socket when no PMT data comes in
7070
7071 if(pfd2[i].fd == listenfd)
7072 {
7073 if(cfg.dvbapi_pmtmode == 6)
7074 {
7075 connfd = listenfd;
7076 disable_pmt_files = 1;
7077 }
7078 else
7079 {
7080 clilen = sizeof(servaddr);
7081 connfd = accept(listenfd, (struct sockaddr *)&servaddr, (socklen_t *)&clilen);
7082 cs_log_dbg(D_DVBAPI, "new socket connection fd: %d", connfd);
7083
7084 if(cfg.dvbapi_listenport)
7085 {
7086 // update webif data
7087 client->ip = SIN_GET_ADDR(servaddr);
7088 client->port = ntohs(SIN_GET_PORT(servaddr));
7089 }
7090 add_to_poll = 1;
7091
7092 if(cfg.dvbapi_pmtmode == 3 || cfg.dvbapi_pmtmode == 0)
7093 {
7094 disable_pmt_files = 1;
7095 }
7096
7097 if(connfd <= 0)
7098 {
7099 cs_log_dbg(D_DVBAPI, "accept() returns error on fd event %d (errno=%d %s)",
7100 pfd2[i].revents, errno, strerror(errno));
7101 }
7102 }
7103 }
7104 else
7105 {
7106 connfd = pfd2[i].fd;
7107 }
7108
7109 //reading and completing data from socket
7110 if(connfd > 0)
7111 {
7112 if(unhandled_buf_used[i])
7113 {
7114 memcpy(mbuf, unhandled_buf[i], unhandled_buf_used[i]);
7115 }
7116
7117 if(!dvbapi_handlesockdata(connfd, mbuf, mbuf_size, unhandled_buf_used[i], &add_to_poll, &unhandled_buf_used[i], &client_proto_version[i]))
7118 {
7119 unhandled_buf_used[i] = 0;
7120 client_proto_version[i] = 0; // reset protocol, next client could old protocol.
7121 last_client_proto_version = 0;
7122 // client disconnects, stop all assigned decoding
7123 cs_log_dbg(D_DVBAPI, "Socket %d reported connection close", connfd);
7124 int active_conn = 0; // other active connections counter
7125 add_to_poll = 0;
7126
7127 for(j = 0; j < MAX_DEMUX; j++)
7128 {
7129 if(demux[j].socket_fd == connfd)
7130 {
7131 dvbapi_stop_descrambling(j, 0);
7132 }
7133 else if(demux[j].socket_fd)
7134 {
7135 active_conn++;
7136 }
7137
7138 // remove from unassoc_fd when necessary
7139 if(unassoc_fd[j] == connfd)
7140 {
7141 unassoc_fd[j] = 0;
7142 }
7143 }
7144 close(connfd);
7145 connfd = -1;
7146
7147 // last connection closed
7148 if(!active_conn && (cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX))
7149 {
7150 if(cfg.dvbapi_listenport)
7151 {
7152 // update webif data
7153 client->ip = get_null_ip();
7154 client->port = 0;
7155 }
7156 }
7157 continue;
7158 }
7159
7160 if(unhandled_buf_used[i])
7161 {
7162 if(unhandled_buf_used[i] > unhandled_buf_len[i])
7163 {
7164 NULLFREE(unhandled_buf[i]);
7165 unhandled_buf_len[i] = unhandled_buf_used[i] < 128 ? 128 : unhandled_buf_used[i];
7166 if(!cs_malloc(&unhandled_buf[i], sizeof(uint8_t) * unhandled_buf_len[i]))
7167 {
7168 unhandled_buf_len[i] = 0;
7169 unhandled_buf_used[i] = 0;
7170 continue;
7171 }
7172 }
7173 memcpy(unhandled_buf[i], mbuf, unhandled_buf_used[i]);
7174 }
7175
7176 // if the connection is new and we read no PMT data, then add it to the poll,
7177 // otherwise this socket will not be checked with poll when data arives
7178 // because fd it is not yet assigned with the demux
7179 if(add_to_poll)
7180 {
7181 for(j = 0; j < MAX_DEMUX; j++)
7182 {
7183 if(!unassoc_fd[j])
7184 {
7185 unassoc_fd[j] = connfd;
7186 break;
7187 }
7188 }
7189 }
7190 }
7191 }
7192 else // type == 0
7193 {
7194 int32_t demux_id = ids[i];
7195 int32_t n = fdn[i];
7196
7197 if((int)demux[demux_id].demux_fd[n].fd != pfd2[i].fd)
7198 {
7199 continue; // filter already killed, no need to process this data!
7200 }
7201
7202 len = dvbapi_read_device(pfd2[i].fd, mbuf, mbuf_size);
7203 if(len < 0) // serious filterdata read error
7204 {
7205 // stop filter since it's giving errors and won't return anything good
7206 dvbapi_stop_filternum(demux_id, n, 0);
7207
7208 maxfilter--; // lower maxfilters to avoid this with new filter setups!
7209 continue;
7210 }
7211
7212 if(!len) // receiver internal filter buffer overflow
7213 {
7214 memset(mbuf, 0, mbuf_size);
7215 }
7216 dvbapi_process_input(demux_id, n, mbuf, len, 0);
7217 }
7218 continue; // continue with other events!
7219 }
7220 }
7221 }
7222
7223 for(j = 0; j < maxpfdsize; j++)
7224 {
7225 NULLFREE(unhandled_buf[j]);
7226 }
7227 free(mbuf);
7228
7229 return NULL;
7230 }
7231
7232 void dvbapi_write_cw(int32_t demux_id, int32_t pid, int32_t stream_id, uint8_t *cw, uint8_t cw_length, uint8_t *iv,
7233 uint8_t iv_length, enum ca_descr_algo algo, enum ca_descr_cipher_mode cipher_mode, uint32_t msgid)
7234 {
7235 int8_t n, cw_empty = 0;
7236 uint8_t null_cw[cw_length];
7237 ca_descr_t ca_descr;
7238 ca_descr_mode_t ca_descr_mode;
7239 ca_descr_data_t ca_descr_data;
7240
7241 memset(null_cw, 0, cw_length);
7242 memset(&ca_descr, 0, sizeof(ca_descr));
7243 memset(&ca_descr_mode, 0, sizeof(ca_descr_mode));
7244 memset(&ca_descr_data, 0, sizeof(ca_descr_data));
7245
7246 if(memcmp(demux[demux_id].last_cw[stream_id][0], null_cw, cw_length) == 0
7247 && memcmp(demux[demux_id].last_cw[stream_id][1], null_cw, cw_length) == 0)
7248 {
7249 cw_empty = 1; // to make sure that both cws get written on constantcw
7250 }
7251
7252 for(n = 0; n < 2; n++)
7253 {
7254 // Check if cw has changed and if new cw is empty (all zeros)
7255 // Skip check for BISS1 - cw could be indeed zero
7256 // Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
7257 if((memcmp(cw + (n * cw_length), demux[demux_id].last_cw[stream_id][n], cw_length) != 0 || cw_empty)
7258 && (memcmp(cw + (n * cw_length), null_cw, cw_length) != 0 || caid_is_biss(demux[demux_id].ECMpids[pid].CAID)))
7259 {
7260 // prepare ca device
7261 uint32_t idx = dvbapi_ca_set_pid(demux_id, pid, stream_id, (algo == CA_ALGO_DES), msgid);
7262 if(idx == INDEX_INVALID)
7263 {
7264 return; // return on no index!
7265 }
7266
7267 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
7268 ca_descr.index = idx;
7269 ca_descr.parity = n;
7270
7271 // just to make the compiler happy (-Wunused-parameter)
7272 // (better move the coolapi code to a separate function)
7273 ca_descr_mode.cipher_mode = cipher_mode;
7274 ca_descr_data.data = iv;
7275 ca_descr_data.length = iv_length;
7276
7277 memcpy(demux[demux_id].last_cw[stream_id][n], cw + (n * 8), 8);
7278 memcpy(ca_descr.cw, cw + (n * 8), 8);
7279
7280 cs_log_dbg(D_DVBAPI, "Demuxer %d write cw%d index: %d (ca_mask %d)",
7281 demux_id, n, ca_descr.index, demux[demux_id].ca_mask);
7282
7283 coolapi_write_cw(demux[demux_id].ca_mask, demux[demux_id].STREAMpids, demux[demux_id].STREAMpidcount, &ca_descr);
7284 #else
7285 int32_t i, j, write_cw = 0;
7286 uint32_t usedidx, lastidx;
7287
7288 char lastcw[2 * cw_length + 1];
7289 char newcw[2 * cw_length + 1];
7290 cs_hexdump(0, demux[demux_id].last_cw[stream_id][n], cw_length, lastcw, sizeof(lastcw));
7291 cs_hexdump(0, cw + (n * cw_length), cw_length, newcw, sizeof(newcw));
7292
7293 for(i = 0; i < CA_MAX; i++)
7294 {
7295 if(!(demux[demux_id].ca_mask & (1 << i)))
7296 {
7297 continue; // ca not in use by this demuxer!
7298 }
7299 lastidx = INDEX_INVALID;
7300
7301 for(j = 0; j < demux[demux_id].STREAMpidcount; j++)
7302 {
7303 write_cw = 0;
7304 if(!demux[demux_id].ECMpids[pid].streams || ((demux[demux_id].ECMpids[pid].streams & (1 << j)) == (uint) (1 << j)))
7305 {
7306 usedidx = is_ca_used(i, demux[demux_id].STREAMpids[j]);
7307 if(usedidx != INDEX_INVALID)
7308 {
7309 if(idx != usedidx)
7310 {
7311 cs_log_dbg(D_DVBAPI,"Demuxer %d ca%d is using index %d for streampid %04X -> skip!",
7312 demux_id, i, usedidx, demux[demux_id].STREAMpids[j]);
7313 continue; // if not used for descrambling -> skip!
7314 }
7315 else
7316 {
7317 if(usedidx == lastidx)
7318 {
7319 cs_log_dbg(D_DVBAPI,"Demuxer %d ca%d is using index %d for streampid %04X -> skip, %s part of cw already written!",
7320 demux_id, i, usedidx, demux[demux_id].STREAMpids[j], (n == 1 ? "even" : "odd"));
7321 continue;
7322 }
7323
7324 cs_log_dbg(D_DVBAPI,"Demuxer %d ca%d is using index %d for streampid %04X -> write %s part of cw!",
7325 demux_id, i, usedidx, demux[demux_id].STREAMpids[j], (n == 1 ? "even" : "odd"));
7326
7327 write_cw = 1;
7328 }
7329 }
7330 }
7331
7332 if(!write_cw)
7333 {
7334 continue; // no need to write the cw since this ca isnt using it!
7335 }
7336
7337 lastidx = usedidx;
7338 ca_descr.index = usedidx;
7339 ca_descr.parity = n;
7340
7341 memcpy(demux[demux_id].last_cw[stream_id][n], cw + (n * cw_length), cw_length);
7342 memcpy(ca_descr.cw, cw + (n * 8), 8); // ca_descr is only used for 8 byte CWs
7343
7344 cs_log_dbg(D_DVBAPI, "Demuxer %d writing %s part (%s) of controlword, replacing expired (%s)",
7345 demux_id, (n == 1 ? "even" : "odd"), newcw, lastcw);
7346
7347 cs_log_dbg(D_DVBAPI, "Demuxer %d write cw%d index: %d (ca%d)", demux_id, n, ca_descr.index, i);
7348
7349 if(cfg.dvbapi_extended_cw_api == 1) // Set descrambler algorithm and mode
7350 {
7351 ca_descr_mode.index = usedidx;
7352 ca_descr_mode.algo = algo;
7353 ca_descr_mode.cipher_mode = cipher_mode;
7354
7355 if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
7356 {
7357 dvbapi_net_send(DVBAPI_CA_SET_DESCR_MODE, demux[demux_id].socket_fd, msgid, demux_id, -1 /*unused*/,
7358 (uint8_t *) &ca_descr_mode, NULL, NULL, demux[demux_id].client_proto_version);
7359 }
7360 else
7361 {
7362 if(ca_fd[i] <= 0)
7363 {
7364 ca_fd[i] = dvbapi_open_device(1, i, demux[demux_id].adapter_index);
7365 if(ca_fd[i] <= 0) { continue; }
7366 }
7367
7368 if(dvbapi_ioctl(ca_fd[i], CA_SET_DESCR_MODE, &ca_descr_mode) < 0)
7369 {
7370 cs_log("ERROR: ioctl(CA_SET_DESCR_MODE): %s", strerror(errno));
7371 }
7372 }
7373 }
7374
7375 // Send 16 byte CW and IV for AES128, DVB-CISSA
7376 if(cfg.dvbapi_extended_cw_api == 1 && algo == CA_ALGO_AES128)
7377 {
7378 // First send IV
7379 ca_descr_data.index = usedidx;
7380 ca_descr_data.data_type = CA_DATA_IV;
7381 ca_descr_data.data = iv;
7382 ca_descr_data.length = iv_length;
7383
7384 if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
7385 {
7386 dvbapi_net_send(DVBAPI_CA_SET_DESCR_DATA, demux[demux_id].socket_fd, msgid, demux_id, -1 /*unused*/,
7387 (uint8_t *) &ca_descr_data, NULL, NULL, demux[demux_id].client_proto_version);
7388 }
7389 else
7390 {
7391 if(dvbapi_ioctl(ca_fd[i], CA_SET_DESCR_DATA, &ca_descr_data) < 0)
7392 {
7393 cs_log("ERROR: ioctl(CA_SET_DESCR_DATA): %s", strerror(errno));
7394 }
7395 }
7396
7397 // Then send CW
7398 ca_descr_data.index = usedidx;
7399 ca_descr_data.data_type = CA_DATA_KEY;
7400 ca_descr_data.data = cw + (n * cw_length);
7401 ca_descr_data.length = cw_length;
7402 ca_descr_data.parity = n;
7403
7404 if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
7405 {
7406 dvbapi_net_send(DVBAPI_CA_SET_DESCR_DATA, demux[demux_id].socket_fd, msgid, demux_id, -1 /*unused*/,
7407 (uint8_t *) &ca_descr_data, NULL, NULL, demux[demux_id].client_proto_version);
7408 }
7409 else
7410 {
7411 if(dvbapi_ioctl(ca_fd[i], CA_SET_DESCR_DATA, &ca_descr_data) < 0)
7412 {
7413 cs_log("ERROR: ioctl(CA_SET_DESCR_DATA): %s", strerror(errno));
7414 }
7415 }
7416 }
7417 else // Send 8 byte CW for DVB-CSA or DES
7418 {
7419 if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
7420 {
7421 dvbapi_net_send(DVBAPI_CA_SET_DESCR, demux[demux_id].socket_fd, msgid, demux_id, -1 /*unused*/,
7422 (uint8_t *) &ca_descr, NULL, NULL, demux[demux_id].client_proto_version);
7423 }
7424 else
7425 {
7426 if(ca_fd[i] <= 0)
7427 {
7428 ca_fd[i] = dvbapi_open_device(1, i, demux[demux_id].adapter_index);
7429 if(ca_fd[i] <= 0)
7430 {
7431 continue;
7432 }
7433 }
7434
7435 if(dvbapi_ioctl(ca_fd[i], CA_SET_DESCR, &ca_descr) < 0)
7436 {
7437 cs_log("ERROR: ioctl(CA_SET_DESCR): %s", strerror(errno));
7438 }
7439 }
7440 }
7441 }
7442 }
7443 #endif
7444 }
7445 }
7446 cs_log_dbg(D_DVBAPI, "Using %d of %d total descramblers", ca_descramblers_used, ca_descramblers_total);
7447 }
7448
7449 void delayer(ECM_REQUEST *er, uint32_t delay)
7450 {
7451 if(delay <= 0) { return; }
7452
7453 struct timeb tpe;
7454 cs_ftime(&tpe);
7455 int64_t gone = comp_timeb(&tpe, &er->tps);
7456
7457 if(gone < delay)
7458 {
7459 cs_log_dbg(D_DVBAPI, "delayer: gone=%"PRId64" ms, cfg=%d ms -> delay=%"PRId64" ms", gone, delay, delay - gone);
7460 cs_sleepms(delay - gone);
7461 }
7462 }
7463
7464 void dvbapi_send_dcw(struct s_client *client, ECM_REQUEST *er)
7465 {
7466 int32_t i, j, k, handled = 0;
7467 for(i = 0; i < MAX_DEMUX; i++)
7468 {
7469 uint32_t nocw_write = 0; // 0 = write cw, 1 = dont write cw to hardware demuxer
7470
7471 // ignore empty demuxers, skip ecm response for other
7472 // srvid and ecm recponse for different adapter
7473 if(demux[i].program_number == 0
7474 || demux[i].program_number != er->srvid
7475 || demux[i].adapter_index != er->adapter_index)
7476 {
7477 continue;
7478 }
7479
7480 #ifdef WITH_STAPI5
7481 if(strcmp(dev_list[demux[i].dev_index].name, er->dev_name) != 0)
7482 {
7483 continue; // skip request if PTI device doesn't match request
7484 }
7485 #endif
7486
7487 demux[i].rdr = er->selected_reader;
7488
7489 for(j = 0; j < demux[i].ECMpidcount; j++) // check for matching ecmpid
7490 {
7491 if((demux[i].ECMpids[j].CAID == er->caid || demux[i].ECMpids[j].CAID == er->ocaid)
7492 && demux[i].ECMpids[j].ECM_PID == er->pid && demux[i].ECMpids[j].PROVID == er->prid
7493 && demux[i].ECMpids[j].VPID == er->vpid)
7494 {
7495 break;
7496 }
7497 }
7498
7499 if(j == demux[i].ECMpidcount)
7500 {
7501 continue; // ecm response srvid ok but no matching ecmpid, perhaps this for other demuxer
7502 }
7503
7504 cs_log_dbg(D_DVBAPI, "Demuxer %d %scontrol word received for PID %d CAID %04X PROVID %06X ECMPID %04X CHID %04X VPID %04X",
7505 i, (er->rc >= E_NOTFOUND ? "no " : ""), j, er->caid, er->prid, er->pid, er->chid, er->vpid);
7506
7507 uint32_t status = dvbapi_check_ecm_delayed_delivery(i, er);
7508 uint32_t comparecw0 = 0, comparecw1 = 0;
7509 char ecmd5[17 * 3];
7510 cs_hexdump(0, er->ecmd5, 16, ecmd5, sizeof(ecmd5));
7511
7512 if(status == 1 && er->rc) // wrong ecmhash
7513 {
7514 cs_log_dbg(D_DVBAPI, "Demuxer %d not interested in response ecmhash %s (requested different one)", i, ecmd5);
7515 continue;
7516 }
7517
7518 if(status == 2) // no filter
7519 {
7520 cs_log_dbg(D_DVBAPI, "Demuxer %d not interested in response ecmhash %s (filter already killed)", i, ecmd5);
7521 continue;
7522 }
7523
7524 if(status == 5) // empty cw
7525 {
7526 cs_log_dbg(D_DVBAPI, "Demuxer %d not interested in response ecmhash %s (delivered cw is empty!)", i, ecmd5);
7527 nocw_write = 1;
7528
7529 if(er->rc < E_NOTFOUND)
7530 {
7531 er->rc = E_NOTFOUND;
7532 }
7533 }
7534
7535 // 0=matching ecm hash, 2=no filter, 3=table reset, 4=cache-ex response
7536 // Check only against last_cw[0] (index 0) - No need to check the rest
7537 // Skip check for BISS1 - cw could be indeed zero
7538 // Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
7539 if((status == 0 || status == 3 || status == 4) && er->rc < E_NOTFOUND && !caid_is_biss(er->caid))
7540 {
7541 // check for matching control word
7542 if(memcmp(er->cw, demux[i].last_cw[0][0], 8) == 0 &&
7543 memcmp(er->cw + 8, demux[i].last_cw[0][1], 8) == 0)
7544 {
7545 comparecw0 = 1;
7546 }
7547 else if(memcmp(er->cw, demux[i].last_cw[0][1], 8) == 0 &&
7548 memcmp(er->cw + 8, demux[i].last_cw[0][0], 8) == 0)
7549 {
7550 comparecw1 = 1;
7551 }
7552
7553 if(comparecw0 == 1 || comparecw1 == 1)
7554 {
7555 cs_log_dbg(D_DVBAPI, "Demuxer %d duplicate controlword ecm response hash %s (duplicate controlword!)", i, ecmd5);
7556 nocw_write = 1;
7557 }
7558 }
7559
7560 if(status == 3) // table reset
7561 {
7562 cs_log_dbg(D_DVBAPI, "Demuxer %d luckyshot new controlword ecm response hash %s (ecm table reset)", i, ecmd5);
7563 }
7564
7565 if(status == 4) // no check on cache-ex responses!
7566 {
7567 cs_log_dbg(D_DVBAPI, "Demuxer %d new controlword from cache-ex reader (no ecmhash check possible)", i);
7568 }
7569
7570 handled = 1; // mark this ecm response as handled
7571 if(er->rc < E_NOTFOUND && cfg.dvbapi_requestmode == 0 && (demux[i].pidindex == -1) && er->caid != 0)
7572 {
7573 demux[i].ECMpids[j].tries = 0xFE; // reset timeout retry flag
7574 demux[i].ECMpids[j].irdeto_cycle = 0xFE; // reset irdetocycle
7575 demux[i].pidindex = j; // set current index as *the* pid to descramble
7576 demux[i].ECMpids[j].checked = 4;
7577
7578 cs_log_dbg(D_DVBAPI, "Demuxer %d descrambling PID %d CAID %04X PROVID %06X ECMPID %04X CHID %02X VPID %04X",
7579 i, demux[i].pidindex, er->caid, er->prid, er->pid, er->chid, er->vpid);
7580 }
7581
7582 if(er->rc < E_NOTFOUND && cfg.dvbapi_requestmode == 1 && er->caid != 0) // FOUND
7583 {
7584 SAFE_MUTEX_LOCK(&demux[i].answerlock); // only process one ecm answer
7585 if(demux[i].ECMpids[j].checked != 4)
7586 {
7587 int32_t t, o, ecmcounter = 0;
7588 int32_t oldpidindex = demux[i].pidindex;
7589 demux[i].pidindex = j; // set current ecmpid as the new pid to descramble
7590
7591 if(oldpidindex != -1)
7592 {
7593 for(k = 0; k < MAX_STREAM_INDICES; k++)
7594 {
7595 demux[i].ECMpids[j].index[k] = demux[i].ECMpids[oldpidindex].index[k]; // swap index with lower status pid that was descrambling
7596 demux[i].ECMpids[j].useMultipleIndices = demux[i].ECMpids[oldpidindex].useMultipleIndices;
7597 }
7598 }
7599
7600 // check this pid with control word FOUND for higher status
7601 for(t = 0; t < demux[i].ECMpidcount; t++)
7602 {
7603 if(t != j && demux[i].ECMpids[j].status >= demux[i].ECMpids[t].status)
7604 {
7605 // check if ecm filter is in use and
7606 // stop all ecm filters of lower status pids
7607 for(o = 0; o < maxfilter; o++)
7608 {
7609 if(demux[i].demux_fd[o].fd > 0 && demux[i].demux_fd[o].type == TYPE_ECM
7610 && demux[i].demux_fd[o].pidindex == t)
7611 {
7612 // ecm filter belongs to lower status pid -> kill!
7613 dvbapi_stop_filternum(i, o, er->msgid);
7614 }
7615 }
7616 dvbapi_edit_channel_cache(i, t, 0); // remove lower status pid from channel cache
7617 demux[i].ECMpids[t].checked = 4; // mark index t as low status
7618 }
7619 }
7620
7621 for(o = 0; o < maxfilter; o++)
7622 {
7623 if(demux[i].demux_fd[o].type == TYPE_ECM)
7624 {
7625 ecmcounter++; // count all ecm filters
7626 }
7627 }
7628
7629 demux[i].ECMpids[j].tries = 0xFE; // reset timeout retry flag
7630 demux[i].ECMpids[j].irdeto_cycle = 0xFE; // reset irdeto cycle
7631
7632 if(ecmcounter == 1) // if total found running ecmfilters is 1 -> we found the "best" pid
7633 {
7634 dvbapi_edit_channel_cache(i, j, 1);
7635 demux[i].ECMpids[j].checked = 4; // mark best pid last ;)
7636 }
7637 cs_log_dbg(D_DVBAPI, "Demuxer %d descrambling PID %d CAID %04X PROVID %06X ECMPID %04X CHID %02X VPID %04X",
7638 i, demux[i].pidindex, er->caid, er->prid, er->pid, er->chid, er->vpid);
7639 }
7640 SAFE_MUTEX_UNLOCK(&demux[i].answerlock); // and release it!
7641 }
7642
7643 if(er->rc >= E_NOTFOUND) // not found on requestmode 0 + 1
7644 {
7645 if(er->rc == E_SLEEPING)
7646 {
7647 dvbapi_stop_descrambling(i, er->msgid);
7648 return;
7649 }
7650
7651 struct s_dvbapi_priority *forceentry = dvbapi_check_prio_match(i, j, 'p');
7652 if(forceentry && forceentry->force) // forced pid? keep trying the forced ecmpid!
7653 {
7654 // all cas or irdeto cas with forced prio chid
7655 if(!caid_is_irdeto(er->caid) || forceentry->chid < 0x10000)
7656 {
7657 demux[i].ECMpids[j].table = 0;
7658 dvbapi_set_section_filter(i, er, -1);
7659 continue;
7660 }
7661 else // irdeto cas without chid prio forced
7662 {
7663 // init irdeto current index to first one
7664 if(demux[i].ECMpids[j].irdeto_curindex == 0xFE)
7665 {
7666 demux[i].ECMpids[j].irdeto_curindex = 0x00;
7667 }
7668
7669 // check for last / max chid
7670 if(!(demux[i].ECMpids[j].irdeto_curindex + 1 > demux[i].ECMpids[j].irdeto_maxindex))
7671 {
7672 cs_log_dbg(D_DVBAPI, "Demuxer %d trying next irdeto chid of FORCED PID %d CAID %04X PROVID %06X ECMPID %04X",
7673 i, j, er->caid, er->prid, er->pid);
7674
7675 demux[i].ECMpids[j].irdeto_curindex++; // irdeto index one up
7676 demux[i].ECMpids[j].table = 0;
7677 dvbapi_set_section_filter(i, er, -1);
7678 continue;
7679 }
7680 }
7681 }
7682
7683 // in case of timeout or fatal LB event give
7684 // this pid another try but no more than 1 try
7685 if((er->rc == E_TIMEOUT || (er->rcEx && er->rcEx <= E2_CCCAM_NOCARD))
7686 && demux[i].ECMpids[j].tries == 0xFE)
7687 {
7688 demux[i].ECMpids[j].tries -= 0x07;
7689 demux[i].ECMpids[j].table = 0;
7690 dvbapi_set_section_filter(i, er, -1);
7691 continue;
7692 }
7693 else // all not found responses exception: first timeout response and first fatal loadbalancer response
7694 {
7695 demux[i].ECMpids[j].CHID = 0x10000; // get rid of this prio chid since it failed!
7696 demux[i].ECMpids[j].tries = 0xFE; // reset timeout retry
7697 }
7698
7699 if(caid_is_irdeto(er->caid))
7700 {
7701 // init irdeto current index to first one
7702 if(demux[i].ECMpids[j].irdeto_curindex == 0xFE)
7703 {
7704 demux[i].ECMpids[j].irdeto_curindex = 0x00;
7705 }
7706
7707 // check for last / max chid
7708 if(!(demux[i].ECMpids[j].irdeto_curindex + 1 > demux[i].ECMpids[j].irdeto_maxindex))
7709 {
7710 cs_log_dbg(D_DVBAPI, "Demuxer %d trying next irdeto chid of PID %d CAID %04X PROVID %06X ECMPID %04X VPID %04X",
7711 i, j, er->caid, er->prid, er->pid, er->vpid);
7712
7713 demux[i].ECMpids[j].irdeto_curindex++; // irdeto index one up
7714 demux[i].ECMpids[j].table = 0;
7715 dvbapi_set_section_filter(i, er, -1);
7716 continue;
7717 }
7718 }
7719
7720 dvbapi_edit_channel_cache(i, j, 0); // remove this pid from channelcache
7721
7722 if(demux[i].pidindex == j)
7723 {
7724 // current pid delivered a notfound so this pid isn't
7725 // being used to descramble any longer -> clear pidindex
7726 demux[i].pidindex = -1;
7727 }
7728
7729 demux[i].ECMpids[j].irdeto_maxindex = 0;
7730 demux[i].ECMpids[j].irdeto_curindex = 0xFE;
7731 demux[i].ECMpids[j].tries = 0xFE; // reset timeout retry flag
7732 demux[i].ECMpids[j].irdeto_cycle = 0xFE; // reset irdetocycle
7733 demux[i].ECMpids[j].table = 0;
7734 demux[i].ECMpids[j].checked = 4; // flag ecmpid as checked
7735 demux[i].ECMpids[j].status = -1; // flag ecmpid as unusable
7736
7737 int32_t found = 1; // setup for first run
7738 int32_t filternum = -1;
7739
7740 while(found > 0) // disable all ecm + emm filters for this notfound
7741 {
7742 found = 0;
7743
7744 filternum = dvbapi_get_filternum(i, er, TYPE_ECM); // get ecm filternumber
7745 if(filternum > -1) // in case valid filter found
7746 {
7747 int32_t fd = demux[i].demux_fd[filternum].fd;
7748 if(fd > 0) // in case valid fd
7749 {
7750 dvbapi_stop_filternum(i, filternum, er->msgid); // stop ecmfilter
7751 found = 1;
7752 }
7753 }
7754
7755 if(caid_is_irdeto(er->caid)) // in case irdeto cas stop old emm filters
7756 {
7757 filternum = dvbapi_get_filternum(i, er, TYPE_EMM); // get emm filternumber
7758 if(filternum > -1) // in case valid filter found
7759 {
7760 int32_t fd = demux[i].demux_fd[filternum].fd;
7761 if(fd > 0) // in case valid fd
7762 {
7763 dvbapi_stop_filternum(i, filternum, er->msgid); // stop emmfilter
7764 found = 1;
7765 }
7766 }
7767 }
7768 }
7769 continue;
7770 }
7771
7772 // below this should be only run in case of ecm answer is found
7773 uint32_t chid = get_subid(er); // derive current chid in case of irdeto, or a unique part of ecm on other cas systems
7774 demux[i].ECMpids[j].CHID = (chid != 0 ? chid : 0x10000); // if not zero apply, otherwise use no chid value 0x10000
7775 dvbapi_edit_channel_cache(i, j, 1); // do it here to here after the right CHID is registered
7776
7777 //dvbapi_set_section_filter(i, er); is not needed anymore (unsure)
7778 demux[i].ECMpids[j].tries = 0xFE; // reset timeout retry flag
7779 demux[i].ECMpids[j].irdeto_cycle = 0xFE; // reset irdeto cycle
7780
7781 // cw was already written by another filter or current pid
7782 // isn't pid used to descramble so it ends here!
7783 if(nocw_write || demux[i].pidindex != j)
7784 {
7785 continue;
7786 }
7787
7788 struct s_dvbapi_priority *delayentry = dvbapi_check_prio_match(i, demux[i].pidindex, 'd');
7789 uint32_t delay = 0;
7790
7791 if(delayentry)
7792 {
7793 if(delayentry->delay < 1000)
7794 {
7795 delay = delayentry->delay;
7796 cs_log_dbg(D_DVBAPI, "specific delay: write cw %d ms after ecmrequest", delay);
7797 }
7798 }
7799 else if(cfg.dvbapi_delayer > 0)
7800 {
7801 delay = cfg.dvbapi_delayer;
7802 cs_log_dbg(D_DVBAPI, "generic delay: write cw %d ms after ecmrequest", delay);
7803 }
7804
7805 delayer(er, delay);
7806
7807 #ifdef WITH_EMU
7808 if(!chk_ctab_ex(er->caid, &cfg.emu_stream_relay_ctab) || !cfg.emu_stream_relay_enabled)
7809 #endif
7810 switch(selected_api)
7811 {
7812 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
7813 case STAPI:
7814 stapi_write_cw(i, er->cw, demux[i].STREAMpids, demux[i].STREAMpidcount, demux[i].pmt_file);
7815 break;
7816 #endif
7817 default:
7818 {
7819 #ifdef WITH_EXTENDED_CW
7820 if(er->cw_ex.mode != demux[i].ECMpids[j].useMultipleIndices)
7821 {
7822 uint32_t idx;
7823
7824 for(k = 0; k < demux[i].STREAMpidcount; k++)
7825 {
7826 if(demux[i].ECMpids[j].useMultipleIndices)
7827 {
7828 idx = demux[i].ECMpids[j].index[k];
7829 }
7830 else
7831 {
7832 idx = demux[i].ECMpids[j].index[0];
7833 }
7834 dvbapi_set_pid(i, k, idx, false, false, er->msgid); // disable streampid
7835 }
7836
7837 for(k = 0; k < MAX_STREAM_INDICES; k++)
7838 {
7839 demux[i].ECMpids[j].index[k] = INDEX_INVALID;
7840 }
7841 }
7842
7843 if(er->cw_ex.mode == CW_MODE_MULTIPLE_CW)
7844 {
7845 int32_t key_pos_a = 0;
7846 demux[i].ECMpids[j].useMultipleIndices = 1;
7847
7848 for(k = 0; k < demux[i].STREAMpidcount; k++)
7849 {
7850 if(demux[i].STREAMpidsType[k] == STREAM_VIDEO)
7851 {
7852 dvbapi_write_cw(i, j, k, er->cw, 8, NULL, 0, er->cw_ex.algo, er->cw_ex.algo_mode, er->msgid);
7853 }
7854 else if(demux[i].STREAMpidsType[k] == STREAM_AUDIO)
7855 {
7856 if(key_pos_a < 4)
7857 {
7858 dvbapi_write_cw(i, j, k, er->cw_ex.audio[key_pos_a], 8, NULL, 0, er->cw_ex.algo, er->cw_ex.algo_mode, er->msgid);
7859 key_pos_a++;
7860 }
7861 }
7862 // Every channel that uses the extended cw has unencrypted subtitle streams,
7863 // so disable CW writing to save indices for audio streams and recordings.
7864 //else // Data
7865 //{
7866 // dvbapi_write_cw(i, j, k, er->cw_ex.data, 8, NULL, 0, er->cw_ex.algo, er->cw_ex.algo_mode, er->msgid);
7867 //}
7868 }
7869 }
7870 else
7871 {
7872 demux[i].ECMpids[j].useMultipleIndices = 0;
7873
7874 if(er->cw_ex.algo == CW_ALGO_AES128)
7875 {
7876 dvbapi_write_cw(i, j, 0, er->cw_ex.session_word, 16, er->cw_ex.data, 16, er->cw_ex.algo, er->cw_ex.algo_mode, er->msgid);
7877 }
7878 else
7879 {
7880 dvbapi_write_cw(i, j, 0, er->cw, 8, NULL, 0, er->cw_ex.algo, er->cw_ex.algo_mode, er->msgid);
7881 }
7882 }
7883 #else
7884 cfg.dvbapi_extended_cw_api = 0; // in CSA mode extended_cw_api should be always 0 regardless what user selected!
7885 dvbapi_write_cw(i, j, 0, er->cw, 8, NULL, 0, CA_ALGO_DVBCSA, CA_MODE_CBC, er->msgid);
7886 #endif
7887 break;
7888 }
7889 }
7890
7891 // reset idle-Time
7892 client->last = time((time_t *)0); // ********* TO BE FIXED LATER ON ******
7893
7894 if((cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX) && demux[i].client_proto_version >= 2)
7895 {
7896 dvbapi_net_send(DVBAPI_ECM_INFO, demux[i].socket_fd, 0, i, 0, NULL, client, er, demux[i].client_proto_version);
7897 }
7898 #ifndef __CYGWIN__
7899 else if(!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX)
7900 #endif
7901 if(cfg.dvbapi_ecminfo_file != 0 && cfg.dvbapi_boxtype != BOXTYPE_SAMYGO)
7902 {
7903 #ifdef WITH_EXTENDED_CW
7904 // Only print CWs for index 0 in ecm.info file
7905 if(er->cw_ex.algo == CA_ALGO_AES128)
7906 {
7907 dvbapi_write_ecminfo_file(client, er, demux[i].last_cw[0][0], demux[i].last_cw[0][1], 16);
7908 }
7909 else
7910 {
7911 dvbapi_write_ecminfo_file(client, er, demux[i].last_cw[0][0], demux[i].last_cw[0][1], 8);
7912 }
7913 #else
7914 dvbapi_write_ecminfo_file(client, er, demux[i].last_cw[0][0], demux[i].last_cw[0][1], 8);
7915 #endif
7916 }
7917 }
7918
7919 if(handled == 0)
7920 {
7921 cs_log_dbg(D_DVBAPI, "Unhandled ECM response received for CAID %04X PROVID %06X ECMPID %04X CHID %04X VPID %04X",
7922 er->caid, er->prid, er->pid, er->chid, er->vpid);
7923 }
7924 }
7925
7926 static int8_t isValidCW(uint8_t *cw)
7927 {
7928 uint8_t i;
7929 for(i = 0; i < 16; i += 4)
7930 {
7931 if(((cw[i] + cw[i + 1] + cw[i + 2]) & 0xff) != cw[i + 3])
7932 {
7933 return 0;
7934 }
7935 }
7936 return 1;
7937 }
7938
7939 void dvbapi_write_ecminfo_file(struct s_client *client, ECM_REQUEST *er, uint8_t *lastcw0, uint8_t *lastcw1, uint8_t cw_length)
7940 {
7941 #define ECMINFO_TYPE_OSCAM 0
7942 #define ECMINFO_TYPE_OSCAM_MS 1
7943 #define ECMINFO_TYPE_WICARDD 2
7944 #define ECMINFO_TYPE_MGCAMD 3
7945 #define ECMINFO_TYPE_CCCAM 4
7946 #define ECMINFO_TYPE_CAMD3 5
7947
7948 FILE *ecmtxt = fopen(ECMINFO_FILE, "w");
7949 if(ecmtxt != NULL && er->rc < E_NOTFOUND)
7950 {
7951 char tmp[49]; // holds 16 byte cw - (2 hex digits + 1 space) * 16 byte + string termination)
7952 const char *reader_name = NULL, *from_name = NULL, *proto_name = NULL;
7953 int8_t hops = 0;
7954 int32_t from_port = 0;
7955 char system_name[64];
7956 const char *const_system_name = get_cardsystem_desc_by_caid(er->caid);
7957
7958 cs_strncpy(system_name, const_system_name, sizeof(system_name));
7959 system_name[0] = (char)toupper((int)system_name[0]);
7960
7961 if(cfg.dvbapi_ecminfo_type <= ECMINFO_TYPE_WICARDD)
7962 {
7963 if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_WICARDD)
7964 {
7965 fprintf(ecmtxt, "system: %s\n", system_name);
7966 }
7967
7968 fprintf(ecmtxt, "caid: 0x%04X\npid: 0x%04X\n", er->caid, er->pid);
7969
7970 if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_WICARDD)
7971 {
7972 fprintf(ecmtxt, "prov: %06X\n", (uint) er->prid);
7973 }
7974 else
7975 {
7976 fprintf(ecmtxt, "prov: 0x%06X\n", (uint) er->prid);
7977 }
7978
7979 fprintf(ecmtxt, "chid: 0x%04X\n", er->chid);
7980 }
7981 else if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_MGCAMD)
7982 {
7983 fprintf(ecmtxt, "===== %s ECM on CaID 0x%04X, pid 0x%04X =====\nprov: %06X\n",
7984 system_name, er->caid, er->pid, (uint) er->prid);
7985 }
7986 else if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_CCCAM)
7987 {
7988 char provider_name[128];
7989 get_providername(er->prid, er->caid, provider_name, sizeof(provider_name));
7990
7991 if(provider_name[0])
7992 {
7993 fprintf(ecmtxt, "system: %s\ncaid: 0x%04X\nprovider: %s\nprovid: 0x%06X\npid: 0x%04X\n",
7994 system_name, er->caid, provider_name, (uint) er->prid, er->pid);
7995 }
7996 else
7997 {
7998 fprintf(ecmtxt, "system: %s\ncaid: 0x%04X\nprovid: 0x%06X\npid: 0x%04X\n",
7999 system_name, er->caid, (uint) er->prid, er->pid);
8000 }
8001 }
8002 else if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_CAMD3)
8003 {
8004 fprintf(ecmtxt, "CAID 0x%04X, PID 0x%04X, PROVIDER 0x%06X\n",
8005 er->caid, er->pid, (uint) er->prid);
8006 }
8007
8008 switch(er->rc)
8009 {
8010 case E_FOUND:
8011 if(er->selected_reader)
8012 {
8013 reader_name = er->selected_reader->label;
8014 if(is_network_reader(er->selected_reader))
8015 {
8016 from_name = er->selected_reader->device;
8017 }
8018 else
8019 {
8020 from_name = "local";
8021 }
8022 from_port = er->selected_reader->r_port;
8023 proto_name = reader_get_type_desc(er->selected_reader, 1);
8024 hops = er->selected_reader->currenthops;
8025 }
8026 else
8027 {
8028 reader_name = "none";
8029 from_name = "local";
8030 proto_name = "none";
8031 }
8032 break;
8033
8034 case E_CACHE1:
8035 reader_name = "Cache";
8036 from_name = "cache1";
8037 proto_name = "none";
8038 break;
8039
8040 case E_CACHE2:
8041 reader_name = "Cache";
8042 from_name = "cache2";
8043 proto_name = "none";
8044 break;
8045
8046 case E_CACHEEX:
8047 reader_name = "Cache";
8048 from_name = "cache3";
8049 proto_name = "none";
8050 break;
8051 }
8052
8053 if(cfg.dvbapi_ecminfo_type <= ECMINFO_TYPE_OSCAM_MS)
8054 {
8055 switch(er->rc)
8056 {
8057 case E_FOUND:
8058 if(er->selected_reader)
8059 {
8060 fprintf(ecmtxt, "reader: %s\nfrom: %s:%d\nprotocol: %s\nhops: %d\n",
8061 reader_name, from_name, from_port, proto_name, hops);
8062 }
8063 break;
8064
8065 case E_CACHE1:
8066 case E_CACHE2:
8067 case E_CACHEEX:
8068 fprintf(ecmtxt, "reader: %s\nfrom: %s:%d\nprotocol: %s\n",
8069 reader_name, from_name, from_port, proto_name);
8070 break;
8071 }
8072
8073 if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_OSCAM)
8074 {
8075 fprintf(ecmtxt, "ecm time: %.3f\n", (float) client->cwlastresptime / 1000);
8076 }
8077 else
8078 {
8079 fprintf(ecmtxt, "ecm time: %d\n", client->cwlastresptime);
8080 }
8081 }
8082
8083 if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_CAMD3)
8084 {
8085 fprintf(ecmtxt, "FROM: %s\n", reader_name);
8086 fprintf(ecmtxt, "CW0: %s\n", cs_hexdump(1, lastcw0, cw_length, tmp, sizeof(tmp)));
8087 fprintf(ecmtxt, "CW1: %s\n", cs_hexdump(1, lastcw1, cw_length, tmp, sizeof(tmp)));
8088 }
8089 else
8090 {
8091 fprintf(ecmtxt, "cw0: %s\n", cs_hexdump(1, lastcw0, cw_length, tmp, sizeof(tmp)));
8092 fprintf(ecmtxt, "cw1: %s\n", cs_hexdump(1, lastcw1, cw_length, tmp, sizeof(tmp)));
8093 }
8094
8095 if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_WICARDD || cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_MGCAMD)
8096 {
8097 time_t walltime;
8098 struct tm lt;
8099 char timebuf[32];
8100
8101 if(cw_length == 8) // only check checksum for 8 byte CWs
8102 {
8103 fprintf(ecmtxt, "Signature %s\n", (isValidCW(lastcw0) || isValidCW(lastcw1)) ? "OK" : "NOK");
8104 }
8105 else
8106 {
8107 fprintf(ecmtxt, "Signature %s\n", "OK");
8108 }
8109
8110 if(reader_name != NULL)
8111 {
8112 fprintf(ecmtxt, "source: %s (%s at %s:%d)\n", reader_name, proto_name, from_name, from_port);
8113 }
8114
8115 walltime = cs_time();
8116 localtime_r(&walltime, &lt);
8117
8118 if(strftime(timebuf, 32, "%a %b %d %H:%M:%S %Y", &lt) != 0)
8119 {
8120 fprintf(ecmtxt, "%d msec -- %s\n", client->cwlastresptime, timebuf);
8121 }
8122 }
8123
8124 if(cfg.dvbapi_ecminfo_type == ECMINFO_TYPE_CCCAM)
8125 {
8126 if(reader_name != NULL)
8127 {
8128 fprintf(ecmtxt, "using: %s\naddress: %s:%d\nhops: %d\n",
8129 proto_name, from_name, from_port, hops);
8130 }
8131 fprintf(ecmtxt, "ecm time: %d\n", client->cwlastresptime);
8132 }
8133 }
8134
8135 if(ecmtxt)
8136 {
8137 int32_t ret = fclose(ecmtxt);
8138 if(ret < 0)
8139 {
8140 cs_log("ERROR: Could not close ecmtxt fd (errno=%d %s)", errno, strerror(errno));
8141 }
8142 ecmtxt = NULL;
8143 }
8144 }
8145
8146
8147 void *dvbapi_start_handler(struct s_client *cl, uint8_t *UNUSED(mbuf), int32_t module_idx, void *(*_main_func)(void *))
8148 {
8149 // cs_log("dvbapi loaded fd=%d", idx);
8150 if(cfg.dvbapi_enabled == 1)
8151 {
8152 cl = create_client(get_null_ip());
8153 cl->module_idx = module_idx;
8154 cl->typ = 'c';
8155
8156 int32_t ret = start_thread("dvbapi handler", _main_func, (void *)cl, &cl->thread, 1, 0);
8157 if(ret)
8158 {
8159 return NULL;
8160 }
8161 }
8162 return NULL;
8163 }
8164
8165 void *dvbapi_handler(struct s_client *cl, uint8_t *mbuf, int32_t module_idx)
8166 {
8167 return dvbapi_start_handler(cl, mbuf, module_idx, dvbapi_main_local);
8168 }
8169
8170 int32_t dvbapi_set_section_filter(int32_t demux_id, ECM_REQUEST *er, int32_t n)
8171 {
8172 if(!er) { return -1; }
8173
8174 if(USE_OPENXCAS || (selected_api != DVBAPI_3 && selected_api != DVBAPI_1 && selected_api != STAPI) // only valid for dvbapi3, dvbapi1 and STAPI
8175 || (cfg.dvbapi_boxtype == BOXTYPE_IPBOX || cfg.dvbapi_boxtype == BOXTYPE_IPBOX_PMT)) // reported buggy using sectionfiltering after 1~4 hours -> for now disabled!
8176 {
8177 return 0;
8178 }
8179
8180 if(n == -1)
8181 {
8182 n = dvbapi_get_filternum(demux_id, er, TYPE_ECM);
8183 }
8184
8185 if(n < 0) // in case no valid filter found;
8186 {
8187 return -1;
8188 }
8189
8190 int32_t fd = demux[demux_id].demux_fd[n].fd;
8191 if(fd < 1) // in case no valid fd
8192 {
8193 return -1;
8194 }
8195
8196 uint8_t filter[16];
8197 uint8_t mask[16];
8198 memset(filter, 0, 16);
8199 memset(mask, 0, 16);
8200 struct s_ecmpid *curpid = NULL;
8201
8202 int32_t pid = demux[demux_id].demux_fd[n].pidindex;
8203 if(pid != -1)
8204 {
8205 curpid = &demux[demux_id].ECMpids[pid];
8206 }
8207
8208 if(curpid->table != er->ecm[0] && curpid->table != 0)
8209 {
8210 return -1; // if current ecmtype differs from latest requested ecmtype do not apply section filtering!
8211 }
8212
8213 uint8_t ecmfilter = 0;
8214
8215 if(er->ecm[0] == 0x80)
8216 {
8217 ecmfilter = 0x81; // current processed ecm is even, next will be filtered for odd
8218 }
8219 else
8220 {
8221 ecmfilter = 0x80; // current processed ecm is odd, next will be filtered for even
8222 }
8223
8224 if(curpid->table != 0) // cycle ecmtype from odd to even or even to odd
8225 {
8226 filter[0] = ecmfilter; // only accept new ecms (if previous odd, filter for even and vice versa)
8227 mask[0] = 0xFF;
8228 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d set ecmtable to %s (CAID %04X PROVID %06X FD %d)",
8229 demux_id, n + 1, (ecmfilter == 0x80 ? "EVEN" : "ODD"), curpid->CAID, curpid->PROVID, fd);
8230 }
8231 else // not decoding right now so we are interessted in all ecm types!
8232 {
8233 filter[0] = 0x80; // set filter to wait for any ecms
8234 mask[0] = 0xF0;
8235 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d set ecmtable to ODD+EVEN (CAID %04X PROVID %06X FD %d)",
8236 demux_id, n + 1, curpid->CAID, curpid->PROVID, fd);
8237 }
8238
8239 uint32_t offset = 0, extramask = 0xFF;
8240 struct s_dvbapi_priority *forceentry = dvbapi_check_prio_match(demux_id, pid, 'p');
8241 //cs_log("**** curpid->CHID %04X, checked = %d, er->chid = %04X *****", curpid->CHID, curpid->checked, er->chid);
8242 // checked 4 to make sure we dont set chid filter and no such ecm in dvbstream except for forced pids!
8243
8244 if(curpid->CHID < 0x10000 && (curpid->checked == 4 || (forceentry && forceentry->force)))
8245 {
8246 switch(er->caid >> 8)
8247 {
8248 case 0x01: // seca
8249 offset = 7;
8250 extramask = 0xF0;
8251 break;
8252
8253 case 0x05: // viaccess
8254 offset = 8;
8255 break;
8256
8257 case 0x06: // irdeto
8258 offset = 6;
8259 break;
8260
8261 case 0x09: // videoguard
8262 offset = 11;
8263 break;
8264
8265 case 0x4A: // DRE-Crypt, Bulcrypt, Tongang and others?
8266 if(!caid_is_bulcrypt(er->caid))
8267 {
8268 offset = 6;
8269 }
8270 break;
8271 }
8272 }
8273
8274 int32_t irdetomatch = 1; // check if wanted irdeto index is the one the delivers current chid!
8275 if(caid_is_irdeto(curpid->CAID))
8276 {
8277 if(curpid->irdeto_curindex == er->ecm[4]) { irdetomatch = 1; } // ok apply chid filtering
8278 else { irdetomatch = 0; } // skip chid filtering but apply irdeto index filtering
8279 }
8280
8281 if(offset && irdetomatch) // we have a cas with chid or unique part in checked ecm
8282 {
8283 i2b_buf(2, curpid->CHID, filter + (offset - 2));
8284 mask[(offset - 2)] = 0xFF & extramask; // additional mask seca2 chid can be FC10 or FD10 varies each month so only apply F?10
8285 mask[(offset - 1)] = 0xFF;
8286 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d set chid to %04X on fd %d", demux_id, n + 1, curpid->CHID, fd);
8287 }
8288 else
8289 {
8290 // on irdeto we can always apply irdeto index filtering!
8291 if(caid_is_irdeto(curpid->CAID) && (curpid->irdeto_curindex < 0xFE))
8292 {
8293 filter[2] = curpid->irdeto_curindex;
8294 mask[2] = 0xFF;
8295 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d set irdetoindex to %d on fd %d",
8296 demux_id, n + 1, curpid->irdeto_curindex, fd);
8297 }
8298 else // all other cas systems also cas systems without chid or unique ecm part
8299 {
8300 cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d set chid to ANY CHID on fd %d", demux_id, n + 1, fd);
8301 }
8302 }
8303
8304 int32_t ret = dvbapi_activate_section_filter(demux_id, n, fd, curpid->ECM_PID, filter, mask, er->msgid);
8305 if(ret < 0) // something went wrong setting filter!
8306 {
8307 cs_log("Demuxer %d Filter %d (fd %d) error setting section filtering -> stop filter!", demux_id, n + 1, fd);
8308
8309 ret = dvbapi_stop_filternum(demux_id, n, er->msgid);
8310 if(ret == -1)
8311 {
8312 cs_log("Demuxer %d Filter %d (fd %d) stopping filter failed -> kill all filters of this demuxer!", demux_id, n + 1, fd);
8313 dvbapi_stop_filter(demux_id, TYPE_EMM, er->msgid);
8314 dvbapi_stop_filter(demux_id, TYPE_ECM, er->msgid);
8315 }
8316 return -1;
8317 }
8318 return n;
8319 }
8320
8321 int32_t dvbapi_activate_section_filter(int32_t demux_id, int32_t num, int32_t fd, int32_t pid, uint8_t *filter, uint8_t *mask, uint32_t msgid)
8322 {
8323 int32_t ret = -1;
8324
8325 switch(selected_api)
8326 {
8327 case DVBAPI_3:
8328 {
8329 struct dmx_sct_filter_params sFP2;
8330 memset(&sFP2, 0, sizeof(sFP2));
8331 sFP2.pid = pid;
8332 sFP2.timeout = 0;
8333 sFP2.flags = DMX_IMMEDIATE_START;
8334
8335 if(cfg.dvbapi_boxtype == BOXTYPE_NEUMO)
8336 {
8337 //DeepThought: on dgs/cubestation and neumo images, perhaps others
8338 //the following code is needed to descramble
8339 sFP2.filter.filter[0] = filter[0];
8340 sFP2.filter.mask[0] = mask[0];
8341 sFP2.filter.filter[1] = 0;
8342 sFP2.filter.mask[1] = 0;
8343 sFP2.filter.filter[2] = 0;
8344 sFP2.filter.mask[2] = 0;
8345 memcpy(sFP2.filter.filter + 3, filter + 1, 16 - 3);
8346 memcpy(sFP2.filter.mask + 3, mask + 1, 16 - 3);
8347
8348 //DeepThought: in the drivers of the dgs/cubestation and neumo images,
8349 //dvbapi 1 and 3 are somehow mixed. In the kernel drivers, the DMX_SET_FILTER
8350 //ioctl expects to receive a dmx_sct_filter_params structure (DVBAPI 3) but
8351 //due to a bug its sets the "positive mask" wrongly (they should be all 0).
8352 //On the other hand, the DMX_SET_FILTER1 ioctl also uses the dmx_sct_filter_params
8353 //structure, which is incorrect (it should be dmxSctFilterParams).
8354 //The only way to get it right is to call DMX_SET_FILTER1 with the argument
8355 //expected by DMX_SET_FILTER. Otherwise, the timeout parameter is not passed correctly.
8356
8357 ret = dvbapi_ioctl(fd, DMX_SET_FILTER1, &sFP2);
8358 }
8359 else
8360 {
8361 memcpy(sFP2.filter.filter, filter, 16);
8362 memcpy(sFP2.filter.mask, mask, 16);
8363
8364 if(cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
8365 {
8366 ret = dvbapi_net_send(DVBAPI_DMX_SET_FILTER,
8367 demux[demux_id].socket_fd,
8368 msgid,
8369 demux_id,
8370 num,
8371 (uint8_t *) &sFP2,
8372 NULL,
8373 NULL,
8374 demux[demux_id].client_proto_version);
8375 }
8376 else
8377 {
8378 ret = dvbapi_ioctl(fd, DMX_SET_FILTER, &sFP2);
8379 }
8380 }
8381 break;
8382 }
8383
8384 case DVBAPI_1:
8385 {
8386 struct dmxSctFilterParams sFP1;
8387 memset(&sFP1, 0, sizeof(sFP1));
8388 sFP1.pid = pid;
8389 sFP1.timeout = 0;
8390 sFP1.flags = DMX_IMMEDIATE_START;
8391 memcpy(sFP1.filter.filter, filter, 16);
8392 memcpy(sFP1.filter.mask, mask, 16);
8393 ret = dvbapi_ioctl(fd, DMX_SET_FILTER1, &sFP1);
8394 break;
8395 }
8396
8397 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
8398 case STAPI:
8399 {
8400 ret = stapi_activate_section_filter(fd, filter, mask);
8401 break;
8402 }
8403 #endif
8404 // Isn't implemented in COOLAPI-1 (legacy)
8405 #if defined WITH_COOLAPI2
8406 case COOLAPI:
8407 {
8408 int32_t n = coolapi_get_filter_num(fd);
8409 if(n < 0)
8410 {
8411 return n;
8412 }
8413 coolapi_set_filter(fd, n, pid, filter, mask, TYPE_ECM);
8414 break;
8415 }
8416 #endif
8417
8418 default:
8419 break;
8420 }
8421
8422 if(ret != -1) // only change filter/mask for comparing if box returned no errors!
8423 {
8424 // copy filter and mask to check later on if receiver delivered accordingly
8425 memcpy(demux[demux_id].demux_fd[num].filter, filter, 16);
8426 memcpy(demux[demux_id].demux_fd[num].mask, mask, 16);
8427 }
8428 return ret;
8429 }
8430
8431 int32_t dvbapi_check_ecm_delayed_delivery(int32_t demux_id, ECM_REQUEST *er)
8432 {
8433 int32_t ret = 0;
8434 int32_t filternum = dvbapi_get_filternum(demux_id, er, TYPE_ECM);
8435 char nullcw[CS_ECMSTORESIZE];
8436 memset(nullcw, 0, CS_ECMSTORESIZE);
8437
8438 if(filternum < 0) // if no matching filter act like ecm response is delayed
8439 {
8440 return 2;
8441 }
8442
8443 if(memcmp(demux[demux_id].demux_fd[filternum].lastecmd5, nullcw, CS_ECMSTORESIZE))
8444 {
8445 demux[demux_id].demux_fd[filternum].lastresult = er->rc; // save last result
8446 char ecmd5[17 * 3];
8447 cs_hexdump(0, er->ecmd5, 16, ecmd5, sizeof(ecmd5));
8448
8449 cs_log_dbg(D_DVBAPI, "Demuxer %d requested controlword for ecm %s on fd %d",
8450 demux_id, ecmd5, demux[demux_id].demux_fd[filternum].fd);
8451
8452 uint8_t md5tmp[MD5_DIGEST_LENGTH];
8453 MD5(er->ecm, er->ecmlen, md5tmp);
8454
8455 // 1 = no response on the ecm we request last for this fd!
8456 ret = (memcmp(demux[demux_id].demux_fd[filternum].lastecmd5, md5tmp, CS_ECMSTORESIZE) != 0 ? 1 : 0);
8457 }
8458
8459 // Check for null cw
8460 // Skip check for BISS1 - cw could be indeed zero
8461 // Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
8462 if(memcmp(er->cw, nullcw, 8) == 0 && memcmp(er->cw + 8, nullcw, 8) == 0 && !caid_is_biss(er->caid))
8463 {
8464 return 5;
8465 }
8466
8467 struct s_ecmpid *curpid = NULL;
8468 int32_t pid = demux[demux_id].demux_fd[filternum].pidindex;
8469
8470 if(pid !=-1)
8471 {
8472 curpid = &demux[demux_id].ECMpids[pid];
8473 if(curpid->table == 0) // on change table act like ecm response is found
8474 {
8475 return 3;
8476 }
8477 }
8478
8479 if(er->rc == E_CACHEEX) // on cache-ex response act like ecm response is found
8480 {
8481 return 4;
8482 }
8483
8484 return ret;
8485 }
8486
8487 int32_t dvbapi_get_filternum(int32_t demux_id, ECM_REQUEST *er, int32_t type)
8488 {
8489 if(!er) { return -1; }
8490
8491 int32_t n;
8492 int32_t fd = -1;
8493
8494 for(n = 0; n < maxfilter; n++) // determine fd
8495 {
8496 // check for valid and right type (ecm or emm)
8497 if(demux[demux_id].demux_fd[n].fd > 0 && demux[demux_id].demux_fd[n].type == type)
8498 {
8499 if(type == TYPE_ECM && er->srvid != demux[demux_id].program_number)
8500 {
8501 continue;
8502 }
8503
8504 if((demux[demux_id].demux_fd[n].pid == er->pid) && ((demux[demux_id].demux_fd[n].provid == er->prid)
8505 || demux[demux_id].demux_fd[n].provid == 0 || er->prid == 0) && ((demux[demux_id].demux_fd[n].caid == er->caid)
8506 || (demux[demux_id].demux_fd[n].caid == er->ocaid))) // current ecm pid?
8507 {
8508 fd = demux[demux_id].demux_fd[n].fd; // found!
8509 if(demux[demux_id].demux_fd[n].caid == er->ocaid)
8510 {
8511 // clear ecmd5 hash since betatunneled ecms hash different!
8512 memset(demux[demux_id].demux_fd[n].lastecmd5, 0, CS_ECMSTORESIZE);
8513 }
8514 break;
8515 }
8516 }
8517 }
8518
8519 if(fd > 0 && demux[demux_id].demux_fd[n].provid == 0)
8520 {
8521 demux[demux_id].demux_fd[n].provid = er->prid; // hack to fill in provid into demuxer
8522 }
8523 return (fd > 0 ? n : fd); // return -1(fd) on not found, on found return filternumber(n)
8524 }
8525
8526 uint32_t dvbapi_ca_set_pid(int32_t demux_id, int32_t pid, int32_t stream_id, bool use_des, uint32_t msgid)
8527 {
8528 uint32_t idx;
8529 int32_t n;
8530
8531 if(pid == -1 || pid > demux[demux_id].ECMpidcount)
8532 {
8533 return INDEX_INVALID;
8534 }
8535
8536 if(demux[demux_id].ECMpids[pid].useMultipleIndices)
8537 {
8538 n = stream_id;
8539 idx = demux[demux_id].ECMpids[pid].index[n];
8540
8541 if(idx == INDEX_INVALID) // if we have no index for this pid, get one!
8542 {
8543 idx = dvbapi_get_desc_index(demux_id, pid, n);
8544 if(idx == INDEX_INVALID)
8545 {
8546 cs_log_dbg(D_DVBAPI, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X has no free index",
8547 demux_id, pid, demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].ECM_PID);
8548
8549 return INDEX_INVALID;
8550 }
8551
8552 cs_log_dbg(D_DVBAPI, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X is using index %d for stream %d",
8553 demux_id, pid, demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].ECM_PID, idx, n);
8554 }
8555
8556 if(!demux[demux_id].ECMpids[pid].streams || ((demux[demux_id].ECMpids[pid].streams & (1 << n)) == (uint) (1 << n)))
8557 {
8558 dvbapi_set_pid(demux_id, n, idx, true, use_des, msgid); // enable stream pid
8559 }
8560 else
8561 {
8562 dvbapi_set_pid(demux_id, n, idx, false, false, msgid); // disable stream pid
8563 }
8564 }
8565 else
8566 {
8567 idx = demux[demux_id].ECMpids[pid].index[0];
8568
8569 if(idx == INDEX_INVALID) // if we have no index for this pid, get one!
8570 {
8571 idx = dvbapi_get_desc_index(demux_id, pid, 0);
8572 if(idx == INDEX_INVALID)
8573 {
8574 cs_log_dbg(D_DVBAPI, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X has no free index",
8575 demux_id, pid, demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].ECM_PID);
8576
8577 return INDEX_INVALID;
8578 }
8579
8580 cs_log_dbg(D_DVBAPI, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X is using index %d",
8581 demux_id, pid, demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].ECM_PID, idx);
8582 }
8583
8584 for(n = 0; n < demux[demux_id].STREAMpidcount; n++)
8585 {
8586 if(!demux[demux_id].ECMpids[pid].streams || ((demux[demux_id].ECMpids[pid].streams & (1 << n)) == (uint) (1 << n)))
8587 {
8588 dvbapi_set_pid(demux_id, n, idx, true, use_des, 0); // enable stream pid
8589 }
8590 else
8591 {
8592 dvbapi_set_pid(demux_id, n, idx, false, false, 0); // disable stream pid
8593 }
8594 }
8595 }
8596 return idx; // return ca index
8597 }
8598
8599 int8_t update_streampid_list(uint8_t cadevice, uint16_t pid, uint32_t idx, bool use_des)
8600 {
8601 struct s_streampid *listitem, *newlistitem;
8602 LL_ITER itr;
8603 if(!ll_activestreampids)
8604 {
8605 ll_activestreampids = ll_create("ll_activestreampids");
8606 }
8607
8608 if(idx >= INDEX_MAX)
8609 {
8610 return INVALID_STREAMPID_INDEX;
8611 }
8612
8613 if(ll_count(ll_activestreampids) > 0)
8614 {
8615 itr = ll_iter_create(ll_activestreampids);
8616 while((listitem = ll_iter_next(&itr)))
8617 {
8618 if(cadevice == listitem->cadevice && pid == listitem->streampid)
8619 {
8620 if((listitem->activeindexers & (1 << idx)) == (uint64_t) (1 << idx))
8621 {
8622 if(cfg.dvbapi_extended_cw_api == 2 && use_des != listitem->use_des)
8623 {
8624 listitem->use_des = use_des;
8625 return FIRST_STREAMPID_INDEX;
8626 }
8627 return FOUND_STREAMPID_INDEX; // match found
8628 }
8629 else
8630 {
8631 listitem->activeindexers |= (1 << idx); // ca + pid found but not this index -> add this index
8632 cs_log_dbg(D_DVBAPI, "Added existing streampid %04X with new index %d to ca%d", pid, idx, cadevice);
8633
8634 if(cfg.dvbapi_extended_cw_api == 2 && use_des != listitem->use_des)
8635 {
8636 listitem->use_des = use_des;
8637 return FIRST_STREAMPID_INDEX;
8638 }
8639 return ADDED_STREAMPID_INDEX;
8640 }
8641 }
8642 }
8643 }
8644
8645 if(!cs_malloc(&newlistitem, sizeof(struct s_streampid)))
8646 {
8647 return FIRST_STREAMPID_INDEX; // not sure if this is correct
8648 }
8649
8650 newlistitem->cadevice = cadevice;
8651 newlistitem->streampid = pid;
8652 newlistitem->activeindexers = (1 << idx);
8653 newlistitem->caindex = idx; // set this index as used to decode on ca device
8654 newlistitem->use_des = use_des;
8655
8656 ll_append(ll_activestreampids, newlistitem);
8657 cs_log_dbg(D_DVBAPI, "Added new streampid %04X with index %d to ca%d", pid, idx, cadevice);
8658
8659 return FIRST_STREAMPID_INDEX;
8660 }
8661
8662 int8_t remove_streampid_from_list(uint8_t cadevice, uint16_t pid, uint32_t idx)
8663 {
8664 struct s_streampid *listitem;
8665 int8_t removed = 0;
8666 LL_ITER itr;
8667
8668 if(!ll_activestreampids)
8669 {
8670 return NO_STREAMPID_LISTED;
8671 }
8672
8673 if(idx >= INDEX_MAX)
8674 {
8675 return INVALID_STREAMPID_INDEX;
8676 }
8677
8678 if(ll_count(ll_activestreampids) > 0)
8679 {
8680 itr = ll_iter_create(ll_activestreampids);
8681 while((listitem = ll_iter_next(&itr)))
8682 {
8683 if(cadevice == listitem->cadevice && pid == listitem->streampid)
8684 {
8685 if(idx == INDEX_DISABLE_ALL)
8686 {
8687 listitem->activeindexers = 0;
8688 removed = 1;
8689 }
8690 else if((listitem->activeindexers & (1 << idx)) == (uint64_t) (1 << idx))
8691 {
8692 listitem->activeindexers &= ~(1 << idx); // flag it as disabled for this index
8693 removed = 1;
8694 }
8695
8696 if(removed)
8697 {
8698 cs_log_dbg(D_DVBAPI, "Remove streampid %04X using indexer %d from ca%d", pid, idx, cadevice);
8699 }
8700
8701 if(listitem->activeindexers == 0 && removed == 1) // all indexers disabled? -> remove pid from list!
8702 {
8703 ll_iter_remove_data(&itr);
8704 cs_log_dbg(D_DVBAPI, "Removed last indexer of streampid %04X from ca%d", pid, cadevice);
8705 return REMOVED_STREAMPID_LASTINDEX;
8706 }
8707 else if(removed == 1)
8708 {
8709 if(idx != INDEX_DISABLE_ALL && idx != listitem->caindex)
8710 {
8711 return REMOVED_STREAMPID_INDEX;
8712 }
8713 else
8714 {
8715 listitem->caindex = INDEX_INVALID;
8716 cs_log_dbg(D_DVBAPI, "Streampid %04X index %d was used for decoding on ca%d", pid, idx, cadevice);
8717 return REMOVED_DECODING_STREAMPID_INDEX;
8718 }
8719 }
8720 return INVALID_STREAMPID_INDEX;
8721 }
8722 }
8723 }
8724 return NO_STREAMPID_LISTED;
8725 }
8726
8727 void disable_unused_streampids(int16_t demux_id)
8728 {
8729 int32_t ecmpid = demux[demux_id].pidindex;
8730
8731 if(ecmpid == -1 // no active ecmpid!
8732 || !ll_activestreampids
8733 || selected_api == STAPI // stapi handles pids itself!
8734 || ll_count(ll_activestreampids) == 0) // no items in list?
8735 {
8736 return;
8737 }
8738
8739 int32_t j;
8740 if(demux[demux_id].ECMpids[ecmpid].useMultipleIndices == 0)
8741 {
8742 uint32_t idx = demux[demux_id].ECMpids[ecmpid].index[0];
8743 int32_t i, n;
8744 struct s_streampid *listitem;
8745
8746 // search for old enabled streampids on
8747 // all ca devices that have to be disabled
8748 for(i = 0; i < CA_MAX && idx != INDEX_INVALID; i++)
8749 {
8750 if(!((demux[demux_id].ca_mask & (1 << i)) == (uint32_t) (1 << i)))
8751 {
8752 continue; // ca is not used by this demuxer
8753 }
8754
8755 LL_ITER itr;
8756 itr = ll_iter_create(ll_activestreampids);
8757
8758 while((listitem = ll_iter_next(&itr)))
8759 {
8760 if(i != listitem->cadevice)
8761 {
8762 continue; // ca doesn't match
8763 }
8764
8765 if(!((listitem->activeindexers & (1 << (idx))) == (uint64_t) (1 << (idx))))
8766 {
8767 continue; // index doesn't match
8768 }
8769
8770 for(n = 0; n < demux[demux_id].STREAMpidcount; n++)
8771 {
8772 if(demux[demux_id].ECMpidcount == 0) // FTA? -> disable stream!
8773 {
8774 n = demux[demux_id].STREAMpidcount;
8775 break;
8776 }
8777
8778 // check if pid matches with current stream pid on demuxer
8779 if(listitem->streampid == demux[demux_id].STREAMpids[n])
8780 {
8781 break;
8782 }
8783 }
8784
8785 if(n == demux[demux_id].STREAMpidcount) // no match found
8786 {
8787 demux[demux_id].STREAMpids[n] = listitem->streampid; // put it here temporarily!
8788 dvbapi_set_pid(demux_id, n, idx, false, false, 0); // disable this unused streampid
8789 demux[demux_id].STREAMpids[n] = 0; // remove it from temp position!
8790 }
8791 }
8792
8793 // ECMpidcount != 0 -> skip enabling on fta
8794 for(n = 0; n < demux[demux_id].STREAMpidcount && demux[demux_id].ECMpidcount != 0; n++)
8795 {
8796 ll_iter_reset(&itr);
8797 if(!demux[demux_id].ECMpids[ecmpid].streams || ((demux[demux_id].ECMpids[ecmpid].streams & (1 << n)) == (uint) (1 << n)))
8798 {
8799 while((listitem = ll_iter_next(&itr)))
8800 {
8801 if(i != listitem->cadevice) // ca doesn't match
8802 {
8803 continue;
8804 }
8805
8806 if(!((listitem->activeindexers & (1 << (idx))) == (uint64_t) (1 << (idx)))) // index doesn't match
8807 {
8808 continue;
8809 }
8810
8811 // check if pid matches with current streampid on demuxer
8812 if(listitem->streampid == demux[demux_id].STREAMpids[n])
8813 {
8814 break;
8815 }
8816 }
8817
8818 if(!listitem) // if streampid not listed -> enable it!
8819 {
8820 dvbapi_set_pid(demux_id, n, idx, true, false, 0); // enable streampid
8821 }
8822 }
8823 }
8824 }
8825 }
8826 else
8827 {
8828 uint32_t idx = INDEX_INVALID;
8829 int32_t i, n;
8830 uint8_t skip;
8831 struct s_streampid *listitem;
8832
8833 // search for old enabled streampids
8834 // on all ca devices that have to be disabled
8835 for(i = 0; i < CA_MAX && idx != INDEX_INVALID; i++)
8836 {
8837 if(!((demux[demux_id].ca_mask & (1 << i)) == (uint32_t) (1 << i)))
8838 {
8839 continue; // continue if ca is unused by this demuxer
8840 }
8841
8842 LL_ITER itr;
8843 itr = ll_iter_create(ll_activestreampids);
8844
8845 while((listitem = ll_iter_next(&itr)))
8846 {
8847 if(i != listitem->cadevice)
8848 {
8849 continue; // ca doesn't match
8850 }
8851
8852 for(skip = 1, j = 0; j < MAX_STREAM_INDICES; j++)
8853 {
8854 idx = demux[demux_id].ECMpids[ecmpid].index[j];
8855 if(idx == INDEX_INVALID)
8856 {
8857 continue;
8858 }
8859
8860 // index match
8861 if((listitem->activeindexers & (1 << (idx))) == (uint64_t) (1 << (idx)))
8862 {
8863 skip = 0;
8864 break;
8865 }
8866 }
8867
8868 if(skip)
8869 {
8870 continue;
8871 }
8872
8873 for(n = 0; n < demux[demux_id].STREAMpidcount; n++)
8874 {
8875 if(demux[demux_id].ECMpidcount == 0) // FTA? -> disable stream!
8876 {
8877 n = demux[demux_id].STREAMpidcount;
8878 break;
8879 }
8880
8881 // check if pid matches with current streampid on demuxer
8882 if(listitem->streampid == demux[demux_id].STREAMpids[n])
8883 {
8884 break;
8885 }
8886 }
8887
8888 if(n == demux[demux_id].STREAMpidcount)
8889 {
8890 demux[demux_id].STREAMpids[n] = listitem->streampid; // put it temp here!
8891 dvbapi_set_pid(demux_id, n, idx, false, false, 0); // no match found so disable this now unused streampid
8892 demux[demux_id].STREAMpids[n] = 0; // remove temp!
8893 }
8894 }
8895
8896 // ECMpidcount != 0 -> skip enabling on fta
8897 for(n = 0; n < demux[demux_id].STREAMpidcount && demux[demux_id].ECMpidcount != 0; n++)
8898 {
8899 ll_iter_reset(&itr);
8900 if(!demux[demux_id].ECMpids[ecmpid].streams || ((demux[demux_id].ECMpids[ecmpid].streams & (1 << n)) == (uint) (1 << n)))
8901 {
8902 while((listitem = ll_iter_next(&itr)))
8903 {
8904 if(i != listitem->cadevice) // ca doesn't match
8905 {
8906 continue;
8907 }
8908
8909 for(skip = 1, j = 0; j < MAX_STREAM_INDICES; j++)
8910 {
8911 idx = demux[demux_id].ECMpids[ecmpid].index[j];
8912 if(idx == INDEX_INVALID)
8913 {
8914 continue;
8915 }
8916
8917 if((listitem->activeindexers & (1 << (idx))) == (uint64_t) (1 << (idx)))
8918 {
8919 skip = 0; // index match
8920 break;
8921 }
8922 }
8923
8924 if(skip)
8925 {
8926 continue;
8927 }
8928
8929 // check if pid matches with current streampid on demuxer
8930 if(listitem->streampid == demux[demux_id].STREAMpids[n])
8931 {
8932 break;
8933 }
8934 }
8935
8936 if(!listitem) // if streampid not listed -> enable it!
8937 {
8938 dvbapi_set_pid(demux_id, n, idx, true, false, 0); // enable streampid
8939 }
8940 }
8941 }
8942 }
8943 }
8944 }
8945
8946 uint32_t is_ca_used(uint8_t cadevice, int32_t pid)
8947 {
8948 struct s_streampid *listitem;
8949 LL_ITER itr;
8950 if(!ll_activestreampids)
8951 {
8952 return INDEX_INVALID;
8953 }
8954
8955 if(ll_count(ll_activestreampids) > 0)
8956 {
8957 itr = ll_iter_create(ll_activestreampids);
8958 while((listitem = ll_iter_next(&itr)))
8959 {
8960 // if pid is 0, we match ca device only
8961 if(listitem->cadevice != cadevice || (pid && listitem->streampid != pid))
8962 {
8963 continue;
8964 }
8965
8966 uint32_t i = 0;
8967 while(listitem->caindex == INDEX_INVALID && i < INDEX_MAX)
8968 {
8969 if((listitem->activeindexers & (1 << i)) == (uint64_t) (1 << i))
8970 {
8971 listitem->caindex = i; // set fresh one
8972 cs_log_dbg(D_DVBAPI, "Streampid %04X is now using index %d for decoding on ca%d", pid, i, cadevice);
8973 break;
8974 }
8975 i++;
8976 }
8977
8978 if(listitem->caindex == INDEX_INVALID)
8979 {
8980 ll_iter_remove_data(&itr);
8981 return INDEX_INVALID;
8982 }
8983 return listitem->caindex;
8984 }
8985 }
8986 return INDEX_INVALID; // no indexer found for this pid!
8987 }
8988
8989 uint16_t dvbapi_get_client_proto_version(void)
8990 {
8991 return last_client_proto_version;
8992 }
8993
8994 const char *dvbapi_get_client_name(void)
8995 {
8996 return last_client_name ? last_client_name : "";
8997 }
8998
8999 void check_add_emmpid(int32_t demux_id, uint8_t *filter, int32_t l, int32_t emmtype)
9000 {
9001 if(l < 0) { return; }
9002
9003 uint32_t typtext_idx = 0;
9004 int32_t ret = -1;
9005 const char *typtext[] = { "UNIQUE", "SHARED", "GLOBAL", "UNKNOWN" };
9006
9007 while(((emmtype >> typtext_idx) & 0x01) == 0 && typtext_idx < sizeof(typtext) / sizeof(const char *))
9008 {
9009 ++typtext_idx;
9010 }
9011
9012 // filter already in list?
9013 if(is_emmfilter_in_list(filter, demux[demux_id].EMMpids[l].PID, demux[demux_id].EMMpids[l].PROVID, demux[demux_id].EMMpids[l].CAID))
9014 {
9015 cs_log_dbg(D_DVBAPI, "Demuxer %d duplicate emm filter type %s, emmpid: 0x%04X, emmcaid: %04X, emmprovid: %06X -> SKIPPED!",
9016 demux_id,
9017 typtext[typtext_idx],
9018 demux[demux_id].EMMpids[l].PID,
9019 demux[demux_id].EMMpids[l].CAID,
9020 demux[demux_id].EMMpids[l].PROVID);
9021 return;
9022 }
9023
9024 if(demux[demux_id].emm_filter < demux[demux_id].max_emm_filter) // can this filter be started?
9025 {
9026 // try to activate this emmfilter
9027 ret = dvbapi_set_filter(demux_id,
9028 selected_api,
9029 demux[demux_id].EMMpids[l].PID,
9030 demux[demux_id].EMMpids[l].CAID,
9031 demux[demux_id].EMMpids[l].PROVID,
9032 filter,
9033 filter + 16,
9034 0,
9035 demux[demux_id].pidindex,
9036 TYPE_EMM, 1);
9037 }
9038
9039 if(ret != -1) // -1 if maxfilter reached or filter start error!
9040 {
9041 if(demux[demux_id].emm_filter == -1) // -1: first run of emm filtering on this demuxer
9042 {
9043 demux[demux_id].emm_filter = 0;
9044 }
9045 demux[demux_id].emm_filter++; // increase total active filters
9046
9047 cs_log_dump_dbg(D_DVBAPI, filter, 32, "Demuxer %d started emm filter type %s, pid: 0x%04X",
9048 demux_id, typtext[typtext_idx], demux[demux_id].EMMpids[l].PID);
9049 return;
9050 }
9051 else // not set successful, so add it to the list for try again later on!
9052 {
9053 add_emmfilter_to_list(demux_id, filter, demux[demux_id].EMMpids[l].CAID, demux[demux_id].EMMpids[l].PROVID, demux[demux_id].EMMpids[l].PID, 0, false);
9054 cs_log_dump_dbg(D_DVBAPI, filter, 32, "Demuxer %d added inactive emm filter type %s, pid: 0x%04X",
9055 demux_id, typtext[typtext_idx], demux[demux_id].EMMpids[l].PID);
9056 }
9057 return;
9058 }
9059
9060 void rotate_emmfilter(int32_t demux_id)
9061 {
9062 // emm filter iteration
9063 if(!ll_emm_active_filter)
9064 {
9065 ll_emm_active_filter = ll_create("ll_emm_active_filter");
9066 }
9067
9068 if(!ll_emm_inactive_filter)
9069 {
9070 ll_emm_inactive_filter = ll_create("ll_emm_inactive_filter");
9071 }
9072
9073 if(!ll_emm_pending_filter)
9074 {
9075 ll_emm_pending_filter = ll_create("ll_emm_pending_filter");
9076 }
9077
9078 uint32_t filter_count = ll_count(ll_emm_active_filter) + ll_count(ll_emm_inactive_filter);
9079 if(demux[demux_id].max_emm_filter > 0 && ll_count(ll_emm_inactive_filter) > 0 && filter_count > demux[demux_id].max_emm_filter)
9080 {
9081 int32_t filter_queue = ll_count(ll_emm_inactive_filter);
9082 int32_t stopped = 0, started = 0;
9083 struct timeb now;
9084 cs_ftime(&now);
9085 struct s_emm_filter *filter_item;
9086 LL_ITER itr;
9087 itr = ll_iter_create(ll_emm_active_filter);
9088
9089 while((filter_item = ll_iter_next(&itr)) != NULL)
9090 {
9091 if(!ll_count(ll_emm_inactive_filter) || started == filter_queue)
9092 {
9093 break;
9094 }
9095
9096 int64_t gone = comp_timeb(&now, &filter_item->time_started);
9097 if(gone > 45 * 1000)
9098 {
9099 struct s_dvbapi_priority *forceentry = dvbapi_check_prio_match_emmpid(filter_item->demux_id, filter_item->caid, filter_item->provid, 'p');
9100 if(!forceentry || (forceentry && !forceentry->force))
9101 {
9102 // stop active filter and add to pending list
9103 dvbapi_stop_filternum(filter_item->demux_id, filter_item->num - 1, 0);
9104 ll_iter_remove_data(&itr);
9105 add_emmfilter_to_list(filter_item->demux_id, filter_item->filter, filter_item->caid, filter_item->provid, filter_item->pid, -1, false);
9106 stopped++;
9107 }
9108 }
9109
9110 int32_t ret;
9111 if(stopped > started) // we have room for new filters, try to start an inactive emmfilter!
9112 {
9113 struct s_emm_filter *filter_item2;
9114 LL_ITER itr2 = ll_iter_create(ll_emm_inactive_filter);
9115 while((filter_item2 = ll_iter_next(&itr2)))
9116 {
9117 ret = dvbapi_set_filter(filter_item2->demux_id,
9118 selected_api,
9119 filter_item2->pid,
9120 filter_item2->caid,
9121 filter_item2->provid,
9122 filter_item2->filter,
9123 filter_item2->filter + 16,
9124 0,
9125 demux[filter_item2->demux_id].pidindex,
9126 TYPE_EMM, 1);
9127 if(ret != -1)
9128 {
9129 ll_iter_remove_data(&itr2);
9130 started++;
9131 break;
9132 }
9133 }
9134 }
9135 }
9136
9137 itr = ll_iter_create(ll_emm_pending_filter);
9138 while((filter_item = ll_iter_next(&itr)) != NULL) // move pending filters to inactive
9139 {
9140 add_emmfilter_to_list(filter_item->demux_id, filter_item->filter, filter_item->caid, filter_item->provid, filter_item->pid, 0, false);
9141 ll_iter_remove_data(&itr);
9142 }
9143 }
9144 }
9145
9146 int32_t filtermatch(uint8_t *buffer, int32_t filter_num, int32_t demux_id, int32_t len)
9147 {
9148 int32_t i, k, match;
9149 uint8_t flt, mask;
9150
9151 match = 1;
9152 for(i = 0, k = 0; i < 16 && match; i++, k++)
9153 {
9154 mask = demux[demux_id].demux_fd[filter_num].mask[i];
9155 if(k == 1) // skip len bytes
9156 {
9157 k += 2;
9158 }
9159
9160 if(!mask)
9161 {
9162 continue;
9163 }
9164
9165 flt = (demux[demux_id].demux_fd[filter_num].filter[i]&mask);
9166 cs_log_dbg(D_DVBAPI,"Demuxer %d filter%d[%d] = %02X, filter mask[%d] = %02X, flt&mask = %02X , buffer[%d] = %02X, buffer[%d] & mask = %02X",
9167 demux_id, filter_num + 1, i, demux[demux_id].demux_fd[filter_num].filter[i], i, mask, flt&mask, k, buffer[k], k, buffer[k] & mask);
9168
9169 if(k <= len)
9170 {
9171 match = (flt == (buffer[k] & mask));
9172 }
9173 else
9174 {
9175 match = 0;
9176 }
9177 }
9178 return (match && i == 16); // 0 = delivered data does not match with filter, 1 = delivered data matches with filter
9179 }
9180
9181 /*
9182 * protocol structure
9183 */
9184 void module_dvbapi(struct s_module *ph)
9185 {
9186 ph->desc = "dvbapi";
9187 ph->type = MOD_CONN_SERIAL;
9188 ph->listenertype = LIS_DVBAPI;
9189 #if defined(WITH_AZBOX)
9190 ph->s_handler = azbox_handler;
9191 ph->send_dcw = azbox_send_dcw;
9192 #elif defined(WITH_MCA)
9193 ph->s_handler = mca_handler;
9194 ph->send_dcw = mca_send_dcw;
9195 selected_box = selected_api = 0; // HACK: This fixes incorrect warning about out of bounds array access in functionas that are not even called when WITH_MCA is defined
9196 #else
9197 ph->s_handler = dvbapi_handler;
9198 ph->send_dcw = dvbapi_send_dcw;
9199 #endif
9200 }
9201 #endif // HAVE_DVBAPI
Open Source Conditional Access Modul