1 #define MODULE_LOG_PREFIX "dvbapi"
7 #include "module-dvbapi.h"
8 #include "module-cacheex.h"
9 #include "module-dvbapi-azbox.h"
10 #include "module-dvbapi-mca.h"
11 #include "module-dvbapi-coolapi.h"
12 #include "module-dvbapi-stapi.h"
13 #include "module-dvbapi-chancache.h"
14 #include "module-stat.h"
15 #include "oscam-chk.h"
16 #include "oscam-client.h"
17 #include "oscam-config.h"
18 #include "oscam-ecm.h"
19 #include "oscam-emm.h"
20 #include "oscam-files.h"
21 #include "oscam-net.h"
22 #include "oscam-reader.h"
23 #include "oscam-string.h"
24 #include "oscam-time.h"
25 #include "oscam-work.h"
26 #include "reader-irdeto.h"
27 #include "cscrypt/md5.h"
28 extern int32_t exit_oscam
;
30 #if defined (__CYGWIN__)
36 #define DN_MULTISHOT 0
39 static const char *get_stream_type_txt(uint8_t stream_type
)
43 case 0x00: return "invalid";
44 case 0x01: return "MPEG-1 video";
45 case 0x02: return "MPEG-2 video"; // MPEG-1 (constrained parameter) or MPEG-2 video
46 case 0x03: return "MPEG-1 audio"; // MP1, MP2, MP3
47 case 0x04: return "MPEG-2 audio"; // MP1, MP2, MP3
48 case 0x05: return "MPEG-2 private sections";
49 case 0x06: return "MPEG-2 PES private data"; // AC-3, Enhanced AC-3, AC-4, DTS(-HD) audio, subtitles, etc (DVB) (depends on descriptor)
50 case 0x07: return "MHEG data";
51 case 0x08: return "DSM-CC data";
52 case 0x09: return "MPEG-2 over ATM data";
53 case 0x0A: return "DSM-CC data";
54 case 0x0B: return "DSM-CC data";
55 case 0x0C: return "DSM-CC data";
56 case 0x0D: return "DSM-CC data";
57 case 0x0E: return "MPEG-2 auxiliary data";
58 case 0x0F: return "MPEG-2 audio"; // AAC
59 case 0x10: return "MPEG-4 video";
60 case 0x11: return "MPEG-4 audio"; // AAC, HE AAC and AAC v2
61 case 0x12: return "MPEG-4 PES data";
62 case 0x13: return "MPEG-4 data";
63 case 0x14: return "DSM-CC data";
64 case 0x15: return "MPEG-7 MetaData";
65 case 0x16: return "MPEG-7 MetaData";
66 case 0x17: return "MPEG-7 MetaData";
67 case 0x18: return "MPEG-7 MetaData";
68 case 0x19: return "MPEG-7 MetaData";
69 case 0x1A: return "MPEG-2 IPMP data";
70 case 0x1B: return "AVC video";
71 case 0x1C: return "MPEG-4 audio"; // DST, ALS, SLS
72 case 0x24: return "HEVC video";
73 case 0x25: return "HEVC subset video";
74 case 0x2D: return "MPEG-H 3D audio"; // main stream
75 case 0x2E: return "MPEG-H 3D audio"; // auxiliary stream
76 case 0x42: return "Chinese video";
77 case 0x7F: return "IPMP data";
78 case 0x81: return "AC-3 audio (ATSC)"; // with descriptor tag 0x81
79 case 0x86: return "SCTE 35 data";
80 case 0x87: return "enhanced AC-3 audio (ATSC)";
81 //case 0x88: return "DTS-HD audio (ATSC 2.0)"; // fixme: has ATSC 2.0 ever been used?
82 //case 0x??: return "AC-4 audio (ATSC 3.0)"; // fixme: add the actual value when it gets published
83 //case 0x??: return "MPEG-H 3D audio (ATSC 3.0)"; // fixme: add the actual value when it gets published
84 case 0xD1: return "BBC Dirac video";
85 case 0xEA: return "VC-1 video";
86 default: return "user private";
90 static const char *get_descriptor_tag_txt(uint8_t descriptor_tag
)
92 switch(descriptor_tag
)
94 // Valid in all MPEG contexts:
95 case 0x00: return "reserved";
96 case 0x01: return "forbidden";
97 case 0x02: return "video stream";
98 case 0x03: return "audio stream";
99 case 0x04: return "hierarchy";
100 case 0x05: return "registration";
101 case 0x06: return "data stream alignment";
102 case 0x07: return "target background grid";
103 case 0x08: return "video window";
104 case 0x09: return "CA";
105 case 0x0A: return "ISO 639 language";
106 case 0x0B: return "system clock";
107 case 0x0C: return "multiplex buffer utilization";
108 case 0x0D: return "copyright";
109 case 0x0E: return "maximum bitrate";
110 case 0x0F: return "private data indicator";
111 case 0x10: return "smoothing buffer";
112 case 0x11: return "STD";
113 case 0x12: return "IBP";
114 case 0x13: return "DSM-CC carousel identifier";
115 case 0x14: return "DSM-CC association tag";
116 case 0x15: return "DSM-CC deferred association tags";
117 case 0x17: return "DSM-CC NPT reference";
118 case 0x18: return "DSM-CC NPT endpoint";
119 case 0x19: return "DSM-CC stream mode";
120 case 0x1A: return "DSM-CC stream event";
121 case 0x1B: return "MPEG-4 video";
122 case 0x1C: return "MPEG-4 audio";
123 case 0x1D: return "IOD";
124 case 0x1E: return "SL";
125 case 0x1F: return "FMC";
126 case 0x20: return "External ES id";
127 case 0x21: return "MuxCode";
128 case 0x22: return "FmxBufferSize";
129 case 0x23: return "MultiplexBuffer";
130 case 0x24: return "Content labeling";
131 case 0x25: return "Metadata association";
132 case 0x26: return "Metadata";
133 case 0x27: return "Metadata STD";
134 case 0x28: return "AVC video";
135 case 0x29: return "MPEG-2 IPMP";
136 case 0x2A: return "AVC timing and HRD";
137 case 0x2B: return "MPEG-2 AAC Audio";
138 case 0x2C: return "FlexMuxTiming";
139 case 0x2D: return "MPEG-4 Text";
140 case 0x2E: return "MPEG-4 Audio Extension";
141 case 0x2F: return "Auxiliary Video Stream";
142 case 0x30: return "SVC Extension";
143 case 0x31: return "MVC Extension";
144 case 0x32: return "J2K Video";
145 case 0x33: return "MVC Operation Point";
146 case 0x34: return "MPEG-2 Stereoscopic Video Format";
147 case 0x35: return "Stereoscopic Program Info";
148 case 0x36: return "Stereoscopic Video Info";
149 case 0x37: return "Transport Profile";
150 case 0x38: return "HEVC Video";
151 case 0x3F: return "MPEG-2 Extension";
152 // Valid in DVB context:
153 case 0x45: return "VBI data";
154 case 0x46: return "VBI teletext";
155 case 0x51: return "mosaic";
156 case 0x52: return "stream identifier";
157 case 0x56: return "teletext";
158 case 0x59: return "subtitling"; // with stream type 0x06
159 case 0x5F: return "private data specifier";
160 case 0x60: return "service move";
161 case 0x65: return "scrambling";
162 case 0x66: return "data broadcast id";
163 case 0x6A: return "AC-3"; // with stream type 0x06
164 case 0x6B: return "ancillary data";
165 case 0x6F: return "application signalling";
166 case 0x70: return "adaptation field data";
167 case 0x74: return "related content";
168 case 0x78: return "ECM repetition rate";
169 case 0x7A: return "enhanced AC-3"; // with stream type 0x06
170 case 0x7B: return "DTS"; // with stream type 0x06
171 case 0x7C: return "AAC"; // with stream type 0x06
172 case 0x7D: return "XAIT location";
173 case 0x7F: return "DVB extension";
174 // Valid in ATSC context:
175 case 0x81: return "AC-3"; // with stream type 0x81
176 case 0xCC: return "enhanced AC-3"; // with stream type 0x87
177 default: return "user private";
181 static const char *get_extension_descriptor_txt(uint8_t extension_tag
)
183 switch(extension_tag
)
185 case 0x02: return "CP";
186 case 0x06: return "supplementary audio";
187 case 0x0E: return "DTS-HD"; // with stream type 0x06
188 case 0x0F: return "DTS Neural"; // with stream type 0x06
189 case 0x11: return "T2MI";
190 case 0x13: return "URI linkage";
191 case 0x15: return "AC-4"; // with stream type 0x06
192 case 0x18: return "protection message";
193 case 0x19: return "audio preselection";
194 case 0x20: return "TTML subtitling"; // (could become 0x1A, value in A038 draft seems weird)
195 case 0x21: return "DTS-UHD"; // with stream type 0x06 (could become 0x1B, value in A038 draft seems weird)
196 default: return "Undefined";
200 void flush_read_fd(int32_t demux_id
, int32_t num
, int fd
)
202 if(!cfg
.dvbapi_listenport
&& cfg
.dvbapi_boxtype
!= BOXTYPE_PC_NODMX
)
204 cs_log_dbg(D_DVBAPI
,"Demuxer %d flushing stale input data of filter %d (fd:%d)", demux_id
, num
+ 1, fd
);
216 while(select(fd
+ 1, &rd
, NULL
, NULL
, &t
) > 0)
218 if(read(fd
, buff
, 100)) { ; }
223 static int dvbapi_ioctl(int fd
, uint32_t request
, ...)
227 va_start(args
, request
);
228 if(!(cfg
.dvbapi_boxtype
== BOXTYPE_SAMYGO
))
230 void *param
= va_arg(args
, void *);
231 ret
= ioctl(fd
, request
, param
);
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);
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);
254 case DMX_SET_FILTER1
:
256 cs_log("error: samygo does not support DMX_SET_FILTER1");
263 ret
= send(fd
, &request
, sizeof(request
), 0);
268 case CA_GET_DESCR_INFO
:
270 ca_descr_info_t
*ca_descr_info
= va_arg(args
, ca_descr_info_t
*);
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);
282 ca_descr_t
*ca_descr
= va_arg(args
, ca_descr_t
*);
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);
294 ca_pid_t
*ca_pid2
= va_arg(args
, ca_pid_t
*);
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);
304 case CA_SET_DESCR_MODE
:
306 cs_log("error: samygo does not support CA_SET_DESCR_MODE");
311 case CA_SET_DESCR_DATA
:
313 cs_log("error: samygo does not support CA_SET_DESCR_DATA");
319 if(ret
> 0) // send() may return larger than 1
324 #if defined(__powerpc__)
325 // Old dm500 boxes (ppc old) are using broken kernel, se we need some fixups
334 // FIXME: Workaround for su980 bug
335 // See: http://www.streamboard.tv/wbb2/thread.php?postid=533940
336 if(boxtype_is("su980"))
348 int32_t pausecam
= 0, disable_pmt_files
= 0;
350 DEMUXTYPE demux
[MAX_DEMUX
];
351 struct s_dvbapi_priority
*dvbapi_priority
;
352 struct s_client
*dvbapi_client
;
354 const char *boxdesc
[] = { "none", "dreambox", "duckbox", "ufs910", "dbox2", "ipbox", "ipbox-pmt",
355 "dm7000", "qboxhd", "coolstream", "neumo", "pc", "pc-nodmx", "samygo" };
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
362 static const struct box_devices devices
[BOX_COUNT
] =
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
},
370 /* sh4 (stapi5)*/ { "/dev/stapi/", "stpti5_ioctl", "stpti5_ioctl", "/tmp/camd.socket", STAPI
},
372 /* sh4 (stapi)*/ { "/dev/stapi/", "stpti4_ioctl", "stpti4_ioctl", "/tmp/camd.socket", STAPI
},
374 /* coolstream*/ { "/dev/cnxt/", "null", "null", "/tmp/camd.socket", COOLAPI
},
377 static int32_t selected_box
= -1;
378 static int32_t selected_api
= -1;
379 static int32_t maxfilter
= MAX_FILTER
;
380 static int32_t dir_fd
= -1;
381 static uint16_t last_client_proto_version
= 0;
382 static char *last_client_name
= NULL
;
383 static uint32_t ca_descramblers_total
= 0; // total number of available descramblers in box
384 static uint32_t ca_descramblers_used
= 0; // total number of used descramblers during decoding
385 static int32_t ca_fd
[CA_MAX
]; // holds fd handle of all ca devices (0 not in use)
386 static LLIST
*ll_activestreampids
; // list of all enabled streampids on ca devices
387 static int32_t unassoc_fd
[MAX_DEMUX
];
389 bool is_dvbapi_usr(char *usr
)
391 return streq(cfg
.dvbapi_usr
, usr
);
402 struct timeb time_started
;
405 static LLIST
*ll_emm_active_filter
;
406 static LLIST
*ll_emm_inactive_filter
;
407 static LLIST
*ll_emm_pending_filter
;
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
)
411 if(!ll_emm_active_filter
)
413 ll_emm_active_filter
= ll_create("ll_emm_active_filter");
416 if(!ll_emm_inactive_filter
)
418 ll_emm_inactive_filter
= ll_create("ll_emm_inactive_filter");
421 if(!ll_emm_pending_filter
)
423 ll_emm_pending_filter
= ll_create("ll_emm_pending_filter");
426 struct s_emm_filter
*filter_item
;
427 if(!cs_malloc(&filter_item
, sizeof(struct s_emm_filter
)))
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
;
441 cs_ftime(&filter_item
->time_started
);
445 memset(&filter_item
->time_started
, 0, sizeof(filter_item
->time_started
));
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
);
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
);
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
);
469 int32_t is_emmfilter_in_list_internal(LLIST
*ll
, uint8_t *filter
, uint16_t emmpid
, uint32_t provid
, uint16_t caid
)
471 struct s_emm_filter
*filter_item
;
475 itr
= ll_iter_create(ll
);
476 while((filter_item
= ll_iter_next(&itr
)) != NULL
)
478 if(!memcmp(filter_item
->filter
, filter
, 32) && (filter_item
->pid
== emmpid
)
479 && (filter_item
->provid
== provid
) && (filter_item
->caid
== caid
))
488 int32_t is_emmfilter_in_list(uint8_t *filter
, uint16_t emmpid
, uint32_t provid
, uint16_t caid
)
490 if(!ll_emm_active_filter
)
492 ll_emm_active_filter
= ll_create("ll_emm_active_filter");
495 if(!ll_emm_inactive_filter
)
497 ll_emm_inactive_filter
= ll_create("ll_emm_inactive_filter");
500 if(!ll_emm_pending_filter
)
502 ll_emm_pending_filter
= ll_create("ll_emm_pending_filter");
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
))
514 struct s_emm_filter
*get_emmfilter_by_filternum_internal(LLIST
*ll
, int32_t demux_id
, uint32_t num
)
516 struct s_emm_filter
*filter
;
520 itr
= ll_iter_create(ll
);
521 while((filter
= ll_iter_next(&itr
)))
523 if(filter
->demux_id
== demux_id
&& filter
->num
== num
)
532 struct s_emm_filter
*get_emmfilter_by_filternum(int32_t demux_id
, uint32_t num
)
534 if(!ll_emm_active_filter
)
536 ll_emm_active_filter
= ll_create("ll_emm_active_filter");
539 if(!ll_emm_inactive_filter
)
541 ll_emm_inactive_filter
= ll_create("ll_emm_inactive_filter");
544 if(!ll_emm_pending_filter
)
546 ll_emm_pending_filter
= ll_create("ll_emm_pending_filter");
549 struct s_emm_filter
*emm_filter
= NULL
;
551 emm_filter
= get_emmfilter_by_filternum_internal(ll_emm_active_filter
, demux_id
, num
);
557 emm_filter
= get_emmfilter_by_filternum_internal(ll_emm_inactive_filter
, demux_id
, num
);
563 emm_filter
= get_emmfilter_by_filternum_internal(ll_emm_pending_filter
, demux_id
, num
);
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
)
574 struct s_emm_filter
*filter
;
579 itr
= ll_iter_create(ll
);
580 while((filter
= ll_iter_next(&itr
)))
582 if(filter
->demux_id
== demux_id
&& filter
->caid
== caid
&& filter
->provid
== provid
&& filter
->pid
== pid
&& filter
->num
== num
)
584 ll_iter_remove_data(&itr
);
592 void remove_emmfilter_from_list(int32_t demux_id
, uint16_t caid
, uint32_t provid
, uint16_t pid
, uint32_t num
)
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
)))
602 void dvbapi_net_add_str(uint8_t *packet
, int *size
, const char *str
)
604 uint8_t *str_len
= &packet
[*size
]; // string length
606 *str_len
= snprintf((char *) &packet
[*size
], DVBAPI_MAX_PACKET_SIZE
- *size
, "%s", str
);
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
)
613 uint8_t packet
[DVBAPI_MAX_PACKET_SIZE
]; // maximum possible packet size
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)
628 packet
[size
++] = demux
[demux_id
].adapter_index
; // adapter index - 1 byte
630 else if(client_proto_version
>= 3)
632 packet
[size
++] = 0xa5; // message start
634 memcpy(&packet
[size
], &u32
, 4);
640 if(client_proto_version
>= 1)
644 memcpy(&packet
[size
], &u32
, 4);
647 // preparing packet - adapter index for proto >= 1
648 if((request
!= DVBAPI_SERVER_INFO
) && client_proto_version
>= 1)
650 packet
[size
++] = demux
[demux_id
].adapter_index
; // adapter index - 1 byte
656 case DVBAPI_SERVER_INFO
:
658 int16_t proto_version
= htons(DVBAPI_PROTOCOL_VERSION
); // our protocol version
659 char capabilities
[128] = "\x00"; // two zero characters
660 memcpy(&packet
[size
], &proto_version
, 2);
662 uint8_t *info_len
= &packet
[size
]; // info string length
665 if(cfg
.dvbapi_extended_cw_api
== 1)
667 strcat(capabilities
, ",e1mk"); // extended cw, key follows mode - supports CSA, DES, AES128
670 if(cfg
.dvbapi_extended_cw_api
== 2)
672 strcat(capabilities
, ",e2"); // usage of DES algo signalled through PID index - CSA and DES only
675 *info_len
= snprintf((char *) &packet
[size
], sizeof(packet
) - size
, "OSCam v%s, build r%s (%s); %s",
676 CS_VERSION
, CS_SVN_VERSION
, CS_TARGET
, capabilities
+ 1);
682 case DVBAPI_ECM_INFO
:
684 if(er
->rc
>= E_NOTFOUND
)
691 uint16_t sid
= htons(er
->srvid
); // service ID (program number)
692 memcpy(&packet
[size
], &sid
, 2);
695 uint16_t caid
= htons(er
->caid
); // CAID
696 memcpy(&packet
[size
], &caid
, 2);
699 uint16_t pid
= htons(er
->pid
); // PID
700 memcpy(&packet
[size
], &pid
, 2);
703 uint32_t prid
= htonl(er
->prid
); // Provider ID
704 memcpy(&packet
[size
], &prid
, 4);
707 uint32_t ecmtime
= htonl(client
->cwlastresptime
); // ECM time
708 memcpy(&packet
[size
], &ecmtime
, 4);
711 dvbapi_net_add_str(packet
, &size
, get_cardsystem_desc_by_caid(er
->caid
)); // cardsystem name
716 if(er
->selected_reader
)
718 dvbapi_net_add_str(packet
, &size
, er
->selected_reader
->label
); // reader
719 if(is_network_reader(er
->selected_reader
))
721 dvbapi_net_add_str(packet
, &size
, er
->selected_reader
->device
); // from
725 dvbapi_net_add_str(packet
, &size
, "local"); // from
727 dvbapi_net_add_str(packet
, &size
, reader_get_type_desc(er
->selected_reader
, 1)); // protocol
728 hops
= er
->selected_reader
->currenthops
;
733 dvbapi_net_add_str(packet
, &size
, "Cache"); // reader
734 dvbapi_net_add_str(packet
, &size
, "cache1"); // from
735 dvbapi_net_add_str(packet
, &size
, "none"); // protocol
739 dvbapi_net_add_str(packet
, &size
, "Cache"); // reader
740 dvbapi_net_add_str(packet
, &size
, "cache2"); // from
741 dvbapi_net_add_str(packet
, &size
, "none"); // protocol
745 dvbapi_net_add_str(packet
, &size
, "Cache"); // reader
746 dvbapi_net_add_str(packet
, &size
, "cache3"); // from
747 dvbapi_net_add_str(packet
, &size
, "none"); // protocol
750 packet
[size
++] = hops
; // hops
754 case DVBAPI_CA_GET_DESCR_INFO
:
756 int sct_cadescr_info_size
= sizeof(ca_descr_info_t
);
757 if(client_proto_version
>= 1)
759 ca_descr_info_t
*cadescr_info
= (ca_descr_info_t
*) data
;
760 cadescr_info
->num
= htonl(cadescr_info
->num
);
761 cadescr_info
->type
= htonl(cadescr_info
->type
);
763 memcpy(&packet
[size
], data
, sct_cadescr_info_size
);
764 size
+= sct_cadescr_info_size
;
768 case DVBAPI_CA_SET_DESCR
:
770 int sct_cadescr_size
= sizeof(ca_descr_t
);
771 if(client_proto_version
>= 1)
773 ca_descr_t
*cadesc
= (ca_descr_t
*) data
;
774 cadesc
->index
= htonl(cadesc
->index
);
775 cadesc
->parity
= htonl(cadesc
->parity
);
777 memcpy(&packet
[size
], data
, sct_cadescr_size
);
778 size
+= sct_cadescr_size
;
782 case DVBAPI_CA_SET_PID
:
784 int sct_capid_size
= sizeof(ca_pid_t
);
785 if(client_proto_version
>= 1)
787 ca_pid_t
*capid
= (ca_pid_t
*) data
;
788 capid
->pid
= htonl(capid
->pid
);
789 capid
->index
= htonl(capid
->index
);
791 memcpy(&packet
[size
], data
, sct_capid_size
);
792 size
+= sct_capid_size
;
796 case DVBAPI_CA_SET_DESCR_MODE
:
798 int sct_cadescr_mode_size
= sizeof(ca_descr_mode_t
);
799 if(client_proto_version
>= 1)
801 ca_descr_mode_t
*cadesc_mode
= (ca_descr_mode_t
*) data
;
802 cadesc_mode
->index
= htonl(cadesc_mode
->index
);
803 cadesc_mode
->algo
= htonl(cadesc_mode
->algo
);
804 cadesc_mode
->cipher_mode
= htonl(cadesc_mode
->cipher_mode
);
806 memcpy(&packet
[size
], data
, sct_cadescr_mode_size
);
807 size
+= sct_cadescr_mode_size
;
811 case DVBAPI_CA_SET_DESCR_DATA
:
813 ca_descr_data_t
*cadesc_data
= (ca_descr_data_t
*) data
;
814 uint32_t length
= cadesc_data
->length
;
815 if(client_proto_version
>= 1)
817 cadesc_data
->index
= htonl(cadesc_data
->index
);
818 cadesc_data
->parity
= htonl(cadesc_data
->parity
);
819 cadesc_data
->data_type
= htonl(cadesc_data
->data_type
);
820 cadesc_data
->length
= htonl(cadesc_data
->length
);
822 memcpy(&packet
[size
], &cadesc_data
->index
, 4);
823 memcpy(&packet
[size
+ 4], &cadesc_data
->parity
, 4);
824 memcpy(&packet
[size
+ 8], &cadesc_data
->data_type
, 4);
825 memcpy(&packet
[size
+ 12], &cadesc_data
->length
, 4);
826 memcpy(&packet
[size
+ 16], cadesc_data
->data
, length
);
831 case DVBAPI_DMX_SET_FILTER
:
832 case DVBAPI_DMX_STOP
:
834 int32_t sct_filter_size
= sizeof(struct dmx_sct_filter_params
);
835 packet
[size
++] = demux_id
; // demux id - 1 byte
836 packet
[size
++] = filter_number
; // filter number - 1 byte
837 if(data
) // filter data when starting
839 if(client_proto_version
>= 1)
841 struct dmx_sct_filter_params
*fp
= (struct dmx_sct_filter_params
*)data
;
842 // adding all dmx_sct_filter_params structure fields
843 // one by one to avoid padding problems
844 uint16_t pid
= htons(fp
->pid
);
845 memcpy(&packet
[size
], &pid
, 2);
847 memcpy(&packet
[size
], fp
->filter
.filter
, 16);
849 memcpy(&packet
[size
], fp
->filter
.mask
, 16);
851 memcpy(&packet
[size
], fp
->filter
.mode
, 16);
853 uint32_t timeout
= htonl(fp
->timeout
);
854 memcpy(&packet
[size
], &timeout
, 4);
856 uint32_t flags
= htonl(fp
->flags
);
857 memcpy(&packet
[size
], &flags
, 4);
862 memcpy(&packet
[size
], data
, sct_filter_size
); // dmx_sct_filter_params struct
863 size
+= sct_filter_size
;
866 else // pid when stopping
868 if(client_proto_version
>= 1)
870 uint16_t pid
= htons(demux
[demux_id
].demux_fd
[filter_number
].pid
);
871 memcpy(&packet
[size
], &pid
, 2);
876 uint16_t pid
= demux
[demux_id
].demux_fd
[filter_number
].pid
;
877 packet
[size
++] = pid
>> 8;
878 packet
[size
++] = pid
& 0xff;
884 default: // unknown request
886 cs_log("ERROR: dvbapi_net_send: invalid request");
891 cs_log_dump_dbg(D_DVBAPI
, packet
, size
, "Sending packet to dvbapi client (fd=%d):", socket_fd
);
892 send(socket_fd
, &packet
, size
, MSG_DONTWAIT
);
893 // always returning success as the client could close socket
897 int32_t dvbapi_set_filter(int32_t demux_id
, int32_t api
, uint16_t pid
, uint16_t caid
, uint32_t provid
,
898 uint8_t *filt
, uint8_t *mask
, int32_t timeout
, int32_t pidindex
, int32_t type
, int8_t add_to_emm_list
)
900 int32_t ret
= -1, n
= -1, i
, filterfd
= -1;
902 for(i
= 0; i
< maxfilter
&& demux
[demux_id
].demux_fd
[i
].fd
> 0; i
++) { ; }
906 cs_log_dbg(D_DVBAPI
, "no free filter");
915 openxcas_set_caid(demux
[demux_id
].ECMpids
[pidindex
].CAID
);
916 openxcas_set_ecm_pid(pid
);
919 demux
[demux_id
].demux_fd
[n
].fd
= DUMMY_FD
;
920 demux
[demux_id
].demux_fd
[n
].pidindex
= pidindex
;
921 demux
[demux_id
].demux_fd
[n
].pid
= pid
;
922 demux
[demux_id
].demux_fd
[n
].caid
= caid
;
923 demux
[demux_id
].demux_fd
[n
].provid
= provid
;
924 demux
[demux_id
].demux_fd
[n
].type
= type
;
925 memcpy(demux
[demux_id
].demux_fd
[n
].filter
, filt
, 16); // copy filter to check later on if receiver delivered accordingly
926 memcpy(demux
[demux_id
].demux_fd
[n
].mask
, mask
, 16); // copy mask to check later on if receiver delivered accordingly
934 if(cfg
.dvbapi_listenport
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
936 ret
= filterfd
= DUMMY_FD
;
940 ret
= filterfd
= dvbapi_open_device(0, demux
[demux_id
].demux_index
, demux
[demux_id
].adapter_index
);
945 return ret
; // return if device cant be opened!
948 struct dmx_sct_filter_params sFP2
;
949 memset(&sFP2
, 0, sizeof(sFP2
));
951 sFP2
.timeout
= timeout
;
952 sFP2
.flags
= DMX_IMMEDIATE_START
;
954 if(cfg
.dvbapi_boxtype
== BOXTYPE_NEUMO
)
956 //DeepThought: on dgs/cubestation and neumo images, perhaps others
957 //the following code is needed to descramble
958 sFP2
.filter
.filter
[0] = filt
[0];
959 sFP2
.filter
.mask
[0] = mask
[0];
960 sFP2
.filter
.filter
[1] = 0;
961 sFP2
.filter
.mask
[1] = 0;
962 sFP2
.filter
.filter
[2] = 0;
963 sFP2
.filter
.mask
[2] = 0;
964 memcpy(sFP2
.filter
.filter
+ 3, filt
+ 1, 16 - 3);
965 memcpy(sFP2
.filter
.mask
+ 3, mask
+ 1, 16 - 3);
967 //DeepThought: in the drivers of the dgs/cubestation and neumo images,
968 //dvbapi 1 and 3 are somehow mixed. In the kernel drivers, the DMX_SET_FILTER
969 //ioctl expects to receive a dmx_sct_filter_params structure (DVBAPI 3) but
970 //due to a bug its sets the "positive mask" wrongly (they should be all 0).
971 //On the other hand, the DMX_SET_FILTER1 ioctl also uses the dmx_sct_filter_params
972 //structure, which is incorrect (it should be dmxSctFilterParams).
973 //The only way to get it right is to call DMX_SET_FILTER1 with the argument
974 //expected by DMX_SET_FILTER. Otherwise, the timeout parameter is not passed correctly.
975 ret
= dvbapi_ioctl(filterfd
, DMX_SET_FILTER1
, &sFP2
);
979 memcpy(sFP2
.filter
.filter
, filt
, 16);
980 memcpy(sFP2
.filter
.mask
, mask
, 16);
981 if(cfg
.dvbapi_listenport
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
983 ret
= dvbapi_net_send(DVBAPI_DMX_SET_FILTER
,
984 demux
[demux_id
].socket_fd
,
991 demux
[demux_id
].client_proto_version
);
995 ret
= dvbapi_ioctl(filterfd
, DMX_SET_FILTER
, &sFP2
);
1003 ret
= filterfd
= dvbapi_open_device(0, demux
[demux_id
].demux_index
, demux
[demux_id
].adapter_index
);
1004 if(ret
< 0) { return ret
; } // return if device cant be opened!
1006 struct dmxSctFilterParams sFP1
;
1007 memset(&sFP1
, 0, sizeof(sFP1
));
1009 sFP1
.timeout
= timeout
;
1010 sFP1
.flags
= DMX_IMMEDIATE_START
;
1011 memcpy(sFP1
.filter
.filter
, filt
, 16);
1012 memcpy(sFP1
.filter
.mask
, mask
, 16);
1013 ret
= dvbapi_ioctl(filterfd
, DMX_SET_FILTER1
, &sFP1
);
1017 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
1020 ret
= filterfd
= stapi_set_filter(demux_id
, pid
, filt
, mask
, n
, demux
[demux_id
].pmt_file
);
1023 ret
= -1; // error setting filter!
1029 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
1032 ret
= filterfd
= coolapi_open_device(demux
[demux_id
].demux_index
, demux_id
);
1035 ret
= coolapi_set_filter(filterfd
, n
, pid
, filt
, mask
, type
);
1049 if(ret
!= -1) // filter set successful
1051 // only register if filter was set successful
1052 demux
[demux_id
].demux_fd
[n
].fd
= filterfd
;
1053 demux
[demux_id
].demux_fd
[n
].pidindex
= pidindex
;
1054 demux
[demux_id
].demux_fd
[n
].pid
= pid
;
1055 demux
[demux_id
].demux_fd
[n
].caid
= caid
;
1056 demux
[demux_id
].demux_fd
[n
].provid
= provid
;
1057 demux
[demux_id
].demux_fd
[n
].type
= type
;
1059 // copy filter and mask to check later on if receiver delivered accordingly
1060 memcpy(demux
[demux_id
].demux_fd
[n
].filter
, filt
, 16);
1061 memcpy(demux
[demux_id
].demux_fd
[n
].mask
, mask
, 16);
1063 cs_log_dbg(D_DVBAPI
, "Demuxer %d Filter %d started successfully (caid %04X provid %06X pid %04X)",
1064 demux_id
, n
+ 1, caid
, provid
, pid
);
1066 if(type
== TYPE_EMM
&& add_to_emm_list
)
1068 add_emmfilter_to_list(demux_id
, filt
, caid
, provid
, pid
, n
+ 1, true);
1073 cs_log("ERROR: Could not start demux filter (api: %d errno=%d %s)", selected_api
, errno
, strerror(errno
));
1079 * Get number of available descramblers from box. On success, it stores result on
1080 * global variable "ca_descramblers_total". On failure, it uses a safe default value.
1082 static int32_t dvbapi_get_descrambler_info(void)
1084 // In enigma2 all ca devices are listed under adapter0. In addition we only
1085 // need to ask one ca device to get the total number of descramblers. In
1086 // PC installations, there are no ca devices, so we use a predefined value.
1088 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
1090 ca_descramblers_total
= INDEX_MAX_NET
;
1091 return 1; // nothing else to do for PCs
1094 int32_t fd
= 0, ca_offset
= 0;
1095 char device_path
[128], device_path2
[128];
1096 struct ca_descr_info descr_info
;
1097 memset(&descr_info
, 0, sizeof(descr_info
));
1099 // Use a safe default in case we fail to get the exact number
1100 ca_descramblers_total
= INDEX_MAX_LOCAL
;
1102 if(cfg
.dvbapi_boxtype
== BOXTYPE_DUCKBOX
||
1103 cfg
.dvbapi_boxtype
== BOXTYPE_DBOX2
||
1104 cfg
.dvbapi_boxtype
== BOXTYPE_UFS910
)
1109 // Ask device for exact number of ca descramblers
1110 snprintf(device_path2
, sizeof(device_path2
), devices
[selected_box
].ca_device
, ca_offset
);
1111 snprintf(device_path
, sizeof(device_path
), devices
[selected_box
].path
, 0);
1112 strncat(device_path
, device_path2
, sizeof(device_path
) - strlen(device_path
));
1114 if((fd
= open(device_path
, O_RDWR
| O_NONBLOCK
)) < 0)
1116 cs_log("ERROR: Can't open device %s (errno=%d %s)", device_path
, errno
, strerror(errno
));
1120 if(dvbapi_ioctl(fd
, CA_GET_DESCR_INFO
, &descr_info
) < 0)
1122 cs_log("ERROR: ioctl(CA_GET_DESCR_INFO): %s", strerror(errno
));
1127 cs_log("ERROR: Can't close device %s (errno=%d %s)", device_path
, errno
, strerror(errno
));
1130 // We got a valid response from device (count the ECD type only)
1131 if(descr_info
.num
> 0 && (descr_info
.type
& 1))
1133 ca_descramblers_total
= descr_info
.num
;
1134 cs_log("Detected %s device, total available descramblers: %d", device_path
, ca_descramblers_total
);
1141 static int32_t dvbapi_detect_api(void)
1143 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
1144 selected_api
= COOLAPI
;
1145 selected_box
= BOX_INDEX_COOLSTREAM
;
1146 disable_pmt_files
= 1;
1147 cfg
.dvbapi_listenport
= 0;
1148 cs_log("Detected Coolstream API");
1151 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC
)
1153 selected_api
= DVBAPI_3
;
1154 selected_box
= BOX_INDEX_DREAMBOX_DVBAPI3
;
1155 if(cfg
.dvbapi_listenport
)
1157 cs_log("Using TCP listen socket, API forced to DVBAPIv3 (%d), userconfig boxtype: %d",
1158 selected_api
, cfg
.dvbapi_boxtype
);
1162 cs_log("Using %s listen socket, API forced to DVBAPIv3 (%d), userconfig boxtype: %d",
1163 devices
[selected_box
].cam_socket_path
, selected_api
, cfg
.dvbapi_boxtype
);
1167 else if(cfg
.dvbapi_boxtype
== BOXTYPE_SAMYGO
)
1169 selected_api
= DVBAPI_3
;
1170 selected_box
= BOX_INDEX_QBOXHD
;
1171 cfg
.dvbapi_listenport
= 0;
1172 disable_pmt_files
= 1;
1173 cs_log("Using SamyGO dvbapi v0.1");
1178 cfg
.dvbapi_listenport
= 0;
1181 int32_t i
= 0, n
= 0, devnum
= -1, dmx_fd
= 0, filtercount
= 0;
1182 char device_path
[128], device_path2
[128];
1183 static LLIST
*ll_max_fd
;
1184 ll_max_fd
= ll_create("ll_max_fd");
1191 struct s_open_fd
*open_fd
;
1193 while(i
< BOX_COUNT
)
1197 snprintf(device_path2
, sizeof(device_path2
), devices
[i
].demux_device
, 0);
1198 snprintf(device_path
, sizeof(device_path
), devices
[i
].path
, n
);
1199 strncat(device_path
, device_path2
, sizeof(device_path
) - strlen(device_path
));
1202 while((dmx_fd
= open(device_path
, O_RDWR
| O_NONBLOCK
)) > 0 && filtercount
< MAX_FILTER
)
1205 if(!cs_malloc(&open_fd
, sizeof(struct s_open_fd
)))
1210 open_fd
->fd
= dmx_fd
;
1211 ll_append(ll_max_fd
, open_fd
);
1216 itr
= ll_iter_create(ll_max_fd
);
1217 while((open_fd
= ll_iter_next(&itr
)))
1219 dmx_fd
= open_fd
->fd
;
1224 while(close(dmx_fd
) < 0);
1225 ll_iter_remove_data(&itr
);
1228 selected_api
= devices
[devnum
].api
;
1229 selected_box
= devnum
;
1231 if(cfg
.dvbapi_boxtype
== BOXTYPE_NEUMO
)
1233 selected_api
= DVBAPI_3
; //DeepThought
1236 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
1237 if(selected_api
== STAPI
&& stapi_open() == 0)
1239 cs_log("ERROR: stapi: setting up stapi failed.");
1243 maxfilter
= filtercount
;
1244 cs_log("Detected %s Api: %d, userconfig boxtype: %d maximum number of filters is %d (oscam limit is %d)",
1245 device_path
, selected_api
, cfg
.dvbapi_boxtype
, filtercount
, MAX_FILTER
);
1248 // try at least 8 adapters
1249 if((strchr(devices
[i
].path
, '%') != NULL
) && (n
< 8))
1258 } while(n
!= 0); // n is set to 0 again if 8 adapters are tried!
1262 break; // check if box detected
1266 ll_destroy(&ll_max_fd
);
1276 static int32_t dvbapi_read_device(int32_t dmx_fd
, uint8_t *buf
, uint32_t length
)
1280 struct pollfd pfd
[1];
1283 pfd
[0].events
= (POLLIN
| POLLPRI
);
1285 while(count
< length
)
1287 if(poll(pfd
, 1, 0)) // fd ready for reading?
1289 if(pfd
[0].revents
& (POLLIN
| POLLPRI
)) // is there data to read?
1291 readed
= read(dmx_fd
, &buf
[count
], length
-count
);
1292 if(readed
< 0) // error occured while reading
1294 if(errno
== EINTR
|| errno
== EAGAIN
) // try again in case of interrupt
1299 cs_log("ERROR: Read error on fd %d (errno=%d %s)", dmx_fd
, errno
, strerror(errno
));
1300 return (errno
== EOVERFLOW
? 0 : -1);
1303 if(readed
> 0) // succesfull read
1308 if(readed
== 0 && count
> 0) // nothing to read left
1315 return -1; // other events than pollin/pri means bad news -> abort!
1323 cs_log_dump_dbg(D_TRACE
, buf
, count
, "Received:");
1327 int32_t dvbapi_open_device(int32_t type
, int32_t num
, int32_t adapter
)
1329 int32_t dmx_fd
, ret
;
1330 int32_t ca_offset
= 0;
1331 char device_path
[128], device_path2
[128];
1333 if(cfg
.dvbapi_listenport
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
1340 snprintf(device_path2
, sizeof(device_path2
), devices
[selected_box
].demux_device
, num
);
1341 snprintf(device_path
, sizeof(device_path
), devices
[selected_box
].path
, adapter
);
1342 strncat(device_path
, device_path2
, sizeof(device_path
) - strlen(device_path
));
1346 if(cfg
.dvbapi_boxtype
== BOXTYPE_DUCKBOX
1347 || cfg
.dvbapi_boxtype
== BOXTYPE_DBOX2
1348 || cfg
.dvbapi_boxtype
== BOXTYPE_UFS910
)
1353 if(cfg
.dvbapi_boxtype
== BOXTYPE_QBOXHD
1354 || cfg
.dvbapi_boxtype
== BOXTYPE_PC
1355 || cfg
.dvbapi_boxtype
== BOXTYPE_SAMYGO
)
1360 snprintf(device_path2
, sizeof(device_path2
), devices
[selected_box
].ca_device
, num
+ ca_offset
);
1361 snprintf(device_path
, sizeof(device_path
), devices
[selected_box
].path
, adapter
);
1362 strncat(device_path
, device_path2
, sizeof(device_path
) - strlen(device_path
));
1365 if(cfg
.dvbapi_boxtype
== BOXTYPE_SAMYGO
)
1369 struct sockaddr_un saddr
;
1370 memset(&saddr
, 0, sizeof(saddr
));
1371 saddr
.sun_family
= AF_UNIX
;
1372 cs_strncpy(saddr
.sun_path
, device_path
, sizeof(saddr
.sun_path
));
1373 dmx_fd
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1374 ret
= connect(dmx_fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
1382 int32_t udp_port
= 9000;
1383 struct sockaddr_in saddr
;
1384 memset(&saddr
, 0, sizeof(saddr
));
1385 saddr
.sin_family
= AF_INET
;
1386 saddr
.sin_port
= htons(udp_port
+ adapter
);
1387 saddr
.sin_addr
.s_addr
= inet_addr("127.0.0.1");
1388 dmx_fd
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_UDP
);
1389 set_nonblock(dmx_fd
, true);
1390 ret
= connect(dmx_fd
, (struct sockaddr
*) &saddr
, sizeof(saddr
));
1395 cs_log_dbg(D_DVBAPI
, "NET DEVICE open (port = %d) fd %d", udp_port
+ adapter
, dmx_fd
);
1404 dmx_fd
= ret
= open(device_path
, O_RDWR
| O_NONBLOCK
);
1409 cs_log("ERROR: Can't open device %s (errno=%d %s)", device_path
, errno
, strerror(errno
));
1412 cs_log_dbg(D_DVBAPI
, "Open device %s (fd %d)", device_path
, dmx_fd
);
1416 uint16_t tunemm_caid_map(uint8_t direct
, uint16_t caid
, uint16_t srvid
)
1419 struct s_client
*cl
= cur_client();
1420 TUNTAB
*ttab
= &cl
->ttab
;
1429 for(i
= 0; i
< ttab
->ttnum
; i
++)
1431 if(caid
== ttab
->ttdata
[i
].bt_caidto
&&
1432 (srvid
== ttab
->ttdata
[i
].bt_srvid
|| ttab
->ttdata
[i
].bt_srvid
== 0xFFFF || !ttab
->ttdata
[i
].bt_srvid
))
1434 return ttab
->ttdata
[i
].bt_caidfrom
;
1440 for(i
= 0; i
< ttab
->ttnum
; i
++)
1442 if(caid
== ttab
->ttdata
[i
].bt_caidfrom
&&
1443 (srvid
== ttab
->ttdata
[i
].bt_srvid
|| ttab
->ttdata
[i
].bt_srvid
== 0xFFFF || !ttab
->ttdata
[i
].bt_srvid
))
1445 return ttab
->ttdata
[i
].bt_caidto
;
1452 int32_t dvbapi_stop_filter(int32_t demux_id
, int32_t type
, uint32_t msgid
)
1454 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
1455 // We prevented PAT and PMT from starting, so lets don't close them either.
1456 if(type
== TYPE_PAT
|| type
== TYPE_PMT
)
1462 int32_t g
, error
= 0;
1464 // just stop them all, we don't want to risk leaving
1465 // any stale filter running due to lowering of maxfilters
1466 for(g
= 0; g
< MAX_FILTER
; g
++)
1468 if(demux
[demux_id
].demux_fd
[g
].type
== type
)
1470 if(dvbapi_stop_filternum(demux_id
, g
, msgid
) == -1)
1476 return !error
; // on error return 0, all ok 1
1479 int32_t dvbapi_stop_filternum(int32_t demux_id
, int32_t num
, uint32_t msgid
)
1481 int32_t retfilter
= -1, retfd
= -1, fd
= demux
[demux_id
].demux_fd
[num
].fd
, try = 0;
1485 demux
[demux_id
].demux_fd
[num
].type
= 0;
1486 demux
[demux_id
].demux_fd
[num
].fd
= 0;
1487 return 1; // all ok!
1501 cs_log_dbg(D_DVBAPI
, "Demuxer %d stop filter %d try %d (fd: %d api: %d, caid: %04X, provid: %06X, %spid: %04X)",
1507 demux
[demux_id
].demux_fd
[num
].caid
,
1508 demux
[demux_id
].demux_fd
[num
].provid
,
1509 demux
[demux_id
].demux_fd
[num
].type
== TYPE_ECM
? "ecm" : "emm",
1510 demux
[demux_id
].demux_fd
[num
].pid
);
1512 switch(selected_api
)
1516 if(cfg
.dvbapi_listenport
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
1518 retfilter
= dvbapi_net_send(DVBAPI_DMX_STOP
,
1519 demux
[demux_id
].socket_fd
,
1526 demux
[demux_id
].client_proto_version
);
1530 retfilter
= dvbapi_ioctl(fd
, DMX_STOP
, NULL
);
1537 retfilter
= dvbapi_ioctl(fd
, DMX_STOP
, NULL
);
1541 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
1544 retfilter
= stapi_remove_filter(demux_id
, num
, demux
[demux_id
].pmt_file
);
1545 if(retfilter
!= 1) // stapi returns 0 for error, 1 for all ok
1552 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
1555 retfilter
= coolapi_remove_filter(fd
, num
);
1558 retfd
= coolapi_close_device(fd
);
1567 if(errno
== 9) // no error on bad file descriptor
1571 } while(retfilter
< 0 && try < 10);
1573 #if !defined WITH_COOLAPI && !defined WITH_COOLAPI2 // no fd close for coolapi and stapi, all others do close fd!
1584 // on bad filterfd dont try to close!
1585 if(!cfg
.dvbapi_listenport
&& cfg
.dvbapi_boxtype
!= BOXTYPE_PC_NODMX
&& errno
!= 9)
1587 if(selected_api
== STAPI
)
1589 retfd
= 0; // stapi closes its own filter fd!
1593 // flush filter input buffer in attempt to avoid overflow receivers internal buffer
1594 flush_read_fd(demux_id
, num
, fd
);
1598 retfd
= 0; // no error on bad file descriptor
1607 } while(retfd
< 0 && try < 10);
1612 return 1; // filter was already killed!
1615 if(retfilter
< 0) // error on remove filter
1617 cs_log("ERROR: Demuxer %d could not stop Filter %d (fd:%d api:%d errno=%d %s)",
1618 demux_id
, num
+ 1, fd
, selected_api
, errno
, strerror(errno
));
1622 if(retfd
< 0) // error on close filter fd
1624 cs_log("ERROR: Demuxer %d could not close fd of Filter %d (fd=%d api:%d errno=%d %s)",
1625 demux_id
, num
+ 1, fd
, selected_api
, errno
, strerror(errno
));
1629 // code below runs only if nothing has gone wrong
1630 if(demux
[demux_id
].demux_fd
[num
].type
== TYPE_ECM
) // ecm filter stopped: reset index!
1632 int32_t oldpid
= demux
[demux_id
].demux_fd
[num
].pidindex
;
1633 int32_t curpid
= demux
[demux_id
].pidindex
;
1635 // workaround: below dont run on stapi since it handles it own pids...
1636 // stapi need to be better integrated in oscam dvbapi.
1637 if(selected_api
!= STAPI
)
1640 for(z
= 0; z
< MAX_STREAM_INDICES
; z
++)
1642 uint32_t idx
= demux
[demux_id
].ECMpids
[oldpid
].index
[z
];
1643 demux
[demux_id
].ECMpids
[oldpid
].index
[z
] = INDEX_INVALID
;
1645 if(idx
!= INDEX_INVALID
) // if in use
1648 for(i
= 0; i
< demux
[demux_id
].STREAMpidcount
; i
++)
1652 // check streams of old disabled ecmpid
1653 if(!demux
[demux_id
].ECMpids
[oldpid
].streams
1654 || ((demux
[demux_id
].ECMpids
[oldpid
].streams
& (1 << i
)) == (uint
) (1 << i
)))
1656 // check if new ecmpid is using same streams
1657 if(curpid
!= -1 && (!demux
[demux_id
].ECMpids
[curpid
].streams
1658 || ((demux
[demux_id
].ECMpids
[curpid
].streams
& (1 << i
)) == (uint
) (1 << i
))))
1660 continue; // found same stream on old and new ecmpid -> skip! (and leave it enabled!)
1662 int32_t pidtobestopped
= demux
[demux_id
].STREAMpids
[i
];
1663 int32_t j
, k
, otherdemuxpid
;
1664 uint32_t otherdemuxidx
;
1666 for(j
= 0; j
< MAX_DEMUX
; j
++) // check other demuxers for same streampid with same index
1668 if(demux
[j
].program_number
== 0 || demux_id
== j
|| demux
[j
].ca_mask
!= demux
[demux_id
].ca_mask
)
1671 // skip empty demuxers
1672 // skip same demuxer
1673 // skip streampid running on other ca device
1676 otherdemuxpid
= demux
[j
].pidindex
;
1677 if(otherdemuxpid
== -1)
1679 continue; // Other demuxer not descrambling yet
1683 for(y
= 0; y
< MAX_STREAM_INDICES
; y
++)
1685 otherdemuxidx
= demux
[j
].ECMpids
[otherdemuxpid
].index
[y
];
1686 if(otherdemuxidx
== INDEX_INVALID
|| otherdemuxidx
!= idx
)
1688 continue; // Other demuxer has no index yet, or index is different
1691 for(k
= 0; k
< demux
[j
].STREAMpidcount
; k
++)
1693 if(!demux
[j
].ECMpids
[otherdemuxpid
].streams
1694 || ((demux
[j
].ECMpids
[otherdemuxpid
].streams
& (1 << k
)) == (uint
) (1 << k
)))
1696 if(demux
[j
].STREAMpids
[k
] == pidtobestopped
)
1698 continue; // found same streampid enabled with same index
1699 // on one or more other demuxers -> skip! (and leave it enabled!)
1702 match
= 1; // matching stream found
1709 for(j
= 0; j
< CA_MAX
; j
++)
1711 if(((demux
[demux_id
].ca_mask
& (1 << j
)) == (uint32_t) (1 << j
)))
1713 remove_streampid_from_list(j
, pidtobestopped
, idx
);
1725 if(demux
[demux_id
].demux_fd
[num
].type
== TYPE_EMM
) // If emm type remove from emm filterlist
1727 remove_emmfilter_from_list(demux_id
,
1728 demux
[demux_id
].demux_fd
[num
].caid
,
1729 demux
[demux_id
].demux_fd
[num
].provid
,
1730 demux
[demux_id
].demux_fd
[num
].pid
,
1733 demux
[demux_id
].demux_fd
[num
].type
= 0;
1734 demux
[demux_id
].demux_fd
[num
].fd
= 0;
1735 return 1; // all ok!
1738 void dvbapi_start_filter(int32_t demux_id
, int32_t pidindex
, uint16_t pid
, uint16_t caid
,
1739 uint32_t provid
, uint8_t table
, uint8_t mask
, int32_t timeout
, int32_t type
)
1742 for(i
= 0; i
< maxfilter
; i
++) // check if filter is present
1744 if(demux
[demux_id
].demux_fd
[i
].fd
> 0 &&
1745 demux
[demux_id
].demux_fd
[i
].pid
== pid
&&
1746 demux
[demux_id
].demux_fd
[i
].type
== type
&&
1747 demux
[demux_id
].demux_fd
[i
].filter
[0] == table
&&
1748 demux
[demux_id
].demux_fd
[i
].mask
[0] == mask
)
1755 memset(filter
, 0, 32);
1759 cs_log_dbg(D_DVBAPI
, "Demuxer %d try to start new filter for caid: %04X, provid: %06X, pid: %04X",
1760 demux_id
, caid
, provid
, pid
);
1762 dvbapi_set_filter(demux_id
, selected_api
, pid
, caid
, provid
, filter
, filter
+ 16, timeout
, pidindex
, type
, 0);
1765 void dvbapi_start_sdt_filter(int32_t demux_id
)
1767 dvbapi_start_filter(demux_id
, demux
[demux_id
].pidindex
, 0x0011, 0x001, 0x01, 0x42, 0xFF, 0, TYPE_SDT
);
1768 demux
[demux_id
].sdt_filter
= 0;
1771 void dvbapi_start_pat_filter(int32_t demux_id
)
1773 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
1774 // PAT-Filter breaks API and OSCAM for Coolstream.
1778 dvbapi_start_filter(demux_id
, demux
[demux_id
].pidindex
, 0x0000, 0x001, 0x01, 0x00, 0xFF, 0, TYPE_PAT
);
1781 void dvbapi_start_pmt_filter(int32_t demux_id
)
1783 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
1784 // PMT-Filter breaks API and OSCAM for Coolstream.
1788 uint8_t filter
[16], mask
[16];
1789 memset(filter
, 0, 16);
1790 memset(mask
, 0, 16);
1793 i2b_buf(2, demux
[demux_id
].program_number
, filter
+ 1); // add srvid to filter since the pid can deliver pmt for multiple srvid
1798 dvbapi_set_filter(demux_id
, selected_api
, demux
[demux_id
].pmtpid
, 0x001, 0x01, filter
, mask
, 0, 0, TYPE_PMT
, 0);
1801 void dvbapi_start_cat_filter(int32_t demux_id
)
1803 dvbapi_start_filter(demux_id
, demux
[demux_id
].pidindex
, 0x0001, 0x001, 0x01, 0x01, 0xFF, 0, TYPE_CAT
);
1804 demux
[demux_id
].emm_filter
= 0;
1807 void dvbapi_start_emm_filter(int32_t demux_id
)
1810 if(!demux
[demux_id
].EMMpidcount
)
1815 struct s_csystem_emm_filter
*dmx_filter
= NULL
;
1816 unsigned int filter_count
= 0;
1817 uint16_t caid
, ncaid
;
1819 struct s_reader
*rdr
= NULL
;
1820 struct s_client
*cl
= cur_client();
1822 if(!cl
|| !cl
->aureader_list
)
1827 LL_ITER itr
= ll_iter_create(cl
->aureader_list
);
1828 while((rdr
= ll_iter_next(&itr
)))
1830 if(!(rdr
->grp
& cl
->grp
))
1835 if(rdr
->audisabled
|| !rdr
->enable
|| (!is_network_reader(rdr
) && rdr
->card_status
!= CARD_INSERTED
))
1840 const struct s_cardsystem
*csystem
;
1842 cs_log_dbg(D_DVBAPI
, "Demuxer %d matching reader %s against available emmpids -> START!", demux_id
, rdr
->label
);
1844 for(c
= 0; c
< demux
[demux_id
].EMMpidcount
; c
++)
1846 caid
= ncaid
= demux
[demux_id
].EMMpids
[c
].CAID
;
1849 if(chk_is_betatunnel_caid(caid
) == 2)
1851 ncaid
= tunemm_caid_map(FROM_TO
, caid
, demux
[demux_id
].program_number
);
1853 provid
= demux
[demux_id
].EMMpids
[c
].PROVID
;
1857 match
= emm_reader_match(rdr
, caid
, provid
);
1861 match
= emm_reader_match(rdr
, ncaid
, provid
);
1866 if(rdr
->typ
== R_EMU
)
1868 csystem
= rdr
->csystem
;
1872 csystem
= get_cardsystem_by_caid(caid
);
1878 csystem
= get_cardsystem_by_caid(ncaid
);
1879 if(csystem
&& csystem
->get_tunemm_filter
)
1881 csystem
->get_tunemm_filter(rdr
, &dmx_filter
, &filter_count
);
1882 cs_log_dbg(D_DVBAPI
, "Demuxer %d setting emm filter for betatunnel: %04X -> %04X",
1883 demux_id
, ncaid
, caid
);
1887 cs_log_dbg(D_DVBAPI
, "Demuxer %d cardsystem for emm filter for caid %04X of reader %s not found",
1888 demux_id
, ncaid
, rdr
->label
);
1892 else if(csystem
->get_emm_filter
)
1894 if(rdr
->typ
== R_EMU
)
1896 csystem
->get_emm_filter_adv(rdr
, &dmx_filter
, &filter_count
, caid
, provid
, demux
[demux_id
].program_number
,
1897 demux
[demux_id
].tsid
, demux
[demux_id
].onid
, demux
[demux_id
].ens
);
1901 csystem
->get_emm_filter(rdr
, &dmx_filter
, &filter_count
);
1907 cs_log_dbg(D_DVBAPI
, "Demuxer %d cardsystem for emm filter for caid %04X of reader %s not found",
1908 demux_id
, caid
, rdr
->label
);
1912 for(j
= 0; j
< filter_count
; j
++)
1914 if(dmx_filter
[j
].enabled
== 0)
1920 memset(filter
, 0, sizeof(filter
)); // reset filter
1921 uint32_t usefilterbytes
= 16; // default use all filters
1922 memcpy(filter
, dmx_filter
[j
].filter
, usefilterbytes
);
1923 memcpy(filter
+ 16, dmx_filter
[j
].mask
, usefilterbytes
);
1924 int32_t emmtype
= dmx_filter
[j
].type
;
1926 if(filter
[0] && (((1 << (filter
[0] % 0x80)) & rdr
->b_nano
) && !((1 << (filter
[0] % 0x80)) & rdr
->s_nano
)))
1928 cs_log_dbg(D_DVBAPI
, "Demuxer %d reader %s emmfilter %d/%d blocked by userconfig -> SKIP!",
1929 demux_id
, rdr
->label
, j
+ 1, filter_count
);
1933 if((rdr
->blockemm
& emmtype
) && !(((1 << (filter
[0] % 0x80)) & rdr
->s_nano
) || (rdr
->saveemm
& emmtype
)))
1935 cs_log_dbg(D_DVBAPI
, "Demuxer %d reader %s emmfilter %d/%d blocked by userconfig -> SKIP!",
1936 demux_id
, rdr
->label
, j
+ 1, filter_count
);
1940 if(demux
[demux_id
].EMMpids
[c
].type
& emmtype
)
1942 cs_log_dbg(D_DVBAPI
, "Demuxer %d reader %s emmfilter %d/%d type match -> ENABLE!",
1943 demux_id
, rdr
->label
, j
+ 1, filter_count
);
1944 check_add_emmpid(demux_id
, filter
, c
, emmtype
);
1948 cs_log_dbg(D_DVBAPI
, "Demuxer %d reader %s emmfilter %d/%d type mismatch -> SKIP!",
1949 demux_id
, rdr
->label
, j
+ 1, filter_count
);
1952 // dmx_filter not use below this point;
1953 NULLFREE(dmx_filter
);
1957 cs_log_dbg(D_DVBAPI
, "Demuxer %d matching reader %s against available emmpids -> DONE!", demux_id
, rdr
->label
);
1960 if(demux
[demux_id
].emm_filter
== -1) // first run -1
1962 demux
[demux_id
].emm_filter
= 0;
1964 cs_log_dbg(D_DVBAPI
, "Demuxer %d handles %i emm filters", demux_id
, demux
[demux_id
].emm_filter
);
1967 void dvbapi_add_ecmpid_int(int32_t demux_id
, uint16_t caid
, uint16_t ecmpid
, uint32_t provid
, uint32_t cadata
, char *txt
)
1969 int32_t n
, added
= 0;
1970 int32_t stream
= demux
[demux_id
].STREAMpidcount
- 1;
1972 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
1974 if(demux
[demux_id
].ECMpids
[n
].CAID
== caid
&& demux
[demux_id
].ECMpids
[n
].ECM_PID
== ecmpid
1975 && (!provid
|| (provid
&& demux
[demux_id
].ECMpids
[n
].PROVID
== provid
)))
1980 if(!demux
[demux_id
].ECMpids
[n
].streams
)
1982 // we already got this caid/ecmpid as global, no need to add the single stream
1983 cs_log_dbg(D_DVBAPI
, "Demuxer %d skipped stream CAID: %04X ECM_PID: %04X PROVID: %06X (Same as ECMPID %d)",
1984 demux_id
, caid
, ecmpid
, provid
, n
);
1987 demux
[demux_id
].ECMpids
[n
].streams
|= (1 << stream
);
1988 cs_log("Demuxer %d added stream to ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X",
1989 demux_id
, n
, caid
, ecmpid
, provid
);
1999 if(demux
[demux_id
].ECMpidcount
>= MAX_ECM_PIDS
)
2001 cs_log("We reached maximum ECMpids: unable to add to demuxer %d ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X %s",
2002 demux_id
, demux
[demux_id
].ECMpidcount
, caid
, ecmpid
, provid
, txt
);
2006 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].ECM_PID
= ecmpid
;
2007 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].CAID
= caid
;
2008 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].PROVID
= provid
;
2009 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].CHID
= 0x10000; // reset CHID
2010 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].checked
= 0;
2011 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].status
= 0;
2012 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].tries
= 0xFE;
2013 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].streams
= 0; // reset streams!
2014 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].irdeto_curindex
= 0xFE; // reset
2015 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].irdeto_maxindex
= 0; // reset
2016 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].irdeto_cycle
= 0xFE; // reset
2017 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].table
= 0;
2018 demux
[demux_id
].ECMpids
[demux
[demux_id
].ECMpidcount
].cadata
= cadata
;
2020 cs_log("Demuxer %d ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X %s",
2021 demux_id
, demux
[demux_id
].ECMpidcount
, caid
, ecmpid
, provid
, txt
);
2023 // marker to fetch emms early irdeto needs them!
2024 if(caid_is_irdeto(caid
) || (caid_is_dre(caid
) && (provid
== 0x11 || provid
== 0xFE)))
2026 demux
[demux_id
].emmstart
.time
= 1;
2028 demux
[demux_id
].ECMpidcount
++;
2031 void dvbapi_add_ecmpid(int32_t demux_id
, uint16_t caid
, uint16_t ecmpid
, uint32_t provid
, uint32_t cadata
, char *txt
)
2033 dvbapi_add_ecmpid_int(demux_id
, caid
, ecmpid
, provid
, cadata
, txt
);
2034 struct s_dvbapi_priority
*joinentry
;
2036 for(joinentry
= dvbapi_priority
; joinentry
!= NULL
; joinentry
= joinentry
->next
)
2038 if((joinentry
->type
!= 'j')
2039 || (joinentry
->caid
&& joinentry
->caid
!= caid
)
2040 || (joinentry
->provid
&& joinentry
->provid
!= provid
)
2041 || (joinentry
->ecmpid
&& joinentry
->ecmpid
!= ecmpid
)
2042 || (joinentry
->srvid
&& joinentry
->srvid
!= demux
[demux_id
].program_number
))
2047 cs_log_dbg(D_DVBAPI
, "Join ecmpid %04X@%06X:%04X to %04X@%06X:%04X",
2048 caid
, provid
, ecmpid
, joinentry
->mapcaid
, joinentry
->mapprovid
, joinentry
->mapecmpid
);
2049 dvbapi_add_ecmpid_int(demux_id
, joinentry
->mapcaid
, joinentry
->mapecmpid
, joinentry
->mapprovid
, 0, txt
);
2053 void dvbapi_add_emmpid(int32_t demux_id
, uint16_t caid
, uint16_t emmpid
, uint32_t provid
, uint32_t cadata
, uint8_t type
)
2056 char cadatatext
[40];
2057 cs_strncpy(typetext
, ":", sizeof(typetext
));
2059 if(type
& 0x01) { strcat(typetext
, "UNIQUE:"); }
2060 if(type
& 0x02) { strcat(typetext
, "SHARED:"); }
2061 if(type
& 0x04) { strcat(typetext
, "GLOBAL:"); }
2062 if(type
& 0xF8) { strcat(typetext
, "UNKNOWN:"); }
2066 snprintf(cadatatext
, 40, " CA DATA %X ", cadata
);
2070 cadatatext
[0] = '\t'; cadatatext
[1] = '\0';
2073 if(caid
== 0x4AE1 && provid
== 0x11 && cadata
== 0)
2079 for(i
= 0; i
< demux
[demux_id
].EMMpidcount
; i
++)
2081 if(demux
[demux_id
].EMMpids
[i
].PID
== emmpid
&& demux
[demux_id
].EMMpids
[i
].CAID
== caid
&&
2082 demux
[demux_id
].EMMpids
[i
].PROVID
== provid
&& demux
[demux_id
].EMMpids
[i
].cadata
== cadata
)
2084 if(!(demux
[demux_id
].EMMpids
[i
].type
& type
))
2086 demux
[demux_id
].EMMpids
[i
].type
|= type
; // register this emm kind to this emmpid
2087 cs_log_dbg(D_DVBAPI
, "Added to existing emmpid %d additional emmtype %s",
2088 demux
[demux_id
].EMMpidcount
- 1, typetext
);
2094 if(i
< MAX_EMM_PIDS
)
2096 demux
[demux_id
].EMMpids
[demux
[demux_id
].EMMpidcount
].PID
= emmpid
;
2097 demux
[demux_id
].EMMpids
[demux
[demux_id
].EMMpidcount
].CAID
= caid
;
2098 demux
[demux_id
].EMMpids
[demux
[demux_id
].EMMpidcount
].PROVID
= provid
;
2099 demux
[demux_id
].EMMpids
[demux
[demux_id
].EMMpidcount
].type
= type
;
2100 demux
[demux_id
].EMMpids
[demux
[demux_id
].EMMpidcount
++].cadata
= cadata
;
2101 cs_log_dbg(D_DVBAPI
, "Added new emmpid %d CAID: %04X EMM_PID: %04X PROVID: %06X%sTYPE %s",
2102 demux
[demux_id
].EMMpidcount
- 1, caid
, emmpid
, provid
, cadatatext
, typetext
);
2106 cs_log_dbg(D_DVBAPI
, "We reached max emmpids: unable to add new emmpid %d CAID: %04X EMM_PID: %04X PROVID: %06X%sTYPE %s",
2107 demux
[demux_id
].EMMpidcount
- 1, caid
, emmpid
, provid
, cadatatext
, typetext
);
2111 static void dvbapi_parse_cat_ca_descriptor(int32_t demux_id
, const uint8_t *buffer
, uint8_t descriptor_length
)
2113 uint16_t i
, ca_system_id
, ca_pid
;
2114 uint32_t ca_provider
= 0, ca_data
= 0;
2116 if(descriptor_length
< 4)
2118 return; // CA descriptor has a minimum length of 4 bytes
2121 ca_system_id
= b2i(2, buffer
);
2122 ca_pid
= b2i(2, buffer
+ 2) & 0x1FFF;
2124 switch(ca_system_id
>> 8)
2128 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, 0, 0, EMM_UNIQUE
| EMM_GLOBAL
);
2130 for(i
= 5; i
< descriptor_length
; i
+= 4)
2132 ca_pid
= b2i(2, buffer
+ i
) & 0x1FFF;
2133 ca_provider
= b2i(2, buffer
+ i
+ 2);
2135 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, 0, EMM_SHARED
);
2142 for(i
= 4; i
< descriptor_length
; i
+= 2 + buffer
[i
+ 1])
2144 if(buffer
[i
] == 0x14)
2146 ca_provider
= (b2i(3, buffer
+ i
+ 2) & 0xFFFFF0); // viaccess fixup: don't care about last digit
2147 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, 0, EMM_UNIQUE
| EMM_SHARED
| EMM_GLOBAL
);
2155 if(descriptor_length
== 0x07 || descriptor_length
== 0x0B)
2157 for(i
= 5; i
< 5 + buffer
[4]; i
+= 2)
2159 ca_provider
= b2i(2, buffer
+ i
);
2160 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, 0, EMM_UNIQUE
| EMM_SHARED
| EMM_GLOBAL
);
2165 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, 0, EMM_UNIQUE
| EMM_SHARED
| EMM_GLOBAL
);
2173 if(caid_is_bulcrypt(ca_system_id
))
2175 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, 0, 0, EMM_UNIQUE
| EMM_SHARED
| EMM_GLOBAL
);
2179 ca_provider
= buffer
[4];
2181 if(buffer
[4] == 0xFE)
2183 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, 0x102, EMM_GLOBAL
);
2187 if(descriptor_length
== 0x0A)
2189 ca_data
= b2i(4, buffer
+ 6);
2192 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, ca_data
, EMM_UNIQUE
| EMM_SHARED
| EMM_GLOBAL
);
2198 dvbapi_add_emmpid(demux_id
, ca_system_id
, ca_pid
, 0, 0, EMM_UNIQUE
| EMM_SHARED
| EMM_GLOBAL
);
2203 static void dvbapi_parse_cat(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint32_t msgid
)
2205 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
2206 // driver sometimes reports error if too many emm filter
2207 // but adding more ecm filter is no problem
2208 // ... so ifdef here instead of limiting MAX_FILTER
2209 demux
[demux_id
].max_emm_filter
= 14;
2211 if(cfg
.dvbapi_requestmode
== 1)
2213 uint16_t ecm_filter_needed
= 0, n
;
2214 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
2216 if(demux
[demux_id
].ECMpids
[n
].status
> -1)
2218 ecm_filter_needed
++;
2222 if(maxfilter
- ecm_filter_needed
<= 0)
2224 demux
[demux_id
].max_emm_filter
= 0;
2228 demux
[demux_id
].max_emm_filter
= maxfilter
- ecm_filter_needed
;
2233 demux
[demux_id
].max_emm_filter
= maxfilter
- 1;
2238 uint8_t descriptor_tag
, descriptor_length
;
2240 dvbapi_stop_filter(demux_id
, TYPE_CAT
, msgid
);
2242 for(i
= 8; i
+ 1 < length
; i
+= 2 + descriptor_length
)
2244 descriptor_tag
= buffer
[i
];
2245 descriptor_length
= buffer
[i
+ 1];
2247 if(descriptor_tag
== 0x09) // There should be only CA descriptors here
2249 dvbapi_parse_cat_ca_descriptor(demux_id
, buffer
+ i
+ 2, descriptor_length
);
2254 static pthread_mutex_t lockindex
= PTHREAD_MUTEX_INITIALIZER
;
2256 uint32_t dvbapi_get_desc_index(int32_t demux_id
, int32_t pid
, int32_t stream_id
)
2258 int32_t i
, j
, k
, fail
= 1;
2261 if(cfg
.dvbapi_boxtype
== BOXTYPE_NEUMO
)
2263 sscanf(demux
[demux_id
].pmt_file
, "pmt%3d.tmp", &idx
);
2267 SAFE_MUTEX_LOCK(&lockindex
); // to avoid race when readers become responsive!
2268 while(fail
&& idx
<= INDEX_MAX
)
2271 for(i
= 0; i
< MAX_DEMUX
&& !fail
&& idx
< INDEX_MAX
; i
++)
2273 if(demux
[i
].program_number
== 0)
2275 continue; // skip empty demuxers
2278 if(demux
[i
].ca_mask
!= demux
[demux_id
].ca_mask
2279 && (!(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)))
2281 continue; // skip demuxer using other ca device
2284 for(j
= 0; j
< demux
[i
].ECMpidcount
&& !fail
; j
++) // search for new unique index
2286 for(k
= 0; k
< MAX_STREAM_INDICES
; k
++)
2288 if(demux
[i
].ECMpids
[j
].index
[k
] == idx
)
2298 if(selected_api
== DVBAPI_3
|| selected_api
== DVBAPI_1
)
2300 // make sure we haven't run out of descramblers
2301 if(ca_descramblers_used
< ca_descramblers_total
)
2303 ca_descramblers_used
++; // increase number of descramblers used
2307 idx
= INDEX_INVALID
; // we don't have any descramblers left
2310 else // old style check for STAPI, COOLAPI, etc
2312 if(idx
> ca_descramblers_total
)
2314 idx
= INDEX_INVALID
; // we don't have any descramblers left
2318 demux
[demux_id
].ECMpids
[pid
].index
[stream_id
] = idx
;
2319 SAFE_MUTEX_UNLOCK(&lockindex
); // and release it!
2324 void dvbapi_set_pid(int32_t demux_id
, int32_t num
, uint32_t idx
, bool enable
, bool use_des
, uint32_t msgid
)
2326 int32_t i
, currentfd
;
2327 uint16_t streampid
= demux
[demux_id
].STREAMpids
[num
];
2328 uint32_t newidx
= 0, curidx
;
2331 if(demux
[demux_id
].pidindex
== -1 && enable
)
2333 return; // no current pid on enable? --> exit
2336 switch(selected_api
)
2338 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
2340 if(!enable
) idx
= INDEX_INVALID
;
2341 stapi_set_pid(demux_id
, num
, idx
, streampid
, demux
[demux_id
].pmt_file
); // only used to disable pids!!!
2345 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
2351 for(i
= 0; i
< CA_MAX
; i
++)
2353 newidx
= INDEX_INVALID
;
2356 if(((demux
[demux_id
].ca_mask
& (1 << i
)) == (uint32_t) (1 << i
)))
2358 uint32_t action
= 0;
2361 action
= update_streampid_list(i
, streampid
, curidx
, use_des
);
2366 action
= remove_streampid_from_list(i
, streampid
, curidx
);
2369 if(action
!= NO_STREAMPID_LISTED
&& action
!= INVALID_STREAMPID_INDEX
&&
2370 action
!= FOUND_STREAMPID_INDEX
&& action
!= ADDED_STREAMPID_INDEX
&&
2371 action
!= REMOVED_STREAMPID_INDEX
)
2373 // removed last index of this streampid on ca? -> disable this pid with -1 on this ca
2374 if((action
== REMOVED_STREAMPID_LASTINDEX
|| action
== FIRST_STREAMPID_INDEX
)
2375 && (is_ca_used(i
, streampid
) == INDEX_INVALID
))
2377 curidx
= DVBAPI_INDEX_DISABLE
;
2380 // removed index of streampid that is used to decode on ca -> get a fresh one
2381 if(action
== REMOVED_DECODING_STREAMPID_INDEX
|| action
== FIRST_STREAMPID_INDEX
)
2383 newidx
= is_ca_used(i
, streampid
); // get an active index for this pid and enable it on ca device
2384 curidx
= DVBAPI_INDEX_DISABLE
;
2387 while(curidx
!= INDEX_INVALID
|| newidx
!= INDEX_INVALID
)
2389 memset(&ca_pid2
, 0, sizeof(ca_pid2
));
2390 ca_pid2
.pid
= streampid
;
2391 if(curidx
!= INDEX_INVALID
)
2393 (curidx
== DVBAPI_INDEX_DISABLE
) ? (ca_pid2
.index
= -1) : (ca_pid2
.index
= curidx
);
2394 cs_log_dbg(D_DVBAPI
, "Demuxer %d %s stream %d pid=0x%04x index=%d on ca%d",
2396 ((enable
&& curidx
!= DVBAPI_INDEX_DISABLE
) ? "enable" : "disable"),
2401 curidx
= INDEX_INVALID
; // flag this index as handled
2403 else if(newidx
!= INDEX_INVALID
)
2405 (newidx
== DVBAPI_INDEX_DISABLE
) ? (ca_pid2
.index
= -1) : (ca_pid2
.index
= newidx
);
2406 cs_log_dbg(D_DVBAPI
, "Demuxer %d %s stream %d pid=0x%04x by index=%d on ca%d",
2408 ((enable
&& action
== FIRST_STREAMPID_INDEX
) ? "enable" : "takeover"),
2413 newidx
= INDEX_INVALID
; // flag this takeover / new index as handled
2416 if(use_des
&& cfg
.dvbapi_extended_cw_api
== 2 && ca_pid2
.index
!= -1)
2418 ca_pid2
.index
|= 0x100; // flag DES algo through pid index
2421 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
2423 dvbapi_net_send(DVBAPI_CA_SET_PID
, demux
[demux_id
].socket_fd
,
2427 (uint8_t *) &ca_pid2
,
2430 demux
[demux_id
].client_proto_version
);
2434 currentfd
= ca_fd
[i
];
2437 currentfd
= dvbapi_open_device(1, i
, demux
[demux_id
].adapter_index
);
2438 ca_fd
[i
] = currentfd
; // save fd of this ca
2443 if(dvbapi_ioctl(currentfd
, CA_SET_PID
, &ca_pid2
) == -1)
2445 cs_log_dbg(D_TRACE
| D_DVBAPI
,"CA_SET_PID ioctl error (errno=%d %s)", errno
, strerror(errno
));
2446 remove_streampid_from_list(i
, ca_pid2
.pid
, INDEX_DISABLE_ALL
);
2449 uint32_t result
= is_ca_used(i
, 0); // check if in use by any pid
2450 if(result
== INDEX_INVALID
)
2452 cs_log_dbg(D_DVBAPI
, "Demuxer %d close now unused CA%d device", demux_id
, i
);
2453 int32_t ret
= close(currentfd
);
2456 cs_log("ERROR: Could not close demuxer fd (errno=%d %s)", errno
, strerror(errno
));
2458 currentfd
= ca_fd
[i
] = 0;
2471 void dvbapi_stop_all_descrambling(uint32_t msgid
)
2475 for(j
= 0; j
< MAX_DEMUX
; j
++)
2477 if(demux
[j
].program_number
== 0)
2482 dvbapi_stop_descrambling(j
, msgid
);
2486 void dvbapi_stop_all_cat_emm_sdt_filtering(uint32_t msgid
)
2490 for(j
= 0; j
< MAX_DEMUX
; j
++)
2492 if(demux
[j
].program_number
== 0)
2497 dvbapi_stop_filter(j
, TYPE_EMM
, msgid
);
2498 dvbapi_stop_filter(j
, TYPE_SDT
, msgid
);
2499 dvbapi_stop_filter(j
, TYPE_CAT
, msgid
);
2500 demux
[j
].emm_filter
= -1;
2504 void dvbapi_stop_descrambling(int32_t demux_id
, uint32_t msgid
)
2507 if(demux
[demux_id
].program_number
== 0) { return; }
2508 char channame
[CS_SERVICENAME_SIZE
];
2510 i
= demux
[demux_id
].pidindex
;
2516 demux
[demux_id
].pidindex
= -1; // no ecmpid is to be descrambling since we start stop descrambling!
2518 get_servicename(dvbapi_client
, demux
[demux_id
].program_number
,
2519 demux
[demux_id
].ECMpidcount
> 0 ? demux
[demux_id
].ECMpids
[i
].PROVID
: NO_PROVID_VALUE
,
2520 demux
[demux_id
].ECMpidcount
> 0 ? demux
[demux_id
].ECMpids
[i
].CAID
: NO_CAID_VALUE
,
2521 channame
, sizeof(channame
));
2523 cs_log("Demuxer %d stopped descrambling for program %04X (%s)",
2524 demux_id
, demux
[demux_id
].program_number
, channame
);
2526 dvbapi_stop_filter(demux_id
, TYPE_EMM
, msgid
);
2527 dvbapi_stop_filter(demux_id
, TYPE_SDT
, msgid
);
2528 dvbapi_stop_filter(demux_id
, TYPE_PAT
, msgid
);
2529 dvbapi_stop_filter(demux_id
, TYPE_PMT
, msgid
);
2530 dvbapi_stop_filter(demux_id
, TYPE_CAT
, msgid
);
2532 for(i
= 0; i
< demux
[demux_id
].ECMpidcount
&& demux
[demux_id
].ECMpidcount
> 0; i
++)
2534 for(j
= 0; j
< MAX_STREAM_INDICES
; j
++)
2536 if(demux
[demux_id
].ECMpids
[i
].index
[j
] == INDEX_INVALID
)
2542 for(z
= 0; z
< demux
[demux_id
].STREAMpidcount
; z
++)
2544 dvbapi_set_pid(demux_id
, z
, demux
[demux_id
].ECMpids
[i
].index
[j
], false, false, msgid
); // disable streampid
2546 demux
[demux_id
].ECMpids
[i
].index
[j
] = INDEX_INVALID
;
2549 dvbapi_stop_filter(demux_id
, TYPE_ECM
, msgid
);
2551 pthread_mutex_destroy(&demux
[demux_id
].answerlock
);
2552 memset(&demux
[demux_id
], 0 , sizeof(DEMUXTYPE
));
2554 SAFE_MUTEX_INIT(&demux
[demux_id
].answerlock
, NULL
);
2555 for(i
= 0; i
< MAX_ECM_PIDS
; i
++)
2557 for(j
= 0; j
< MAX_STREAM_INDICES
; j
++)
2559 demux
[demux_id
].ECMpids
[i
].index
[j
] = INDEX_INVALID
;
2562 demux
[demux_id
].pidindex
= -1;
2563 demux
[demux_id
].curindex
= -1;
2565 if(!cfg
.dvbapi_listenport
&& cfg
.dvbapi_boxtype
!= BOXTYPE_PC_NODMX
)
2567 unlink(ECMINFO_FILE
);
2572 int32_t dvbapi_start_descrambling(int32_t demux_id
, int32_t pid
, int8_t checked
, uint32_t msgid
)
2574 int32_t started
= 0; // in case ecmfilter started = 1
2575 int32_t fake_ecm
= 0;
2577 struct s_reader
*rdr
;
2579 if(!(er
= get_ecmtask()))
2583 demux
[demux_id
].ECMpids
[pid
].checked
= checked
+ 1; // mark this pid as checked!
2585 struct s_dvbapi_priority
*p
;
2586 for(p
= dvbapi_priority
; p
!= NULL
; p
= p
->next
)
2589 || (p
->caid
&& p
->caid
!= demux
[demux_id
].ECMpids
[pid
].CAID
)
2590 || (p
->provid
&& p
->provid
!= demux
[demux_id
].ECMpids
[pid
].PROVID
)
2591 || (p
->ecmpid
&& p
->ecmpid
!= demux
[demux_id
].ECMpids
[pid
].ECM_PID
)
2592 || (p
->srvid
&& p
->srvid
!= demux
[demux_id
].program_number
)
2593 || (p
->pidx
&& p
->pidx
-1 != pid
)
2594 || (p
->cadata
&& p
->cadata
!= demux
[demux_id
].ECMpids
[pid
].cadata
))
2599 // if found chid and first run apply chid filter, on forced pids always apply!
2600 if(p
->type
== 'p' && p
->chid
< 0x10000 && (demux
[demux_id
].ECMpids
[pid
].checked
== 1 || (p
&& p
->force
)))
2602 if(demux
[demux_id
].ECMpids
[pid
].CHID
< 0x10000) // channelcache delivered chid
2604 er
->chid
= demux
[demux_id
].ECMpids
[pid
].CHID
;
2608 er
->chid
= p
->chid
; // no channelcache or no chid in use, so use prio chid
2609 demux
[demux_id
].ECMpids
[pid
].CHID
= p
->chid
;
2611 //cs_log("********* CHID %04X **************", demux[demux_id].ECMpids[pid].CHID);
2612 break; // we only accept one!
2616 if(demux
[demux_id
].ECMpids
[pid
].CHID
< 0x10000) // channelcache delivered chid
2618 er
->chid
= demux
[demux_id
].ECMpids
[pid
].CHID
;
2620 else // no channelcache or no chid in use
2623 demux
[demux_id
].ECMpids
[pid
].CHID
= 0x10000;
2628 er
->srvid
= demux
[demux_id
].program_number
;
2629 er
->caid
= demux
[demux_id
].ECMpids
[pid
].CAID
;
2630 er
->pid
= demux
[demux_id
].ECMpids
[pid
].ECM_PID
;
2631 er
->prid
= demux
[demux_id
].ECMpids
[pid
].PROVID
;
2632 er
->vpid
= demux
[demux_id
].ECMpids
[pid
].VPID
;
2633 er
->pmtpid
= demux
[demux_id
].pmtpid
;
2634 er
->onid
= demux
[demux_id
].onid
;
2638 cs_strncpy(er
->dev_name
, dev_list
[demux
[demux_id
].dev_index
].name
, sizeof(dev_list
[demux
[demux_id
].dev_index
].name
));
2643 for(rdr
= first_active_reader
; rdr
!= NULL
; rdr
= rdr
->next
)
2645 int8_t match
= matching_reader(er
, rdr
); // check for matching reader
2646 int64_t gone
= comp_timeb(&now
, &rdr
->emm_last
);
2647 if(gone
> 3600*1000 && rdr
->needsemmfirst
&& caid_is_irdeto(er
->caid
))
2649 cs_log("Warning reader %s received no emms for the last %d seconds -> skip, this reader needs emms first!",
2650 rdr
->label
, (int)(gone
/ 1000));
2651 continue; // skip this card needs to process emms first before it can be used for descramble
2656 match
= 1; // forced pid always started!
2659 if(!match
) // if this reader does not match, check betatunnel for it
2661 match
= lb_check_auto_betatunnel(er
, rdr
);
2664 if(!match
&& chk_is_betatunnel_caid(er
->caid
)) // these caids might be tunneled invisible by peers
2666 match
= 1; // so make it a match to try it!
2669 // check if cache-ex is matching
2670 if(config_enabled(CS_CACHEEX
) && (!match
&& (cacheex_is_match_alias(dvbapi_client
, er
))))
2672 match
= 1; // so make it a match to try it!
2675 // BISS1 and BISS2 mode 1/E or FAKE caid
2676 // ecm pid is fake, so send out one fake ecm request
2677 // special treatment: if we asked the cw first without starting a filter,
2678 // the cw request will be killed due to no ecmfilter started
2679 if(caid_is_fake(demux
[demux_id
].ECMpids
[pid
].CAID
) || caid_is_biss_fixed(demux
[demux_id
].ECMpids
[pid
].CAID
))
2683 er
->ecm
[0] = 0x80; // to pass the cache check it must be 0x80 or 0x81
2686 i2b_buf(2, er
->srvid
, er
->ecm
+ 3);
2688 for(j
= 0, n
= 5; j
< demux
[demux_id
].STREAMpidcount
; j
++, n
+= 2)
2690 i2b_buf(2, demux
[demux_id
].STREAMpids
[j
], er
->ecm
+ n
);
2695 cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X ANY CHID PMTPID %04X VPID %04X",
2698 demux
[demux_id
].ECMpids
[pid
].CAID
,
2699 demux
[demux_id
].ECMpids
[pid
].PROVID
,
2700 demux
[demux_id
].ECMpids
[pid
].ECM_PID
,
2701 demux
[demux_id
].pmtpid
,
2702 demux
[demux_id
].ECMpids
[pid
].VPID
);
2704 demux
[demux_id
].curindex
= pid
; // set current pid to the fresh started one
2705 dvbapi_start_filter(demux_id
,
2707 demux
[demux_id
].ECMpids
[pid
].ECM_PID
,
2708 demux
[demux_id
].ECMpids
[pid
].CAID
,
2709 demux
[demux_id
].ECMpids
[pid
].PROVID
,
2716 request_cw(dvbapi_client
, er
, demux_id
, 0); // do not register ecm since this try!
2718 break; // we started an ecmfilter so stop looking for next matching reader!
2721 if(match
) // if matching reader found check for irdeto cas if local irdeto card check if it received emms in last 60 minutes
2723 if(caid_is_irdeto(er
->caid
)) // irdeto cas init irdeto_curindex to wait for first index (00)
2725 if(demux
[demux_id
].ECMpids
[pid
].irdeto_curindex
== 0xFE)
2727 demux
[demux_id
].ECMpids
[pid
].irdeto_curindex
= 0x00;
2731 if(p
&& p
->chid
< 0x10000) // do we prio a certain chid?
2733 cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X CHID %04X PMTPID %04X VPID %04X",
2735 demux
[demux_id
].ECMpids
[pid
].CAID
,
2736 demux
[demux_id
].ECMpids
[pid
].PROVID
,
2737 demux
[demux_id
].ECMpids
[pid
].ECM_PID
,
2738 demux
[demux_id
].ECMpids
[pid
].CHID
,
2739 demux
[demux_id
].pmtpid
,
2740 demux
[demux_id
].ECMpids
[pid
].VPID
);
2744 cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X ANY CHID PMTPID %04X VPID %04X",
2746 demux
[demux_id
].ECMpids
[pid
].CAID
,
2747 demux
[demux_id
].ECMpids
[pid
].PROVID
,
2748 demux
[demux_id
].ECMpids
[pid
].ECM_PID
,
2749 demux
[demux_id
].pmtpid
,
2750 demux
[demux_id
].ECMpids
[pid
].VPID
);
2753 demux
[demux_id
].curindex
= pid
; // set current pid to the fresh started one
2754 dvbapi_start_filter(demux_id
,
2756 demux
[demux_id
].ECMpids
[pid
].ECM_PID
,
2757 demux
[demux_id
].ECMpids
[pid
].CAID
,
2758 demux
[demux_id
].ECMpids
[pid
].PROVID
,
2765 break; // we started an ecmfilter so stop looking for next matching reader!
2769 if(demux
[demux_id
].curindex
!= pid
)
2771 cs_log("Demuxer %d impossible to descramble PID %d CAID %04X PROVID %06X ECMPID %04X PMTPID %04X (NO MATCHING READER)",
2773 demux
[demux_id
].ECMpids
[pid
].CAID
,
2774 demux
[demux_id
].ECMpids
[pid
].PROVID
,
2775 demux
[demux_id
].ECMpids
[pid
].ECM_PID
,
2776 demux
[demux_id
].pmtpid
);
2778 demux
[demux_id
].ECMpids
[pid
].checked
= 4; // flag this pid as checked
2779 demux
[demux_id
].ECMpids
[pid
].status
= -1; // flag this pid as unusable
2780 dvbapi_edit_channel_cache(demux_id
, pid
, 0); // remove this pid from channelcache
2790 struct s_dvbapi_priority
*dvbapi_check_prio_match_emmpid(int32_t demux_id
, uint16_t caid
, uint32_t provid
, char type
)
2792 struct s_dvbapi_priority
*p
;
2794 uint16_t ecm_pid
= 0;
2796 for(i
= 0; i
< demux
[demux_id
].ECMpidcount
; i
++)
2798 if((demux
[demux_id
].ECMpids
[i
].CAID
== caid
) && (demux
[demux_id
].ECMpids
[i
].PROVID
== provid
))
2800 ecm_pid
= demux
[demux_id
].ECMpids
[i
].ECM_PID
;
2810 for(p
= dvbapi_priority
; p
!= NULL
; p
= p
->next
)
2813 || (p
->caid
&& p
->caid
!= caid
)
2814 || (p
->provid
&& p
->provid
!= provid
)
2815 || (p
->ecmpid
&& p
->ecmpid
!= ecm_pid
)
2816 || (p
->srvid
&& p
->srvid
!= demux
[demux_id
].program_number
)
2817 || (p
->pidx
&& p
->pidx
-1 !=i
)
2818 || (p
->type
== 'i' && (p
->chid
< 0x10000)))
2828 struct s_dvbapi_priority
*dvbapi_check_prio_match(int32_t demux_id
, int32_t pidindex
, char type
)
2830 if(!dvbapi_priority
)
2835 struct s_dvbapi_priority
*p
;
2836 struct s_ecmpid
*ecmpid
= &demux
[demux_id
].ECMpids
[pidindex
];
2838 for(p
= dvbapi_priority
; p
!= NULL
; p
= p
->next
)
2841 || (p
->caid
&& p
->caid
!= ecmpid
->CAID
)
2842 || (p
->provid
&& p
->provid
!= ecmpid
->PROVID
)
2843 || (p
->ecmpid
&& p
->ecmpid
!= ecmpid
->ECM_PID
)
2844 || (p
->srvid
&& p
->srvid
!= demux
[demux_id
].program_number
)
2845 || (p
->pidx
&& p
->pidx
-1 != pidindex
)
2846 || (p
->chid
< 0x10000 && p
->chid
!= ecmpid
->CHID
))
2856 void dvbapi_process_emm(int32_t demux_id
, int32_t filter_num
, uint8_t *buffer
, uint32_t len
)
2860 struct s_emm_filter
*filter
= get_emmfilter_by_filternum(demux_id
, filter_num
+ 1); // 0 is used for pending emmfilters, so everything increase 1
2863 cs_log_dbg(D_DVBAPI
, "Demuxer %d Filter %d no filter matches -> SKIP!", demux_id
, filter_num
+ 1);
2867 uint32_t provider
= filter
->provid
;
2868 uint16_t caid
= filter
->caid
;
2869 struct s_dvbapi_priority
*mapentry
= dvbapi_check_prio_match_emmpid(filter
->demux_id
, filter
->caid
, filter
->provid
, 'm');
2872 cs_log_dbg(D_DVBAPI
, "Demuxer %d mapping EMM from %04X@%06X to %04X@%06X",
2873 demux_id
, caid
, provider
, mapentry
->mapcaid
, mapentry
->mapprovid
);
2875 caid
= mapentry
->mapcaid
;
2876 provider
= mapentry
->mapprovid
;
2879 memset(&epg
, 0, sizeof(epg
));
2880 i2b_buf(2, caid
, epg
.caid
);
2881 i2b_buf(4, provider
, epg
.provid
);
2882 epg
.emmlen
= len
> sizeof(epg
.emm
) ? sizeof(epg
.emm
) : len
;
2883 memcpy(epg
.emm
, buffer
, epg
.emmlen
);
2885 if(config_enabled(READER_IRDETO
) && chk_is_betatunnel_caid(caid
) == 2)
2887 uint16_t ncaid
= tunemm_caid_map(FROM_TO
, caid
, demux
[demux_id
].program_number
);
2890 irdeto_add_emm_header(&epg
);
2891 i2b_buf(2, ncaid
, epg
.caid
);
2894 do_emm(dvbapi_client
, &epg
);
2897 void dvbapi_read_priority(void)
2900 char token
[128], str1
[128];
2902 int32_t i
, ret
, count
= 0;
2903 const char *cs_prio
= "oscam.dvbapi";
2905 fp
= fopen(get_config_filename(token
, sizeof(token
), cs_prio
), "r");
2908 cs_log_dbg(D_DVBAPI
, "ERROR: Can't open priority file %s", token
);
2914 cs_log_dbg(D_DVBAPI
, "reread priority file %s", cs_prio
);
2915 struct s_dvbapi_priority
*o
, *p
;
2916 for(p
= dvbapi_priority
; p
!= NULL
; p
= o
)
2921 dvbapi_priority
= NULL
;
2924 while(fgets(token
, sizeof(token
), fp
))
2926 // Ignore comments and empty lines
2927 if(token
[0] == '#' || token
[0] == '/' || token
[0] == '\n' || token
[0] == '\r' || token
[0] == '\0' || strlen(token
) > 100)
2931 memset(str1
, 0, 128);
2933 for(i
= 0; i
< (int)strlen(token
) && token
[i
] == ' '; i
++) { ; }
2935 if(i
== (int)strlen(token
) - 1) // empty line or all spaces
2940 for(i
= 0; i
< (int)strlen(token
); i
++)
2948 for(i
= 0; i
< (int)strlen(token
); i
++)
2950 if((token
[i
] == ':' || token
[i
] == ' ') && token
[i
+ 1] == ':') // if "::" or " :"
2952 memmove(token
+ i
+ 2, token
+ i
+ 1, strlen(token
) - i
+ 1); // insert extra position
2953 token
[i
+ 1] = '0'; // and fill it with NULL
2956 if(token
[i
] == '#' || token
[i
] == '/')
2964 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
2965 uint32_t disablefilter
= 0;
2966 ret
= sscanf(trim(token
), "%c: %63s %63s %d", &type
, str1
, str1
+ 64, &disablefilter
);
2968 ret
= sscanf(trim(token
), "%c: %63s %63s", &type
, str1
, str1
+ 64);
2970 type
= tolower((uint8_t)type
);
2972 if(ret
< 1 || (type
!= 'p' && type
!= 'i' && type
!= 'm' && type
!= 'd' &&
2973 type
!= 's' && type
!= 'l' && type
!= 'j' && type
!= 'a' && type
!= 'x'))
2975 //fprintf(stderr, "Warning: line containing %s in %s not recognized, ignoring line\n", token, cs_prio);
2976 // fprintf would issue the warning to the command line, which is more consistent with other config warnings
2977 // however it takes OSCam a long time (>4 seconds) to reach this part of the program, so the warnings are
2978 // reaching tty rather late which leads to confusion. So send the warnings to log file instead
2979 cs_log_dbg(D_DVBAPI
, "WARN: line containing %s in %s not recognized, ignoring...", token
, cs_prio
);
2983 struct s_dvbapi_priority
*entry
;
2984 if(!cs_malloc(&entry
, sizeof(struct s_dvbapi_priority
)))
2989 cs_log("ERROR: Could not close oscam.dvbapi fd (errno=%d %s)", errno
, strerror(errno
));
2998 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
3001 cs_strncpy(entry
->devname
, str1
, sizeof(entry
->devname
));
3002 cs_strncpy(entry
->pmtfile
, str1
+ 64, sizeof(entry
->pmtfile
));
3003 entry
->disablefilter
= disablefilter
;
3004 cs_log_dbg(D_DVBAPI
, "stapi prio: ret=%d | %c: %s %s | disable %d",
3005 ret
, type
, entry
->devname
, entry
->pmtfile
, disablefilter
);
3007 if(!dvbapi_priority
)
3009 dvbapi_priority
= entry
;
3013 struct s_dvbapi_priority
*p
;
3014 for(p
= dvbapi_priority
; p
->next
!= NULL
; p
= p
->next
) { ; }
3022 uint32_t caid
= 0, provid
= 0, srvid
= 0, ecmpid
= 0, cadata
= 0;;
3023 uint32_t chid
= 0x10000; //chid=0 is a valid chid
3025 ret
= sscanf(str1
, "%4x:%6x:%33[^:]:%4x:%4x:%8x"SCNx16
, &caid
, &provid
, c_srvid
, &ecmpid
, &chid
, &cadata
);
3028 cs_log("Error in oscam.dvbapi: ret=%d | %c: %04X %06X %s %04X %04X",
3029 ret
, type
, caid
, provid
, c_srvid
, ecmpid
, chid
);
3030 continue; // skip this entry!
3034 cs_log_dbg(D_DVBAPI
, "Parsing rule: ret=%d | %c: %04X %06X %s %04X %04X %04X",
3035 ret
, type
, caid
, provid
, c_srvid
, ecmpid
, chid
, cadata
);
3039 entry
->provid
= provid
;
3040 entry
->ecmpid
= ecmpid
;
3042 entry
->cadata
= cadata
;
3043 uint32_t delay
= 0, force
= 0, mapcaid
= 0, mapprovid
= 0, mapecmpid
= 0, pidx
= 0;
3048 ret
= sscanf(str1
+ 64, "%1d", &pidx
);
3049 entry
->pidx
= pidx
+ 1;
3050 if(ret
< 1) entry
->pidx
= 0;
3054 sscanf(str1
+ 64, "%4d", &delay
);
3055 entry
->delay
= delay
;
3059 entry
->delay
= dyn_word_atob(str1
+ 64);
3060 if(entry
->delay
== -1) { entry
->delay
= 0; }
3064 ret
= sscanf(str1
+ 64, "%1d:%1d", &force
, &pidx
);
3065 entry
->force
= force
;
3066 entry
->pidx
= pidx
+ 1;
3067 if(ret
< 2) entry
->pidx
= 0;
3071 sscanf(str1
+ 64, "%4x:%6x", &mapcaid
, &mapprovid
);
3072 if(!mapcaid
) { mapcaid
= 0xFFFF; }
3073 entry
->mapcaid
= mapcaid
;
3074 entry
->mapprovid
= mapprovid
;
3079 sscanf(str1
+ 64, "%4x:%6x:%4x", &mapcaid
, &mapprovid
, &mapecmpid
);
3080 if(!mapcaid
) { mapcaid
= 0xFFFF; }
3081 entry
->mapcaid
= mapcaid
;
3082 entry
->mapprovid
= mapprovid
;
3083 entry
->mapecmpid
= mapecmpid
;
3087 if(c_srvid
[0] == '=')
3089 struct s_srvid
*this;
3090 for(i
= 0; i
< 16; i
++)
3092 for(this = cfg
.srvid
[i
]; this != NULL
; this = this->next
)
3094 if(this->name
&& strcmp(this->name
, c_srvid
+ 1) == 0)
3096 struct s_dvbapi_priority
*entry2
;
3097 if(!cs_malloc(&entry2
, sizeof(struct s_dvbapi_priority
)))
3102 memcpy(entry2
, entry
, sizeof(struct s_dvbapi_priority
));
3103 entry2
->srvid
= this->srvid
;
3104 cs_log_dbg(D_DVBAPI
, "prio srvid: ret=%d | %c: %04X %06X %04X %04X %04X -> map %04X %06X %04X | prio %d | delay %d",
3118 if(!dvbapi_priority
)
3120 dvbapi_priority
= entry2
;
3124 struct s_dvbapi_priority
*p
;
3125 for(p
= dvbapi_priority
; p
->next
!= NULL
; p
= p
->next
) { ; }
3136 sscanf(c_srvid
, "%4x", &srvid
);
3137 entry
->srvid
= srvid
;
3139 cs_log_dbg(D_DVBAPI
, "prio: ret=%d | %c: %04X %06X %04X %04X %04X -> map %04X %06X %04X | prio %d | delay %d",
3153 if(!dvbapi_priority
)
3155 dvbapi_priority
= entry
;
3159 struct s_dvbapi_priority
*p
;
3160 for(p
= dvbapi_priority
; p
->next
!= NULL
; p
= p
->next
) { ; }
3164 cs_log_dbg(D_DVBAPI
, "Read %d entries from %s", count
, cs_prio
);
3169 cs_log("ERROR: Could not close oscam.dvbapi fd (errno=%d %s)", errno
, strerror(errno
));
3174 void dvbapi_resort_ecmpids(int32_t demux_id
)
3176 int32_t n
, cache
= 0, matching_done
= 0, found
= -1, match_reader_count
= 0, total_reader
= 0;
3177 uint16_t btun_caid
= 0;
3178 struct timeb start
,end
;
3181 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
3183 demux
[demux_id
].ECMpids
[n
].status
= 0;
3184 demux
[demux_id
].ECMpids
[n
].checked
= 0;
3185 demux
[demux_id
].ECMpids
[n
].irdeto_curindex
= 0xFE;
3186 demux
[demux_id
].ECMpids
[n
].irdeto_maxindex
= 0;
3187 demux
[demux_id
].ECMpids
[n
].irdeto_cycle
= 0xFE;
3188 demux
[demux_id
].ECMpids
[n
].tries
= 0xFE;
3189 demux
[demux_id
].ECMpids
[n
].table
= 0;
3192 demux
[demux_id
].max_status
= 0;
3193 demux
[demux_id
].curindex
= -1;
3194 demux
[demux_id
].pidindex
= -1;
3196 struct s_reader
*rdr
;
3197 int32_t p_order
= demux
[demux_id
].ECMpidcount
+ 1;
3198 struct s_dvbapi_priority
*prio
;
3200 // handle prio order in oscam.dvbapi + ignore all chids
3201 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
3203 total_reader
++; // only need to calculate once!
3207 if(!cs_malloc(&er
, sizeof(ECM_REQUEST
)))
3212 for(prio
= dvbapi_priority
; prio
!= NULL
; prio
= prio
->next
)
3214 if(prio
->type
!= 'p' && prio
->type
!= 'i')
3219 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
3221 if(demux
[demux_id
].ECMpids
[n
].status
== -1) continue; // skip ignores!
3223 er
->caid
= er
->ocaid
= demux
[demux_id
].ECMpids
[n
].CAID
;
3224 er
->prid
= demux
[demux_id
].ECMpids
[n
].PROVID
;
3225 er
->pid
= demux
[demux_id
].ECMpids
[n
].ECM_PID
;
3226 er
->srvid
= demux
[demux_id
].program_number
;
3227 er
->client
= cur_client();
3228 btun_caid
= chk_on_btun(SRVID_MASK
, er
->client
, er
);
3230 if(prio
->type
== 'p' && btun_caid
)
3232 er
->caid
= btun_caid
;
3235 if((prio
->caid
&& (prio
->caid
!= er
->caid
&& prio
->caid
!= er
->ocaid
))
3236 || (prio
->provid
&& prio
->provid
!= er
->prid
)
3237 || (prio
->srvid
&& prio
->srvid
!= er
->srvid
)
3238 || (prio
->ecmpid
&& prio
->ecmpid
!= er
->pid
)
3239 || (prio
->pidx
&& prio
->pidx
- 1 != n
))
3244 if(prio
->type
== 'p') // check for prio
3246 if(prio
->cadata
!= 0 && prio
->cadata
!= demux
[demux_id
].ECMpids
[n
].cadata
)
3251 if(prio
->chid
< 0x10000)
3253 demux
[demux_id
].ECMpids
[n
].CHID
= prio
->chid
;
3259 for(j
= 0; j
< demux
[demux_id
].ECMpidcount
; j
++)
3261 demux
[demux_id
].ECMpids
[j
].status
= -1;
3264 demux
[demux_id
].ECMpids
[n
].status
= 1;
3265 demux
[demux_id
].ECMpids
[n
].checked
= 0;
3266 demux
[demux_id
].max_status
= 1;
3267 demux
[demux_id
].max_emm_filter
= maxfilter
- 1;
3269 cs_log_dbg(D_DVBAPI
, "Demuxer %d prio forced%s ecmpid %d %04X@%06X:%04X:%04X (file)",
3271 ((prio
->caid
== er
->caid
&& prio
->caid
!= er
->ocaid
) ? " betatunneled" : ""),
3273 demux
[demux_id
].ECMpids
[n
].CAID
,
3274 demux
[demux_id
].ECMpids
[n
].PROVID
,
3275 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3276 (uint16_t) prio
->chid
);
3278 return; // go start descrambling since its forced by user!
3282 if(!demux
[demux_id
].ECMpids
[n
].status
) // only accept first matching prio from oscam.dvbapi
3284 demux
[demux_id
].ECMpids
[n
].status
= total_reader
+ p_order
--;
3286 cs_log_dbg(D_DVBAPI
, "Demuxer %d prio%s ecmpid %d %04X@%06X:%04X:%04X weight: %d (file)",
3288 ((prio
->caid
== er
->caid
&& prio
->caid
!= er
->ocaid
) ? " betatunneled" : ""),
3290 demux
[demux_id
].ECMpids
[n
].CAID
,
3291 demux
[demux_id
].ECMpids
[n
].PROVID
,
3292 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3293 (uint16_t) prio
->chid
,
3294 demux
[demux_id
].ECMpids
[n
].status
);
3296 continue; // evaluate next ecmpid
3300 // check for ignore all chids
3301 if(prio
->type
== 'i' && prio
->chid
== 0x10000 && demux
[demux_id
].ECMpids
[n
].status
== 0)
3303 cs_log_dbg(D_DVBAPI
, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X all chids (file)",
3306 demux
[demux_id
].ECMpids
[n
].CAID
,
3307 demux
[demux_id
].ECMpids
[n
].PROVID
,
3308 demux
[demux_id
].ECMpids
[n
].ECM_PID
);
3309 demux
[demux_id
].ECMpids
[n
].status
= -1;
3310 continue; // evaluate next ecmpid
3314 p_order
= demux
[demux_id
].ECMpidcount
+ 1;
3316 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
3318 if(demux
[demux_id
].ECMpids
[n
].status
== -1)
3320 continue; // skip ignores!
3326 er
->caid
= er
->ocaid
= demux
[demux_id
].ECMpids
[n
].CAID
;
3327 er
->prid
= demux
[demux_id
].ECMpids
[n
].PROVID
;
3328 er
->pid
= demux
[demux_id
].ECMpids
[n
].ECM_PID
;
3329 er
->srvid
= demux
[demux_id
].program_number
;
3330 er
->client
= cur_client();
3332 btun_caid
= chk_on_btun(SRVID_MASK
, er
->client
, er
);
3335 er
->caid
= btun_caid
;
3338 match_reader_count
= 0;
3340 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
3342 if(matching_reader(er
, rdr
))
3344 match_reader_count
++;
3348 if(match_reader_count
== 0)
3350 cs_log_dbg(D_DVBAPI
, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X:%04X (no matching reader)",
3353 demux
[demux_id
].ECMpids
[n
].CAID
,
3354 demux
[demux_id
].ECMpids
[n
].PROVID
,
3355 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3356 demux
[demux_id
].ECMpids
[n
].CHID
);
3357 demux
[demux_id
].ECMpids
[n
].status
= -1;
3358 continue; // evaluate next ecmpid
3360 else // ecmpids with no matching readers are disabled and matching sidtabbits have now highest status
3362 for(nr
= 0, sidtab
= cfg
.sidtab
; sidtab
; sidtab
= sidtab
->next
, nr
++)
3364 if(sidtab
->num_caid
| sidtab
->num_provid
| sidtab
->num_srvid
)
3366 if((cfg
.dvbapi_sidtabs
.no
& ((SIDTABBITS
)1 << nr
)) && (chk_srvid_match(er
, sidtab
)))
3368 demux
[demux_id
].ECMpids
[n
].status
= -1; //ignore
3369 cs_log_dbg(D_DVBAPI
, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X (service %s pos %d)",
3372 demux
[demux_id
].ECMpids
[n
].CAID
,
3373 demux
[demux_id
].ECMpids
[n
].PROVID
,
3374 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3377 continue; // evaluate next ecmpid
3379 if((cfg
.dvbapi_sidtabs
.ok
& ((SIDTABBITS
) 1 << nr
)) && (chk_srvid_match(er
, sidtab
)))
3381 demux
[demux_id
].ECMpids
[n
].status
++; // priority
3382 cs_log_dbg(D_DVBAPI
, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (service %s pos %d)",
3385 demux
[demux_id
].ECMpids
[n
].CAID
,
3386 demux
[demux_id
].ECMpids
[n
].PROVID
,
3387 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3388 demux
[demux_id
].ECMpids
[n
].status
,
3397 // ecmpid with highest prio from oscam.dvbapi has now highest status
3398 // check all ecmpids and get the highest amount cache-ex and local readers
3399 int32_t max_local_matching_reader
= 0, max_cacheex_reader
= 0;
3401 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
3403 int32_t count_matching_cacheex_reader
= 0, count_matching_local_reader
= 0;
3404 if(demux
[demux_id
].ECMpids
[n
].status
== -1)
3406 continue; // skip ignores!
3409 er
->caid
= er
->ocaid
= demux
[demux_id
].ECMpids
[n
].CAID
;
3410 er
->prid
= demux
[demux_id
].ECMpids
[n
].PROVID
;
3411 er
->pid
= demux
[demux_id
].ECMpids
[n
].ECM_PID
;
3412 er
->srvid
= demux
[demux_id
].program_number
;
3413 er
->client
= cur_client();
3415 btun_caid
= chk_on_btun(SRVID_MASK
, er
->client
, er
);
3418 er
->caid
= btun_caid
;
3421 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
3423 if(matching_reader(er
, rdr
))
3425 if(cacheex_reader(rdr
))
3427 count_matching_cacheex_reader
++;
3429 else if(is_localreader(rdr
, er
))
3431 count_matching_local_reader
++;
3436 if(max_local_matching_reader
< count_matching_local_reader
)
3438 max_local_matching_reader
= count_matching_local_reader
;
3441 if(max_cacheex_reader
< count_matching_cacheex_reader
)
3443 max_cacheex_reader
= count_matching_cacheex_reader
;
3447 if(max_local_matching_reader
!= 0 || max_cacheex_reader
!= 0)
3449 p_order
= demux
[demux_id
].ECMpidcount
* 2;
3450 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
3452 int32_t count_matching_cacheex_reader
= 0, count_matching_local_reader
= 0;
3453 int32_t localprio
= 1, cacheexprio
= 1;
3455 if(demux
[demux_id
].ECMpids
[n
].status
== -1)
3457 continue; // skip ignores!
3460 if(cfg
.preferlocalcards
== 2) // ecmpids with local reader get highest prio
3462 localprio
= max_cacheex_reader
+ p_order
+ 1;
3464 else if(cfg
.preferlocalcards
== 1) // ecmpids with cacheex reader get highest prio
3466 cacheexprio
= max_local_matching_reader
+ p_order
+ 1;
3469 er
->caid
= er
->ocaid
= demux
[demux_id
].ECMpids
[n
].CAID
;
3470 er
->prid
= demux
[demux_id
].ECMpids
[n
].PROVID
;
3471 er
->pid
= demux
[demux_id
].ECMpids
[n
].ECM_PID
;
3472 er
->srvid
= demux
[demux_id
].program_number
;
3473 er
->client
= cur_client();
3475 btun_caid
= chk_on_btun(SRVID_MASK
, er
->client
, er
);
3478 er
->caid
= btun_caid
;
3481 int32_t oldstatus
= demux
[demux_id
].ECMpids
[n
].status
;
3482 int32_t anyreader
= 0;
3484 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
3486 if(matching_reader(er
, rdr
))
3488 if(cfg
.preferlocalcards
== 0)
3492 demux
[demux_id
].ECMpids
[n
].status
++;
3498 if(cacheex_reader(rdr
))
3500 demux
[demux_id
].ECMpids
[n
].status
+= cacheexprio
;
3501 count_matching_cacheex_reader
++;
3505 if(is_localreader(rdr
, er
))
3507 demux
[demux_id
].ECMpids
[n
].status
+= localprio
;
3508 count_matching_local_reader
++;
3514 if(oldstatus
!= demux
[demux_id
].ECMpids
[n
].status
)
3518 cs_log_dbg(D_DVBAPI
, "Demuxer %d prio ecmpid %d %04X@%06X:%04X:%04X weight: %d (%d readers)",
3521 demux
[demux_id
].ECMpids
[n
].CAID
,
3522 demux
[demux_id
].ECMpids
[n
].PROVID
,
3523 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3524 demux
[demux_id
].ECMpids
[n
].CHID
,
3525 demux
[demux_id
].ECMpids
[n
].status
,
3530 cs_log_dbg(D_DVBAPI
, "Demuxer %d prio ecmpid %d %04X@%06X:%04X:%04X weight: %d (%d local and %d cacheex readers)",
3533 demux
[demux_id
].ECMpids
[n
].CAID
,
3534 demux
[demux_id
].ECMpids
[n
].PROVID
,
3535 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3536 demux
[demux_id
].ECMpids
[n
].CHID
,
3537 demux
[demux_id
].ECMpids
[n
].status
,
3538 count_matching_local_reader
,
3539 count_matching_cacheex_reader
);
3545 struct s_channel_cache
*c
= NULL
;
3547 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
&& matching_done
== 0; n
++)
3549 if(demux
[demux_id
].ECMpids
[n
].status
== -1)
3551 continue; // skip ignores!
3554 c
= dvbapi_find_channel_cache(demux_id
, n
, 0); // find exact channel match
3558 cache
= 2; // found cache entry with higher priority
3559 demux
[demux_id
].ECMpids
[n
].status
++; // prioritize CAIDs which already decoded same caid:provid:srvid
3561 if(c
->chid
< 0x10000)
3563 demux
[demux_id
].ECMpids
[n
].CHID
= c
->chid
; // if chid registered in cache -> use it!
3565 cs_log_dbg(D_DVBAPI
, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (found caid/provid/srvid in cache)",
3568 demux
[demux_id
].ECMpids
[n
].CAID
,
3569 demux
[demux_id
].ECMpids
[n
].PROVID
,
3570 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3571 demux
[demux_id
].ECMpids
[n
].status
);
3578 // prioritize CAIDs which already decoded same caid:provid
3579 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
&& matching_done
== 0; n
++)
3581 if(demux
[demux_id
].ECMpids
[n
].status
== -1) continue; // skip ignores!
3583 c
= dvbapi_find_channel_cache(demux_id
, n
, 1);
3586 cache
= 1; //found cache entry
3587 demux
[demux_id
].ECMpids
[n
].status
++;
3588 cs_log_dbg(D_DVBAPI
, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (found caid/provid in cache)",
3591 demux
[demux_id
].ECMpids
[n
].CAID
,
3592 demux
[demux_id
].ECMpids
[n
].PROVID
,
3593 demux
[demux_id
].ECMpids
[n
].ECM_PID
,
3594 demux
[demux_id
].ECMpids
[n
].status
);
3599 int32_t max_status
= 0;
3600 int32_t highest_priopid
= -1;
3602 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
3604 if(demux
[demux_id
].ECMpids
[n
].status
== -1)
3606 continue; // skip ignores!
3609 if(demux
[demux_id
].ECMpids
[n
].status
> max_status
) // find highest prio pid
3611 max_status
= demux
[demux_id
].ECMpids
[n
].status
;
3612 highest_priopid
= n
;
3615 if(!USE_OPENXCAS
) // openxcas doesnt use prio and non-prio run: all are equal!
3617 if(demux
[demux_id
].ECMpids
[n
].status
== 0)
3619 demux
[demux_id
].ECMpids
[n
].checked
= 2; // set pids with no status to no prio run
3624 demux
[demux_id
].max_status
= max_status
; // register maxstatus
3626 // Found entry in channelcache that is valid and has exact match on srvid
3627 if(highest_priopid
!= -1 && found
== highest_priopid
&& cache
== 2)
3629 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
3631 if(demux
[demux_id
].ECMpids
[n
].status
== -1)
3633 continue; // skip ignores!
3638 // disable non matching pid
3639 demux
[demux_id
].ECMpids
[n
].status
= -1;
3643 demux
[demux_id
].ECMpids
[n
].status
= 1;
3646 demux
[demux_id
].max_emm_filter
= maxfilter
- 1;
3647 demux
[demux_id
].max_status
= 1;
3648 cs_log("Demuxer %d found channel in cache and matching prio -> start descrambling ecmpid %d ", demux_id
, found
);
3653 int64_t gone
= comp_timeb(&end
, &start
);
3654 cs_log_dbg(D_DVBAPI
, "Demuxer %d sorting the ecmpids took %"PRId64
" ms", demux_id
, gone
);
3658 static void dvbapi_priority_read_entry_add(int32_t demux_id
, uint16_t video_pid
)
3660 struct s_dvbapi_priority
*add_entry
;
3662 for(add_entry
= dvbapi_priority
; add_entry
!= NULL
; add_entry
= add_entry
->next
)
3664 // ECM pid is misused to hold PMT pid in case of 'A' rule.
3665 // Some receivers don't forward the PMT pid, so use the video pid instead
3666 if(add_entry
->type
!= 'a' || add_entry
->srvid
!= demux
[demux_id
].program_number
3667 || (add_entry
->ecmpid
&& demux
[demux_id
].pmtpid
&& add_entry
->ecmpid
!= demux
[demux_id
].pmtpid
)
3668 || (add_entry
->ecmpid
&& !demux
[demux_id
].pmtpid
&& add_entry
->ecmpid
!= video_pid
))
3673 dvbapi_add_ecmpid(demux_id
, add_entry
->mapcaid
, add_entry
->mapecmpid
, add_entry
->mapprovid
, 0, "(fake ecm pid)");
3675 cs_log_dbg(D_DVBAPI
, "Demuxer %d added fake ecm pid %04X@%06X:%04X for program %04X", demux_id
,
3676 add_entry
->mapcaid
, add_entry
->mapprovid
, add_entry
->mapecmpid
, demux
[demux_id
].program_number
);
3681 static void dvbapi_priority_read_entry_map(int32_t demux_id
)
3684 struct s_dvbapi_priority
*map_entry
;
3686 for(j
= 0; j
< demux
[demux_id
].ECMpidcount
; j
++)
3688 map_entry
= dvbapi_check_prio_match(demux_id
, j
, 'm');
3691 cs_log_dbg(D_DVBAPI
, "Demuxer %d mapping ecm pid %d from %04X@%06X to %04X@%06X",
3692 demux_id
, j
, demux
[demux_id
].ECMpids
[j
].CAID
, demux
[demux_id
].ECMpids
[j
].PROVID
,
3693 map_entry
->mapcaid
, map_entry
->mapprovid
);
3695 demux
[demux_id
].ECMpids
[j
].CAID
= map_entry
->mapcaid
;
3696 demux
[demux_id
].ECMpids
[j
].PROVID
= map_entry
->mapprovid
;
3701 static void dvbapi_priority_read_entry_extra(int32_t demux_id
)
3703 struct s_dvbapi_priority
*extra_entry
;
3704 int32_t j
, k
, l
, m
, extra_demux_id
;
3706 for(extra_entry
= dvbapi_priority
; extra_entry
!= NULL
; extra_entry
= extra_entry
->next
)
3708 if(extra_entry
->type
!= 'x')
3713 for(j
= 0; j
<= demux
[demux_id
].ECMpidcount
; ++j
)
3715 if((extra_entry
->caid
&& extra_entry
->caid
!= demux
[demux_id
].ECMpids
[j
].CAID
)
3716 || (extra_entry
->provid
&& extra_entry
->provid
!= demux
[demux_id
].ECMpids
[j
].PROVID
)
3717 || (extra_entry
->ecmpid
&& extra_entry
->ecmpid
!= demux
[demux_id
].ECMpids
[j
].ECM_PID
)
3718 || (extra_entry
->srvid
&& extra_entry
->srvid
!= demux
[demux_id
].program_number
))
3723 cs_log("Mapping ecm pid %04X@%06X:%04X:%04X to extra demuxer",
3724 extra_entry
->caid
, extra_entry
->provid
, extra_entry
->ecmpid
, extra_entry
->srvid
);
3726 for(extra_demux_id
= 0; extra_demux_id
< MAX_DEMUX
; extra_demux_id
++)
3728 if(demux
[extra_demux_id
].program_number
!= 0)
3730 continue; // Skip occupied demuxers
3734 if(extra_demux_id
>= MAX_DEMUX
)
3736 cs_log("There is no free demuxer for extra streams");
3740 demux
[extra_demux_id
].ECMpids
[0] = demux
[demux_id
].ECMpids
[j
];
3741 demux
[extra_demux_id
].ECMpidcount
= 1;
3742 demux
[extra_demux_id
].STREAMpidcount
= 0;
3743 demux
[extra_demux_id
].program_number
= demux
[demux_id
].program_number
;
3744 demux
[extra_demux_id
].pmtpid
= demux
[demux_id
].pmtpid
;
3745 demux
[extra_demux_id
].demux_index
= demux
[demux_id
].demux_index
;
3746 demux
[extra_demux_id
].adapter_index
= demux
[demux_id
].adapter_index
;
3747 demux
[extra_demux_id
].ca_mask
= demux
[demux_id
].ca_mask
;
3748 demux
[extra_demux_id
].socket_fd
= demux
[demux_id
].socket_fd
;
3749 demux
[extra_demux_id
].stop_descrambling
= false;
3750 demux
[extra_demux_id
].rdr
= NULL
;
3751 demux
[extra_demux_id
].curindex
= -1;
3753 // Add streams to extra demux
3754 for(k
= 0; k
< demux
[demux_id
].STREAMpidcount
; ++k
)
3756 if(!demux
[demux_id
].ECMpids
[j
].streams
|| (demux
[demux_id
].ECMpids
[j
].streams
& (1 << k
)))
3758 demux
[extra_demux_id
].ECMpids
[0].streams
|= (1 << demux
[extra_demux_id
].STREAMpidcount
);
3759 demux
[extra_demux_id
].STREAMpids
[demux
[extra_demux_id
].STREAMpidcount
] = demux
[demux_id
].STREAMpids
[k
];
3760 demux
[extra_demux_id
].STREAMpidsType
[demux
[extra_demux_id
].STREAMpidcount
] = demux
[demux_id
].STREAMpidsType
[k
];
3761 ++demux
[extra_demux_id
].STREAMpidcount
;
3763 // Shift stream associations in normal demux because we will remove the stream entirely
3764 for(l
= 0; l
< demux
[demux_id
].ECMpidcount
; ++l
)
3766 for(m
= k
; m
< demux
[demux_id
].STREAMpidcount
- 1; ++m
)
3768 if(demux
[demux_id
].ECMpids
[l
].streams
& (1 << (m
+ 1)))
3770 demux
[demux_id
].ECMpids
[l
].streams
|= (1 << m
);
3774 demux
[demux_id
].ECMpids
[l
].streams
&= ~(1 << m
);
3779 // Remove stream association from normal demux device
3780 for(l
= k
; l
< demux
[demux_id
].STREAMpidcount
- 1; ++l
)
3782 demux
[demux_id
].STREAMpids
[l
] = demux
[demux_id
].STREAMpids
[l
+ 1];
3783 demux
[demux_id
].STREAMpidsType
[l
] = demux
[demux_id
].STREAMpidsType
[l
+ 1];
3786 --demux
[demux_id
].STREAMpidcount
;
3791 // Remove ecm pid from normal demuxer
3792 for(k
= j
; k
< demux
[demux_id
].ECMpidcount
; ++k
)
3794 demux
[demux_id
].ECMpids
[k
] = demux
[demux_id
].ECMpids
[k
+ 1];
3797 --demux
[demux_id
].ECMpidcount
;
3800 if(demux
[extra_demux_id
].STREAMpidcount
<= 0)
3802 cs_log("Found no streams for extra demuxer. Not starting additional decoding on it.");
3804 demux
[extra_demux_id
].program_number
= 0;
3805 demux
[extra_demux_id
].stop_descrambling
= true;
3808 if(demux
[demux_id
].STREAMpidcount
< 1)
3810 cs_log("Found no streams for normal demuxer. Not starting additional decoding on it.");
3816 static void dvbapi_parse_pmt_ca_descriptor(int32_t demux_id
, const uint8_t *buffer
, uint8_t descriptor_length
)
3818 uint16_t i
, ca_system_id
, ca_pid
;
3819 uint32_t ca_provider
= 0, ca_data
= 0;
3820 char txt
[40]; // room for PBM: 8 byte pbm and DATE: date
3821 memset(txt
, 0x00, sizeof(txt
));
3823 if(descriptor_length
< 4)
3825 return; // CA descriptor has a minimum length of 4 bytes
3828 ca_system_id
= b2i(2, buffer
);
3829 ca_pid
= b2i(2, buffer
+ 2) & 0x1FFF;
3831 if(caid_is_seca(ca_system_id
))
3833 for(i
= 2; i
< descriptor_length
; i
+= 15)
3835 ca_pid
= b2i(2, buffer
+ i
) & 0x1FFF;
3836 ca_provider
= b2i(2, buffer
+ i
+ 2);
3838 int8_t year
= buffer
[i
+ 13] >> 1;
3839 int8_t month
= (((buffer
[i
+ 13] & 0x01) << 3) | (buffer
[i
+ 14] >> 5));
3840 int8_t day
= buffer
[i
+ 14] & 0x1F;
3842 snprintf(txt
, sizeof(txt
), "PBM: ");
3843 cs_hexdump(0, buffer
+ i
+ 5, 8, txt
+ 5, (2 * 8) + 1); // hexdump 8 byte pbm
3844 snprintf(txt
+ 20, sizeof(txt
) - 20, " DATE: %d-%d-%d", day
, month
, year
+ 1990);
3846 dvbapi_add_ecmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, 0, txt
);
3851 if(caid_is_viaccess(ca_system_id
) && descriptor_length
== 0x0F && buffer
[10] == 0x14)
3853 ca_provider
= b2i(3, buffer
+ 12) & 0xFFFFF0;
3855 else if(caid_is_nagra(ca_system_id
) && descriptor_length
== 0x07)
3857 ca_provider
= b2i(2, buffer
+ 5);
3859 else if((ca_system_id
>> 8 == 0x4A || ca_system_id
== 0x2710) && descriptor_length
> 0x04)
3861 ca_provider
= buffer
[4];
3863 if(caid_is_dre(ca_system_id
) && descriptor_length
== 0x0A)
3865 ca_data
= b2i(4, buffer
+ 6);
3866 snprintf(txt
, 40, "CA DATA: %X", ca_data
);
3870 dvbapi_add_ecmpid(demux_id
, ca_system_id
, ca_pid
, ca_provider
, ca_data
, txt
);
3874 static void dvbapi_parse_pmt_descriptors(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint8_t *type
)
3877 uint8_t descriptor_tag
, descriptor_length
;
3879 for(i
= 0; i
+ 1 < length
; i
+= 2 + descriptor_length
)
3881 descriptor_tag
= buffer
[i
];
3882 descriptor_length
= buffer
[i
+ 1];
3884 cs_log_dbg(D_DVBAPI
, "Demuxer %d found %s descriptor (tag: %02X length: %02X)",
3885 demux_id
, get_descriptor_tag_txt(descriptor_tag
), descriptor_tag
, descriptor_length
);
3887 switch(descriptor_tag
)
3889 case 0x05: // Registration descriptor
3891 // "HDMV" format identifier is removed
3892 // OSCam does not need to know about Blu-ray
3893 const char format_identifiers_audio
[10][5] =
3895 "AC-3", "BSSD", "dmat", "DRA1", "DTS1",
3896 "DTS2", "DTS3", "EAC3", "mlpa", "Opus",
3899 for(j
= 0; j
< 10; j
++)
3901 if(memcmp(buffer
+ i
+ 2, format_identifiers_audio
[j
], 4) == 0)
3903 *type
= STREAM_AUDIO
;
3910 case 0x09: // CA descriptor
3912 dvbapi_parse_pmt_ca_descriptor(demux_id
, buffer
+ i
+ 2, descriptor_length
);
3916 case 0x59: // Subtitling descriptor (DVB)
3918 *type
= STREAM_SUBTITLE
;
3922 case 0x6A: // AC-3 descriptor (DVB)
3923 case 0x7A: // Enhanced AC-3 descriptor (DVB)
3924 case 0x7B: // DTS descriptor (DVB)
3925 case 0x7C: // AAC descriptor (DVB)
3926 case 0x81: // AC-3 descriptor (ATSC)
3927 case 0xCC: // Enhanced AC-3 descriptor (ATSC)
3929 *type
= STREAM_AUDIO
;
3933 case 0x7F: // Extension descriptor (DVB)
3935 uint8_t extension_descriptor_tag
= buffer
[i
+ 2];
3937 cs_log_dbg(D_DVBAPI
, "Demuxer %d found %s descriptor (extension tag: %02X)",
3938 demux_id
, get_extension_descriptor_txt(extension_descriptor_tag
), extension_descriptor_tag
);
3940 switch(extension_descriptor_tag
)
3942 case 0x0E: // DTS-HD descriptor (DVB)
3943 case 0x0F: // DTS Neural descriptor (DVB)
3944 case 0x15: // AC-4 descriptor (DVB)
3945 case 0x21: // DTS-UHD descriptor (DVB)
3946 *type
= STREAM_AUDIO
;
3950 *type
= STREAM_UNDEFINED
;
3962 void request_cw(struct s_client
*client
, ECM_REQUEST
*er
, int32_t demux_id
, uint8_t delayed_ecm_check
)
3966 int32_t filternum
= dvbapi_set_section_filter(demux_id
, er
, -1); // set ecm filter to odd -> even and visaversa
3969 cs_log_dbg(D_DVBAPI
, "Demuxer %d not requesting cw -> ecm filter was killed!", demux_id
);
3974 if(!delayed_ecm_check
) // no delayed ecm check for this filter
3976 memset(demux
[demux_id
].demux_fd
[filternum
].lastecmd5
, 0, CS_ECMSTORESIZE
); // no ecm delay check: zero it!
3980 uint8_t md5tmp
[MD5_DIGEST_LENGTH
];
3981 MD5(er
->ecm
, er
->ecmlen
, md5tmp
);
3983 if(!memcmp(demux
[demux_id
].demux_fd
[filternum
].prevecmd5
, md5tmp
, CS_ECMSTORESIZE
))
3985 if(demux
[demux_id
].demux_fd
[filternum
].prevresult
< E_NOTFOUND
)
3987 cs_log_dbg(D_DVBAPI
, "Demuxer %d not requesting same ecm again! -> SKIP!", demux_id
);
3993 cs_log_dbg(D_DVBAPI
, "Demuxer %d requesting same ecm again (previous result was not found!)", demux_id
);
3996 else if(!memcmp(demux
[demux_id
].demux_fd
[filternum
].lastecmd5
, md5tmp
, CS_ECMSTORESIZE
))
3998 if(demux
[demux_id
].demux_fd
[filternum
].lastresult
< E_NOTFOUND
)
4000 cs_log_dbg(D_DVBAPI
, "Demuxer %d not requesting same ecm again! -> SKIP!", demux_id
);
4006 cs_log_dbg(D_DVBAPI
, "Demuxer %d requesting same ecm again (previous result was not found!)", demux_id
);
4010 memcpy(demux
[demux_id
].demux_fd
[filternum
].prevecmd5
, demux
[demux_id
].demux_fd
[filternum
].lastecmd5
, CS_ECMSTORESIZE
);
4011 demux
[demux_id
].demux_fd
[filternum
].prevresult
= demux
[demux_id
].demux_fd
[filternum
].lastresult
;
4012 memcpy(demux
[demux_id
].demux_fd
[filternum
].lastecmd5
, md5tmp
, CS_ECMSTORESIZE
);
4013 demux
[demux_id
].demux_fd
[filternum
].lastresult
= 0xFF;
4016 er
->adapter_index
= demux
[demux_id
].adapter_index
;
4020 char buf
[ECM_FMT_LEN
];
4021 format_ecm(er
, buf
, ECM_FMT_LEN
);
4022 cs_log_dbg(D_DVBAPI
, "Demuxer %d request controlword for ecm %s", demux_id
, buf
);
4026 void dvbapi_try_next_caid(int32_t demux_id
, int8_t checked
, uint32_t msgid
)
4028 int32_t n
, j
, found
= -1, started
= 0;
4029 int32_t status
= demux
[demux_id
].max_status
;
4031 for(j
= status
; j
>= 0; j
--) // largest status first!
4033 for(n
= 0; n
< demux
[demux_id
].ECMpidcount
; n
++)
4035 //cs_log_dbg(D_DVBAPI,"Demuxer %d PID %d checked = %d status = %d (searching for pid with status = %d)",
4036 // demux_id, n, demux[demux_id].ECMpids[n].checked, demux[demux_id].ECMpids[n].status, j);
4038 if(demux
[demux_id
].ECMpids
[n
].checked
== checked
&& demux
[demux_id
].ECMpids
[n
].status
== j
)
4041 openxcas_set_provid(demux
[demux_id
].ECMpids
[found
].PROVID
);
4042 openxcas_set_caid(demux
[demux_id
].ECMpids
[found
].CAID
);
4043 openxcas_set_ecm_pid(demux
[demux_id
].ECMpids
[found
].ECM_PID
);
4045 // fixup for cas that need emm first!
4046 if(caid_is_irdeto(demux
[demux_id
].ECMpids
[found
].CAID
) || (caid_is_dre(demux
[demux_id
].ECMpids
[found
].CAID
)
4047 && ((demux
[demux_id
].ECMpids
[found
].PROVID
== 0x11 || demux
[demux_id
].ECMpids
[found
].PROVID
== 0xFE))))
4049 demux
[demux_id
].emmstart
.time
= 0;
4052 started
= dvbapi_start_descrambling(demux_id
, found
, checked
, msgid
);
4053 if(cfg
.dvbapi_requestmode
== 0 && started
== 1)
4055 return; // in requestmode 0 we only start 1 ecm request at the time
4061 if(found
== -1 && demux
[demux_id
].pidindex
== -1)
4063 cs_log("Demuxer %d no suitable readers found that can be used for decoding!", demux_id
);
4068 static void dvbapi_parse_pmt_program_info(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint8_t *ca_pmt_cmd_id
)
4070 uint16_t i
, offset
= 0;
4071 uint8_t descriptor_tag
, descriptor_length
;
4073 if(ca_pmt_cmd_id
!= NULL
) // We are on CA PMT parsing
4075 *ca_pmt_cmd_id
= buffer
[0];
4079 for(i
= offset
; i
+ 1 < length
; i
+= 2 + descriptor_length
)
4081 descriptor_tag
= buffer
[i
];
4082 descriptor_length
= buffer
[i
+ 1];
4084 if(descriptor_tag
== 0x09) // We only care about CA descriptors at program level
4086 dvbapi_parse_pmt_ca_descriptor(demux_id
, buffer
+ i
+ 2, descriptor_length
);
4091 static void dvbapi_parse_pmt_es_info(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint8_t *ca_pmt_cmd_id
, uint16_t *video_pid
)
4093 uint16_t i
, elementary_pid
, es_info_length
, offset
= 0;
4094 uint8_t stream_type
, type
;
4096 for(i
= 0; i
+ 4 < length
; i
+= 5 + es_info_length
)
4098 if(demux
[demux_id
].STREAMpidcount
>= MAX_STREAM_PIDS
)
4100 cs_log("Demuxer %d reached maximum number of elementary streams", demux_id
);
4104 type
= STREAM_UNDEFINED
;
4105 stream_type
= buffer
[i
];
4106 elementary_pid
= b2i(2, buffer
+ i
+ 1) & 0x1FFF;
4107 es_info_length
= b2i(2, buffer
+ i
+ 3) & 0x0FFF;
4109 cs_log_dbg(D_DVBAPI
,"Demuxer %d found %s stream (type: %02X pid: %04X)",
4110 demux_id
, get_stream_type_txt(stream_type
), stream_type
, elementary_pid
);
4112 if(es_info_length
!= 0 && es_info_length
< length
)
4114 if(ca_pmt_cmd_id
!= NULL
) // We are on CA PMT parsing
4116 // Only enigma2, Spark and VDR follow the CA PMT specification ("ca_pmt_cmd_id"
4117 // shall be present in the ES info loop). For the first two, checking for boxtype
4118 // "dreambox" is sufficient, but for VDR this is not enough, because it shares
4119 // the same boxtype with tvheadend. So, for every other box (including VDR and
4120 // tvheadend), we stick to the old style check based on the value (descriptors
4121 // with tag 0x00 or 0x01 are not allowed, so this works), while for enigma2 we
4122 // do a proper check, because the "ca_pmt_cmd_id" can also take greater values.
4123 if(cfg
.dvbapi_boxtype
== BOXTYPE_DREAMBOX
)
4125 *ca_pmt_cmd_id
= buffer
[i
+ 5]; // It should be identical for all ES and the same as in program info
4130 offset
= (buffer
[i
+ 5] <= 0x01) ? 1 : 0;
4134 // Parse descriptors at ES level
4135 dvbapi_parse_pmt_descriptors(demux_id
, buffer
+ i
+ 5 + offset
, es_info_length
, &type
);
4138 // Get basic stream type (video, audio, subtitle) for each ES pid
4153 *video_pid
= elementary_pid
;
4155 demux
[demux_id
].STREAMpidsType
[demux
[demux_id
].STREAMpidcount
] = STREAM_VIDEO
;
4166 demux
[demux_id
].STREAMpidsType
[demux
[demux_id
].STREAMpidcount
] = STREAM_AUDIO
;
4170 //case 0x81: some ATSC AC-3 streams do not contain the AC-3 descriptor!
4172 // Set the type based on the descriptors for these stream types
4173 demux
[demux_id
].STREAMpidsType
[demux
[demux_id
].STREAMpidcount
] = type
;
4177 demux
[demux_id
].STREAMpidsType
[demux
[demux_id
].STREAMpidcount
] = STREAM_UNDEFINED
;
4181 demux
[demux_id
].STREAMpids
[demux
[demux_id
].STREAMpidcount
] = elementary_pid
;
4182 demux
[demux_id
].STREAMpidcount
++;
4186 static void dvbapi_parse_pmt_info(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint8_t *ca_pmt_cmd_id
)
4188 uint16_t i
, program_info_length
, video_pid
= 0;
4190 // Cleanout demuxer from possible stale info
4191 // (reset ECM pids and streams)
4192 if(demux
[demux_id
].running
== false)
4194 demux
[demux_id
].ECMpidcount
= 0;
4197 for(i
= 0; i
< demux
[demux_id
].ECMpidcount
; i
++)
4199 demux
[demux_id
].ECMpids
[i
].streams
= 0;
4202 demux
[demux_id
].STREAMpidcount
= 0;
4204 // Parse program info
4205 // In case of CA PMT, read the ca_pmt_cmd_id as well
4206 program_info_length
= b2i(2, buffer
) & 0x0FFF;
4207 if(program_info_length
!= 0 && program_info_length
< length
)
4209 dvbapi_parse_pmt_program_info(demux_id
, buffer
+ 2, program_info_length
, ca_pmt_cmd_id
);
4212 // Parse elementary stream info
4213 // In case of CA PMT, read the ca_pmt_cmd_id for each stream as well
4214 dvbapi_parse_pmt_es_info(demux_id
, buffer
+ 2 + program_info_length
, length
- 2 - program_info_length
, ca_pmt_cmd_id
, &video_pid
);
4216 cs_log("Demuxer %d found %d ECM pids and %d STREAM pids in %sPMT", demux_id
,
4217 demux
[demux_id
].ECMpidcount
, demux
[demux_id
].STREAMpidcount
, ca_pmt_cmd_id
!= NULL
? "CA " : "");
4219 // Various retarded boxes misuse the "ca_pmt_cmd_id" value,
4220 // usually by setting it to zero. If we are on CA PMT parsing,
4221 // make sure we pass a value we can work with later on.
4222 if(ca_pmt_cmd_id
!= NULL
)
4224 *ca_pmt_cmd_id
= (*ca_pmt_cmd_id
< CA_PMT_CMD_OK_DESCRAMBLING
) ? CA_PMT_CMD_OK_DESCRAMBLING
: *ca_pmt_cmd_id
;
4227 // If no elementary streams are available, set the PMT pid as the
4228 // first stream (PMT cannot be encrypted, like it was mentioned
4229 // in the old comment, so not sure why this is needed...)
4230 if(demux
[demux_id
].STREAMpidcount
== 0)
4232 demux
[demux_id
].STREAMpids
[0] = demux
[demux_id
].pmtpid
;
4233 demux
[demux_id
].STREAMpidsType
[0] = STREAM_VIDEO
;
4234 demux
[demux_id
].STREAMpidcount
++;
4235 video_pid
= demux
[demux_id
].pmtpid
;
4238 // Register found video pid on all ECM pids of this demuxer
4239 for(i
= 0; i
< demux
[demux_id
].ECMpidcount
; i
++)
4241 demux
[demux_id
].ECMpids
[i
].VPID
= video_pid
;
4244 // Search for dvbapi priority entries for this program
4245 if(dvbapi_priority
!= NULL
)
4247 dvbapi_priority_read_entry_add(demux_id
, video_pid
);
4248 dvbapi_priority_read_entry_map(demux_id
);
4249 dvbapi_priority_read_entry_extra(demux_id
);
4253 typedef struct demux_parameters
4255 uint8_t demux_index
;
4256 uint8_t adapter_index
;
4258 uint16_t program_number
;
4263 } demux_parameters_t
;
4265 static void get_demux_parameters(const uint8_t *buffer
, demux_parameters_t
*parameters
)
4267 parameters
->ca_mask
= 1;
4268 parameters
->demux_index
= 0;
4269 parameters
->adapter_index
= 0;
4270 parameters
->pmtpid
= 0;
4271 parameters
->program_number
= b2i(2, buffer
+ 1);
4273 uint16_t program_info_length
= b2i(2, buffer
+ 4) & 0x0FFF;
4274 uint16_t pos
= 7; // 4 + 2 (program_info_length) + 1 (ca_pmt_cmd_id)
4276 while(pos
+ 1 < 5 + program_info_length
)
4278 uint8_t descriptor_tag
= buffer
[pos
];
4279 uint8_t descriptor_length
= buffer
[pos
+ 1];
4281 switch(descriptor_tag
)
4288 case ENIGMA_NAMESPACE
:
4290 if(descriptor_length
== 0x08)
4292 parameters
->ens
= b2i(4, buffer
+ pos
+ 2);
4293 parameters
->tsid
= b2i(2, buffer
+ pos
+ 6);
4294 parameters
->onid
= b2i(2, buffer
+ pos
+ 8);
4299 case DEMUX_CA_MASK_ADAPTER
:
4301 if(descriptor_length
== 0x02 && (cfg
.dvbapi_boxtype
== BOXTYPE_PC
||
4302 cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
|| cfg
.dvbapi_boxtype
== BOXTYPE_SAMYGO
))
4304 parameters
->demux_index
= buffer
[pos
+ 2]; // Usually 0, but not always
4305 parameters
->adapter_index
= buffer
[pos
+ 3]; // Can be 0, 1, 2, ...
4306 parameters
->ca_mask
= (1 << parameters
->adapter_index
); // use adapter_index as ca_mask
4308 else if(descriptor_length
== 0x03 && cfg
.dvbapi_boxtype
== BOXTYPE_QBOXHD
)
4310 // ca_mask = buffer[pos + 2]; // with STONE 1.0.4 always 0x01
4311 parameters
->demux_index
= buffer
[pos
+ 3]; // with STONE 1.0.4 always 0x00
4312 parameters
->adapter_index
= buffer
[pos
+ 4]; // with STONE 1.0.4 adapter index can be 0, 1, 2
4313 parameters
->ca_mask
= (1 << parameters
->adapter_index
); // use adapter_index as ca_mask
4315 else if(descriptor_length
== 0x02) // enigma2
4317 parameters
->ca_mask
= buffer
[pos
+ 2];
4318 uint8_t demux_tmp
= buffer
[pos
+ 3];
4320 if(demux_tmp
>= 8 && parameters
->ca_mask
== 0) // openpli based images
4322 parameters
->ca_mask
= 1 << demux_tmp
;
4325 if(demux_tmp
== 0xFF) // tryfix prismcube (0xFF -> "demux-1" = error!)
4329 parameters
->demux_index
= demux_tmp
;
4334 case ADAPTER_DEVICE
:
4336 if(descriptor_length
== 0x01)
4338 parameters
->adapter_index
= buffer
[pos
+ 2];
4345 if(descriptor_length
== 0x02)
4347 parameters
->pmtpid
= b2i(2, buffer
+ pos
+ 2);
4352 case SERVICE_TYPE_MASK
:
4357 if(descriptor_length
== 0x01)
4359 parameters
->demux_index
= buffer
[pos
+ 2];
4360 parameters
->ca_mask
= 1 << parameters
->demux_index
;
4367 if(descriptor_length
== 0x01)
4369 parameters
->ca_mask
= 1 << buffer
[pos
+ 2];
4376 cs_log_dbg(D_DVBAPI
, "Skipped unsupported or CA PMT irrelevant descriptor (tag: %02X length: %02X)", descriptor_tag
, descriptor_length
);
4381 pos
+= 2 + descriptor_length
;
4385 static void dvbapi_capmt_notify(struct demux_s
*dmx
)
4387 struct s_client
*cl
;
4388 for(cl
= first_client
->next
; cl
; cl
= cl
->next
)
4390 if((cl
->typ
== 'p' || cl
->typ
== 'r') && cl
->reader
&& cl
->reader
->ph
.c_capmt
)
4392 struct demux_s
*curdemux
;
4393 if(cs_malloc(&curdemux
, sizeof(struct demux_s
)))
4395 memcpy(curdemux
, dmx
, sizeof(struct demux_s
));
4396 add_job(cl
, ACTION_READER_CAPMT_NOTIFY
, curdemux
, sizeof(struct demux_s
));
4402 static void dvbapi_prepare_descrambling(int32_t demux_id
, uint32_t msgid
)
4404 bool is_powervu
= false, start_emm
= true;
4405 char service_name
[CS_SERVICENAME_SIZE
];
4407 // The CA PMT should have given us enough info to determine if descrambling
4408 // is possible. Parsing the (real) PMT is not necessary, unless we have a
4409 // PowerVu encrypted channel or (for some weird reason) no stream pids at all.
4410 // Actually, when no streams are available, we set the PMT pid as the 1st
4411 // stream pid, so we have to check against that. Finally, if the PMT pid is
4412 // not included in the CA PMT, we start the PAT filter instead.
4414 #ifdef WITH_EXTENDED_CW
4416 for(i
= 0; i
< demux
[demux_id
].ECMpidcount
; i
++)
4418 if(caid_is_powervu(demux
[demux_id
].ECMpids
[i
].CAID
))
4426 if(demux
[demux_id
].pmtpid
== 0)
4428 dvbapi_start_pat_filter(demux_id
);
4430 else if(demux
[demux_id
].STREAMpids
[0] == demux
[demux_id
].pmtpid
|| is_powervu
)
4432 dvbapi_start_pmt_filter(demux_id
);
4435 if(demux
[demux_id
].running
)
4437 disable_unused_streampids(demux_id
); // disable all streampids not in use anymore
4440 if(!demux
[demux_id
].running
&& demux
[demux_id
].ECMpidcount
!= 0) // only start demuxer if it wasn't running
4442 // remove all non important filtering
4443 // (there are images with limited amount of filters available!)
4444 dvbapi_stop_all_cat_emm_sdt_filtering(msgid
);
4446 get_servicename(dvbapi_client
, demux
[demux_id
].program_number
, demux
[demux_id
].ECMpids
[0].PROVID
,
4447 demux
[demux_id
].ECMpids
[0].CAID
, service_name
, sizeof(service_name
));
4449 cs_log_dbg(D_DVBAPI
, "Demuxer %d started descrambling for program %04X (%s) (fd: %d)",
4450 demux_id
, demux
[demux_id
].program_number
, service_name
, demux
[demux_id
].socket_fd
);
4452 demux
[demux_id
].running
= true; // mark channel as running
4453 openxcas_set_sid(demux
[demux_id
].program_number
);
4454 demux
[demux_id
].decodingtries
= -1;
4455 dvbapi_resort_ecmpids(demux_id
);
4456 dvbapi_try_next_caid(demux_id
, 0, msgid
);
4459 else if(demux
[demux_id
].ECMpidcount
== 0) // FTA: do logging and part of ecm handler
4461 get_servicename(dvbapi_client
, demux
[demux_id
].program_number
, NO_PROVID_VALUE
, NO_CAID_VALUE
,
4462 service_name
, sizeof(service_name
));
4464 cs_log_dbg(D_DVBAPI
, "Demuxer %d no descrambling needed for FTA program %04X (%s) (fd: %d)",
4465 demux_id
, demux
[demux_id
].program_number
, service_name
, demux
[demux_id
].socket_fd
);
4467 demux
[demux_id
].running
= false; // reset running flag
4468 demux
[demux_id
].pidindex
= -1; // reset ecmpid used for descrambling
4469 dvbapi_stop_filter(demux_id
, TYPE_ECM
, msgid
);
4471 if(cfg
.usrfileflag
) // add to user log previous channel + time on channel
4473 cs_statistics(dvbapi_client
);
4476 dvbapi_client
->last_srvid
= demux
[demux_id
].program_number
; // set new channel srvid
4477 dvbapi_client
->last_caid
= NO_CAID_VALUE
; // FTA channels have no caid!
4478 dvbapi_client
->last_provid
= NO_PROVID_VALUE
; // FTA channels have no provid!
4479 dvbapi_client
->lastswitch
= dvbapi_client
->last
= time((time_t *)0); // reset idle-Time & last switch
4482 #if defined(WITH_COOLAPI) || defined(WITH_COOLAPI2)
4483 // Don't start and Stop EMM Filters over and over again if we are on FTA
4484 if(dvbapi_client
->last_caid
== NO_CAID_VALUE
)
4490 // only do emm setup if au enabled and not running!
4491 if(cfg
.dvbapi_au
> 0 && demux
[demux_id
].EMMpidcount
== 0 && start_emm
== true)
4493 demux
[demux_id
].emm_filter
= -1; // to register first run emmfilter start
4495 if(demux
[demux_id
].emmstart
.time
== 1) // irdeto fetch emm cat direct!
4497 // trick to let emm fetching start after 30 seconds to speed up zapping
4498 cs_ftime(&demux
[demux_id
].emmstart
);
4500 dvbapi_start_cat_filter(demux_id
);
4504 cs_ftime(&demux
[demux_id
].emmstart
); // for all other caids delayed start!
4509 int32_t dvbapi_parse_capmt(const uint8_t *buffer
, uint32_t length
, int32_t connfd
, char *pmtfile
, uint16_t client_proto_version
, uint32_t msgid
)
4511 int32_t i
, demux_id
= -1;
4512 uint8_t ca_pmt_list_management
, ca_pmt_cmd_id
;
4513 bool is_update
= false;
4514 demux_parameters_t parameters
;
4515 memset(¶meters
, 0, sizeof(parameters
));
4517 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
4518 ca_pmt_list_management
= CA_PMT_LIST_ONLY
;
4520 ca_pmt_list_management
= buffer
[0];
4523 // We received a new list of CA PMT objects.
4524 // Mark all demuxers to stop descrambling, but do not actually stop any of them,
4525 // until we verify the new list does not contain any previously selected program.
4526 if(ca_pmt_list_management
== CA_PMT_LIST_FIRST
|| ca_pmt_list_management
== CA_PMT_LIST_ONLY
)
4528 for(i
= 0; i
< MAX_DEMUX
; i
++)
4530 // Skip empty demuxers, demuxers belonging to different
4531 // CA PMT connections or handled by different PMT files.
4532 if(demux
[i
].program_number
== 0 || demux
[i
].socket_fd
!= connfd
||
4533 (demux
[i
].socket_fd
== -1 && pmtfile
&& strcmp(demux
[i
].pmt_file
, pmtfile
) != 0))
4538 demux
[i
].stop_descrambling
= true; // Mark for deletion if not used again by following CA PMT objects
4540 cs_log_dbg(D_DVBAPI
, "Demuxer %d marked to stop descrambling for program %04X (fd: %d)",
4541 i
, demux
[i
].program_number
, connfd
);
4545 // Read private descriptors inside the CA PMT message
4546 // in order to get adapter, demux, ca, pmt pid and more.
4547 get_demux_parameters(buffer
, ¶meters
);
4549 cs_log_dbg(D_DVBAPI
, "Received CA PMT list management %d for program %04X (pmt pid: %04X adapter: %d demux: %d camask: %d)",
4550 ca_pmt_list_management
, parameters
.program_number
, parameters
.pmtpid
, parameters
.adapter_index
,
4551 parameters
.demux_index
, parameters
.ca_mask
);
4553 // Search current demuxers for having the same program
4554 // as the one we received in this CA PMT object.
4555 for(i
= 0; i
< MAX_DEMUX
; i
++)
4557 if(demux
[i
].program_number
== 0)
4562 if(cfg
.dvbapi_boxtype
== BOXTYPE_IPBOX_PMT
)
4564 parameters
.demux_index
= i
; // fixup for ipbox
4567 bool full_check
= true, matched
= false;
4569 if(config_enabled(WITH_COOLAPI
) || config_enabled(WITH_COOLAPI2
) || cfg
.dvbapi_boxtype
== BOXTYPE_SAMYGO
)
4576 matched
= (connfd
> 0 && demux
[i
].socket_fd
== connfd
) && demux
[i
].program_number
== parameters
.program_number
;
4580 matched
= connfd
> 0 && demux
[i
].program_number
== parameters
.program_number
;
4587 // In PMT mode 6, when zapping between channels with the same program number and PMT pid
4588 // (sometimes the case with satellite feeds), as all hardware parameters being the same
4589 // (adapter, demux, ca_mask, connfd), the new program is considered an existing one (matched).
4590 // The only reliable way to determine whether we actually have a new program is to compare
4591 // the enigma namespace, tsid and onid as well.
4592 if(demux
[i
].demux_index
!= parameters
.demux_index
|| demux
[i
].ca_mask
!= parameters
.ca_mask
||
4593 demux
[i
].adapter_index
!= parameters
.adapter_index
|| demux
[i
].pmtpid
!= parameters
.pmtpid
||
4594 demux
[i
].ens
!= parameters
.ens
|| demux
[i
].tsid
!= parameters
.tsid
|| demux
[i
].onid
!= parameters
.onid
)
4600 // A program update is normally signaled by either a list management:
4601 // 1. UPDATE for an existing program
4602 // 2. ADD for an existing program (which according to the specifications should be treated as an UPDATE)
4603 // 3. ONLY for an existing program (with broken clients, in pmt modes other than 6)
4604 if(ca_pmt_list_management
== CA_PMT_LIST_UPDATE
|| ca_pmt_list_management
== CA_PMT_LIST_ADD
4605 || (cfg
.dvbapi_pmtmode
!= 6 && ca_pmt_list_management
== CA_PMT_LIST_ONLY
))
4608 cs_log("Demuxer %d received updated CA PMT for program %04X", i
, parameters
.program_number
);
4611 cs_log("Demuxer %d continues descrambling for program %04X", i
, demux
[i
].program_number
);
4612 openxcas_set_sid(parameters
.program_number
);
4613 demux
[i
].stop_descrambling
= false; // don't stop current demuxer!
4615 break; // no need to explore other demuxers since we have a match!
4619 // We are currently processing the last object of the CA PMT list.
4620 // We should now stop descrambling all programs not included in this list.
4621 if(ca_pmt_list_management
!= CA_PMT_LIST_FIRST
&& ca_pmt_list_management
!= CA_PMT_LIST_MORE
)
4623 for(i
= 0; i
< MAX_DEMUX
; i
++)
4625 if(demux
[i
].program_number
== 0)
4630 if(demux
[i
].stop_descrambling
)
4632 dvbapi_stop_descrambling(i
, msgid
);
4637 // We continue reading the CA PMT object only when we get
4638 // a new program (demux_id == -1) or an updated program.
4639 if(!(demux_id
== -1 || is_update
))
4644 // We received a CA PMT object for a new program.
4645 // Let's find an empty demuxer for it.
4648 if(ca_pmt_list_management
== CA_PMT_LIST_UPDATE
)
4650 cs_log("ERROR: Received CA PMT list update for unknown program");
4654 for(demux_id
= 0; demux_id
< MAX_DEMUX
; demux_id
++)
4656 if(demux
[demux_id
].program_number
!= 0)
4658 continue; // Skip occupied demuxers
4661 // Probably this box doesn't send any private descriptor in the
4662 // CA PMT, so we have to improvise before saving to the demuxer.
4663 if(cfg
.dvbapi_boxtype
== BOXTYPE_IPBOX_PMT
)
4665 parameters
.ca_mask
= demux_id
+ 1;
4666 parameters
.demux_index
= demux_id
;
4669 demux
[demux_id
].demux_index
= parameters
.demux_index
;
4670 demux
[demux_id
].adapter_index
= parameters
.adapter_index
;
4671 demux
[demux_id
].ca_mask
= parameters
.ca_mask
;
4672 demux
[demux_id
].socket_fd
= connfd
;
4673 demux
[demux_id
].client_proto_version
= client_proto_version
;
4674 demux
[demux_id
].program_number
= parameters
.program_number
;
4675 demux
[demux_id
].pmtpid
= parameters
.pmtpid
;
4676 demux
[demux_id
].ens
= parameters
.ens
;
4677 demux
[demux_id
].tsid
= parameters
.tsid
;
4678 demux
[demux_id
].onid
= parameters
.onid
;
4679 demux
[demux_id
].stop_descrambling
= false;
4680 demux
[demux_id
].running
= false;
4681 demux
[demux_id
].sdt_filter
= -1;
4682 demux
[demux_id
].rdr
= NULL
;
4686 cs_strncpy(demux
[demux_id
].pmt_file
, pmtfile
, sizeof(demux
[demux_id
].pmt_file
));
4692 if(demux_id
>= MAX_DEMUX
)
4694 cs_log("There is no free demuxer for the new program! Aborting...");
4699 // We continue parsing the CA PMT info for new or updated programs.
4700 // For updated programs, we just delete all previous stream pids and
4701 // ECM pids and start parsing the fresh data.
4702 dvbapi_parse_pmt_info(demux_id
, buffer
+ 4, length
- 4, &ca_pmt_cmd_id
);
4704 // Finally, evaluate what response the host requires from OSCam.
4705 // This allows multiple CA applications to run at the host simultaneously.
4706 // "OK query" will be implemented at a later stage, when support is first
4707 // added in enigma2.
4708 switch(ca_pmt_cmd_id
)
4710 case CA_PMT_CMD_OK_DESCRAMBLING
:
4712 // remove from unassoc_fd when necessary
4713 for(i
= 0; i
< MAX_DEMUX
; i
++)
4715 if(unassoc_fd
[i
] == connfd
)
4721 dvbapi_capmt_notify(&demux
[demux_id
]);
4722 dvbapi_prepare_descrambling(demux_id
, msgid
);
4726 case CA_PMT_CMD_QUERY
:
4728 cs_log("Received unsupported CA PMT command ID 'query' for program %04X", demux
[demux_id
].program_number
);
4729 dvbapi_stop_descrambling(demux_id
, msgid
); // Clear all data from this demuxer
4733 case CA_PMT_CMD_NOT_SELECTED
:
4735 cs_log("Program %04X is not selected for descrambling", demux
[demux_id
].program_number
);
4736 dvbapi_stop_descrambling(demux_id
, msgid
); // Clear all data from this demuxer
4742 cs_log("Received unknown or unsupported CA PMT command ID %02X from host", ca_pmt_cmd_id
);
4743 dvbapi_stop_descrambling(demux_id
, msgid
);
4749 static void dvbapi_parse_pmt(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint32_t msgid
)
4751 uint16_t program_number
= b2i(2, buffer
+ 3);
4752 if(program_number
!= demux
[demux_id
].program_number
)
4754 cs_log("Demuxer %d received PMT for undefined program %04X", demux_id
, program_number
);
4758 dvbapi_stop_filter(demux_id
, TYPE_PMT
, msgid
);
4759 dvbapi_parse_pmt_info(demux_id
, buffer
+ 10, length
- 10 - 4, NULL
); // last 4 bytes are the CRC-32
4762 static void dvbapi_create_srvid_line(int32_t demux_id
, char *buffer
, uint32_t buflen
)
4764 int32_t i
, j
, pos
= 0;
4765 uint16_t caid_done
[32], cur_caid
;
4766 uint8_t caid_done_count
= 0, skip_caid
;
4768 if(demux
[demux_id
].ECMpidcount
== 0)
4770 snprintf(buffer
, buflen
, "%04X@%06X", NO_CAID_VALUE
, NO_PROVID_VALUE
);
4774 for(i
= 0; i
< demux
[demux_id
].ECMpidcount
&& i
< 32; i
++)
4777 for(j
= 0; j
< caid_done_count
; j
++)
4779 if(caid_done
[j
] == demux
[demux_id
].ECMpids
[i
].CAID
)
4791 cur_caid
= demux
[demux_id
].ECMpids
[i
].CAID
;
4792 pos
+= snprintf(buffer
+ pos
, buflen
- pos
, "%s%04X", caid_done_count
> 0 ? "," : "", cur_caid
== 0 ? NO_CAID_VALUE
: cur_caid
);
4794 for(j
= i
; j
< demux
[demux_id
].ECMpidcount
; j
++)
4796 if(demux
[demux_id
].ECMpids
[j
].PROVID
== 0)
4801 if(cur_caid
== demux
[demux_id
].ECMpids
[j
].CAID
)
4803 pos
+= snprintf(buffer
+ pos
, buflen
- pos
, "@%06X", demux
[demux_id
].ECMpids
[j
].PROVID
);
4807 caid_done
[caid_done_count
] = demux
[demux_id
].ECMpids
[i
].CAID
;
4812 static void dvbapi_write_sdt_info(int32_t demux_id
, const char *provider_name
, const char* service_name
, const char *service_type
)
4814 int8_t did_save_srvid
= 0;
4815 int32_t provid
, caid
, pidindex
;
4816 char tmp
[256], srvid_line
[1024];
4817 FILE *fpsave
= NULL
;
4819 pidindex
= demux
[demux_id
].pidindex
;
4822 caid
= demux
[demux_id
].ECMpids
[pidindex
].CAID
;
4823 provid
= demux
[demux_id
].ECMpids
[pidindex
].PROVID
;
4827 if(demux
[demux_id
].ECMpidcount
== 0 || demux
[demux_id
].ECMpids
[0].CAID
== 0)
4829 caid
= NO_CAID_VALUE
;
4830 provid
= NO_PROVID_VALUE
;
4834 caid
= demux
[demux_id
].ECMpids
[0].CAID
;
4835 provid
= demux
[demux_id
].ECMpids
[0].PROVID
;
4839 if(strlen(provider_name
) && caid
!= NO_CAID_VALUE
)
4841 get_providername_or_null(provid
, caid
, tmp
, sizeof(tmp
));
4845 get_config_filename(tmp
, sizeof(tmp
), "oscam.provid");
4847 if((fpsave
= fopen(tmp
, "a")))
4849 fprintf(fpsave
, "\n%04X@%06X|%s|", caid
, provid
, provider_name
);
4856 if(strlen(service_name
))
4858 get_servicename_or_null(cur_client(), demux
[demux_id
].program_number
, provid
, caid
, tmp
, sizeof(tmp
));
4862 get_config_filename(tmp
, sizeof(tmp
), "oscam.srvid2");
4864 if(!access(tmp
, F_OK
) && (fpsave
= fopen(tmp
, "a")))
4866 if((caid
!= NO_CAID_VALUE
) || (cfg
.dvbapi_read_sdt
> 1))
4868 dvbapi_create_srvid_line(demux_id
, srvid_line
, sizeof(srvid_line
));
4870 if(cfg
.dvbapi_write_sdt_prov
)
4872 fprintf(fpsave
, "\n%04X:%s|%s|%s||%s", demux
[demux_id
].program_number
, srvid_line
, service_name
, service_type
, provider_name
);
4876 fprintf(fpsave
, "\n%04X:%s|%s|%s", demux
[demux_id
].program_number
, srvid_line
, service_name
, service_type
);
4884 get_config_filename(tmp
, sizeof(tmp
), "oscam.srvid");
4886 if((fpsave
= fopen(tmp
, "a")))
4888 if((caid
!= NO_CAID_VALUE
) || (cfg
.dvbapi_read_sdt
> 1))
4890 dvbapi_create_srvid_line(demux_id
, srvid_line
, sizeof(srvid_line
));
4892 if(cfg
.dvbapi_write_sdt_prov
)
4894 fprintf(fpsave
, "\n%s:%04X|%s|%s|%s", srvid_line
, demux
[demux_id
].program_number
, provider_name
, service_name
, service_type
);
4898 fprintf(fpsave
, "\n%s:%04X||%s|%s", srvid_line
, demux
[demux_id
].program_number
, service_name
, service_type
);
4919 static uint32_t dvbapi_extract_sdt_string(char *buf
, uint32_t buflen
, const uint8_t *source
, uint8_t sourcelen
)
4921 uint32_t i
, j
, offset
= 0;
4922 int8_t iso_mode
= -1;
4924 const uint8_t *ptr_in
;
4926 size_t in_bytes
, out_bytes
;
4934 if(!cs_malloc(&tmpbuf
, buflen
))
4939 if(sourcelen
> buflen
- 1)
4941 sourcelen
= buflen
- 1;
4944 if(sourcelen
> 0 && source
[0] < 0x20)
4946 if(source
[0] >= 0x01 && source
[0] <= 0x0B && source
[0] != 0x08) // ISO/IEC 8859
4949 iso_mode
= 4 + source
[0];
4951 else if(source
[0] == 0x10) // Dynamically selected part of ISO/IEC 8859
4953 if(source
[1] == 0x00 && source
[2] >= 0x01 && source
[2] <= 0x0F && source
[2] != 0x0C)
4956 iso_mode
= source
[2];
4959 else if(source
[0] == 0x11) // ISO/IEC 10646
4964 // missing: 0x12 KSX1001-2004 (Korean Character Set)
4965 // missing: 0x13 GB-2312-1980 (Simplified Chinese Character Set)
4966 // missing: 0x14 Big5 subset of ISO/IEC 10646 (Traditional Chinese)
4967 else if(source
[0] == 0x15) // UTF-8 encoding of ISO/IEC 10646
4972 // missing: 0x1F Described by encoding_type_id
4980 if(offset
>= sourcelen
)
4988 for(i
= 0, j
= 0; i
< sourcelen
- offset
; i
++)
4990 if(source
[offset
+ i
] >= 0x80 && source
[offset
+ i
] <= 0x9F)
4995 tmpbuf
[j
] = source
[offset
+ i
];
5002 ptr_in
= (const uint8_t *)tmpbuf
;
5003 in_bytes
= strlen(tmpbuf
);
5004 ptr_out
= (uint8_t *)buf
;
5007 #ifdef READ_SDT_CHARSETS
5010 memset(buf
, 0, buflen
);
5011 cs_log_dbg(D_DVBAPI
, "sdt-info dbg: iso_mode: %d offset: %u", iso_mode
, offset
);
5012 cs_log_dump_dbg(D_DVBAPI
, (uint8_t *)tmpbuf
, in_bytes
, "sdt-info dbg: raw string:");
5016 if(ISO6937toUTF8(&ptr_in
, &in_bytes
, &ptr_out
, &out_bytes
) == (size_t)(-1))
5018 cs_log_dbg(D_DVBAPI
, "sdt-info error: ISO6937toUTF8 failed");
5025 if(ISO8859toUTF8(iso_mode
, &ptr_in
, &in_bytes
, &ptr_out
, &out_bytes
) == (size_t)(-1))
5027 cs_log_dbg(D_DVBAPI
, "sdt-info error: ISO8859toUTF8 failed");
5036 cs_strncpy(buf
, tmpbuf
, buflen
);
5037 cs_log_dbg(D_DVBAPI
, "sdt-info warning: your build of oscam does not support iso-to-utf8 conversion, special chars may be corrupted!");
5040 else if(iso_mode
== -2)
5042 memset(buf
, 0, buflen
);
5043 cs_log_dbg(D_DVBAPI
, "sdt-info dbg: iso_mode: %d offset: %u", iso_mode
, offset
);
5045 if(UnicodetoUTF8(&ptr_in
, &in_bytes
, &ptr_out
, &out_bytes
) == (size_t)(-1))
5047 cs_log_dbg(D_DVBAPI
, "sdt-info error: UnicodetoUTF8 failed");
5052 else if(iso_mode
== -3) // No conversion, already in UTF-8
5054 memcpy(buf
, source
+ offset
, sourcelen
- offset
);
5055 buf
[sourcelen
- offset
] = '\0';
5056 cs_log_dbg(D_DVBAPI
, "sdt-info dbg: iso_mode: -3 offset: %u", offset
);
5059 cs_log_dump_dbg(D_DVBAPI
, (uint8_t *)buf
, strlen(buf
), "sdt-info dbg: encoded string:");
5064 static const char *dvbapi_get_service_type(uint8_t service_type
)
5066 switch(service_type
)
5100 static void dvbapi_parse_service_descriptor(int32_t demux_id
, const uint8_t *buffer
, uint8_t descriptor_length
)
5102 uint8_t service_provider_name_length
, service_name_length
;
5103 char service_provider_name
[64], service_name
[64];
5104 const char *service_type
;
5106 if(descriptor_length
< 3)
5108 return; // Service descriptor has a minimum length of 3 bytes
5111 service_type
= dvbapi_get_service_type(buffer
[0]);
5113 service_provider_name_length
= buffer
[1];
5114 if(2 + service_provider_name_length
+ 1 > descriptor_length
)
5119 service_name_length
= buffer
[2 + service_provider_name_length
];
5120 if(2 + service_provider_name_length
+ 1 + service_name_length
> descriptor_length
)
5125 if(!dvbapi_extract_sdt_string(service_provider_name
, sizeof(service_provider_name
), buffer
+ 2, service_provider_name_length
) ||
5126 !dvbapi_extract_sdt_string(service_name
, sizeof(service_name
), buffer
+ 2 + service_provider_name_length
+ 1, service_name_length
))
5131 cs_log_dbg(D_DVBAPI
, "Demuxer %d got service info (provider: %s - name: %s - type: %s)",
5132 demux_id
, service_provider_name
, service_name
, service_type
);
5134 dvbapi_write_sdt_info(demux_id
, service_provider_name
, service_name
, service_type
);
5137 static void dvbapi_parse_sdt(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint32_t msgid
)
5139 uint8_t descriptor_tag
, descriptor_length
;
5140 uint16_t service_id
, descriptors_loop_length
, i
, j
;
5142 if(buffer
[0] != 0x42) // SDT sections with table_id value 0x42 describe the actual TS
5147 // Get the tsid and onid (in enigma2 STBs we have
5148 // already received them in the CA PMT message)
5149 demux
[demux_id
].tsid
= b2i(2, buffer
+ 3);
5150 demux
[demux_id
].onid
= b2i(2, buffer
+ 8);
5152 for(i
= 11; i
+ 5 < length
; i
+= 5 + descriptors_loop_length
)
5154 service_id
= b2i(2, buffer
+ i
);
5155 descriptors_loop_length
= b2i(2, buffer
+ i
+ 3) & 0x0FFF;
5157 if(service_id
!= demux
[demux_id
].program_number
)
5162 for(j
= 0; j
+ 1 < descriptors_loop_length
; j
+= 2 + descriptor_length
)
5164 descriptor_tag
= buffer
[i
+ 5 + j
];
5165 descriptor_length
= buffer
[i
+ 5 + j
+ 1];
5167 if(descriptor_tag
== 0x48)
5169 dvbapi_parse_service_descriptor(demux_id
, buffer
+ i
+ 5 + j
+ 2, descriptor_length
);
5173 dvbapi_stop_filter(demux_id
, TYPE_SDT
, msgid
);
5178 static void dvbapi_parse_pat(int32_t demux_id
, const uint8_t *buffer
, uint16_t length
, uint32_t msgid
)
5182 dvbapi_stop_filter(demux_id
, TYPE_PAT
, msgid
);
5184 for(i
= 8; i
+ 7 < length
; i
+= 4)
5186 srvid
= b2i(2, buffer
+ i
);
5192 if(demux
[demux_id
].program_number
== srvid
)
5194 demux
[demux_id
].pmtpid
= b2i(2, buffer
+ i
+ 2) & 0x1FFF;
5195 dvbapi_start_pmt_filter(demux_id
);
5201 int32_t dvbapi_init_listenfd(void)
5203 int32_t clilen
, listenfd
;
5204 struct sockaddr_un servaddr
;
5206 memset(&servaddr
, 0, sizeof(struct sockaddr_un
));
5207 servaddr
.sun_family
= AF_UNIX
;
5208 cs_strncpy(servaddr
.sun_path
, devices
[selected_box
].cam_socket_path
, sizeof(servaddr
.sun_path
));
5209 clilen
= sizeof(servaddr
.sun_family
) + strlen(servaddr
.sun_path
);
5211 if(((unlink(devices
[selected_box
].cam_socket_path
) < 0) && (errno
!= ENOENT
))
5212 || ((listenfd
= socket(AF_UNIX
, SOCK_STREAM
, 0)) < 0)
5213 || (bind(listenfd
, (struct sockaddr
*)&servaddr
, clilen
) < 0)
5214 || (listen(listenfd
, 5) < 0))
5219 // change the access right on the camd.socket
5220 // this will allow oscam to run as root if needed
5221 // and still allow non root client to connect to the socket
5222 chmod(devices
[selected_box
].cam_socket_path
, S_IRWXU
| S_IRWXG
| S_IRWXO
);
5226 int32_t dvbapi_net_init_listenfd(void)
5229 struct SOCKADDR servaddr
;
5231 memset(&servaddr
, 0, sizeof(servaddr
));
5232 SIN_GET_FAMILY(servaddr
) = DEFAULT_AF
;
5233 SIN_GET_ADDR(servaddr
) = ADDR_ANY
;
5234 SIN_GET_PORT(servaddr
) = htons((uint16_t)cfg
.dvbapi_listenport
);
5236 if((listenfd
= socket(DEFAULT_AF
, SOCK_STREAM
, 0)) < 0)
5243 // azbox toolchain do not have this define
5245 #define IPV6_V6ONLY 26
5247 // set the server socket option to listen on IPv4 and IPv6 simultaneously
5248 setsockopt(listenfd
, IPPROTO_IPV6
, IPV6_V6ONLY
, (void *)&opt
, sizeof(opt
));
5252 setsockopt(listenfd
, SOL_SOCKET
, SO_REUSEADDR
, (void *)&opt
, sizeof(opt
));
5253 set_so_reuseport(listenfd
);
5255 if(bind(listenfd
, (struct sockaddr
*)&servaddr
, sizeof(servaddr
)) < 0)
5260 if(listen(listenfd
, 5) < 0)
5267 static pthread_mutex_t event_handler_lock
= PTHREAD_MUTEX_INITIALIZER
;
5269 void event_handler(int32_t UNUSED(signal
))
5271 struct stat pmt_info
;
5274 struct dirent entry
, *dp
= NULL
;
5276 uint8_t mbuf
[2048]; // dirty fix: larger buffer needed for CA PMT mode 6 with many parallel channels to decode
5278 if(dvbapi_client
!= cur_client())
5283 SAFE_MUTEX_LOCK(&event_handler_lock
);
5284 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
|| cfg
.dvbapi_boxtype
== BOXTYPE_SAMYGO
)
5290 int32_t standby_fd
= open(STANDBY_FILE
, O_RDONLY
);
5291 pausecam
= (standby_fd
> 0) ? 1 : 0;
5294 int32_t ret
= close(standby_fd
);
5297 cs_log("ERROR: Could not close standby fd (errno=%d %s)", errno
, strerror(errno
));
5302 if(cfg
.dvbapi_boxtype
== BOXTYPE_IPBOX
|| cfg
.dvbapi_pmtmode
== 1)
5304 SAFE_MUTEX_UNLOCK(&event_handler_lock
);
5308 for(i
= 0; i
< MAX_DEMUX
; i
++)
5310 if(demux
[i
].pmt_file
[0] != 0)
5312 snprintf(dest
, sizeof(dest
), "%s%s", TMPDIR
, demux
[i
].pmt_file
);
5313 pmt_fd
= open(dest
, O_RDONLY
);
5316 if(fstat(pmt_fd
, &pmt_info
) != 0)
5318 int32_t ret
= close(pmt_fd
);
5321 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno
, strerror(errno
));
5326 if((time_t)pmt_info
.st_mtime
!= demux
[i
].pmt_time
)
5328 dvbapi_stop_descrambling(i
, 0);
5331 int32_t ret
= close(pmt_fd
);
5334 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno
, strerror(errno
));
5340 cs_log("Demuxer %d Unable to open PMT file %s -> stop descrambling!", i
, dest
);
5341 dvbapi_stop_descrambling(i
, 0);
5346 if(disable_pmt_files
)
5348 SAFE_MUTEX_UNLOCK(&event_handler_lock
);
5352 dirp
= opendir(TMPDIR
);
5355 cs_log_dbg(D_DVBAPI
, "opendir failed (errno=%d %s)", errno
, strerror(errno
));
5356 SAFE_MUTEX_UNLOCK(&event_handler_lock
);
5360 while(!cs_readdir_r(dirp
, &entry
, &dp
))
5367 if(strlen(dp
->d_name
) < 7)
5372 if(strncmp(dp
->d_name
, "pmt", 3) != 0 || strncmp(dp
->d_name
+ strlen(dp
->d_name
) - 4, ".tmp", 4) != 0)
5377 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
5378 struct s_dvbapi_priority
*p
;
5379 for(p
= dvbapi_priority
; p
!= NULL
; p
= p
->next
) // stapi: check if there is a device connected to this pmt file!
5381 if(p
->type
!= 's') { continue; } // stapi rule?
5382 if(strcmp(dp
->d_name
, p
->pmtfile
) != 0) { continue; } // same file?
5383 break; // found match!
5388 cs_log_dbg(D_DVBAPI
, "No matching S: line in oscam.dvbapi for pmtfile %s -> skip!", dp
->d_name
);
5392 snprintf(dest
, sizeof(dest
), "%s%s", TMPDIR
, dp
->d_name
);
5393 pmt_fd
= open(dest
, O_RDONLY
);
5399 if(fstat(pmt_fd
, &pmt_info
) != 0)
5401 int32_t ret
= close(pmt_fd
);
5404 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno
, strerror(errno
));
5411 for(i
= 0; i
< MAX_DEMUX
; i
++)
5413 if(strcmp(demux
[i
].pmt_file
, dp
->d_name
) == 0)
5415 if((time_t)pmt_info
.st_mtime
== demux
[i
].pmt_time
)
5425 int32_t ret
= close(pmt_fd
);
5428 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno
, strerror(errno
));
5432 cs_log_dbg(D_DVBAPI
, "found pmt file %s", dest
);
5435 uint32_t len
= read(pmt_fd
, mbuf
, sizeof(mbuf
));
5436 int32_t ret
= close(pmt_fd
);
5440 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno
, strerror(errno
));
5445 cs_log_dbg(D_DVBAPI
, "pmt file %s have invalid len!", dest
);
5453 // QboxHD pmt.tmp is the full capmt written as a string of hex values
5454 // pmt.tmp must be longer than 3 bytes (6 hex chars) and even length
5455 if((len
< 6) || ((len
% 2) != 0) || ((len
/ 2) > sizeof(dest
)))
5457 cs_log_dbg(D_DVBAPI
, "error parsing QboxHD pmt.tmp, incorrect length");
5461 for(j2
= 0, j1
= 0; j2
< len
; j2
+= 2, j1
++)
5464 if(sscanf((char *)mbuf
+ j2
, "%02X", &tmp
) != 1)
5466 cs_log_dbg(D_DVBAPI
, "error parsing QboxHD pmt.tmp, data not valid in position %d", j2
);
5467 SAFE_MUTEX_UNLOCK(&event_handler_lock
);
5472 memcpy(dest
+ j1
, &tmp
, 4);
5476 cs_log_dump_dbg(D_DVBAPI
, (uint8_t *)dest
, len
/ 2, "QboxHD pmt.tmp:");
5477 demux_id
= dvbapi_parse_capmt((uint8_t *)dest
+ 4, (len
/ 2) - 4, -1, dp
->d_name
, 0, 0);
5479 if(len
> sizeof(dest
))
5481 cs_log_dbg(D_DVBAPI
, "event_handler() dest buffer is to small for pmt data!");
5487 cs_log_dbg(D_DVBAPI
, "event_handler() received pmt is too small! (%d < 16 bytes!)", len
);
5491 cs_log_dump_dbg(D_DVBAPI
, mbuf
, len
, "PMT file:"); // Original PMT file
5493 // Do some tidying on the PMT file to make it compatible with the CA PMT parser
5494 dest
[0] = CA_PMT_LIST_ONLY
;
5495 memcpy(dest
+ 1, mbuf
+ 3, 2); // program_number
5496 uint16_t pmt_program_info_length
= b2i(2, mbuf
+ 10) & 0x0FFF;
5497 i2b_buf(2, pmt_program_info_length
+ 1, (uint8_t *)dest
+ 4);
5498 dest
[6] = CA_PMT_CMD_OK_DESCRAMBLING
;
5499 memcpy(dest
+ 7, mbuf
+ 12, len
- 12 - 4);
5501 cs_log_dump_dbg(D_DVBAPI
, (uint8_t *)dest
, 7 + len
- 12 - 4, "CA PMT:"); // Actual CA PMT message
5502 demux_id
= dvbapi_parse_capmt((uint8_t *)dest
, 7 + len
- 12 - 4, -1, dp
->d_name
, 0, 0);
5507 cs_strncpy(demux
[demux_id
].pmt_file
, dp
->d_name
, sizeof(demux
[demux_id
].pmt_file
));
5508 demux
[demux_id
].pmt_time
= (time_t)pmt_info
.st_mtime
;
5511 if(cfg
.dvbapi_pmtmode
== 3)
5513 disable_pmt_files
= 1;
5518 SAFE_MUTEX_UNLOCK(&event_handler_lock
);
5521 void *dvbapi_event_thread(void *cli
)
5523 struct s_client
*client
= (struct s_client
*) cli
;
5524 SAFE_SETSPECIFIC(getclient
, client
);
5525 set_thread_name(__func__
);
5535 void dvbapi_process_input(int32_t demux_id
, int32_t filter_num
, uint8_t *buffer
, int32_t len
, uint32_t msgid
)
5537 struct s_ecmpid
*curpid
= NULL
;
5538 int32_t pid
= demux
[demux_id
].demux_fd
[filter_num
].pidindex
;
5539 uint16_t filtertype
= demux
[demux_id
].demux_fd
[filter_num
].type
;
5540 uint16_t sctlen
= SCT_LEN(buffer
);
5544 cs_log_dbg(D_DVBAPI
, "Received filter data with invalid section length!");
5550 cs_log_dbg(D_DVBAPI
, "Received filter data with total length 0x%03X but section length is 0x%03X -> invalid length!", len
, sctlen
);
5554 if(demux_id
< 0 || demux_id
>= MAX_DEMUX
)
5556 cs_log("dvbapi_process_input(): error - received invalid demux_id (%d)", demux_id
);
5560 if(filter_num
< 0 || filter_num
>= MAX_FILTER
)
5562 cs_log("dvbapi_process_input(): error - received invalid filter_num (%d)", filter_num
);
5566 if(pid
!= -1 && filtertype
== TYPE_ECM
)
5568 curpid
= &demux
[demux_id
].ECMpids
[pid
];
5571 int32_t filt_match
= filtermatch(buffer
, filter_num
, demux_id
, sctlen
); // acts on all filters (sdt/emm/ecm)
5574 cs_log_dbg(D_DVBAPI
,"Demuxer %d receiver returned data not matching the filter -> delivered filter data discarded!", demux_id
);
5578 if(curpid
&& curpid
->tries
<= 0xF0 && filtertype
== TYPE_ECM
)
5580 curpid
->irdeto_maxindex
= 0;
5581 curpid
->irdeto_curindex
= 0xFE;
5582 curpid
->tries
= 0xFE; // reset timeout retry flag
5583 curpid
->irdeto_cycle
= 0xFE; // reset irdetocycle
5585 curpid
->checked
= 4; // flag ecmpid as checked
5586 curpid
->status
= -1; // flag ecmpid as unusable
5588 if(pid
== demux
[demux_id
].pidindex
)
5590 // current pid delivered problems so this pid isn't
5591 // being used to descramble any longer -> clear pidindex
5592 demux
[demux_id
].pidindex
= -1;
5594 // remove this pid from channel cache since we had no founds on any ecmpid!
5595 dvbapi_edit_channel_cache(demux_id
, pid
, 0);
5598 dvbapi_stop_filternum(demux_id
, filter_num
, msgid
); // stop this ecm filter!
5602 if(filtertype
== TYPE_ECM
)
5604 uint32_t chid
= 0x10000;
5605 int8_t pvu_skip
= 0;
5608 if(len
!= 0) // len = 0 receiver encountered an internal bufferoverflow!
5610 cs_log_dump_dbg(D_DVBAPI
, buffer
, sctlen
, "Demuxer %d filter %d fetched ECM data (length = 0x%03X):",
5611 demux_id
, filter_num
+ 1, sctlen
);
5613 if(sctlen
> MAX_ECM_SIZE
) // ecm too long to handle!
5615 cs_log_dbg(D_DVBAPI
, "Received data with total length 0x%03X but max supported ECM length is 0x%03X -> Please report!",
5616 sctlen
, MAX_ECM_SIZE
);
5620 curpid
->tries
-= 0x0E;
5625 if(!(buffer
[0] == 0x80 || buffer
[0] == 0x81))
5627 cs_log_dbg(D_DVBAPI
, "Received an ECM with invalid ecmtable ID %02X -> ignoring!", buffer
[0]);
5636 if(caid_is_powervu(curpid
->CAID
)) // ecm counter for powervu
5640 if(sctlen
- 11 > buffer
[9])
5642 if(buffer
[11 + buffer
[9]] > curpid
->pvu_counter
5643 || (curpid
->pvu_counter
== 255 && buffer
[11 + buffer
[9]] == 0)
5644 || ((curpid
->pvu_counter
- buffer
[11 + buffer
[9]]) > 5))
5646 curpid
->pvu_counter
= buffer
[11 + buffer
[9]];
5652 // wait for odd / even ecm change (only not for irdeto!)
5653 if((curpid
->table
== buffer
[0] && !caid_is_irdeto(curpid
->CAID
)) || pvu_skip
)
5655 if(!(er
= get_ecmtask()))
5659 er
->srvid
= demux
[demux_id
].program_number
;
5662 cs_strncpy(er
->dev_name
, dev_list
[demux
[demux_id
].dev_index
].name
, sizeof(dev_list
[demux
[demux_id
].dev_index
].name
));
5664 er
->tsid
= demux
[demux_id
].tsid
;
5665 er
->onid
= demux
[demux_id
].onid
;
5666 er
->pmtpid
= demux
[demux_id
].pmtpid
;
5667 er
->ens
= demux
[demux_id
].ens
;
5668 er
->caid
= curpid
->CAID
;
5669 er
->pid
= curpid
->ECM_PID
;
5670 er
->prid
= curpid
->PROVID
;
5671 er
->vpid
= curpid
->VPID
;
5672 er
->ecmlen
= sctlen
;
5673 memcpy(er
->ecm
, buffer
, er
->ecmlen
);
5674 chid
= get_subid(er
); // fetch chid or fake chid
5677 dvbapi_set_section_filter(demux_id
, er
, filter_num
);
5682 if(caid_is_irdeto(curpid
->CAID
))
5684 // 80 70 39 53 04 05 00 88
5685 // 81 70 41 41 01 06 00 13 00 06 80 38 1F 52 93 D2
5686 //if(buffer[5]>20) return;
5687 if(curpid
->irdeto_maxindex
!= buffer
[5]) // 6, register max irdeto index
5689 cs_log_dbg(D_DVBAPI
, "Found %d IRDETO ECM CHIDs", buffer
[5] + 1);
5690 curpid
->irdeto_maxindex
= buffer
[5]; // numchids = 7 (0..6)
5695 if(!(er
= get_ecmtask()))
5699 er
->srvid
= demux
[demux_id
].program_number
;
5702 cs_strncpy(er
->dev_name
, dev_list
[demux
[demux_id
].dev_index
].name
, sizeof(dev_list
[demux
[demux_id
].dev_index
].name
));
5705 er
->tsid
= demux
[demux_id
].tsid
;
5706 er
->onid
= demux
[demux_id
].onid
;
5707 er
->pmtpid
= demux
[demux_id
].pmtpid
;
5708 er
->ens
= demux
[demux_id
].ens
;
5709 er
->caid
= curpid
->CAID
;
5710 er
->pid
= curpid
->ECM_PID
;
5711 er
->prid
= curpid
->PROVID
;
5712 er
->vpid
= curpid
->VPID
;
5713 er
->ecmlen
= sctlen
;
5714 memcpy(er
->ecm
, buffer
, er
->ecmlen
);
5716 chid
= get_subid(er
); // fetch chid or fake chid
5717 uint32_t fixedprovid
= chk_provid(er
->ecm
, er
->caid
);
5719 if(fixedprovid
&& fixedprovid
!= er
->prid
)
5721 cs_log_dbg(D_DVBAPI
, "Fixing provid ecmpid %d from %06X -> %06X", pid
, curpid
->PROVID
, fixedprovid
);
5722 curpid
->PROVID
= fixedprovid
;
5726 cs_log_dbg(D_DVBAPI
, "Fixing provid filter %d from %06X -> %06X",
5727 filter_num
+ 1, demux
[demux_id
].demux_fd
[filter_num
].provid
, fixedprovid
);
5729 demux
[demux_id
].demux_fd
[filter_num
].provid
= fixedprovid
;
5731 cs_log_dbg(D_DVBAPI
, "Fixing provid ecmrequest from %06X -> %06X", er
->prid
, fixedprovid
);
5732 er
->prid
= fixedprovid
;
5736 // only used on receiver internal buffer overflow
5737 // to get quickly fresh ecm filterdata otherwise freezing!
5741 dvbapi_set_section_filter(demux_id
, er
, filter_num
);
5746 if(caid_is_irdeto(curpid
->CAID
))
5748 if(curpid
->irdeto_curindex
!= buffer
[4]) // old style wrong irdeto index
5750 if(curpid
->irdeto_curindex
== 0xFE) // check if this ecmfilter just started up
5752 // on startup set the current index to the irdeto index of the ecm
5753 curpid
->irdeto_curindex
= buffer
[4];
5755 else // we are already running and not interested in this ecm
5757 if(curpid
->table
!= buffer
[0]) // fix for receivers not supporting section filtering
5762 // set ecm filter to odd + even since
5763 // this ecm doesn't match with current irdeto index
5764 dvbapi_set_section_filter(demux_id
, er
, filter_num
);
5770 else // fix for receivers not supporting section filtering
5772 if(curpid
->table
== buffer
[0])
5778 cs_log_dbg(D_DVBAPI
, "Demuxer %d ECMTYPE %02X CAID %04X PROVID %06X ECMPID %04X IRDETO INDEX %02X MAX INDEX %02X CHID %04X CYCLE %02X VPID %04X",
5779 demux_id
, er
->ecm
[0], er
->caid
, er
->prid
, er
->pid
, er
->ecm
[4], er
->ecm
[5], er
->chid
, curpid
->irdeto_cycle
, er
->vpid
);
5783 cs_log_dbg(D_DVBAPI
, "Demuxer %d ECMTYPE %02X CAID %04X PROVID %06X ECMPID %04X FAKECHID %04X (unique part in ecm)",
5784 demux_id
, er
->ecm
[0], er
->caid
, er
->prid
, er
->pid
, er
->chid
);
5787 // check for matching chid (unique ecm part in case of non-irdeto cas)
5788 // plus added fix for seca2 monthly changing fakechid
5789 if((curpid
->CHID
< 0x10000) && !((chid
== curpid
->CHID
) || ((curpid
->CAID
>> 8 == 0x01) && (chid
& 0xF0FF) == (curpid
->CHID
& 0xF0FF))))
5791 if(caid_is_irdeto(curpid
->CAID
))
5793 // if same: we cycled all indexes but no luck!
5794 if((curpid
->irdeto_cycle
< 0xFE) && (curpid
->irdeto_cycle
== curpid
->irdeto_curindex
))
5796 struct s_dvbapi_priority
*forceentry
= dvbapi_check_prio_match(demux_id
, pid
, 'p');
5798 // forced pid? keep trying the forced ecmpid, no force kill ecm filter
5799 if(!forceentry
|| !forceentry
->force
)
5801 if(curpid
->checked
== 2)
5803 curpid
->checked
= 4;
5806 if(curpid
->checked
== 1)
5808 curpid
->checked
= 2;
5809 curpid
->CHID
= 0x10000;
5812 dvbapi_stop_filternum(demux_id
, filter_num
, msgid
); // stop this ecm filter!
5817 curpid
->irdeto_curindex
++; // set check on next index
5819 if(curpid
->irdeto_cycle
== 0xFE)
5821 curpid
->irdeto_cycle
= buffer
[4]; // on startup set to current irdeto index
5824 if(curpid
->irdeto_curindex
> curpid
->irdeto_maxindex
)
5826 curpid
->irdeto_curindex
= 0; // check if we reached max irdeto index, if so reset to 0
5830 // set ecm filter to odd + even since
5831 // this ecm doesn't match with current irdeto index
5832 dvbapi_set_section_filter(demux_id
, er
, filter_num
);
5837 else // all non irdeto cas systems
5839 struct s_dvbapi_priority
*forceentry
= dvbapi_check_prio_match(demux_id
, pid
, 'p');
5842 // set ecm filter to odd + even since
5843 // this ecm doesn't match with current irdeto index
5844 dvbapi_set_section_filter(demux_id
, er
, filter_num
);
5846 if(forceentry
&& forceentry
->force
)
5849 return; // forced pid? keep trying the forced ecmpid!
5852 if(curpid
->checked
== 2)
5854 curpid
->checked
= 4;
5857 if(curpid
->checked
== 1)
5859 curpid
->checked
= 2;
5860 curpid
->CHID
= 0x10000;
5863 dvbapi_stop_filternum(demux_id
, filter_num
, msgid
); // stop this ecm filter!
5869 struct s_dvbapi_priority
*p
;
5870 for(p
= dvbapi_priority
; p
!= NULL
; p
= p
->next
)
5873 || (p
->caid
&& p
->caid
!= curpid
->CAID
)
5874 || (p
->provid
&& p
->provid
!= curpid
->PROVID
)
5875 || (p
->ecmpid
&& p
->ecmpid
!= curpid
->ECM_PID
)
5876 || (p
->srvid
&& p
->srvid
!= demux
[demux_id
].program_number
))
5881 if((uint
)p
->delay
== sctlen
&& p
->force
< 6)
5896 curpid
->PROVID
= chk_provid(buffer
, curpid
->CAID
);
5899 if(caid_is_irdeto(curpid
->CAID
)) // irdeto: wait for the correct index
5901 if(buffer
[4] != curpid
->irdeto_curindex
)
5905 // set ecm filter to odd + even since
5906 // this ecm doesn't match with current irdeto index
5907 dvbapi_set_section_filter(demux_id
, er
, filter_num
);
5914 // we have an ecm with the correct irdeto index (or fakechid)
5915 for(p
= dvbapi_priority
; p
!= NULL
; p
= p
->next
) // check for ignore!
5918 || (p
->caid
&& p
->caid
!= curpid
->CAID
)
5919 || (p
->provid
&& p
->provid
!= curpid
->PROVID
)
5920 || (p
->ecmpid
&& p
->ecmpid
!= curpid
->ECM_PID
)
5921 || (p
->pidx
&& p
->pidx
- 1 != pid
)
5922 || (p
->srvid
&& p
->srvid
!= demux
[demux_id
].program_number
))
5927 // found an ignore chid match with current ecm -> ignoring this irdeto index
5928 if(p
->type
== 'i' && (p
->chid
< 0x10000 && p
->chid
== chid
))
5930 curpid
->irdeto_curindex
++;
5931 if(curpid
->irdeto_cycle
== 0xFE)
5933 curpid
->irdeto_cycle
= buffer
[4]; // on startup set to current irdeto index
5936 if(curpid
->irdeto_curindex
> curpid
->irdeto_maxindex
) // check if curindex is over the max
5938 curpid
->irdeto_curindex
= 0;
5942 // irdeto: wait for the correct index + check if we cycled all
5943 if(caid_is_irdeto(curpid
->CAID
) && (curpid
->irdeto_cycle
!= curpid
->irdeto_curindex
))
5945 // set ecm filter to odd + even since this chid has to be ignored!
5946 dvbapi_set_section_filter(demux_id
, er
, filter_num
);
5948 else // this fakechid has to be ignored, kill this filter!
5950 if(curpid
->checked
== 2)
5952 curpid
->checked
= 4;
5955 if(curpid
->checked
== 1)
5957 curpid
->checked
= 2;
5958 curpid
->CHID
= 0x10000;
5961 dvbapi_stop_filternum(demux_id
, filter_num
, msgid
); // stop this ecm filter!
5970 curpid
->table
= er
->ecm
[0];
5973 request_cw(dvbapi_client
, er
, demux_id
, 1); // register this ecm for delayed ecm response check
5974 return; // end of ecm filterhandling!
5977 if(filtertype
== TYPE_EMM
)
5979 if(len
!= 0) // len = 0 receiver encountered an internal buffer overflow!
5981 cs_log_dump_dbg(D_DVBAPI
, buffer
, sctlen
, "Demuxer %d filter %d fetched EMM data (length = 0x%03X):",
5982 demux_id
, filter_num
+ 1, sctlen
);
5984 if(sctlen
> MAX_EMM_SIZE
) // emm too long to handle!
5986 cs_log_dbg(D_DVBAPI
, "Received data with total length 0x%03X but max supported EMM length is 0x%03X -> Please report!",
5987 sctlen
, MAX_EMM_SIZE
);
5994 return; // just skip on internal buffer overflow
5998 if(caid_is_director(demux
[demux_id
].demux_fd
[filter_num
].caid
))
6008 for(i
= 0; i
+ 2 < sctlen
; i
++)
6010 if(buffer
[i
] == 0xF0 && (buffer
[i
+ 2] == 0xE1 || buffer
[i
+ 2] == 0xE4))
6012 emmhash
= (buffer
[3] << 8) | buffer
[sctlen
- 2];
6013 if(demux
[demux_id
].demux_fd
[filter_num
].cadata
== emmhash
)
6018 demux
[demux_id
].demux_fd
[filter_num
].cadata
= emmhash
;
6019 dvbapi_process_emm(demux_id
, filter_num
, buffer
, sctlen
);
6026 // fix to handle more than one irdeto emm packet
6027 uint8_t *pbuf
= buffer
;
6029 int32_t unhandled
= len
;
6034 sctlen
= SCT_LEN(pbuf
);
6036 if(unhandled
< 4 || (int32_t)sctlen
> unhandled
|| sctlen
> MAX_EMM_SIZE
|| sctlen
< 4)
6041 dvbapi_process_emm(demux_id
, filter_num
, pbuf
, sctlen
);
6043 unhandled
-= sctlen
;
6047 if(filtertype
== TYPE_SDT
)
6049 cs_log_dump_dbg(D_DVBAPI
, buffer
, sctlen
, "Demuxer %d filter %d fetched SDT data (length = 0x%03X):",
6050 demux_id
, filter_num
+ 1, sctlen
);
6052 dvbapi_parse_sdt(demux_id
, buffer
, sctlen
, msgid
);
6055 if(filtertype
== TYPE_PAT
)
6057 cs_log_dump_dbg(D_DVBAPI
, buffer
, sctlen
, "Demuxer %d filter %d fetched PAT data (length = 0x%03X):",
6058 demux_id
, filter_num
+ 1, sctlen
);
6060 dvbapi_parse_pat(demux_id
, buffer
, sctlen
, msgid
);
6063 if(filtertype
== TYPE_PMT
)
6065 cs_log_dump_dbg(D_DVBAPI
, buffer
, sctlen
, "Demuxer %d filter %d fetched PMT data (length = 0x%03X):",
6066 demux_id
, filter_num
+ 1, sctlen
);
6068 dvbapi_parse_pmt(demux_id
, buffer
, sctlen
, msgid
);
6071 if(filtertype
== TYPE_CAT
)
6073 cs_log_dump_dbg(D_DVBAPI
, buffer
, sctlen
, "Demuxer %d filter %d fetched CAT data (length = 0x%03X):",
6074 demux_id
, filter_num
+ 1, sctlen
);
6076 dvbapi_parse_cat(demux_id
, buffer
, sctlen
, msgid
);
6080 static int32_t dvbapi_recv(int32_t connfd
, uint8_t *mbuf
, size_t rlen
)
6082 ssize_t len
= cs_recv(connfd
, mbuf
, rlen
, MSG_DONTWAIT
);
6084 if((len
== -1 && (errno
!= EINTR
&& errno
!= EAGAIN
&& errno
!= EWOULDBLOCK
)) || (len
== 0))
6097 static uint16_t dvbapi_get_nbof_missing_header_bytes(uint8_t *mbuf
, uint16_t mbuf_len
, uint32_t msgid_size
)
6099 uint16_t commandsize
= 4;
6100 commandsize
+= msgid_size
;
6101 if(mbuf_len
< commandsize
)
6103 return commandsize
- mbuf_len
;
6108 uint32_t opcode
= b2i(4, mbuf
);
6110 if((opcode
& 0xFFFFF000) == DVBAPI_AOT_CA
)
6114 uint32_t size
= mbuf
[3] & 0x7F;
6115 if(mbuf_len
< (commandsize
+ size
))
6117 return (commandsize
+ size
) - mbuf_len
;
6126 case DVBAPI_FILTER_DATA
:
6128 commandsize
+= msgid_size
;
6129 if(mbuf_len
< commandsize
)
6131 return commandsize
- mbuf_len
;
6135 case DVBAPI_CLIENT_INFO
:
6137 commandsize
+= msgid_size
;
6138 if(mbuf_len
< commandsize
)
6140 return commandsize
- mbuf_len
;
6151 static void set_chunksize_data_len_to_invalid(uint16_t *chunksize
, uint16_t *data_len
)
6157 static void log_packeterror(uint16_t mbuf_len
, const char* command
)
6159 cs_log("dvbapi_get_packet_size(): error - buffer length (%" PRIu16
") too short for %s", mbuf_len
, command
);
6162 static bool is_commandsize_valid(uint32_t commandsize
, uint16_t mbuf_len
, const char* command
)
6164 bool isValid
= mbuf_len
>= commandsize
;
6167 log_packeterror(mbuf_len
, command
);
6172 static uint8_t get_asn1packetsize(uint8_t *mbuf
, uint16_t mbuf_len
, const char *command
, uint32_t *tmp_data_len
)
6174 uint8_t sizebytes
= 0;
6175 uint8_t commandsize
= 4;
6176 *tmp_data_len
= mbuf
[3] & 0x7F;
6179 sizebytes
= *tmp_data_len
;
6180 if(is_commandsize_valid(3 + sizebytes
, mbuf_len
, command
))
6182 *tmp_data_len
= b2i(sizebytes
, mbuf
+ 4);
6189 return commandsize
+ sizebytes
;
6192 static void dvbapi_get_packet_size(uint8_t *mbuf
, uint16_t mbuf_len
, uint16_t *chunksize
, uint16_t *data_len
)
6194 //chunksize: size of complete chunk in the buffer (an opcode with the data)
6195 //data_len: variable for internal data length (eg. for the filter data size, PMT len)
6201 cs_log("dvbapi_get_packet_size(): error - buffer length (%" PRIu16
") too short", mbuf_len
);
6202 set_chunksize_data_len_to_invalid(chunksize
, data_len
);
6206 int32_t commandsize
= 0;
6207 char* command
= "DVBAPI_UNKNOWN_COMMAND";
6208 uint32_t tmp_data_len
= 0;
6209 uint32_t opcode
= b2i(4, mbuf
);
6214 case DVBAPI_AOT_CA_STOP
:
6216 command
= "DVBAPI_AOT_CA_STOP";
6217 commandsize
= get_asn1packetsize(mbuf
, mbuf_len
, command
, &tmp_data_len
);
6220 case DVBAPI_FILTER_DATA
:
6222 command
= "DVBAPI_FILTER_DATA";
6224 if(is_commandsize_valid(commandsize
, mbuf_len
, command
))
6226 tmp_data_len
= b2i(2, mbuf
+ 7) & 0x0FFF;
6231 case DVBAPI_CLIENT_INFO
:
6233 command
= "DVBAPI_CLIENT_INFO";
6235 if(is_commandsize_valid(commandsize
, mbuf_len
, command
))
6237 tmp_data_len
= mbuf
[6];
6244 if((opcode
& 0xFFFFFF00) == DVBAPI_AOT_CA_PMT
)
6246 command
= "DVBAPI_AOT_CA_PMT";
6247 commandsize
= get_asn1packetsize(mbuf
, mbuf_len
, command
, &tmp_data_len
);
6252 cs_log("Unknown socket command received: 0x%08X", opcode
);
6258 if(tmp_data_len
== 0 || commandsize
== 0)
6260 set_chunksize_data_len_to_invalid(chunksize
, data_len
);
6264 if(tmp_data_len
+ commandsize
> 0xFFFF)
6266 cs_log("This packet is too big: %d bytes => truncated!", tmp_data_len
);
6267 tmp_data_len
= 0xFFFF - commandsize
;
6270 (*data_len
) = tmp_data_len
;
6271 (*chunksize
) += commandsize
+ tmp_data_len
;
6273 if(*chunksize
> mbuf_len
)
6275 cs_log_dbg(D_DVBAPI
, "This %s packet is incomplete => command length is (%" PRIu16
")", command
, *chunksize
);
6279 cs_log_dbg(D_DVBAPI
, "This is a %s packet with size %d => lets process it!", command
, (*chunksize
));
6283 static void dvbapi_handlesockmsg(uint8_t *mbuf
, uint16_t chunksize
, uint16_t data_len
, uint8_t *add_to_poll
, int32_t connfd
, uint16_t *client_proto_version
)
6286 if(*client_proto_version
>= 3)
6290 cs_log("Error: network packet malformed! (no start)");
6293 msgid
= b2i(4, mbuf
+ 1);
6297 uint32_t opcode
= b2i(4, mbuf
);
6301 case DVBAPI_FILTER_DATA
:
6303 int32_t demux_id
= mbuf
[4];
6304 int32_t filter_num
= mbuf
[5];
6306 if(demux_id
< 0 || demux_id
>= MAX_DEMUX
)
6308 cs_log("dvbapi_handlesockmsg(): error - received invalid demux_id (%d)", demux_id
);
6312 if(filter_num
< 0 || filter_num
>= MAX_FILTER
)
6314 cs_log("dvbapi_handlesockmsg(): error - received invalid filter_num (%d)", filter_num
);
6317 dvbapi_process_input(demux_id
, filter_num
, mbuf
+ 6, data_len
+ 3, msgid
);
6321 case DVBAPI_CLIENT_INFO
:
6323 uint16_t client_proto
= b2i(2, mbuf
+ 4);
6324 NULLFREE(last_client_name
);
6326 if(cs_malloc(&last_client_name
, data_len
+ 1))
6328 memcpy(last_client_name
, &mbuf
[7], data_len
);
6329 last_client_name
[data_len
] = 0;
6330 cs_log("Client connected: '%s' (protocol version = %" PRIu16
")", last_client_name
, client_proto
);
6332 dvbapi_net_send(DVBAPI_SERVER_INFO
, connfd
, msgid
, -1, -1, NULL
, NULL
, NULL
, client_proto
);
6334 // now the protocol handshake is complete set correct version so all further packets are sent with correct message id.
6335 (*client_proto_version
) = client_proto
;
6337 // setting the global var according to the client
6338 last_client_proto_version
= client_proto
;
6342 case DVBAPI_AOT_CA_PMT
:
6344 cs_log_dbg(D_DVBAPI
,"Received DVBAPI_AOT_CA_PMT object on socket %d:", connfd
);
6345 dvbapi_parse_capmt(mbuf
+ (chunksize
- data_len
), data_len
, connfd
, NULL
, *client_proto_version
, msgid
);
6350 case (DVBAPI_AOT_CA_STOP
):
6352 cs_log_dbg(D_DVBAPI
, "Received DVBAPI_AOT_CA_STOP object on socket %d:", connfd
);
6353 if(cfg
.dvbapi_boxtype
== BOXTYPE_IPBOX
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
|| cfg
.dvbapi_listenport
)
6356 int32_t demux_index
= mbuf
[7];
6357 for(i
= 0; i
< MAX_DEMUX
; i
++)
6359 // 0xff demux_index is a wildcard => close all related demuxers
6360 if(demux_index
== 0xff)
6362 if(demux
[i
].socket_fd
== connfd
)
6364 dvbapi_stop_descrambling(i
, msgid
);
6367 else if(demux
[i
].demux_index
== demux_index
)
6369 dvbapi_stop_descrambling(i
, msgid
);
6375 if(cfg
.dvbapi_boxtype
== BOXTYPE_IPBOX
)
6377 // check do we have any demux running on this fd
6378 int16_t execlose
= 1;
6379 for(i
= 0; i
< MAX_DEMUX
; i
++)
6381 if(demux
[i
].socket_fd
== connfd
)
6389 int32_t ret
= close(connfd
);
6392 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno
, strerror(errno
));
6397 if(cfg
.dvbapi_listenport
)
6403 else if(cfg
.dvbapi_pmtmode
!= 6)
6405 int32_t ret
= close(connfd
);
6408 cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno
, strerror(errno
));
6416 if((opcode
& 0xFFFFFF00) == DVBAPI_AOT_CA_PMT
)
6418 cs_log_dbg(D_DVBAPI
, "Received DVBAPI_AOT_CA_PMT object on socket %d:", connfd
);
6419 dvbapi_parse_capmt(mbuf
+ (chunksize
- data_len
), data_len
, connfd
, NULL
, *client_proto_version
, msgid
);
6423 cs_log("Unknown socket command received: 0x%08X", opcode
);
6430 static bool dvbapi_handlesockdata(int32_t connfd
, uint8_t *mbuf
, uint16_t mbuf_size
, uint16_t unhandled_len
,
6431 uint8_t *add_to_poll
, uint16_t *new_unhandled_len
, uint16_t *client_proto_version
)
6433 int32_t recv_result
;
6434 uint16_t chunksize
= 1, data_len
= 1;
6435 uint8_t packet_count
= 1;
6436 uint32_t msgid_size
= 0;
6437 uint16_t missing_header_bytes
= 0;
6438 if(*client_proto_version
>= 3)
6445 missing_header_bytes
= dvbapi_get_nbof_missing_header_bytes(mbuf
, unhandled_len
, msgid_size
);
6447 if(missing_header_bytes
!= 0)
6449 // read first few bytes so we know packet type and length
6450 cs_log_dbg(D_TRACE
, "%s reading %" PRIu16
" bytes from connection fd %d", (unhandled_len
== 0) ? "Try" : "Continue", missing_header_bytes
, connfd
);
6452 recv_result
= dvbapi_recv(connfd
, mbuf
+ unhandled_len
, mbuf_size
- unhandled_len
);
6455 (*new_unhandled_len
) = unhandled_len
;
6456 return (recv_result
!= -1);
6460 unhandled_len
+= recv_result
;
6461 if(unhandled_len
< missing_header_bytes
)
6463 (*new_unhandled_len
) = unhandled_len
;
6469 cs_log_dump_dbg(D_DVBAPI
, mbuf
, unhandled_len
, "Got packetdata (msgid size: %d, clientprotocol: %d)", msgid_size
, *client_proto_version
);
6470 dvbapi_get_packet_size(mbuf
+msgid_size
, unhandled_len
-msgid_size
, &chunksize
, &data_len
);
6472 chunksize
+=msgid_size
;
6473 if(chunksize
> mbuf_size
)
6475 cs_log("***** WARNING: SOCKET DATA BUFFER OVERFLOW (%" PRIu16
" bytes), PLEASE REPORT! ****** ", chunksize
);
6476 (*new_unhandled_len
) = 0;
6480 if(unhandled_len
< chunksize
) // we are missing some bytes, try to read them
6482 cs_log_dbg(D_TRACE
, "Continue to read the missing %d bytes from connection fd %d", chunksize
- unhandled_len
, connfd
);
6483 recv_result
= dvbapi_recv(connfd
, mbuf
+ unhandled_len
, mbuf_size
- unhandled_len
);
6486 (*new_unhandled_len
) = unhandled_len
;
6487 return (recv_result
!= -1);
6491 unhandled_len
+= recv_result
;
6492 if(unhandled_len
< chunksize
)
6494 (*new_unhandled_len
) = unhandled_len
;
6500 dvbapi_handlesockmsg(mbuf
, chunksize
-msgid_size
, data_len
, add_to_poll
, connfd
, client_proto_version
);
6502 unhandled_len
-= chunksize
;
6503 if(unhandled_len
> 0)
6505 memmove(mbuf
, mbuf
+ chunksize
, unhandled_len
);
6507 } while(unhandled_len
!= 0 && packet_count
++ < 8);
6509 cs_log_dbg(D_DVBAPI
, "Processing socketdata completed after %d packets with %d bytes left unprocessed", packet_count
, unhandled_len
);
6511 (*new_unhandled_len
) = unhandled_len
;
6515 static void *dvbapi_main_local(void *cli
)
6518 struct s_client
*client
= (struct s_client
*)cli
;
6519 client
->thread
= pthread_self();
6520 SAFE_SETSPECIFIC(getclient
, cli
);
6521 dvbapi_client
= cli
;
6522 int32_t maxpfdsize
= (MAX_DEMUX
* maxfilter
) + MAX_DEMUX
+ 2;
6523 struct pollfd pfd2
[maxpfdsize
];
6524 struct timeb start
, end
; // start time poll, end time poll
6525 #define PMT_SERVER_SOCKET "/tmp/.listen.camd.socket"
6526 struct sockaddr_un saddr
;
6527 saddr
.sun_family
= AF_UNIX
;
6528 cs_strncpy(saddr
.sun_path
, PMT_SERVER_SOCKET
, sizeof(saddr
.sun_path
));
6529 int32_t rc
, pfdcount
, g
, connfd
, clilen
;
6530 int32_t ids
[maxpfdsize
], fdn
[maxpfdsize
], type
[maxpfdsize
];
6531 struct SOCKADDR servaddr
;
6533 static const uint16_t mbuf_size
= 2048;
6535 uint16_t unhandled_buf_len
[maxpfdsize
], unhandled_buf_used
[maxpfdsize
];
6536 uint8_t *unhandled_buf
[maxpfdsize
];
6537 struct s_auth
*account
;
6539 uint16_t client_proto_version
[maxpfdsize
];
6541 if(!cs_malloc(&mbuf
, sizeof(uint8_t) * mbuf_size
))
6546 for(i
= 0; i
< maxpfdsize
; i
++)
6548 unhandled_buf
[i
] = NULL
;
6549 unhandled_buf_len
[i
] = 0;
6550 unhandled_buf_used
[i
] = 0;
6551 client_proto_version
[i
] = 0;
6554 for(account
= cfg
.account
; account
!= NULL
; account
= account
->next
)
6556 if((ok
= is_dvbapi_usr(account
->usr
)))
6562 cs_auth_client(client
, ok
? account
: (struct s_auth
*)(-1), "dvbapi");
6563 memset(demux
, 0, sizeof(demux
));
6565 for(i
= 0; i
< MAX_DEMUX
; i
++)
6567 SAFE_MUTEX_INIT(&demux
[i
].answerlock
, NULL
);
6568 for(j
= 0; j
< MAX_ECM_PIDS
; j
++)
6570 for(l
= 0; l
< MAX_STREAM_INDICES
; l
++)
6572 demux
[i
].ECMpids
[j
].index
[l
] = INDEX_INVALID
;
6575 demux
[i
].pidindex
= -1;
6576 demux
[i
].curindex
= -1;
6579 memset(ca_fd
, 0, sizeof(ca_fd
));
6580 memset(unassoc_fd
, 0, sizeof(unassoc_fd
));
6581 dvbapi_read_priority();
6582 dvbapi_load_channel_cache();
6583 dvbapi_detect_api();
6585 if(selected_box
== -1 || selected_api
== -1)
6587 cs_log("ERROR: Could not detect DVBAPI version.");
6592 // detect box type first and then get descrambler info
6593 dvbapi_get_descrambler_info();
6595 if(cfg
.dvbapi_pmtmode
== 1)
6597 disable_pmt_files
= 1;
6600 int32_t listenfd
= -1;
6601 if(cfg
.dvbapi_boxtype
!= BOXTYPE_IPBOX_PMT
&&
6602 cfg
.dvbapi_pmtmode
!= 2 && cfg
.dvbapi_pmtmode
!= 5 && cfg
.dvbapi_pmtmode
!= 6)
6604 if(!cfg
.dvbapi_listenport
)
6606 listenfd
= dvbapi_init_listenfd();
6610 listenfd
= dvbapi_net_init_listenfd();
6615 cs_log("ERROR: Could not init socket: (errno=%d: %s)", errno
, strerror(errno
));
6621 for(i
= 0; i
< MAX_DEMUX
; i
++) // init all demuxers!
6623 demux
[i
].pidindex
= -1;
6624 demux
[i
].curindex
= -1;
6627 if(cfg
.dvbapi_pmtmode
!= 4 && cfg
.dvbapi_pmtmode
!= 5 && cfg
.dvbapi_pmtmode
!= 6)
6629 struct sigaction signal_action
;
6630 signal_action
.sa_handler
= event_handler
;
6631 sigemptyset(&signal_action
.sa_mask
);
6632 signal_action
.sa_flags
= SA_RESTART
;
6633 sigaction(SIGRTMIN
+ 1, &signal_action
, NULL
);
6635 dir_fd
= open(TMPDIR
, O_RDONLY
);
6638 fcntl(dir_fd
, F_SETSIG
, SIGRTMIN
+ 1);
6639 fcntl(dir_fd
, F_NOTIFY
, DN_MODIFY
| DN_CREATE
| DN_DELETE
| DN_MULTISHOT
);
6640 event_handler(SIGRTMIN
+ 1);
6645 int32_t ret
= start_thread("dvbapi event", dvbapi_event_thread
, (void *) dvbapi_client
, NULL
, 1, 0);
6655 pfd2
[0].fd
= listenfd
;
6656 pfd2
[0].events
= (POLLIN
| POLLPRI
);
6660 #if defined WITH_COOLAPI || defined WITH_COOLAPI2 || defined WITH_NEUTRINO
6661 system("pzapit -rz");
6663 cs_ftime(&start
); // register start time
6667 if(pausecam
) // for dbox2, STAPI or PC in standby mode don't parse any ecm/emm or try to start next filter
6672 if(cfg
.dvbapi_pmtmode
== 6)
6676 cs_log("PMT mode 6: Connecting to enigma CA PMT listen socket...");
6679 if((listenfd
= socket(AF_UNIX
, SOCK_STREAM
, 0)) < 0)
6681 cs_log("socket error (errno=%d %s)", errno
, strerror(errno
));
6684 else if(connect(listenfd
, (struct sockaddr
*)&saddr
, sizeof(saddr
)) < 0)
6686 cs_log("socket connect error (errno=%d %s)", errno
, strerror(errno
));
6692 pfd2
[0].fd
= listenfd
;
6693 pfd2
[0].events
= (POLLIN
| POLLPRI
);
6695 cs_log("PMT mode 6: Successfully connected to CA PMT server (fd %d)", listenfd
);
6699 if(listenfd
== -1) // not connected!
6702 continue; // start fresh connect attempt!
6706 pfdcount
= (listenfd
> -1) ? 1 : 0;
6707 for(i
= 0; i
< MAX_DEMUX
; i
++)
6709 // add client fd's which are not yet associated
6710 // with the demux but needs to be polled for data
6713 pfd2
[pfdcount
].fd
= unassoc_fd
[i
];
6714 pfd2
[pfdcount
].events
= (POLLIN
| POLLPRI
);
6715 client_proto_version
[pfdcount
] = last_client_proto_version
;
6716 type
[pfdcount
++] = 1;
6719 if(demux
[i
].program_number
== 0)
6721 continue; // only evalutate demuxers that have channels assigned
6724 uint32_t ecmcounter
= 0, emmcounter
= 0;
6725 for(g
= 0; g
< maxfilter
; g
++)
6727 if(demux
[i
].demux_fd
[g
].fd
<= 0)
6729 continue; // deny obvious invalid fd!
6732 if(!cfg
.dvbapi_listenport
&& cfg
.dvbapi_boxtype
!= BOXTYPE_PC_NODMX
6733 && selected_api
!= STAPI
&& selected_api
!= COOLAPI
)
6735 pfd2
[pfdcount
].fd
= demux
[i
].demux_fd
[g
].fd
;
6736 pfd2
[pfdcount
].events
= (POLLIN
| POLLPRI
);
6739 type
[pfdcount
++] = 0;
6742 // count ecm filters to see if demuxing is possible anyway
6743 if(demux
[i
].demux_fd
[g
].type
== TYPE_ECM
)
6748 // count emm filters also
6749 if(demux
[i
].demux_fd
[g
].type
== TYPE_EMM
)
6755 // only produce log if something changed
6756 if(ecmcounter
!= demux
[i
].old_ecmfiltercount
|| emmcounter
!= demux
[i
].old_emmfiltercount
)
6758 cs_log_dbg(D_DVBAPI
, "Demuxer %d has %d ecmpids, %d streampids, %d ecmfilters and %d of max %d emmfilters",
6759 i
, demux
[i
].ECMpidcount
, demux
[i
].STREAMpidcount
, ecmcounter
, emmcounter
, demux
[i
].max_emm_filter
);
6761 demux
[i
].old_ecmfiltercount
= ecmcounter
; // save new amount of ecm filters
6762 demux
[i
].old_emmfiltercount
= emmcounter
; // save new amount of emm filters
6765 // delayed emm start for non irdeto caids,
6766 // start emm cat if not already done for this demuxer!
6770 int8_t do_emm_start
= (cfg
.dvbapi_au
> 0 && demux
[i
].emm_filter
== -1 && demux
[i
].EMMpidcount
== 0 && emmcounter
== 0);
6771 int8_t do_sdt_start
= (cfg
.dvbapi_read_sdt
&& demux
[i
].sdt_filter
== -1 && cfg
.dvbapi_boxtype
!= BOXTYPE_SAMYGO
);
6773 if(do_emm_start
|| do_sdt_start
)
6775 gone
= comp_timeb(&now
, &demux
[i
].emmstart
);
6776 if(gone
> 20 * 1000)
6780 cs_ftime(&demux
[i
].emmstart
); // trick to let emm fetching start after 30 seconds to speed up zapping
6781 dvbapi_start_cat_filter(i
);
6789 dvbapi_start_sdt_filter(i
);
6794 // early start for irdeto since they need emm before ecm
6795 // (pmt emmstart = 1 if detected caid 0x06)
6796 int32_t emmstarted
= demux
[i
].emm_filter
;
6798 // check every time since share readers might
6799 // give us new filters due to hexserial change
6800 if(cfg
.dvbapi_au
&& demux
[i
].EMMpidcount
> 0)
6802 if(!emmcounter
&& emmstarted
== -1)
6804 demux
[i
].emmstart
= now
;
6805 dvbapi_start_emm_filter(i
); // start emm filtering if emm pids are found
6809 gone
= comp_timeb(&now
, &demux
[i
].emmstart
);
6810 if(gone
> 30 * 1000)
6812 demux
[i
].emmstart
= now
;
6813 dvbapi_start_emm_filter(i
); // start emm filtering delayed if filters already were running
6814 rotate_emmfilter(i
); // rotate active emm filters
6819 // Restart decoding all caids we have ecmpids but no ecm filters!
6820 if(ecmcounter
== 0 && demux
[i
].ECMpidcount
> 0)
6822 int32_t started
= 0;
6824 // avoid race: not all pids are asked and checked out yet!
6825 for(g
= 0; g
< demux
[i
].ECMpidcount
; g
++)
6827 // check if prio run is done
6828 if(demux
[i
].ECMpids
[g
].checked
== 0 && demux
[i
].ECMpids
[g
].status
>= 0)
6830 dvbapi_try_next_caid(i
, 0, 0); // not done, so start next prio pid
6838 continue; // if started a filter proceed with next demuxer
6841 // all usable pids (with prio) are tried, lets start over again without prio!
6842 if(g
== demux
[i
].ECMpidcount
)
6844 // avoid race: not all pids are asked and checked out yet!
6845 for(g
= 0; g
< demux
[i
].ECMpidcount
; g
++)
6847 // check if noprio run is done
6848 if(demux
[i
].ECMpids
[g
].checked
== 2 && demux
[i
].ECMpids
[g
].status
>= 0)
6850 demux
[i
].ECMpids
[g
].irdeto_curindex
= 0xFE;
6851 demux
[i
].ECMpids
[g
].irdeto_maxindex
= 0;
6852 demux
[i
].ECMpids
[g
].irdeto_cycle
= 0xFE;
6853 demux
[i
].ECMpids
[g
].tries
= 0xFE;
6854 demux
[i
].ECMpids
[g
].table
= 0;
6855 demux
[i
].ECMpids
[g
].CHID
= 0x10000; // remove chid prio
6857 dvbapi_try_next_caid(i
, 2, 0); // not done, so start next no prio pid
6866 continue; // if started a filter proceed with next demuxer
6869 if(g
== demux
[i
].ECMpidcount
) // all usable pids are tried, lets start over again!
6871 if(demux
[i
].decodingtries
== -1) // first redecoding attempt?
6873 cs_ftime(&demux
[i
].decstart
);
6875 // re-init some used things from second run (without prio)
6876 for(g
= 0; g
< demux
[i
].ECMpidcount
; g
++)
6878 demux
[i
].ECMpids
[g
].checked
= 0;
6879 demux
[i
].ECMpids
[g
].irdeto_curindex
= 0xFE;
6880 demux
[i
].ECMpids
[g
].irdeto_maxindex
= 0;
6881 demux
[i
].ECMpids
[g
].irdeto_cycle
= 0xFE;
6882 demux
[i
].ECMpids
[g
].table
= 0;
6883 demux
[i
].decodingtries
= 0;
6885 // remove this pid from channel cache since we had no founds on any ecmpid!
6886 dvbapi_edit_channel_cache(i
, g
, 0);
6890 uint8_t number_of_enabled_pids
= 0;
6891 demux
[i
].decodingtries
++;
6892 dvbapi_resort_ecmpids(i
);
6894 for(g
= 0; g
< demux
[i
].ECMpidcount
; g
++) // count number of enabled pids!
6896 if(demux
[i
].ECMpids
[g
].status
>= 0) number_of_enabled_pids
++;
6899 if(!number_of_enabled_pids
)
6901 if(demux
[i
].decodingtries
== 10)
6903 demux
[i
].decodingtries
= 0;
6904 cs_log("Demuxer %d no enabled matching ecmpids -> decoding is waiting for matching readers!",i
);
6909 cs_ftime(&demux
[i
].decend
);
6910 demux
[i
].decodingtries
= -1; // reset to first run again!
6911 gone
= comp_timeb(&demux
[i
].decend
, &demux
[i
].decstart
);
6913 cs_log("Demuxer %d restarting decoding requests after %"PRId64
" ms with %d enabled and %d disabled ecmpids!",
6914 i
, gone
, number_of_enabled_pids
, (demux
[i
].ECMpidcount
-number_of_enabled_pids
));
6916 dvbapi_try_next_caid(i
, 0, 0);
6921 if(demux
[i
].socket_fd
> 0 && cfg
.dvbapi_pmtmode
!= 6)
6924 for(j
= 0; j
< pfdcount
; j
++)
6926 if(pfd2
[j
].fd
== demux
[i
].socket_fd
)
6938 pfd2
[pfdcount
].fd
= demux
[i
].socket_fd
;
6939 pfd2
[pfdcount
].events
= (POLLIN
| POLLPRI
);
6941 type
[pfdcount
++] = 1;
6946 while(!(listenfd
== -1 && cfg
.dvbapi_pmtmode
== 6))
6948 rc
= poll(pfd2
, pfdcount
, 500);
6949 if(rc
< 0) // error occured while polling for fd's with fresh data
6951 if(errno
== EINTR
|| errno
== EAGAIN
) // try again in case of interrupt
6955 cs_log("ERROR: error on poll of %d fd's (errno=%d %s)", pfdcount
, errno
, strerror(errno
));
6966 cs_ftime(&end
); // register end time
6967 int64_t timeout
= comp_timeb(&end
, &start
);
6970 cs_log("*** WARNING: BAD TIME AFFECTING WHOLE OSCAM ECM HANDLING ****");
6972 cs_log_dbg(D_TRACE
, "New events occurred on %d of %d handlers after %"PRId64
" ms inactivity", rc
, pfdcount
, timeout
);
6973 cs_ftime(&start
); // register new start time for next poll
6976 for(i
= 0; i
< pfdcount
&& rc
> 0; i
++)
6978 if(pfd2
[i
].revents
== 0) { continue; } // skip sockets with no changes
6979 rc
--; //event handled!
6980 cs_log_dbg(D_TRACE
, "Now handling fd %d that reported event %d", pfd2
[i
].fd
, pfd2
[i
].revents
);
6982 if(pfd2
[i
].revents
& (POLLHUP
| POLLNVAL
| POLLERR
))
6986 for(j
= 0; j
< MAX_DEMUX
; j
++)
6988 // if listenfd closes stop all assigned decoding!
6989 if(demux
[j
].socket_fd
== pfd2
[i
].fd
)
6991 dvbapi_stop_descrambling(j
, 0);
6994 // remove from unassoc_fd when necessary
6995 if(unassoc_fd
[j
] == pfd2
[i
].fd
)
7001 int32_t ret
= close(pfd2
[i
].fd
);
7002 if(ret
< 0 && errno
!= 9)
7004 cs_log("ERROR: Could not close demuxer socket fd (errno=%d %s)", errno
, strerror(errno
));
7007 if(pfd2
[i
].fd
== listenfd
&& cfg
.dvbapi_pmtmode
== 6)
7011 cs_log_dbg(D_DVBAPI
, "Socket %d reported hard connection close", pfd2
[i
].fd
);
7015 int32_t demux_id
= ids
[i
];
7018 if(cfg
.dvbapi_boxtype
!= BOXTYPE_SAMYGO
)
7020 // stop filter since its giving errors and wont return anything good
7021 dvbapi_stop_filternum(demux_id
, n
, 0);
7027 struct dmx_sct_filter_params sFP
;
7028 cs_log_dbg(D_DVBAPI
, "re-opening connection to demux socket");
7029 close(demux
[demux_id
].demux_fd
[n
].fd
);
7030 demux
[demux_id
].demux_fd
[n
].fd
= -1;
7032 ret
= dvbapi_open_device(0, demux
[demux_id
].demux_index
, demux
[demux_id
].adapter_index
);
7035 demux
[demux_id
].demux_fd
[n
].fd
= ret
;
7036 pid
= demux
[demux_id
].curindex
;
7037 memset(filter
, 0, 32);
7038 memset(&sFP
, 0, sizeof(sFP
));
7041 sFP
.pid
= demux
[demux_id
].ECMpids
[pid
].ECM_PID
;
7043 sFP
.flags
= DMX_IMMEDIATE_START
;
7044 memcpy(sFP
.filter
.filter
, filter
, 16);
7045 memcpy(sFP
.filter
.mask
, filter
+ 16, 16);
7046 ret
= dvbapi_ioctl(demux
[demux_id
].demux_fd
[n
].fd
, DMX_SET_FILTER
, &sFP
);
7051 // stop filter since it's giving errors and wont return anything good
7052 dvbapi_stop_filternum(demux_id
, n
, 0);
7056 continue; // continue with other events
7059 if(pfd2
[i
].revents
& (POLLIN
| POLLPRI
))
7063 connfd
= -1; // initially no socket to read from
7064 uint8_t add_to_poll
= 0; // we may need to additionally poll this socket when no PMT data comes in
7066 if(pfd2
[i
].fd
== listenfd
)
7068 if(cfg
.dvbapi_pmtmode
== 6)
7071 disable_pmt_files
= 1;
7075 clilen
= sizeof(servaddr
);
7076 connfd
= accept(listenfd
, (struct sockaddr
*)&servaddr
, (socklen_t
*)&clilen
);
7077 cs_log_dbg(D_DVBAPI
, "new socket connection fd: %d", connfd
);
7079 if(cfg
.dvbapi_listenport
)
7081 // update webif data
7082 client
->ip
= SIN_GET_ADDR(servaddr
);
7083 client
->port
= ntohs(SIN_GET_PORT(servaddr
));
7087 if(cfg
.dvbapi_pmtmode
== 3 || cfg
.dvbapi_pmtmode
== 0)
7089 disable_pmt_files
= 1;
7094 cs_log_dbg(D_DVBAPI
, "accept() returns error on fd event %d (errno=%d %s)",
7095 pfd2
[i
].revents
, errno
, strerror(errno
));
7101 connfd
= pfd2
[i
].fd
;
7104 //reading and completing data from socket
7107 if(unhandled_buf_used
[i
])
7109 memcpy(mbuf
, unhandled_buf
[i
], unhandled_buf_used
[i
]);
7112 if(!dvbapi_handlesockdata(connfd
, mbuf
, mbuf_size
, unhandled_buf_used
[i
], &add_to_poll
, &unhandled_buf_used
[i
], &client_proto_version
[i
]))
7114 unhandled_buf_used
[i
] = 0;
7115 client_proto_version
[i
] = 0; // reset protocol, next client could old protocol.
7116 last_client_proto_version
= 0;
7117 // client disconnects, stop all assigned decoding
7118 cs_log_dbg(D_DVBAPI
, "Socket %d reported connection close", connfd
);
7119 int active_conn
= 0; // other active connections counter
7122 for(j
= 0; j
< MAX_DEMUX
; j
++)
7124 if(demux
[j
].socket_fd
== connfd
)
7126 dvbapi_stop_descrambling(j
, 0);
7128 else if(demux
[j
].socket_fd
)
7133 // remove from unassoc_fd when necessary
7134 if(unassoc_fd
[j
] == connfd
)
7142 // last connection closed
7143 if(!active_conn
&& (cfg
.dvbapi_listenport
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
))
7145 if(cfg
.dvbapi_listenport
)
7147 // update webif data
7148 client
->ip
= get_null_ip();
7155 if(unhandled_buf_used
[i
])
7157 if(unhandled_buf_used
[i
] > unhandled_buf_len
[i
])
7159 NULLFREE(unhandled_buf
[i
]);
7160 unhandled_buf_len
[i
] = unhandled_buf_used
[i
] < 128 ? 128 : unhandled_buf_used
[i
];
7161 if(!cs_malloc(&unhandled_buf
[i
], sizeof(uint8_t) * unhandled_buf_len
[i
]))
7163 unhandled_buf_len
[i
] = 0;
7164 unhandled_buf_used
[i
] = 0;
7168 memcpy(unhandled_buf
[i
], mbuf
, unhandled_buf_used
[i
]);
7171 // if the connection is new and we read no PMT data, then add it to the poll,
7172 // otherwise this socket will not be checked with poll when data arives
7173 // because fd it is not yet assigned with the demux
7176 for(j
= 0; j
< MAX_DEMUX
; j
++)
7180 unassoc_fd
[j
] = connfd
;
7189 int32_t demux_id
= ids
[i
];
7192 if((int)demux
[demux_id
].demux_fd
[n
].fd
!= pfd2
[i
].fd
)
7194 continue; // filter already killed, no need to process this data!
7197 len
= dvbapi_read_device(pfd2
[i
].fd
, mbuf
, mbuf_size
);
7198 if(len
< 0) // serious filterdata read error
7200 // stop filter since it's giving errors and won't return anything good
7201 dvbapi_stop_filternum(demux_id
, n
, 0);
7203 maxfilter
--; // lower maxfilters to avoid this with new filter setups!
7207 if(!len
) // receiver internal filter buffer overflow
7209 memset(mbuf
, 0, mbuf_size
);
7211 dvbapi_process_input(demux_id
, n
, mbuf
, len
, 0);
7213 continue; // continue with other events!
7218 for(j
= 0; j
< maxpfdsize
; j
++)
7220 NULLFREE(unhandled_buf
[j
]);
7227 void dvbapi_write_cw(int32_t demux_id
, int32_t pid
, int32_t stream_id
, uint8_t *cw
, uint8_t cw_length
, uint8_t *iv
,
7228 uint8_t iv_length
, enum ca_descr_algo algo
, enum ca_descr_cipher_mode cipher_mode
, uint32_t msgid
)
7230 int8_t n
, cw_empty
= 0;
7231 uint8_t null_cw
[cw_length
];
7232 ca_descr_t ca_descr
;
7233 ca_descr_mode_t ca_descr_mode
;
7234 ca_descr_data_t ca_descr_data
;
7236 memset(null_cw
, 0, cw_length
);
7237 memset(&ca_descr
, 0, sizeof(ca_descr
));
7238 memset(&ca_descr_mode
, 0, sizeof(ca_descr_mode
));
7239 memset(&ca_descr_data
, 0, sizeof(ca_descr_data
));
7241 if(memcmp(demux
[demux_id
].last_cw
[stream_id
][0], null_cw
, cw_length
) == 0
7242 && memcmp(demux
[demux_id
].last_cw
[stream_id
][1], null_cw
, cw_length
) == 0)
7244 cw_empty
= 1; // to make sure that both cws get written on constantcw
7247 for(n
= 0; n
< 2; n
++)
7249 // Check if cw has changed and if new cw is empty (all zeros)
7250 // Skip check for BISS1 - cw could be indeed zero
7251 // Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
7252 if((memcmp(cw
+ (n
* cw_length
), demux
[demux_id
].last_cw
[stream_id
][n
], cw_length
) != 0 || cw_empty
)
7253 && (memcmp(cw
+ (n
* cw_length
), null_cw
, cw_length
) != 0 || caid_is_biss(demux
[demux_id
].ECMpids
[pid
].CAID
)))
7255 // prepare ca device
7256 uint32_t idx
= dvbapi_ca_set_pid(demux_id
, pid
, stream_id
, (algo
== CA_ALGO_DES
), msgid
);
7257 if(idx
== INDEX_INVALID
)
7259 return; // return on no index!
7262 #if defined WITH_COOLAPI || defined WITH_COOLAPI2
7263 ca_descr
.index
= idx
;
7264 ca_descr
.parity
= n
;
7266 // just to make the compiler happy (-Wunused-parameter)
7267 // (better move the coolapi code to a separate function)
7268 ca_descr_mode
.cipher_mode
= cipher_mode
;
7269 ca_descr_data
.data
= iv
;
7270 ca_descr_data
.length
= iv_length
;
7272 memcpy(demux
[demux_id
].last_cw
[stream_id
][n
], cw
+ (n
* 8), 8);
7273 memcpy(ca_descr
.cw
, cw
+ (n
* 8), 8);
7275 cs_log_dbg(D_DVBAPI
, "Demuxer %d write cw%d index: %d (ca_mask %d)",
7276 demux_id
, n
, ca_descr
.index
, demux
[demux_id
].ca_mask
);
7278 coolapi_write_cw(demux
[demux_id
].ca_mask
, demux
[demux_id
].STREAMpids
, demux
[demux_id
].STREAMpidcount
, &ca_descr
);
7280 int32_t i
, j
, write_cw
= 0;
7281 uint32_t usedidx
, lastidx
;
7283 char lastcw
[2 * cw_length
+ 1];
7284 char newcw
[2 * cw_length
+ 1];
7285 cs_hexdump(0, demux
[demux_id
].last_cw
[stream_id
][n
], cw_length
, lastcw
, sizeof(lastcw
));
7286 cs_hexdump(0, cw
+ (n
* cw_length
), cw_length
, newcw
, sizeof(newcw
));
7288 for(i
= 0; i
< CA_MAX
; i
++)
7290 if(!(demux
[demux_id
].ca_mask
& (1 << i
)))
7292 continue; // ca not in use by this demuxer!
7294 lastidx
= INDEX_INVALID
;
7296 for(j
= 0; j
< demux
[demux_id
].STREAMpidcount
; j
++)
7299 if(!demux
[demux_id
].ECMpids
[pid
].streams
|| ((demux
[demux_id
].ECMpids
[pid
].streams
& (1 << j
)) == (uint
) (1 << j
)))
7301 usedidx
= is_ca_used(i
, demux
[demux_id
].STREAMpids
[j
]);
7302 if(usedidx
!= INDEX_INVALID
)
7306 cs_log_dbg(D_DVBAPI
,"Demuxer %d ca%d is using index %d for streampid %04X -> skip!",
7307 demux_id
, i
, usedidx
, demux
[demux_id
].STREAMpids
[j
]);
7308 continue; // if not used for descrambling -> skip!
7312 if(usedidx
== lastidx
)
7314 cs_log_dbg(D_DVBAPI
,"Demuxer %d ca%d is using index %d for streampid %04X -> skip, %s part of cw already written!",
7315 demux_id
, i
, usedidx
, demux
[demux_id
].STREAMpids
[j
], (n
== 1 ? "even" : "odd"));
7319 cs_log_dbg(D_DVBAPI
,"Demuxer %d ca%d is using index %d for streampid %04X -> write %s part of cw!",
7320 demux_id
, i
, usedidx
, demux
[demux_id
].STREAMpids
[j
], (n
== 1 ? "even" : "odd"));
7329 continue; // no need to write the cw since this ca isnt using it!
7333 ca_descr
.index
= usedidx
;
7334 ca_descr
.parity
= n
;
7336 memcpy(demux
[demux_id
].last_cw
[stream_id
][n
], cw
+ (n
* cw_length
), cw_length
);
7337 memcpy(ca_descr
.cw
, cw
+ (n
* 8), 8); // ca_descr is only used for 8 byte CWs
7339 cs_log_dbg(D_DVBAPI
, "Demuxer %d writing %s part (%s) of controlword, replacing expired (%s)",
7340 demux_id
, (n
== 1 ? "even" : "odd"), newcw
, lastcw
);
7342 cs_log_dbg(D_DVBAPI
, "Demuxer %d write cw%d index: %d (ca%d)", demux_id
, n
, ca_descr
.index
, i
);
7344 if(cfg
.dvbapi_extended_cw_api
== 1) // Set descrambler algorithm and mode
7346 ca_descr_mode
.index
= usedidx
;
7347 ca_descr_mode
.algo
= algo
;
7348 ca_descr_mode
.cipher_mode
= cipher_mode
;
7350 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
7352 dvbapi_net_send(DVBAPI_CA_SET_DESCR_MODE
, demux
[demux_id
].socket_fd
, msgid
, demux_id
, -1 /*unused*/,
7353 (uint8_t *) &ca_descr_mode
, NULL
, NULL
, demux
[demux_id
].client_proto_version
);
7359 ca_fd
[i
] = dvbapi_open_device(1, i
, demux
[demux_id
].adapter_index
);
7360 if(ca_fd
[i
] <= 0) { continue; }
7363 if(dvbapi_ioctl(ca_fd
[i
], CA_SET_DESCR_MODE
, &ca_descr_mode
) < 0)
7365 cs_log("ERROR: ioctl(CA_SET_DESCR_MODE): %s", strerror(errno
));
7370 // Send 16 byte CW and IV for AES128, DVB-CISSA
7371 if(cfg
.dvbapi_extended_cw_api
== 1 && algo
== CA_ALGO_AES128
)
7374 ca_descr_data
.index
= usedidx
;
7375 ca_descr_data
.data_type
= CA_DATA_IV
;
7376 ca_descr_data
.data
= iv
;
7377 ca_descr_data
.length
= iv_length
;
7379 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
7381 dvbapi_net_send(DVBAPI_CA_SET_DESCR_DATA
, demux
[demux_id
].socket_fd
, msgid
, demux_id
, -1 /*unused*/,
7382 (uint8_t *) &ca_descr_data
, NULL
, NULL
, demux
[demux_id
].client_proto_version
);
7386 if(dvbapi_ioctl(ca_fd
[i
], CA_SET_DESCR_DATA
, &ca_descr_data
) < 0)
7388 cs_log("ERROR: ioctl(CA_SET_DESCR_DATA): %s", strerror(errno
));
7393 ca_descr_data
.index
= usedidx
;
7394 ca_descr_data
.data_type
= CA_DATA_KEY
;
7395 ca_descr_data
.data
= cw
+ (n
* cw_length
);
7396 ca_descr_data
.length
= cw_length
;
7397 ca_descr_data
.parity
= n
;
7399 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
7401 dvbapi_net_send(DVBAPI_CA_SET_DESCR_DATA
, demux
[demux_id
].socket_fd
, msgid
, demux_id
, -1 /*unused*/,
7402 (uint8_t *) &ca_descr_data
, NULL
, NULL
, demux
[demux_id
].client_proto_version
);
7406 if(dvbapi_ioctl(ca_fd
[i
], CA_SET_DESCR_DATA
, &ca_descr_data
) < 0)
7408 cs_log("ERROR: ioctl(CA_SET_DESCR_DATA): %s", strerror(errno
));
7412 else // Send 8 byte CW for DVB-CSA or DES
7414 if(cfg
.dvbapi_boxtype
== BOXTYPE_PC
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
7416 dvbapi_net_send(DVBAPI_CA_SET_DESCR
, demux
[demux_id
].socket_fd
, msgid
, demux_id
, -1 /*unused*/,
7417 (uint8_t *) &ca_descr
, NULL
, NULL
, demux
[demux_id
].client_proto_version
);
7423 ca_fd
[i
] = dvbapi_open_device(1, i
, demux
[demux_id
].adapter_index
);
7430 if(dvbapi_ioctl(ca_fd
[i
], CA_SET_DESCR
, &ca_descr
) < 0)
7432 cs_log("ERROR: ioctl(CA_SET_DESCR): %s", strerror(errno
));
7441 cs_log_dbg(D_DVBAPI
, "Using %d of %d total descramblers", ca_descramblers_used
, ca_descramblers_total
);
7444 void delayer(ECM_REQUEST
*er
, uint32_t delay
)
7446 if(delay
<= 0) { return; }
7450 int64_t gone
= comp_timeb(&tpe
, &er
->tps
);
7454 cs_log_dbg(D_DVBAPI
, "delayer: gone=%"PRId64
" ms, cfg=%d ms -> delay=%"PRId64
" ms", gone
, delay
, delay
- gone
);
7455 cs_sleepms(delay
- gone
);
7459 void dvbapi_send_dcw(struct s_client
*client
, ECM_REQUEST
*er
)
7461 int32_t i
, j
, k
, handled
= 0;
7462 for(i
= 0; i
< MAX_DEMUX
; i
++)
7464 uint32_t nocw_write
= 0; // 0 = write cw, 1 = dont write cw to hardware demuxer
7466 // ignore empty demuxers, skip ecm response for other
7467 // srvid and ecm recponse for different adapter
7468 if(demux
[i
].program_number
== 0
7469 || demux
[i
].program_number
!= er
->srvid
7470 || demux
[i
].adapter_index
!= er
->adapter_index
)
7476 if(strcmp(dev_list
[demux
[i
].dev_index
].name
, er
->dev_name
) != 0)
7478 continue; // skip request if PTI device doesn't match request
7482 demux
[i
].rdr
= er
->selected_reader
;
7484 for(j
= 0; j
< demux
[i
].ECMpidcount
; j
++) // check for matching ecmpid
7486 if((demux
[i
].ECMpids
[j
].CAID
== er
->caid
|| demux
[i
].ECMpids
[j
].CAID
== er
->ocaid
)
7487 && demux
[i
].ECMpids
[j
].ECM_PID
== er
->pid
&& demux
[i
].ECMpids
[j
].PROVID
== er
->prid
7488 && demux
[i
].ECMpids
[j
].VPID
== er
->vpid
)
7494 if(j
== demux
[i
].ECMpidcount
)
7496 continue; // ecm response srvid ok but no matching ecmpid, perhaps this for other demuxer
7499 cs_log_dbg(D_DVBAPI
, "Demuxer %d %scontrol word received for PID %d CAID %04X PROVID %06X ECMPID %04X CHID %04X VPID %04X",
7500 i
, (er
->rc
>= E_NOTFOUND
? "no " : ""), j
, er
->caid
, er
->prid
, er
->pid
, er
->chid
, er
->vpid
);
7502 uint32_t status
= dvbapi_check_ecm_delayed_delivery(i
, er
);
7503 uint32_t comparecw0
= 0, comparecw1
= 0;
7505 cs_hexdump(0, er
->ecmd5
, 16, ecmd5
, sizeof(ecmd5
));
7507 if(status
== 1 && er
->rc
) // wrong ecmhash
7509 cs_log_dbg(D_DVBAPI
, "Demuxer %d not interested in response ecmhash %s (requested different one)", i
, ecmd5
);
7513 if(status
== 2) // no filter
7515 cs_log_dbg(D_DVBAPI
, "Demuxer %d not interested in response ecmhash %s (filter already killed)", i
, ecmd5
);
7519 if(status
== 5) // empty cw
7521 cs_log_dbg(D_DVBAPI
, "Demuxer %d not interested in response ecmhash %s (delivered cw is empty!)", i
, ecmd5
);
7524 if(er
->rc
< E_NOTFOUND
)
7526 er
->rc
= E_NOTFOUND
;
7530 // 0=matching ecm hash, 2=no filter, 3=table reset, 4=cache-ex response
7531 // Check only against last_cw[0] (index 0) - No need to check the rest
7532 // Skip check for BISS1 - cw could be indeed zero
7533 // Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
7534 if((status
== 0 || status
== 3 || status
== 4) && er
->rc
< E_NOTFOUND
&& !caid_is_biss(er
->caid
))
7536 // check for matching control word
7537 if(memcmp(er
->cw
, demux
[i
].last_cw
[0][0], 8) == 0 &&
7538 memcmp(er
->cw
+ 8, demux
[i
].last_cw
[0][1], 8) == 0)
7542 else if(memcmp(er
->cw
, demux
[i
].last_cw
[0][1], 8) == 0 &&
7543 memcmp(er
->cw
+ 8, demux
[i
].last_cw
[0][0], 8) == 0)
7548 if(comparecw0
== 1 || comparecw1
== 1)
7550 cs_log_dbg(D_DVBAPI
, "Demuxer %d duplicate controlword ecm response hash %s (duplicate controlword!)", i
, ecmd5
);
7555 if(status
== 3) // table reset
7557 cs_log_dbg(D_DVBAPI
, "Demuxer %d luckyshot new controlword ecm response hash %s (ecm table reset)", i
, ecmd5
);
7560 if(status
== 4) // no check on cache-ex responses!
7562 cs_log_dbg(D_DVBAPI
, "Demuxer %d new controlword from cache-ex reader (no ecmhash check possible)", i
);
7565 handled
= 1; // mark this ecm response as handled
7566 if(er
->rc
< E_NOTFOUND
&& cfg
.dvbapi_requestmode
== 0 && (demux
[i
].pidindex
== -1) && er
->caid
!= 0)
7568 demux
[i
].ECMpids
[j
].tries
= 0xFE; // reset timeout retry flag
7569 demux
[i
].ECMpids
[j
].irdeto_cycle
= 0xFE; // reset irdetocycle
7570 demux
[i
].pidindex
= j
; // set current index as *the* pid to descramble
7571 demux
[i
].ECMpids
[j
].checked
= 4;
7573 cs_log_dbg(D_DVBAPI
, "Demuxer %d descrambling PID %d CAID %04X PROVID %06X ECMPID %04X CHID %02X VPID %04X",
7574 i
, demux
[i
].pidindex
, er
->caid
, er
->prid
, er
->pid
, er
->chid
, er
->vpid
);
7577 if(er
->rc
< E_NOTFOUND
&& cfg
.dvbapi_requestmode
== 1 && er
->caid
!= 0) // FOUND
7579 SAFE_MUTEX_LOCK(&demux
[i
].answerlock
); // only process one ecm answer
7580 if(demux
[i
].ECMpids
[j
].checked
!= 4)
7582 int32_t t
, o
, ecmcounter
= 0;
7583 int32_t oldpidindex
= demux
[i
].pidindex
;
7584 demux
[i
].pidindex
= j
; // set current ecmpid as the new pid to descramble
7586 if(oldpidindex
!= -1)
7588 for(k
= 0; k
< MAX_STREAM_INDICES
; k
++)
7590 demux
[i
].ECMpids
[j
].index
[k
] = demux
[i
].ECMpids
[oldpidindex
].index
[k
]; // swap index with lower status pid that was descrambling
7591 demux
[i
].ECMpids
[j
].useMultipleIndices
= demux
[i
].ECMpids
[oldpidindex
].useMultipleIndices
;
7595 // check this pid with control word FOUND for higher status
7596 for(t
= 0; t
< demux
[i
].ECMpidcount
; t
++)
7598 if(t
!= j
&& demux
[i
].ECMpids
[j
].status
>= demux
[i
].ECMpids
[t
].status
)
7600 // check if ecm filter is in use and
7601 // stop all ecm filters of lower status pids
7602 for(o
= 0; o
< maxfilter
; o
++)
7604 if(demux
[i
].demux_fd
[o
].fd
> 0 && demux
[i
].demux_fd
[o
].type
== TYPE_ECM
7605 && demux
[i
].demux_fd
[o
].pidindex
== t
)
7607 // ecm filter belongs to lower status pid -> kill!
7608 dvbapi_stop_filternum(i
, o
, er
->msgid
);
7611 dvbapi_edit_channel_cache(i
, t
, 0); // remove lower status pid from channel cache
7612 demux
[i
].ECMpids
[t
].checked
= 4; // mark index t as low status
7616 for(o
= 0; o
< maxfilter
; o
++)
7618 if(demux
[i
].demux_fd
[o
].type
== TYPE_ECM
)
7620 ecmcounter
++; // count all ecm filters
7624 demux
[i
].ECMpids
[j
].tries
= 0xFE; // reset timeout retry flag
7625 demux
[i
].ECMpids
[j
].irdeto_cycle
= 0xFE; // reset irdeto cycle
7627 if(ecmcounter
== 1) // if total found running ecmfilters is 1 -> we found the "best" pid
7629 dvbapi_edit_channel_cache(i
, j
, 1);
7630 demux
[i
].ECMpids
[j
].checked
= 4; // mark best pid last ;)
7632 cs_log_dbg(D_DVBAPI
, "Demuxer %d descrambling PID %d CAID %04X PROVID %06X ECMPID %04X CHID %02X VPID %04X",
7633 i
, demux
[i
].pidindex
, er
->caid
, er
->prid
, er
->pid
, er
->chid
, er
->vpid
);
7635 SAFE_MUTEX_UNLOCK(&demux
[i
].answerlock
); // and release it!
7638 if(er
->rc
>= E_NOTFOUND
) // not found on requestmode 0 + 1
7640 if(er
->rc
== E_SLEEPING
)
7642 dvbapi_stop_descrambling(i
, er
->msgid
);
7646 struct s_dvbapi_priority
*forceentry
= dvbapi_check_prio_match(i
, j
, 'p');
7647 if(forceentry
&& forceentry
->force
) // forced pid? keep trying the forced ecmpid!
7649 // all cas or irdeto cas with forced prio chid
7650 if(!caid_is_irdeto(er
->caid
) || forceentry
->chid
< 0x10000)
7652 demux
[i
].ECMpids
[j
].table
= 0;
7653 dvbapi_set_section_filter(i
, er
, -1);
7656 else // irdeto cas without chid prio forced
7658 // init irdeto current index to first one
7659 if(demux
[i
].ECMpids
[j
].irdeto_curindex
== 0xFE)
7661 demux
[i
].ECMpids
[j
].irdeto_curindex
= 0x00;
7664 // check for last / max chid
7665 if(!(demux
[i
].ECMpids
[j
].irdeto_curindex
+ 1 > demux
[i
].ECMpids
[j
].irdeto_maxindex
))
7667 cs_log_dbg(D_DVBAPI
, "Demuxer %d trying next irdeto chid of FORCED PID %d CAID %04X PROVID %06X ECMPID %04X",
7668 i
, j
, er
->caid
, er
->prid
, er
->pid
);
7670 demux
[i
].ECMpids
[j
].irdeto_curindex
++; // irdeto index one up
7671 demux
[i
].ECMpids
[j
].table
= 0;
7672 dvbapi_set_section_filter(i
, er
, -1);
7678 // in case of timeout or fatal LB event give
7679 // this pid another try but no more than 1 try
7680 if((er
->rc
== E_TIMEOUT
|| (er
->rcEx
&& er
->rcEx
<= E2_CCCAM_NOCARD
))
7681 && demux
[i
].ECMpids
[j
].tries
== 0xFE)
7683 demux
[i
].ECMpids
[j
].tries
-= 0x07;
7684 demux
[i
].ECMpids
[j
].table
= 0;
7685 dvbapi_set_section_filter(i
, er
, -1);
7688 else // all not found responses exception: first timeout response and first fatal loadbalancer response
7690 demux
[i
].ECMpids
[j
].CHID
= 0x10000; // get rid of this prio chid since it failed!
7691 demux
[i
].ECMpids
[j
].tries
= 0xFE; // reset timeout retry
7694 if(caid_is_irdeto(er
->caid
))
7696 // init irdeto current index to first one
7697 if(demux
[i
].ECMpids
[j
].irdeto_curindex
== 0xFE)
7699 demux
[i
].ECMpids
[j
].irdeto_curindex
= 0x00;
7702 // check for last / max chid
7703 if(!(demux
[i
].ECMpids
[j
].irdeto_curindex
+ 1 > demux
[i
].ECMpids
[j
].irdeto_maxindex
))
7705 cs_log_dbg(D_DVBAPI
, "Demuxer %d trying next irdeto chid of PID %d CAID %04X PROVID %06X ECMPID %04X VPID %04X",
7706 i
, j
, er
->caid
, er
->prid
, er
->pid
, er
->vpid
);
7708 demux
[i
].ECMpids
[j
].irdeto_curindex
++; // irdeto index one up
7709 demux
[i
].ECMpids
[j
].table
= 0;
7710 dvbapi_set_section_filter(i
, er
, -1);
7715 dvbapi_edit_channel_cache(i
, j
, 0); // remove this pid from channelcache
7717 if(demux
[i
].pidindex
== j
)
7719 // current pid delivered a notfound so this pid isn't
7720 // being used to descramble any longer -> clear pidindex
7721 demux
[i
].pidindex
= -1;
7724 demux
[i
].ECMpids
[j
].irdeto_maxindex
= 0;
7725 demux
[i
].ECMpids
[j
].irdeto_curindex
= 0xFE;
7726 demux
[i
].ECMpids
[j
].tries
= 0xFE; // reset timeout retry flag
7727 demux
[i
].ECMpids
[j
].irdeto_cycle
= 0xFE; // reset irdetocycle
7728 demux
[i
].ECMpids
[j
].table
= 0;
7729 demux
[i
].ECMpids
[j
].checked
= 4; // flag ecmpid as checked
7730 demux
[i
].ECMpids
[j
].status
= -1; // flag ecmpid as unusable
7732 int32_t found
= 1; // setup for first run
7733 int32_t filternum
= -1;
7735 while(found
> 0) // disable all ecm + emm filters for this notfound
7739 filternum
= dvbapi_get_filternum(i
, er
, TYPE_ECM
); // get ecm filternumber
7740 if(filternum
> -1) // in case valid filter found
7742 int32_t fd
= demux
[i
].demux_fd
[filternum
].fd
;
7743 if(fd
> 0) // in case valid fd
7745 dvbapi_stop_filternum(i
, filternum
, er
->msgid
); // stop ecmfilter
7750 if(caid_is_irdeto(er
->caid
)) // in case irdeto cas stop old emm filters
7752 filternum
= dvbapi_get_filternum(i
, er
, TYPE_EMM
); // get emm filternumber
7753 if(filternum
> -1) // in case valid filter found
7755 int32_t fd
= demux
[i
].demux_fd
[filternum
].fd
;
7756 if(fd
> 0) // in case valid fd
7758 dvbapi_stop_filternum(i
, filternum
, er
->msgid
); // stop emmfilter
7767 // below this should be only run in case of ecm answer is found
7768 uint32_t chid
= get_subid(er
); // derive current chid in case of irdeto, or a unique part of ecm on other cas systems
7769 demux
[i
].ECMpids
[j
].CHID
= (chid
!= 0 ? chid
: 0x10000); // if not zero apply, otherwise use no chid value 0x10000
7770 dvbapi_edit_channel_cache(i
, j
, 1); // do it here to here after the right CHID is registered
7772 //dvbapi_set_section_filter(i, er); is not needed anymore (unsure)
7773 demux
[i
].ECMpids
[j
].tries
= 0xFE; // reset timeout retry flag
7774 demux
[i
].ECMpids
[j
].irdeto_cycle
= 0xFE; // reset irdeto cycle
7776 // cw was already written by another filter or current pid
7777 // isn't pid used to descramble so it ends here!
7778 if(nocw_write
|| demux
[i
].pidindex
!= j
)
7783 struct s_dvbapi_priority
*delayentry
= dvbapi_check_prio_match(i
, demux
[i
].pidindex
, 'd');
7788 if(delayentry
->delay
< 1000)
7790 delay
= delayentry
->delay
;
7791 cs_log_dbg(D_DVBAPI
, "specific delay: write cw %d ms after ecmrequest", delay
);
7794 else if(cfg
.dvbapi_delayer
> 0)
7796 delay
= cfg
.dvbapi_delayer
;
7797 cs_log_dbg(D_DVBAPI
, "generic delay: write cw %d ms after ecmrequest", delay
);
7803 if(!chk_ctab_ex(er
->caid
, &cfg
.emu_stream_relay_ctab
) || !cfg
.emu_stream_relay_enabled
)
7805 switch(selected_api
)
7807 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
7809 stapi_write_cw(i
, er
->cw
, demux
[i
].STREAMpids
, demux
[i
].STREAMpidcount
, demux
[i
].pmt_file
);
7814 #ifdef WITH_EXTENDED_CW
7815 if(er
->cw_ex
.mode
!= demux
[i
].ECMpids
[j
].useMultipleIndices
)
7819 for(k
= 0; k
< demux
[i
].STREAMpidcount
; k
++)
7821 if(demux
[i
].ECMpids
[j
].useMultipleIndices
)
7823 idx
= demux
[i
].ECMpids
[j
].index
[k
];
7827 idx
= demux
[i
].ECMpids
[j
].index
[0];
7829 dvbapi_set_pid(i
, k
, idx
, false, false, er
->msgid
); // disable streampid
7832 for(k
= 0; k
< MAX_STREAM_INDICES
; k
++)
7834 demux
[i
].ECMpids
[j
].index
[k
] = INDEX_INVALID
;
7838 if(er
->cw_ex
.mode
== CW_MODE_MULTIPLE_CW
)
7840 int32_t key_pos_a
= 0;
7841 demux
[i
].ECMpids
[j
].useMultipleIndices
= 1;
7843 for(k
= 0; k
< demux
[i
].STREAMpidcount
; k
++)
7845 if(demux
[i
].STREAMpidsType
[k
] == STREAM_VIDEO
)
7847 dvbapi_write_cw(i
, j
, k
, er
->cw
, 8, NULL
, 0, er
->cw_ex
.algo
, er
->cw_ex
.algo_mode
, er
->msgid
);
7849 else if(demux
[i
].STREAMpidsType
[k
] == STREAM_AUDIO
)
7853 dvbapi_write_cw(i
, j
, k
, er
->cw_ex
.audio
[key_pos_a
], 8, NULL
, 0, er
->cw_ex
.algo
, er
->cw_ex
.algo_mode
, er
->msgid
);
7857 // Every channel that uses the extended cw has unencrypted subtitle streams,
7858 // so disable CW writing to save indices for audio streams and recordings.
7861 // dvbapi_write_cw(i, j, k, er->cw_ex.data, 8, NULL, 0, er->cw_ex.algo, er->cw_ex.algo_mode, er->msgid);
7867 demux
[i
].ECMpids
[j
].useMultipleIndices
= 0;
7869 if(er
->cw_ex
.algo
== CW_ALGO_AES128
)
7871 dvbapi_write_cw(i
, j
, 0, er
->cw_ex
.session_word
, 16, er
->cw_ex
.data
, 16, er
->cw_ex
.algo
, er
->cw_ex
.algo_mode
, er
->msgid
);
7875 dvbapi_write_cw(i
, j
, 0, er
->cw
, 8, NULL
, 0, er
->cw_ex
.algo
, er
->cw_ex
.algo_mode
, er
->msgid
);
7879 cfg
.dvbapi_extended_cw_api
= 0; // in CSA mode extended_cw_api should be always 0 regardless what user selected!
7880 dvbapi_write_cw(i
, j
, 0, er
->cw
, 8, NULL
, 0, CA_ALGO_DVBCSA
, CA_MODE_CBC
, er
->msgid
);
7887 client
->last
= time((time_t *)0); // ********* TO BE FIXED LATER ON ******
7889 if((cfg
.dvbapi_listenport
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
) && demux
[i
].client_proto_version
>= 2)
7891 dvbapi_net_send(DVBAPI_ECM_INFO
, demux
[i
].socket_fd
, 0, i
, 0, NULL
, client
, er
, demux
[i
].client_proto_version
);
7894 else if(!cfg
.dvbapi_listenport
&& cfg
.dvbapi_boxtype
!= BOXTYPE_PC_NODMX
)
7896 if(cfg
.dvbapi_ecminfo_file
!= 0 && cfg
.dvbapi_boxtype
!= BOXTYPE_SAMYGO
)
7898 #ifdef WITH_EXTENDED_CW
7899 // Only print CWs for index 0 in ecm.info file
7900 if(er
->cw_ex
.algo
== CA_ALGO_AES128
)
7902 dvbapi_write_ecminfo_file(client
, er
, demux
[i
].last_cw
[0][0], demux
[i
].last_cw
[0][1], 16);
7906 dvbapi_write_ecminfo_file(client
, er
, demux
[i
].last_cw
[0][0], demux
[i
].last_cw
[0][1], 8);
7909 dvbapi_write_ecminfo_file(client
, er
, demux
[i
].last_cw
[0][0], demux
[i
].last_cw
[0][1], 8);
7916 cs_log_dbg(D_DVBAPI
, "Unhandled ECM response received for CAID %04X PROVID %06X ECMPID %04X CHID %04X VPID %04X",
7917 er
->caid
, er
->prid
, er
->pid
, er
->chid
, er
->vpid
);
7921 static int8_t isValidCW(uint8_t *cw
)
7924 for(i
= 0; i
< 16; i
+= 4)
7926 if(((cw
[i
] + cw
[i
+ 1] + cw
[i
+ 2]) & 0xff) != cw
[i
+ 3])
7934 void dvbapi_write_ecminfo_file(struct s_client
*client
, ECM_REQUEST
*er
, uint8_t *lastcw0
, uint8_t *lastcw1
, uint8_t cw_length
)
7936 #define ECMINFO_TYPE_OSCAM 0
7937 #define ECMINFO_TYPE_OSCAM_MS 1
7938 #define ECMINFO_TYPE_WICARDD 2
7939 #define ECMINFO_TYPE_MGCAMD 3
7940 #define ECMINFO_TYPE_CCCAM 4
7941 #define ECMINFO_TYPE_CAMD3 5
7942 #define ECMINFO_TYPE_GBOX 6
7944 FILE *ecmtxt
= fopen(ECMINFO_FILE
, "w");
7945 if(ecmtxt
!= NULL
&& er
->rc
< E_NOTFOUND
)
7947 char tmp
[49]; // holds 16 byte cw - (2 hex digits + 1 space) * 16 byte + string termination)
7948 const char *reader_name
= NULL
, *from_name
= NULL
, *proto_name
= NULL
, *from_device
= NULL
;
7950 int32_t from_port
= 0;
7951 char system_name
[64];
7952 const char *const_system_name
= get_cardsystem_desc_by_caid(er
->caid
);
7954 cs_strncpy(system_name
, const_system_name
, sizeof(system_name
));
7955 system_name
[0] = (char)toupper((int)system_name
[0]);
7957 if(cfg
.dvbapi_ecminfo_type
<= ECMINFO_TYPE_WICARDD
)
7959 if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_WICARDD
)
7961 fprintf(ecmtxt
, "system: %s\n", system_name
);
7964 fprintf(ecmtxt
, "caid: 0x%04X\npid: 0x%04X\n", er
->caid
, er
->pid
);
7966 if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_WICARDD
)
7968 fprintf(ecmtxt
, "prov: %06X\n", (uint
) er
->prid
);
7972 fprintf(ecmtxt
, "prov: 0x%06X\n", (uint
) er
->prid
);
7975 fprintf(ecmtxt
, "chid: 0x%04X\n", er
->chid
);
7977 else if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_MGCAMD
)
7979 fprintf(ecmtxt
, "===== %s ECM on CaID 0x%04X, pid 0x%04X =====\nprov: %06X\n",
7980 system_name
, er
->caid
, er
->pid
, (uint
) er
->prid
);
7982 else if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_CCCAM
)
7984 char provider_name
[128];
7985 get_providername(er
->prid
, er
->caid
, provider_name
, sizeof(provider_name
));
7987 if(provider_name
[0])
7989 fprintf(ecmtxt
, "system: %s\ncaid: 0x%04X\nprovider: %s\nprovid: 0x%06X\npid: 0x%04X\n",
7990 system_name
, er
->caid
, provider_name
, (uint
) er
->prid
, er
->pid
);
7994 fprintf(ecmtxt
, "system: %s\ncaid: 0x%04X\nprovid: 0x%06X\npid: 0x%04X\n",
7995 system_name
, er
->caid
, (uint
) er
->prid
, er
->pid
);
7998 else if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_CAMD3
)
8000 fprintf(ecmtxt
, "CAID 0x%04X, PID 0x%04X, PROVIDER 0x%06X\n",
8001 er
->caid
, er
->pid
, (uint
) er
->prid
);
8004 else if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_GBOX
)
8006 fprintf(ecmtxt
, "===== %s ECM on CaID 0x%04X, pid 0x%04X, sid 0x%04X =====\nprov: %04X, slot: %d, level: %d, dist: %d\nprovider: %06X\n",
8007 system_name
, er
->caid
, er
->pid
, er
->srvid
, er
->selected_reader
->gbox_cw_src_peer
, er
->selected_reader
->gbox_crd_slot_lev
>> 4,
8008 er
->selected_reader
->gbox_crd_slot_lev
& 0xf, er
->selected_reader
->currenthops
, (uint
) er
->prid
);
8015 if(er
->selected_reader
)
8017 reader_name
= er
->selected_reader
->label
;
8018 if(is_network_reader(er
->selected_reader
))
8020 from_name
= er
->selected_reader
->device
;
8021 from_port
= er
->selected_reader
->r_port
;
8025 from_name
= "local";
8026 from_device
= er
->selected_reader
->device
;
8028 proto_name
= reader_get_type_desc(er
->selected_reader
, 1);
8029 hops
= er
->selected_reader
->currenthops
;
8033 reader_name
= "none";
8034 from_name
= "local";
8035 proto_name
= "none";
8040 reader_name
= "Cache";
8041 from_name
= "cache1";
8042 proto_name
= "none";
8046 reader_name
= "Cache";
8047 from_name
= "cache2";
8048 proto_name
= "none";
8052 reader_name
= "Cache";
8053 from_name
= "cache3";
8054 proto_name
= "none";
8058 if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_GBOX
)
8063 if(er
->selected_reader
)
8065 if(is_network_reader(er
->selected_reader
))
8067 fprintf(ecmtxt
, "reader: %s\nfrom: %s:%d\nprotocol: %s\n",
8068 reader_name
, from_name
, from_port
, proto_name
);
8072 fprintf(ecmtxt
, "reader: %s\nfrom: %s - %s\nprotocol: %s\n",
8073 reader_name
, from_name
, from_device
, proto_name
);
8081 fprintf(ecmtxt
, "reader: %s\nfrom: %s:%d\nprotocol: %s\n",
8082 reader_name
, from_name
, from_port
, proto_name
);
8085 fprintf(ecmtxt
, "ecm time: %.3f\n", (float) client
->cwlastresptime
/ 1000);
8088 if(cfg
.dvbapi_ecminfo_type
<= ECMINFO_TYPE_OSCAM_MS
)
8093 if(er
->selected_reader
)
8095 fprintf(ecmtxt
, "reader: %s\nfrom: %s:%d\nprotocol: %s\nhops: %d\n",
8096 reader_name
, from_name
, from_port
, proto_name
, hops
);
8103 fprintf(ecmtxt
, "reader: %s\nfrom: %s:%d\nprotocol: %s\n",
8104 reader_name
, from_name
, from_port
, proto_name
);
8108 if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_OSCAM
)
8110 fprintf(ecmtxt
, "ecm time: %.3f\n", (float) client
->cwlastresptime
/ 1000);
8114 fprintf(ecmtxt
, "ecm time: %d\n", client
->cwlastresptime
);
8118 if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_CAMD3
)
8120 fprintf(ecmtxt
, "FROM: %s\n", reader_name
);
8121 fprintf(ecmtxt
, "CW0: %s\n", cs_hexdump(1, lastcw0
, cw_length
, tmp
, sizeof(tmp
)));
8122 fprintf(ecmtxt
, "CW1: %s\n", cs_hexdump(1, lastcw1
, cw_length
, tmp
, sizeof(tmp
)));
8126 fprintf(ecmtxt
, "cw0: %s\n", cs_hexdump(1, lastcw0
, cw_length
, tmp
, sizeof(tmp
)));
8127 fprintf(ecmtxt
, "cw1: %s\n", cs_hexdump(1, lastcw1
, cw_length
, tmp
, sizeof(tmp
)));
8130 if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_WICARDD
|| cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_MGCAMD
)
8136 if(cw_length
== 8) // only check checksum for 8 byte CWs
8138 fprintf(ecmtxt
, "Signature %s\n", (isValidCW(lastcw0
) || isValidCW(lastcw1
)) ? "OK" : "NOK");
8142 fprintf(ecmtxt
, "Signature %s\n", "OK");
8145 if(reader_name
!= NULL
)
8147 fprintf(ecmtxt
, "source: %s (%s at %s:%d)\n", reader_name
, proto_name
, from_name
, from_port
);
8150 walltime
= cs_time();
8151 localtime_r(&walltime
, <
);
8153 if(strftime(timebuf
, 32, "%a %b %d %H:%M:%S %Y", <
) != 0)
8155 fprintf(ecmtxt
, "%d msec -- %s\n", client
->cwlastresptime
, timebuf
);
8159 if(cfg
.dvbapi_ecminfo_type
== ECMINFO_TYPE_CCCAM
)
8161 if(reader_name
!= NULL
)
8163 fprintf(ecmtxt
, "using: %s\naddress: %s:%d\nhops: %d\n",
8164 proto_name
, from_name
, from_port
, hops
);
8166 fprintf(ecmtxt
, "ecm time: %d\n", client
->cwlastresptime
);
8172 int32_t ret
= fclose(ecmtxt
);
8175 cs_log("ERROR: Could not close ecmtxt fd (errno=%d %s)", errno
, strerror(errno
));
8182 void *dvbapi_start_handler(struct s_client
*cl
, uint8_t *UNUSED(mbuf
), int32_t module_idx
, void *(*_main_func
)(void *))
8184 // cs_log("dvbapi loaded fd=%d", idx);
8185 if(cfg
.dvbapi_enabled
== 1)
8187 cl
= create_client(get_null_ip());
8188 cl
->module_idx
= module_idx
;
8191 int32_t ret
= start_thread("dvbapi handler", _main_func
, (void *)cl
, &cl
->thread
, 1, 0);
8200 void *dvbapi_handler(struct s_client
*cl
, uint8_t *mbuf
, int32_t module_idx
)
8202 return dvbapi_start_handler(cl
, mbuf
, module_idx
, dvbapi_main_local
);
8205 int32_t dvbapi_set_section_filter(int32_t demux_id
, ECM_REQUEST
*er
, int32_t n
)
8207 if(!er
) { return -1; }
8209 if(USE_OPENXCAS
|| (selected_api
!= DVBAPI_3
&& selected_api
!= DVBAPI_1
&& selected_api
!= STAPI
) // only valid for dvbapi3, dvbapi1 and STAPI
8210 || (cfg
.dvbapi_boxtype
== BOXTYPE_IPBOX
|| cfg
.dvbapi_boxtype
== BOXTYPE_IPBOX_PMT
)) // reported buggy using sectionfiltering after 1~4 hours -> for now disabled!
8217 n
= dvbapi_get_filternum(demux_id
, er
, TYPE_ECM
);
8220 if(n
< 0) // in case no valid filter found;
8225 int32_t fd
= demux
[demux_id
].demux_fd
[n
].fd
;
8226 if(fd
< 1) // in case no valid fd
8233 memset(filter
, 0, 16);
8234 memset(mask
, 0, 16);
8235 struct s_ecmpid
*curpid
= NULL
;
8237 int32_t pid
= demux
[demux_id
].demux_fd
[n
].pidindex
;
8240 curpid
= &demux
[demux_id
].ECMpids
[pid
];
8243 if(curpid
->table
!= er
->ecm
[0] && curpid
->table
!= 0)
8245 return -1; // if current ecmtype differs from latest requested ecmtype do not apply section filtering!
8248 uint8_t ecmfilter
= 0;
8250 if(er
->ecm
[0] == 0x80)
8252 ecmfilter
= 0x81; // current processed ecm is even, next will be filtered for odd
8256 ecmfilter
= 0x80; // current processed ecm is odd, next will be filtered for even
8259 if(curpid
->table
!= 0) // cycle ecmtype from odd to even or even to odd
8261 filter
[0] = ecmfilter
; // only accept new ecms (if previous odd, filter for even and vice versa)
8263 cs_log_dbg(D_DVBAPI
, "Demuxer %d Filter %d set ecmtable to %s (CAID %04X PROVID %06X FD %d)",
8264 demux_id
, n
+ 1, (ecmfilter
== 0x80 ? "EVEN" : "ODD"), curpid
->CAID
, curpid
->PROVID
, fd
);
8266 else // not decoding right now so we are interessted in all ecm types!
8268 filter
[0] = 0x80; // set filter to wait for any ecms
8270 cs_log_dbg(D_DVBAPI
, "Demuxer %d Filter %d set ecmtable to ODD+EVEN (CAID %04X PROVID %06X FD %d)",
8271 demux_id
, n
+ 1, curpid
->CAID
, curpid
->PROVID
, fd
);
8274 uint32_t offset
= 0, extramask
= 0xFF;
8275 struct s_dvbapi_priority
*forceentry
= dvbapi_check_prio_match(demux_id
, pid
, 'p');
8276 //cs_log("**** curpid->CHID %04X, checked = %d, er->chid = %04X *****", curpid->CHID, curpid->checked, er->chid);
8277 // checked 4 to make sure we dont set chid filter and no such ecm in dvbstream except for forced pids!
8279 if(curpid
->CHID
< 0x10000 && (curpid
->checked
== 4 || (forceentry
&& forceentry
->force
)))
8281 switch(er
->caid
>> 8)
8288 case 0x05: // viaccess
8292 case 0x06: // irdeto
8296 case 0x09: // videoguard
8300 case 0x4A: // DRE-Crypt, Bulcrypt, Tongang and others?
8301 if(!caid_is_bulcrypt(er
->caid
))
8309 int32_t irdetomatch
= 1; // check if wanted irdeto index is the one the delivers current chid!
8310 if(caid_is_irdeto(curpid
->CAID
))
8312 if(curpid
->irdeto_curindex
== er
->ecm
[4]) { irdetomatch
= 1; } // ok apply chid filtering
8313 else { irdetomatch
= 0; } // skip chid filtering but apply irdeto index filtering
8316 if(offset
&& irdetomatch
) // we have a cas with chid or unique part in checked ecm
8318 i2b_buf(2, curpid
->CHID
, filter
+ (offset
- 2));
8319 mask
[(offset
- 2)] = 0xFF & extramask
; // additional mask seca2 chid can be FC10 or FD10 varies each month so only apply F?10
8320 mask
[(offset
- 1)] = 0xFF;
8321 cs_log_dbg(D_DVBAPI
, "Demuxer %d Filter %d set chid to %04X on fd %d", demux_id
, n
+ 1, curpid
->CHID
, fd
);
8325 // on irdeto we can always apply irdeto index filtering!
8326 if(caid_is_irdeto(curpid
->CAID
) && (curpid
->irdeto_curindex
< 0xFE))
8328 filter
[2] = curpid
->irdeto_curindex
;
8330 cs_log_dbg(D_DVBAPI
, "Demuxer %d Filter %d set irdetoindex to %d on fd %d",
8331 demux_id
, n
+ 1, curpid
->irdeto_curindex
, fd
);
8333 else // all other cas systems also cas systems without chid or unique ecm part
8335 cs_log_dbg(D_DVBAPI
, "Demuxer %d Filter %d set chid to ANY CHID on fd %d", demux_id
, n
+ 1, fd
);
8339 int32_t ret
= dvbapi_activate_section_filter(demux_id
, n
, fd
, curpid
->ECM_PID
, filter
, mask
, er
->msgid
);
8340 if(ret
< 0) // something went wrong setting filter!
8342 cs_log("Demuxer %d Filter %d (fd %d) error setting section filtering -> stop filter!", demux_id
, n
+ 1, fd
);
8344 ret
= dvbapi_stop_filternum(demux_id
, n
, er
->msgid
);
8347 cs_log("Demuxer %d Filter %d (fd %d) stopping filter failed -> kill all filters of this demuxer!", demux_id
, n
+ 1, fd
);
8348 dvbapi_stop_filter(demux_id
, TYPE_EMM
, er
->msgid
);
8349 dvbapi_stop_filter(demux_id
, TYPE_ECM
, er
->msgid
);
8356 int32_t dvbapi_activate_section_filter(int32_t demux_id
, int32_t num
, int32_t fd
, int32_t pid
, uint8_t *filter
, uint8_t *mask
, uint32_t msgid
)
8360 switch(selected_api
)
8364 struct dmx_sct_filter_params sFP2
;
8365 memset(&sFP2
, 0, sizeof(sFP2
));
8368 sFP2
.flags
= DMX_IMMEDIATE_START
;
8370 if(cfg
.dvbapi_boxtype
== BOXTYPE_NEUMO
)
8372 //DeepThought: on dgs/cubestation and neumo images, perhaps others
8373 //the following code is needed to descramble
8374 sFP2
.filter
.filter
[0] = filter
[0];
8375 sFP2
.filter
.mask
[0] = mask
[0];
8376 sFP2
.filter
.filter
[1] = 0;
8377 sFP2
.filter
.mask
[1] = 0;
8378 sFP2
.filter
.filter
[2] = 0;
8379 sFP2
.filter
.mask
[2] = 0;
8380 memcpy(sFP2
.filter
.filter
+ 3, filter
+ 1, 16 - 3);
8381 memcpy(sFP2
.filter
.mask
+ 3, mask
+ 1, 16 - 3);
8383 //DeepThought: in the drivers of the dgs/cubestation and neumo images,
8384 //dvbapi 1 and 3 are somehow mixed. In the kernel drivers, the DMX_SET_FILTER
8385 //ioctl expects to receive a dmx_sct_filter_params structure (DVBAPI 3) but
8386 //due to a bug its sets the "positive mask" wrongly (they should be all 0).
8387 //On the other hand, the DMX_SET_FILTER1 ioctl also uses the dmx_sct_filter_params
8388 //structure, which is incorrect (it should be dmxSctFilterParams).
8389 //The only way to get it right is to call DMX_SET_FILTER1 with the argument
8390 //expected by DMX_SET_FILTER. Otherwise, the timeout parameter is not passed correctly.
8392 ret
= dvbapi_ioctl(fd
, DMX_SET_FILTER1
, &sFP2
);
8396 memcpy(sFP2
.filter
.filter
, filter
, 16);
8397 memcpy(sFP2
.filter
.mask
, mask
, 16);
8399 if(cfg
.dvbapi_listenport
|| cfg
.dvbapi_boxtype
== BOXTYPE_PC_NODMX
)
8401 ret
= dvbapi_net_send(DVBAPI_DMX_SET_FILTER
,
8402 demux
[demux_id
].socket_fd
,
8409 demux
[demux_id
].client_proto_version
);
8413 ret
= dvbapi_ioctl(fd
, DMX_SET_FILTER
, &sFP2
);
8421 struct dmxSctFilterParams sFP1
;
8422 memset(&sFP1
, 0, sizeof(sFP1
));
8425 sFP1
.flags
= DMX_IMMEDIATE_START
;
8426 memcpy(sFP1
.filter
.filter
, filter
, 16);
8427 memcpy(sFP1
.filter
.mask
, mask
, 16);
8428 ret
= dvbapi_ioctl(fd
, DMX_SET_FILTER1
, &sFP1
);
8432 #if defined(WITH_STAPI) || defined(WITH_STAPI5)
8435 ret
= stapi_activate_section_filter(fd
, filter
, mask
);
8439 // Isn't implemented in COOLAPI-1 (legacy)
8440 #if defined WITH_COOLAPI2
8443 int32_t n
= coolapi_get_filter_num(fd
);
8448 coolapi_set_filter(fd
, n
, pid
, filter
, mask
, TYPE_ECM
);
8457 if(ret
!= -1) // only change filter/mask for comparing if box returned no errors!
8459 // copy filter and mask to check later on if receiver delivered accordingly
8460 memcpy(demux
[demux_id
].demux_fd
[num
].filter
, filter
, 16);
8461 memcpy(demux
[demux_id
].demux_fd
[num
].mask
, mask
, 16);
8466 int32_t dvbapi_check_ecm_delayed_delivery(int32_t demux_id
, ECM_REQUEST
*er
)
8469 int32_t filternum
= dvbapi_get_filternum(demux_id
, er
, TYPE_ECM
);
8470 char nullcw
[CS_ECMSTORESIZE
];
8471 memset(nullcw
, 0, CS_ECMSTORESIZE
);
8473 if(filternum
< 0) // if no matching filter act like ecm response is delayed
8478 if(memcmp(demux
[demux_id
].demux_fd
[filternum
].lastecmd5
, nullcw
, CS_ECMSTORESIZE
))
8480 demux
[demux_id
].demux_fd
[filternum
].lastresult
= er
->rc
; // save last result
8482 cs_hexdump(0, er
->ecmd5
, 16, ecmd5
, sizeof(ecmd5
));
8484 cs_log_dbg(D_DVBAPI
, "Demuxer %d requested controlword for ecm %s on fd %d",
8485 demux_id
, ecmd5
, demux
[demux_id
].demux_fd
[filternum
].fd
);
8487 uint8_t md5tmp
[MD5_DIGEST_LENGTH
];
8488 MD5(er
->ecm
, er
->ecmlen
, md5tmp
);
8490 // 1 = no response on the ecm we request last for this fd!
8491 ret
= (memcmp(demux
[demux_id
].demux_fd
[filternum
].lastecmd5
, md5tmp
, CS_ECMSTORESIZE
) != 0 ? 1 : 0);
8494 // Check for null cw
8495 // Skip check for BISS1 - cw could be indeed zero
8496 // Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
8497 if(memcmp(er
->cw
, nullcw
, 8) == 0 && memcmp(er
->cw
+ 8, nullcw
, 8) == 0 && !caid_is_biss(er
->caid
))
8502 struct s_ecmpid
*curpid
= NULL
;
8503 int32_t pid
= demux
[demux_id
].demux_fd
[filternum
].pidindex
;
8507 curpid
= &demux
[demux_id
].ECMpids
[pid
];
8508 if(curpid
->table
== 0) // on change table act like ecm response is found
8514 if(er
->rc
== E_CACHEEX
) // on cache-ex response act like ecm response is found
8522 int32_t dvbapi_get_filternum(int32_t demux_id
, ECM_REQUEST
*er
, int32_t type
)
8524 if(!er
) { return -1; }
8529 for(n
= 0; n
< maxfilter
; n
++) // determine fd
8531 // check for valid and right type (ecm or emm)
8532 if(demux
[demux_id
].demux_fd
[n
].fd
> 0 && demux
[demux_id
].demux_fd
[n
].type
== type
)
8534 if(type
== TYPE_ECM
&& er
->srvid
!= demux
[demux_id
].program_number
)
8539 if((demux
[demux_id
].demux_fd
[n
].pid
== er
->pid
) && ((demux
[demux_id
].demux_fd
[n
].provid
== er
->prid
)
8540 || demux
[demux_id
].demux_fd
[n
].provid
== 0 || er
->prid
== 0) && ((demux
[demux_id
].demux_fd
[n
].caid
== er
->caid
)
8541 || (demux
[demux_id
].demux_fd
[n
].caid
== er
->ocaid
))) // current ecm pid?
8543 fd
= demux
[demux_id
].demux_fd
[n
].fd
; // found!
8544 if(demux
[demux_id
].demux_fd
[n
].caid
== er
->ocaid
)
8546 // clear ecmd5 hash since betatunneled ecms hash different!
8547 memset(demux
[demux_id
].demux_fd
[n
].lastecmd5
, 0, CS_ECMSTORESIZE
);
8554 if(fd
> 0 && demux
[demux_id
].demux_fd
[n
].provid
== 0)
8556 demux
[demux_id
].demux_fd
[n
].provid
= er
->prid
; // hack to fill in provid into demuxer
8558 return (fd
> 0 ? n
: fd
); // return -1(fd) on not found, on found return filternumber(n)
8561 uint32_t dvbapi_ca_set_pid(int32_t demux_id
, int32_t pid
, int32_t stream_id
, bool use_des
, uint32_t msgid
)
8566 if(pid
== -1 || pid
> demux
[demux_id
].ECMpidcount
)
8568 return INDEX_INVALID
;
8571 if(demux
[demux_id
].ECMpids
[pid
].useMultipleIndices
)
8574 idx
= demux
[demux_id
].ECMpids
[pid
].index
[n
];
8576 if(idx
== INDEX_INVALID
) // if we have no index for this pid, get one!
8578 idx
= dvbapi_get_desc_index(demux_id
, pid
, n
);
8579 if(idx
== INDEX_INVALID
)
8581 cs_log_dbg(D_DVBAPI
, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X has no free index",
8582 demux_id
, pid
, demux
[demux_id
].ECMpids
[pid
].CAID
, demux
[demux_id
].ECMpids
[pid
].ECM_PID
);
8584 return INDEX_INVALID
;
8587 cs_log_dbg(D_DVBAPI
, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X is using index %d for stream %d",
8588 demux_id
, pid
, demux
[demux_id
].ECMpids
[pid
].CAID
, demux
[demux_id
].ECMpids
[pid
].ECM_PID
, idx
, n
);
8591 if(!demux
[demux_id
].ECMpids
[pid
].streams
|| ((demux
[demux_id
].ECMpids
[pid
].streams
& (1 << n
)) == (uint
) (1 << n
)))
8593 dvbapi_set_pid(demux_id
, n
, idx
, true, use_des
, msgid
); // enable stream pid
8597 dvbapi_set_pid(demux_id
, n
, idx
, false, false, msgid
); // disable stream pid
8602 idx
= demux
[demux_id
].ECMpids
[pid
].index
[0];
8604 if(idx
== INDEX_INVALID
) // if we have no index for this pid, get one!
8606 idx
= dvbapi_get_desc_index(demux_id
, pid
, 0);
8607 if(idx
== INDEX_INVALID
)
8609 cs_log_dbg(D_DVBAPI
, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X has no free index",
8610 demux_id
, pid
, demux
[demux_id
].ECMpids
[pid
].CAID
, demux
[demux_id
].ECMpids
[pid
].ECM_PID
);
8612 return INDEX_INVALID
;
8615 cs_log_dbg(D_DVBAPI
, "Demuxer %d PID: %d CAID: %04X ECMPID: %04X is using index %d",
8616 demux_id
, pid
, demux
[demux_id
].ECMpids
[pid
].CAID
, demux
[demux_id
].ECMpids
[pid
].ECM_PID
, idx
);
8619 for(n
= 0; n
< demux
[demux_id
].STREAMpidcount
; n
++)
8621 if(!demux
[demux_id
].ECMpids
[pid
].streams
|| ((demux
[demux_id
].ECMpids
[pid
].streams
& (1 << n
)) == (uint
) (1 << n
)))
8623 dvbapi_set_pid(demux_id
, n
, idx
, true, use_des
, 0); // enable stream pid
8627 dvbapi_set_pid(demux_id
, n
, idx
, false, false, 0); // disable stream pid
8631 return idx
; // return ca index
8634 int8_t update_streampid_list(uint8_t cadevice
, uint16_t pid
, uint32_t idx
, bool use_des
)
8636 struct s_streampid
*listitem
, *newlistitem
;
8638 if(!ll_activestreampids
)
8640 ll_activestreampids
= ll_create("ll_activestreampids");
8643 if(idx
>= INDEX_MAX
)
8645 return INVALID_STREAMPID_INDEX
;
8648 if(ll_count(ll_activestreampids
) > 0)
8650 itr
= ll_iter_create(ll_activestreampids
);
8651 while((listitem
= ll_iter_next(&itr
)))
8653 if(cadevice
== listitem
->cadevice
&& pid
== listitem
->streampid
)
8655 if((listitem
->activeindexers
& (1 << idx
)) == (uint64_t) (1 << idx
))
8657 if(cfg
.dvbapi_extended_cw_api
== 2 && use_des
!= listitem
->use_des
)
8659 listitem
->use_des
= use_des
;
8660 return FIRST_STREAMPID_INDEX
;
8662 return FOUND_STREAMPID_INDEX
; // match found
8666 listitem
->activeindexers
|= (1 << idx
); // ca + pid found but not this index -> add this index
8667 cs_log_dbg(D_DVBAPI
, "Added existing streampid %04X with new index %d to ca%d", pid
, idx
, cadevice
);
8669 if(cfg
.dvbapi_extended_cw_api
== 2 && use_des
!= listitem
->use_des
)
8671 listitem
->use_des
= use_des
;
8672 return FIRST_STREAMPID_INDEX
;
8674 return ADDED_STREAMPID_INDEX
;
8680 if(!cs_malloc(&newlistitem
, sizeof(struct s_streampid
)))
8682 return FIRST_STREAMPID_INDEX
; // not sure if this is correct
8685 newlistitem
->cadevice
= cadevice
;
8686 newlistitem
->streampid
= pid
;
8687 newlistitem
->activeindexers
= (1 << idx
);
8688 newlistitem
->caindex
= idx
; // set this index as used to decode on ca device
8689 newlistitem
->use_des
= use_des
;
8691 ll_append(ll_activestreampids
, newlistitem
);
8692 cs_log_dbg(D_DVBAPI
, "Added new streampid %04X with index %d to ca%d", pid
, idx
, cadevice
);
8694 return FIRST_STREAMPID_INDEX
;
8697 int8_t remove_streampid_from_list(uint8_t cadevice
, uint16_t pid
, uint32_t idx
)
8699 struct s_streampid
*listitem
;
8703 if(!ll_activestreampids
)
8705 return NO_STREAMPID_LISTED
;
8708 if(idx
>= INDEX_MAX
)
8710 return INVALID_STREAMPID_INDEX
;
8713 if(ll_count(ll_activestreampids
) > 0)
8715 itr
= ll_iter_create(ll_activestreampids
);
8716 while((listitem
= ll_iter_next(&itr
)))
8718 if(cadevice
== listitem
->cadevice
&& pid
== listitem
->streampid
)
8720 if(idx
== INDEX_DISABLE_ALL
)
8722 listitem
->activeindexers
= 0;
8725 else if((listitem
->activeindexers
& (1 << idx
)) == (uint64_t) (1 << idx
))
8727 listitem
->activeindexers
&= ~(1 << idx
); // flag it as disabled for this index
8733 cs_log_dbg(D_DVBAPI
, "Remove streampid %04X using indexer %d from ca%d", pid
, idx
, cadevice
);
8736 if(listitem
->activeindexers
== 0 && removed
== 1) // all indexers disabled? -> remove pid from list!
8738 ll_iter_remove_data(&itr
);
8739 cs_log_dbg(D_DVBAPI
, "Removed last indexer of streampid %04X from ca%d", pid
, cadevice
);
8740 ca_descramblers_used
= count_active_indexers();
8741 return REMOVED_STREAMPID_LASTINDEX
;
8743 else if(removed
== 1)
8745 if(idx
!= INDEX_DISABLE_ALL
&& idx
!= listitem
->caindex
)
8747 return REMOVED_STREAMPID_INDEX
;
8751 listitem
->caindex
= INDEX_INVALID
;
8752 cs_log_dbg(D_DVBAPI
, "Streampid %04X index %d was used for decoding on ca%d", pid
, idx
, cadevice
);
8753 return REMOVED_DECODING_STREAMPID_INDEX
;
8756 return INVALID_STREAMPID_INDEX
;
8760 return NO_STREAMPID_LISTED
;
8763 void disable_unused_streampids(int16_t demux_id
)
8765 int32_t ecmpid
= demux
[demux_id
].pidindex
;
8767 if(ecmpid
== -1 // no active ecmpid!
8768 || !ll_activestreampids
8769 || selected_api
== STAPI
// stapi handles pids itself!
8770 || ll_count(ll_activestreampids
) == 0) // no items in list?
8776 if(demux
[demux_id
].ECMpids
[ecmpid
].useMultipleIndices
== 0)
8778 uint32_t idx
= demux
[demux_id
].ECMpids
[ecmpid
].index
[0];
8780 struct s_streampid
*listitem
;
8782 // search for old enabled streampids on
8783 // all ca devices that have to be disabled
8784 for(i
= 0; i
< CA_MAX
&& idx
!= INDEX_INVALID
; i
++)
8786 if(!((demux
[demux_id
].ca_mask
& (1 << i
)) == (uint32_t) (1 << i
)))
8788 continue; // ca is not used by this demuxer
8792 itr
= ll_iter_create(ll_activestreampids
);
8794 while((listitem
= ll_iter_next(&itr
)))
8796 if(i
!= listitem
->cadevice
)
8798 continue; // ca doesn't match
8801 if(!((listitem
->activeindexers
& (1 << (idx
))) == (uint64_t) (1 << (idx
))))
8803 continue; // index doesn't match
8806 for(n
= 0; n
< demux
[demux_id
].STREAMpidcount
; n
++)
8808 if(demux
[demux_id
].ECMpidcount
== 0) // FTA? -> disable stream!
8810 n
= demux
[demux_id
].STREAMpidcount
;
8814 // check if pid matches with current stream pid on demuxer
8815 if(listitem
->streampid
== demux
[demux_id
].STREAMpids
[n
])
8821 if(n
== demux
[demux_id
].STREAMpidcount
) // no match found
8823 demux
[demux_id
].STREAMpids
[n
] = listitem
->streampid
; // put it here temporarily!
8824 dvbapi_set_pid(demux_id
, n
, idx
, false, false, 0); // disable this unused streampid
8825 demux
[demux_id
].STREAMpids
[n
] = 0; // remove it from temp position!
8829 // ECMpidcount != 0 -> skip enabling on fta
8830 for(n
= 0; n
< demux
[demux_id
].STREAMpidcount
&& demux
[demux_id
].ECMpidcount
!= 0; n
++)
8832 ll_iter_reset(&itr
);
8833 if(!demux
[demux_id
].ECMpids
[ecmpid
].streams
|| ((demux
[demux_id
].ECMpids
[ecmpid
].streams
& (1 << n
)) == (uint
) (1 << n
)))
8835 while((listitem
= ll_iter_next(&itr
)))
8837 if(i
!= listitem
->cadevice
) // ca doesn't match
8842 if(!((listitem
->activeindexers
& (1 << (idx
))) == (uint64_t) (1 << (idx
)))) // index doesn't match
8847 // check if pid matches with current streampid on demuxer
8848 if(listitem
->streampid
== demux
[demux_id
].STREAMpids
[n
])
8854 if(!listitem
) // if streampid not listed -> enable it!
8856 dvbapi_set_pid(demux_id
, n
, idx
, true, false, 0); // enable streampid
8864 uint32_t idx
= INDEX_INVALID
;
8867 struct s_streampid
*listitem
;
8869 // search for old enabled streampids
8870 // on all ca devices that have to be disabled
8871 for(i
= 0; i
< CA_MAX
&& idx
!= INDEX_INVALID
; i
++)
8873 if(!((demux
[demux_id
].ca_mask
& (1 << i
)) == (uint32_t) (1 << i
)))
8875 continue; // continue if ca is unused by this demuxer
8879 itr
= ll_iter_create(ll_activestreampids
);
8881 while((listitem
= ll_iter_next(&itr
)))
8883 if(i
!= listitem
->cadevice
)
8885 continue; // ca doesn't match
8888 for(skip
= 1, j
= 0; j
< MAX_STREAM_INDICES
; j
++)
8890 idx
= demux
[demux_id
].ECMpids
[ecmpid
].index
[j
];
8891 if(idx
== INDEX_INVALID
)
8897 if((listitem
->activeindexers
& (1 << (idx
))) == (uint64_t) (1 << (idx
)))
8909 for(n
= 0; n
< demux
[demux_id
].STREAMpidcount
; n
++)
8911 if(demux
[demux_id
].ECMpidcount
== 0) // FTA? -> disable stream!
8913 n
= demux
[demux_id
].STREAMpidcount
;
8917 // check if pid matches with current streampid on demuxer
8918 if(listitem
->streampid
== demux
[demux_id
].STREAMpids
[n
])
8924 if(n
== demux
[demux_id
].STREAMpidcount
)
8926 demux
[demux_id
].STREAMpids
[n
] = listitem
->streampid
; // put it temp here!
8927 dvbapi_set_pid(demux_id
, n
, idx
, false, false, 0); // no match found so disable this now unused streampid
8928 demux
[demux_id
].STREAMpids
[n
] = 0; // remove temp!
8932 // ECMpidcount != 0 -> skip enabling on fta
8933 for(n
= 0; n
< demux
[demux_id
].STREAMpidcount
&& demux
[demux_id
].ECMpidcount
!= 0; n
++)
8935 ll_iter_reset(&itr
);
8936 if(!demux
[demux_id
].ECMpids
[ecmpid
].streams
|| ((demux
[demux_id
].ECMpids
[ecmpid
].streams
& (1 << n
)) == (uint
) (1 << n
)))
8938 while((listitem
= ll_iter_next(&itr
)))
8940 if(i
!= listitem
->cadevice
) // ca doesn't match
8945 for(skip
= 1, j
= 0; j
< MAX_STREAM_INDICES
; j
++)
8947 idx
= demux
[demux_id
].ECMpids
[ecmpid
].index
[j
];
8948 if(idx
== INDEX_INVALID
)
8953 if((listitem
->activeindexers
& (1 << (idx
))) == (uint64_t) (1 << (idx
)))
8955 skip
= 0; // index match
8965 // check if pid matches with current streampid on demuxer
8966 if(listitem
->streampid
== demux
[demux_id
].STREAMpids
[n
])
8972 if(!listitem
) // if streampid not listed -> enable it!
8974 dvbapi_set_pid(demux_id
, n
, idx
, true, false, 0); // enable streampid
8982 uint32_t is_ca_used(uint8_t cadevice
, int32_t pid
)
8984 struct s_streampid
*listitem
;
8986 if(!ll_activestreampids
)
8988 return INDEX_INVALID
;
8991 if(ll_count(ll_activestreampids
) > 0)
8993 itr
= ll_iter_create(ll_activestreampids
);
8994 while((listitem
= ll_iter_next(&itr
)))
8996 // if pid is 0, we match ca device only
8997 if(listitem
->cadevice
!= cadevice
|| (pid
&& listitem
->streampid
!= pid
))
9003 while(listitem
->caindex
== INDEX_INVALID
&& i
< INDEX_MAX
)
9005 if((listitem
->activeindexers
& (1 << i
)) == (uint64_t) (1 << i
))
9007 listitem
->caindex
= i
; // set fresh one
9008 cs_log_dbg(D_DVBAPI
, "Streampid %04X is now using index %d for decoding on ca%d", pid
, i
, cadevice
);
9014 if(listitem
->caindex
== INDEX_INVALID
)
9016 ll_iter_remove_data(&itr
);
9017 return INDEX_INVALID
;
9019 return listitem
->caindex
;
9022 return INDEX_INVALID
; // no indexer found for this pid!
9025 uint32_t count_active_indexers(void)
9027 struct s_streampid
*listitem
;
9029 if(!ll_activestreampids
)
9034 bool indexer_in_use
[ca_descramblers_total
];
9035 memset(&indexer_in_use
, 0, sizeof(indexer_in_use
));
9037 uint32_t usecounter
= 0;
9038 if(ll_count(ll_activestreampids
) > 0)
9040 itr
= ll_iter_create(ll_activestreampids
);
9041 while((listitem
= ll_iter_next(&itr
)))
9043 if(listitem
->caindex
!= INDEX_INVALID
&& listitem
->caindex
< INDEX_MAX
)
9045 indexer_in_use
[listitem
->caindex
] = true;
9049 for(i
= 0; i
< ca_descramblers_total
; i
++)
9051 if(indexer_in_use
[i
] == true)
9061 uint16_t dvbapi_get_client_proto_version(void)
9063 return last_client_proto_version
;
9066 const char *dvbapi_get_client_name(void)
9068 return last_client_name
? last_client_name
: "";
9071 void check_add_emmpid(int32_t demux_id
, uint8_t *filter
, int32_t l
, int32_t emmtype
)
9073 if(l
< 0) { return; }
9075 uint32_t typtext_idx
= 0;
9077 const char *typtext
[] = { "UNIQUE", "SHARED", "GLOBAL", "UNKNOWN" };
9079 while(((emmtype
>> typtext_idx
) & 0x01) == 0 && typtext_idx
< sizeof(typtext
) / sizeof(const char *))
9084 // filter already in list?
9085 if(is_emmfilter_in_list(filter
, demux
[demux_id
].EMMpids
[l
].PID
, demux
[demux_id
].EMMpids
[l
].PROVID
, demux
[demux_id
].EMMpids
[l
].CAID
))
9087 cs_log_dbg(D_DVBAPI
, "Demuxer %d duplicate emm filter type %s, emmpid: 0x%04X, emmcaid: %04X, emmprovid: %06X -> SKIPPED!",
9089 typtext
[typtext_idx
],
9090 demux
[demux_id
].EMMpids
[l
].PID
,
9091 demux
[demux_id
].EMMpids
[l
].CAID
,
9092 demux
[demux_id
].EMMpids
[l
].PROVID
);
9096 if(demux
[demux_id
].emm_filter
< demux
[demux_id
].max_emm_filter
) // can this filter be started?
9098 // try to activate this emmfilter
9099 ret
= dvbapi_set_filter(demux_id
,
9101 demux
[demux_id
].EMMpids
[l
].PID
,
9102 demux
[demux_id
].EMMpids
[l
].CAID
,
9103 demux
[demux_id
].EMMpids
[l
].PROVID
,
9107 demux
[demux_id
].pidindex
,
9111 if(ret
!= -1) // -1 if maxfilter reached or filter start error!
9113 if(demux
[demux_id
].emm_filter
== -1) // -1: first run of emm filtering on this demuxer
9115 demux
[demux_id
].emm_filter
= 0;
9117 demux
[demux_id
].emm_filter
++; // increase total active filters
9119 cs_log_dump_dbg(D_DVBAPI
, filter
, 32, "Demuxer %d started emm filter type %s, pid: 0x%04X",
9120 demux_id
, typtext
[typtext_idx
], demux
[demux_id
].EMMpids
[l
].PID
);
9123 else // not set successful, so add it to the list for try again later on!
9125 add_emmfilter_to_list(demux_id
, filter
, demux
[demux_id
].EMMpids
[l
].CAID
, demux
[demux_id
].EMMpids
[l
].PROVID
, demux
[demux_id
].EMMpids
[l
].PID
, 0, false);
9126 cs_log_dump_dbg(D_DVBAPI
, filter
, 32, "Demuxer %d added inactive emm filter type %s, pid: 0x%04X",
9127 demux_id
, typtext
[typtext_idx
], demux
[demux_id
].EMMpids
[l
].PID
);
9132 void rotate_emmfilter(int32_t demux_id
)
9134 // emm filter iteration
9135 if(!ll_emm_active_filter
)
9137 ll_emm_active_filter
= ll_create("ll_emm_active_filter");
9140 if(!ll_emm_inactive_filter
)
9142 ll_emm_inactive_filter
= ll_create("ll_emm_inactive_filter");
9145 if(!ll_emm_pending_filter
)
9147 ll_emm_pending_filter
= ll_create("ll_emm_pending_filter");
9150 uint32_t filter_count
= ll_count(ll_emm_active_filter
) + ll_count(ll_emm_inactive_filter
);
9151 if(demux
[demux_id
].max_emm_filter
> 0 && ll_count(ll_emm_inactive_filter
) > 0 && filter_count
> demux
[demux_id
].max_emm_filter
)
9153 int32_t filter_queue
= ll_count(ll_emm_inactive_filter
);
9154 int32_t stopped
= 0, started
= 0;
9157 struct s_emm_filter
*filter_item
;
9159 itr
= ll_iter_create(ll_emm_active_filter
);
9161 while((filter_item
= ll_iter_next(&itr
)) != NULL
)
9163 if(!ll_count(ll_emm_inactive_filter
) || started
== filter_queue
)
9168 int64_t gone
= comp_timeb(&now
, &filter_item
->time_started
);
9169 if(gone
> 45 * 1000)
9171 struct s_dvbapi_priority
*forceentry
= dvbapi_check_prio_match_emmpid(filter_item
->demux_id
, filter_item
->caid
, filter_item
->provid
, 'p');
9172 if(!forceentry
|| (forceentry
&& !forceentry
->force
))
9174 // stop active filter and add to pending list
9175 dvbapi_stop_filternum(filter_item
->demux_id
, filter_item
->num
- 1, 0);
9176 ll_iter_remove_data(&itr
);
9177 add_emmfilter_to_list(filter_item
->demux_id
, filter_item
->filter
, filter_item
->caid
, filter_item
->provid
, filter_item
->pid
, -1, false);
9183 if(stopped
> started
) // we have room for new filters, try to start an inactive emmfilter!
9185 struct s_emm_filter
*filter_item2
;
9186 LL_ITER itr2
= ll_iter_create(ll_emm_inactive_filter
);
9187 while((filter_item2
= ll_iter_next(&itr2
)))
9189 ret
= dvbapi_set_filter(filter_item2
->demux_id
,
9193 filter_item2
->provid
,
9194 filter_item2
->filter
,
9195 filter_item2
->filter
+ 16,
9197 demux
[filter_item2
->demux_id
].pidindex
,
9201 ll_iter_remove_data(&itr2
);
9209 itr
= ll_iter_create(ll_emm_pending_filter
);
9210 while((filter_item
= ll_iter_next(&itr
)) != NULL
) // move pending filters to inactive
9212 add_emmfilter_to_list(filter_item
->demux_id
, filter_item
->filter
, filter_item
->caid
, filter_item
->provid
, filter_item
->pid
, 0, false);
9213 ll_iter_remove_data(&itr
);
9218 int32_t filtermatch(uint8_t *buffer
, int32_t filter_num
, int32_t demux_id
, int32_t len
)
9220 int32_t i
, k
, match
;
9224 for(i
= 0, k
= 0; i
< 16 && match
; i
++, k
++)
9226 mask
= demux
[demux_id
].demux_fd
[filter_num
].mask
[i
];
9227 if(k
== 1) // skip len bytes
9237 flt
= (demux
[demux_id
].demux_fd
[filter_num
].filter
[i
]&mask
);
9238 cs_log_dbg(D_DVBAPI
,"Demuxer %d filter%d[%d] = %02X, filter mask[%d] = %02X, flt&mask = %02X , buffer[%d] = %02X, buffer[%d] & mask = %02X",
9239 demux_id
, filter_num
+ 1, i
, demux
[demux_id
].demux_fd
[filter_num
].filter
[i
], i
, mask
, flt
&mask
, k
, buffer
[k
], k
, buffer
[k
] & mask
);
9243 match
= (flt
== (buffer
[k
] & mask
));
9250 return (match
&& i
== 16); // 0 = delivered data does not match with filter, 1 = delivered data matches with filter
9254 * protocol structure
9256 void module_dvbapi(struct s_module
*ph
)
9258 ph
->desc
= "dvbapi";
9259 ph
->type
= MOD_CONN_SERIAL
;
9260 ph
->listenertype
= LIS_DVBAPI
;
9261 #if defined(WITH_AZBOX)
9262 ph
->s_handler
= azbox_handler
;
9263 ph
->send_dcw
= azbox_send_dcw
;
9264 #elif defined(WITH_MCA)
9265 ph
->s_handler
= mca_handler
;
9266 ph
->send_dcw
= mca_send_dcw
;
9267 selected_box
= selected_api
= 0; // HACK: This fixes incorrect warning about out of bounds array access in functionas that are not even called when WITH_MCA is defined
9269 ph
->s_handler
= dvbapi_handler
;
9270 ph
->send_dcw
= dvbapi_send_dcw
;
9273 #endif // HAVE_DVBAPI