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