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