source: trunk/module-dvbapi.c @ 11067

Last change on this file since 11067 was 11067, checked in by theparasol, 4 years ago

DVBAPI:

  • Some rework on ca pmt parsing & connection handling
  • Property svn:eol-style set to LF
File size: 202.6 KB
Line 
1#define MODULE_LOG_PREFIX "dvbapi"
2
3#include "globals.h"
4
5#ifdef HAVE_DVBAPI
6
7#include "module-dvbapi.h"
8#include "module-cacheex.h"
9#include "module-dvbapi-azbox.h"
10#include "module-dvbapi-mca.h"
11#include "module-dvbapi-coolapi.h"
12#include "module-dvbapi-stapi.h"
13#include "module-dvbapi-chancache.h"
14#include "module-stat.h"
15#include "oscam-chk.h"
16#include "oscam-client.h"
17#include "oscam-config.h"
18#include "oscam-ecm.h"
19#include "oscam-emm.h"
20#include "oscam-files.h"
21#include "oscam-net.h"
22#include "oscam-reader.h"
23#include "oscam-string.h"
24#include "oscam-time.h"
25#include "oscam-work.h"
26#include "reader-irdeto.h"
27#include "cscrypt/md5.h"
28
29extern int32_t exit_oscam;
30
31#if defined (__CYGWIN__)
32#define F_NOTIFY 0
33#define F_SETSIG 0
34#define DN_MODIFY 0
35#define DN_CREATE 0
36#define DN_DELETE 0
37#define DN_MULTISHOT 0
38#endif
39
40const char *streamtxt[] = {
41                                "",                                                                                         // 00
42                                "",                                                                                         // 01
43                                "Videostream ",                                                                             // 02
44                                "Audiostream ",                                                                             // 03
45                                "",                                                                                         // 04
46                                "",                                                                                         // 05
47                                "Datastream ",                                                                              // 06
48                                "",                                                                                         // 07
49                                "",                                                                                         // 08
50                                "Conditional Access ",                                                                      // 09
51                                "",                                                                                         // 0A
52                                "",                                                                                         // 0B
53                                "",                                                                                         // 0C
54                                "",                                                                                         // 0D
55                                "",                                                                                         // 0E
56                                "",                                                                                         // 0F
57                                "",                                                                                         // 10
58                                "",                                                                                         // 11
59                                "",                                                                                         // 12
60                                "",                                                                                         // 13
61                                "",                                                                                         // 14
62                                "",                                                                                         // 15
63                                "",                                                                                         // 16
64                                "",                                                                                         // 17
65                                "",                                                                                         // 18
66                                "",                                                                                         // 19
67                                "",                                                                                         // 1A
68                                "MPEG-4 videostream ",                                                                      // 1B
69                                "MPEG-4 audiostream ",
70                            };
71
72
73void flush_read_fd(int32_t demux_index, int32_t num, int fd)
74{
75    if(!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX)
76    {
77        cs_log_dbg(D_DVBAPI,"Demuxer %d flushing stale input data of filter %d (fd:%d)", demux_index, num + 1, fd);
78        fd_set rd;
79        struct timeval t;
80        char buff[100];
81        t.tv_sec=0;
82        t.tv_usec=0;
83        FD_ZERO(&rd);
84        FD_SET(fd,&rd);
85        while(select(fd+1,&rd,NULL,NULL,&t) > 0)
86        {
87             if (read(fd,buff,100)){;}
88        }
89    }
90}
91
92static int dvbapi_ioctl(int fd, uint32_t request, ...)
93{ 
94    int ret = 0;
95    va_list args; 
96    va_start(args, request);
97    if (!(cfg.dvbapi_boxtype == BOXTYPE_SAMYGO))
98    {
99        void *param = va_arg(args, void *);
100        ret = ioctl(fd, request, param);
101    } 
102    else 
103    {
104        switch(request) 
105        {
106            case DMX_SET_FILTER:
107            {
108                struct dmx_sct_filter_params *sFP = va_arg(args, struct dmx_sct_filter_params *);
109               
110                //fix filter for samygo
111                //note: we only have 14 available filter bytes (instead of 16) on samygo
112                memmove(&sFP->filter.filter[3], &sFP->filter.filter[1], 13);
113                memset(&sFP->filter.filter[1], 0, 2);
114               
115                memmove(&sFP->filter.mask[3], &sFP->filter.mask[1], 13);
116                memset(&sFP->filter.mask[1], 0, 2);
117
118                // prepare packet
119                unsigned char packet[sizeof(request) + sizeof(struct dmx_sct_filter_params)];
120                memcpy(&packet, &request, sizeof(request));
121                memcpy(&packet[sizeof(request)], sFP, sizeof(struct dmx_sct_filter_params));
122                ret = send(fd, packet, sizeof(packet), 0);
123                break;
124            }
125            case DMX_SET_FILTER1:
126            {
127                cs_log("error: samygo does not support DMX_SET_FILTER1");
128                ret = -1;
129                break;
130            }
131            case DMX_STOP:
132            {
133                ret = send(fd, &request, sizeof(request), 0);
134                ret = 1;
135                break;
136            }
137            case CA_SET_PID:
138            {
139                ca_pid_t *ca_pid2 = va_arg(args, ca_pid_t *);
140               
141                // preparing packet
142                unsigned char packet[sizeof(request) + sizeof(ca_pid_t)];
143                memcpy(&packet[0], &request, sizeof(request));
144                memcpy(&packet[sizeof(request)], ca_pid2, sizeof(ca_pid_t));
145
146                // sending data to UDP
147                ret = send(fd, &packet[0], sizeof(packet), 0);
148                break;
149            }
150            case CA_SET_DESCR:
151            {
152                ca_descr_t *ca_descr = va_arg(args, ca_descr_t *);
153
154                // preparing packet
155                unsigned char packet[sizeof(request) + sizeof(ca_descr_t)];
156                memcpy(&packet[0], &request, sizeof(request));
157                memcpy(&packet[sizeof(request)], ca_descr, sizeof(ca_descr_t));
158
159                // sending data to UDP
160                ret = send(fd, &packet[0], sizeof(packet), 0);
161                break;
162            }
163        }
164        if (ret > 0) // send() may return larger than 1
165            ret = 1;
166    }
167#if defined(__powerpc__)
168    // Old dm500 boxes (ppc old) are using broken kernel, se we need some fixups
169    switch (request)
170    {
171        case DMX_STOP:
172        case CA_SET_DESCR:
173        case CA_SET_PID:
174        ret = 1;
175    }
176#endif
177    // FIXME: Workaround for su980 bug
178    // See: http://www.streamboard.tv/wbb2/thread.php?postid=533940
179    if(boxtype_is("su980"))
180        ret = 1;
181    va_end(args);
182    return ret;
183}
184
185// tunemm_caid_map
186#define FROM_TO 0
187#define TO_FROM 1
188
189#if defined(CARDREADER_STAPI) || defined(CARDREADER_STAPI5)
190//fix from stapi5 patch
191int32_t pausecam = 0, disable_pmt_files = 0, pmt_stopmarking = 1, pmthandling = 0;
192#else
193int32_t pausecam = 0, disable_pmt_files = 0, pmt_stopmarking = 0, pmthandling = 0;
194#endif
195
196DEMUXTYPE demux[MAX_DEMUX];
197struct s_dvbapi_priority *dvbapi_priority;
198struct s_client *dvbapi_client;
199
200const char *boxdesc[] = { "none", "dreambox", "duckbox", "ufs910", "dbox2", "ipbox", "ipbox-pmt", "dm7000", "qboxhd", "coolstream", "neumo", "pc", "pc-nodmx", "samygo" };
201
202
203// when updating devices[BOX_COUNT] make sure to update these index defines
204#define BOX_INDEX_QBOXHD 0
205#define BOX_INDEX_DREAMBOX_DVBAPI3 1
206#define BOX_INDEX_COOLSTREAM 6
207
208static const struct box_devices devices[BOX_COUNT] =
209{
210    /* QboxHD (dvb-api-3)*/     { "/tmp/virtual_adapter/",  "ca%d",         "demux%d",      "/tmp/camd.socket", DVBAPI_3    },
211    /* dreambox (dvb-api-3)*/   { "/dev/dvb/adapter%d/",    "ca%d",         "demux%d",      "/tmp/camd.socket", DVBAPI_3    },
212    /* wetek (dvb-api-3)*/      { "/dev/dvb%d.",            "ca%d",         "demux%d",      "/tmp/camd.socket", DVBAPI_3    },
213    /* dreambox (dvb-api-1)*/   { "/dev/dvb/card%d/",       "ca%d",         "demux%d",      "/tmp/camd.socket", DVBAPI_1    },
214    /* neumo (dvb-api-1)*/      { "/dev/",                  "demuxapi",     "demuxapi",     "/tmp/camd.socket", DVBAPI_1    },
215#ifdef WITH_STAPI5
216    /* sh4      (stapi5)*/      { "/dev/stapi/",            "stpti5_ioctl", "stpti5_ioctl", "/tmp/camd.socket", STAPI       },
217#else
218    /* sh4      (stapi)*/       { "/dev/stapi/",            "stpti4_ioctl", "stpti4_ioctl", "/tmp/camd.socket", STAPI       },
219#endif
220    /* coolstream*/             { "/dev/cnxt/",             "null",         "null",         "/tmp/camd.socket", COOLAPI     },
221};
222
223static int32_t selected_box = -1;
224static int32_t selected_api = -1;
225static int32_t maxfilter = MAX_FILTER;
226static int32_t dir_fd = -1;
227char *client_name = NULL;
228static uint16_t client_proto_version = 0;
229
230static int32_t ca_fd[MAX_DEMUX]; // holds fd handle of each ca device 0 = not in use
231static LLIST * ll_activestreampids; // list of all enabled streampids on ca devices
232
233static int32_t unassoc_fd[MAX_DEMUX];
234
235bool is_dvbapi_usr(char *usr) {
236    return streq(cfg.dvbapi_usr, usr);
237}
238
239struct s_emm_filter
240{
241    int32_t      demux_id;
242    uchar        filter[32];
243    uint16_t     caid;
244    uint32_t     provid;
245    uint16_t     pid;
246    uint32_t     num;
247    struct timeb time_started;
248};
249
250static LLIST *ll_emm_active_filter;
251static LLIST *ll_emm_inactive_filter;
252static LLIST *ll_emm_pending_filter;
253
254int32_t add_emmfilter_to_list(int32_t demux_id, uchar *filter, uint16_t caid, uint32_t provid, uint16_t emmpid, int32_t num, bool enable)
255{
256    if(!ll_emm_active_filter)
257        { ll_emm_active_filter = ll_create("ll_emm_active_filter"); }
258
259    if(!ll_emm_inactive_filter)
260        { ll_emm_inactive_filter = ll_create("ll_emm_inactive_filter"); }
261
262    if(!ll_emm_pending_filter)
263        { ll_emm_pending_filter = ll_create("ll_emm_pending_filter"); }
264
265    struct s_emm_filter *filter_item;
266    if(!cs_malloc(&filter_item, sizeof(struct s_emm_filter)))
267        { return 0; }
268
269    filter_item->demux_id       = demux_id;
270    memcpy(filter_item->filter, filter, 32);
271    filter_item->caid           = caid;
272    filter_item->provid         = provid;
273    filter_item->pid            = emmpid;
274    filter_item->num            = num;
275    if (enable)
276    {
277        cs_ftime(&filter_item->time_started);
278    }
279    else
280    {
281        memset(&filter_item->time_started, 0, sizeof(filter_item->time_started));
282    }
283       
284    if(num > 0)
285    {
286        ll_append(ll_emm_active_filter, filter_item);
287        cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d added to active emmfilters (CAID %04X PROVID %06X EMMPID %04X)",
288                      filter_item->demux_id, filter_item->num, filter_item->caid, filter_item->provid, filter_item->pid);
289    }
290    else if(num < 0)
291    {
292        ll_append(ll_emm_pending_filter, filter_item);
293        cs_log_dbg(D_DVBAPI, "Demuxer %d Filter added to pending emmfilters (CAID %04X PROVID %06X EMMPID %04X)",
294                      filter_item->demux_id, filter_item->caid, filter_item->provid, filter_item->pid);
295    }
296    else
297    {
298        ll_append(ll_emm_inactive_filter, filter_item);
299        cs_log_dbg(D_DVBAPI, "Demuxer %d Filter added to inactive emmfilters (CAID %04X PROVID %06X EMMPID %04X)",
300                      filter_item->demux_id, filter_item->caid, filter_item->provid, filter_item->pid);
301    }
302    return 1;
303}
304
305int32_t is_emmfilter_in_list_internal(LLIST *ll, uchar *filter, uint16_t emmpid, uint32_t provid, uint16_t caid)
306{
307    struct s_emm_filter *filter_item;
308    LL_ITER itr;
309    if(ll_count(ll) > 0)
310    {
311        itr = ll_iter_create(ll);
312        while((filter_item = ll_iter_next(&itr)) != NULL)
313        {
314            if(!memcmp(filter_item->filter, filter, 32) && (filter_item->pid == emmpid) && (filter_item->provid == provid) && (filter_item->caid == caid))
315            { return 1; }
316        }
317    }
318    return 0;
319}
320
321int32_t is_emmfilter_in_list(uchar *filter, uint16_t emmpid, uint32_t provid, uint16_t caid)
322{
323    if(!ll_emm_active_filter)
324        { ll_emm_active_filter = ll_create("ll_emm_active_filter"); }
325
326    if(!ll_emm_inactive_filter)
327        { ll_emm_inactive_filter = ll_create("ll_emm_inactive_filter"); }
328
329    if(!ll_emm_pending_filter)
330        { ll_emm_pending_filter = ll_create("ll_emm_pending_filter"); }
331
332    if(is_emmfilter_in_list_internal(ll_emm_active_filter, filter, emmpid, provid, caid))
333        { return 1; }
334    if(is_emmfilter_in_list_internal(ll_emm_inactive_filter, filter, emmpid, provid, caid))
335        { return 1; }
336    if(is_emmfilter_in_list_internal(ll_emm_pending_filter, filter, emmpid, provid, caid))
337        { return 1; }
338
339    return 0;
340}
341
342struct s_emm_filter *get_emmfilter_by_filternum_internal(LLIST *ll, int32_t demux_id, uint32_t num)
343{
344    struct s_emm_filter *filter;
345    LL_ITER itr;
346    if(ll_count(ll) > 0)
347    {
348        itr = ll_iter_create(ll);
349        while((filter = ll_iter_next(&itr)))
350        {
351            if(filter->demux_id == demux_id && filter->num == num)
352                { return filter; }
353        }
354    }
355    return NULL;
356}
357
358struct s_emm_filter *get_emmfilter_by_filternum(int32_t demux_id, uint32_t num)
359{
360    if(!ll_emm_active_filter)
361        { ll_emm_active_filter = ll_create("ll_emm_active_filter"); }
362
363    if(!ll_emm_inactive_filter)
364        { ll_emm_inactive_filter = ll_create("ll_emm_inactive_filter"); }
365
366    if(!ll_emm_pending_filter)
367        { ll_emm_pending_filter = ll_create("ll_emm_pending_filter"); }
368
369    struct s_emm_filter *emm_filter = NULL;
370    emm_filter = get_emmfilter_by_filternum_internal(ll_emm_active_filter, demux_id, num);
371    if(emm_filter)
372        { return emm_filter; }
373    emm_filter = get_emmfilter_by_filternum_internal(ll_emm_inactive_filter, demux_id, num);
374    if(emm_filter)
375        { return emm_filter; }
376    emm_filter = get_emmfilter_by_filternum_internal(ll_emm_pending_filter, demux_id, num);
377    if(emm_filter)
378        { return emm_filter; }
379
380    return NULL;
381}
382
383int8_t remove_emmfilter_from_list_internal(LLIST *ll, int32_t demux_id, uint16_t caid, uint32_t provid, uint16_t pid, uint32_t num)
384{
385    struct s_emm_filter *filter;
386    LL_ITER itr;
387    if(ll_count(ll) > 0)
388    {
389        itr = ll_iter_create(ll);
390        while((filter = ll_iter_next(&itr)))
391        {
392            if(filter->demux_id == demux_id && filter->caid == caid && filter->provid == provid && filter->pid == pid && filter->num == num)
393            {
394                ll_iter_remove_data(&itr);
395                return 1;
396            }
397        }
398    }
399    return 0;
400}
401
402void remove_emmfilter_from_list(int32_t demux_id, uint16_t caid, uint32_t provid, uint16_t pid, uint32_t num)
403{
404    if(ll_emm_active_filter && remove_emmfilter_from_list_internal(ll_emm_active_filter, demux_id, caid, provid, pid, num))
405        { return; }
406    if(ll_emm_inactive_filter && remove_emmfilter_from_list_internal(ll_emm_inactive_filter, demux_id, caid, provid, pid, num))
407        { return; }
408    if(ll_emm_pending_filter && remove_emmfilter_from_list_internal(ll_emm_pending_filter, demux_id, caid, provid, pid, num))
409        { return; }
410}
411
412void dvbapi_net_add_str(unsigned char *packet, int *size, const char *str)
413{
414    unsigned char *str_len = &packet[*size];                            //string length
415    *size += 1;
416
417    *str_len = snprintf((char *) &packet[*size], DVBAPI_MAX_PACKET_SIZE - *size, "%s", str);
418    *size += *str_len;
419}
420
421int32_t dvbapi_net_send(uint32_t request, int32_t socket_fd, int32_t demux_index, uint32_t filter_number, unsigned char *data, struct s_client *client, ECM_REQUEST *er)
422{
423    unsigned char packet[DVBAPI_MAX_PACKET_SIZE];                       //maximum possible packet size
424    int32_t size = 0;
425
426    // not connected?
427    if (socket_fd <= 0)
428        return 0;
429
430    // preparing packet - header
431    // in old protocol client expect this first byte as adapter index, changed in the new protocol
432    // to be always after request type (opcode)
433    if (client_proto_version <= 0)
434        packet[size++] = demux[demux_index].adapter_index;          //adapter index - 1 byte
435
436    // type of request
437    uint32_t req = request;
438    if (client_proto_version >= 1)
439        req = htonl(req);
440    memcpy(&packet[size], &req, 4);                                     //request - 4 bytes
441    size += 4;
442
443    // preparing packet - adapter index for proto >= 1
444    if ((request != DVBAPI_SERVER_INFO) && client_proto_version >= 1)
445        packet[size++] = demux[demux_index].adapter_index;          //adapter index - 1 byte
446
447    // struct with data
448    switch (request)
449    {
450        case DVBAPI_SERVER_INFO:
451        {
452            int16_t proto_version = htons(DVBAPI_PROTOCOL_VERSION);           //our protocol version
453            memcpy(&packet[size], &proto_version, 2);
454            size += 2;
455
456            unsigned char *info_len = &packet[size];   //info string length
457            size += 1;
458
459            *info_len = snprintf((char *) &packet[size], sizeof(packet) - size, "OSCam v%s, build r%s (%s)", CS_VERSION, CS_SVN_VERSION, CS_TARGET);
460            size += *info_len;
461            break;
462        }
463        case DVBAPI_ECM_INFO:
464        {
465            if (er->rc >= E_NOTFOUND)
466                return 0;
467
468            int8_t hops = 0;
469
470            uint16_t sid = htons(er->srvid);                                           //service ID (program number)
471            memcpy(&packet[size], &sid, 2);
472            size += 2;
473
474            uint16_t caid = htons(er->caid);                                           //CAID
475            memcpy(&packet[size], &caid, 2);
476            size += 2;
477
478            uint16_t pid = htons(er->pid);                                             //PID
479            memcpy(&packet[size], &pid, 2);
480            size += 2;
481
482            uint32_t prid = htonl(er->prid);                                           //Provider ID
483            memcpy(&packet[size], &prid, 4);
484            size += 4;
485
486            uint32_t ecmtime = htonl(client->cwlastresptime);                          //ECM time
487            memcpy(&packet[size], &ecmtime, 4);
488            size += 4;
489
490            dvbapi_net_add_str(packet, &size, get_cardsystem_desc_by_caid(er->caid));  //cardsystem name
491
492            switch (er->rc)
493            {
494                case E_FOUND:
495                    if (er->selected_reader)
496                    {
497                        dvbapi_net_add_str(packet, &size, er->selected_reader->label);                   //reader
498                        if (is_network_reader(er->selected_reader))
499                            dvbapi_net_add_str(packet, &size, er->selected_reader->device);          //from
500                        else
501                            dvbapi_net_add_str(packet, &size, "local");                              //from
502                        dvbapi_net_add_str(packet, &size, reader_get_type_desc(er->selected_reader, 1)); //protocol
503                        hops = er->selected_reader->currenthops;
504                    }
505                    break;
506
507                case E_CACHE1:
508                    dvbapi_net_add_str(packet, &size, "Cache");                //reader
509                    dvbapi_net_add_str(packet, &size, "cache1");               //from
510                    dvbapi_net_add_str(packet, &size, "none");                 //protocol
511                    break;
512
513                case E_CACHE2:
514                    dvbapi_net_add_str(packet, &size, "Cache");                //reader
515                    dvbapi_net_add_str(packet, &size, "cache2");               //from
516                    dvbapi_net_add_str(packet, &size, "none");                 //protocol
517                    break;
518
519                case E_CACHEEX:
520                    dvbapi_net_add_str(packet, &size, "Cache");                //reader
521                    dvbapi_net_add_str(packet, &size, "cache3");               //from
522                    dvbapi_net_add_str(packet, &size, "none");                 //protocol
523                    break;
524            }
525
526            packet[size++] = hops;                                                     //hops
527
528            break;
529        }
530        case DVBAPI_CA_SET_PID:
531        {
532            int sct_capid_size = sizeof(ca_pid_t);
533
534            if (client_proto_version >= 1)
535            {
536                ca_pid_t *capid = (ca_pid_t *) data;
537                capid->pid = htonl(capid->pid);
538                capid->index = htonl(capid->index);
539            }
540            memcpy(&packet[size], data, sct_capid_size);
541
542            size += sct_capid_size;
543            break;
544        }
545        case DVBAPI_CA_SET_DESCR:
546        {
547            int sct_cadescr_size = sizeof(ca_descr_t);
548
549            if (client_proto_version >= 1)
550            {
551                ca_descr_t *cadesc = (ca_descr_t *) data;
552                cadesc->index = htonl(cadesc->index);
553                cadesc->parity = htonl(cadesc->parity);
554            }
555            memcpy(&packet[size], data, sct_cadescr_size);
556
557            size += sct_cadescr_size;
558            break;
559        }
560        case DVBAPI_DMX_SET_FILTER:
561        case DVBAPI_DMX_STOP:
562        {
563            int32_t sct_filter_size = sizeof(struct dmx_sct_filter_params);
564            packet[size++] = demux_index;                               //demux index - 1 byte
565            packet[size++] = filter_number;                             //filter number - 1 byte
566
567            if (data)       // filter data when starting
568            {
569                if (client_proto_version >= 1)
570                {
571                    struct dmx_sct_filter_params *fp = (struct dmx_sct_filter_params *) data;
572
573                    // adding all dmx_sct_filter_params structure fields
574                    // one by one to avoid padding problems
575                    uint16_t pid = htons(fp->pid);
576                    memcpy(&packet[size], &pid, 2);
577                    size += 2;
578
579                    memcpy(&packet[size], fp->filter.filter, 16);
580                    size += 16;
581                    memcpy(&packet[size], fp->filter.mask, 16);
582                    size += 16;
583                    memcpy(&packet[size], fp->filter.mode, 16);
584                    size += 16;
585
586                    uint32_t timeout = htonl(fp->timeout);
587                    memcpy(&packet[size], &timeout, 4);
588                    size += 4;
589
590                    uint32_t flags = htonl(fp->flags);
591                    memcpy(&packet[size], &flags, 4);
592                    size += 4;
593                }
594                else
595                {
596                    memcpy(&packet[size], data, sct_filter_size);       //dmx_sct_filter_params struct
597                    size += sct_filter_size;
598                }
599            }
600            else            // pid when stopping
601            {
602                if (client_proto_version >= 1)
603                {
604                    uint16_t pid = htons(demux[demux_index].demux_fd[filter_number].pid);
605                    memcpy(&packet[size], &pid, 2);
606                    size += 2;
607                }
608                else
609                {
610                    uint16_t pid = demux[demux_index].demux_fd[filter_number].pid;
611                    packet[size++] = pid >> 8;
612                    packet[size++] = pid & 0xff;
613                }
614            }
615            break;
616        }
617        default:  //unknown request
618        {
619            cs_log("ERROR: dvbapi_net_send: invalid request");
620            return 0;
621        }
622    }
623
624    // sending
625    cs_log_dump_dbg(D_DVBAPI, packet, size, "Sending packet to dvbapi client (fd=%d):", socket_fd);
626    send(socket_fd, &packet, size, MSG_DONTWAIT);
627
628    // always returning success as the client could close socket
629    return 0;
630}
631
632int32_t dvbapi_set_filter(int32_t demux_id, int32_t api, uint16_t pid, uint16_t caid, uint32_t provid, uchar *filt, uchar *mask, int32_t timeout, int32_t pidindex, int32_t type,
633    int8_t add_to_emm_list)
634{
635    if(USE_OPENXCAS && type == TYPE_ECM)
636    {
637        openxcas_set_caid(demux[demux_id].ECMpids[pidindex].CAID);
638        openxcas_set_ecm_pid(pid);
639    }
640    if (USE_OPENXCAS)
641        return 1;
642
643    int32_t ret = -1, n = -1, i, filterfd = -1;
644
645    for(i = 0; i < maxfilter && demux[demux_id].demux_fd[i].fd > 0; i++) { ; }
646
647    if(i >= maxfilter)
648    {
649        cs_log_dbg(D_DVBAPI, "no free filter");
650        return -1;
651    }
652    n = i;
653
654    switch(api)
655    {
656    case DVBAPI_3:
657        if (cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
658            ret = filterfd = DUMMY_FD;
659        else
660            ret = filterfd = dvbapi_open_device(0, demux[demux_id].demux_index, demux[demux_id].adapter_index);
661        if(ret < 0) { return ret; }  // return if device cant be opened!
662        struct dmx_sct_filter_params sFP2;
663
664        memset(&sFP2, 0, sizeof(sFP2));
665
666        sFP2.pid            = pid;
667        sFP2.timeout        = timeout;
668        sFP2.flags          = DMX_IMMEDIATE_START;
669        if(cfg.dvbapi_boxtype == BOXTYPE_NEUMO)
670        {
671            //DeepThought: on dgs/cubestation and neumo images, perhaps others
672            //the following code is needed to descramble
673            sFP2.filter.filter[0] = filt[0];
674            sFP2.filter.mask[0] = mask[0];
675            sFP2.filter.filter[1] = 0;
676            sFP2.filter.mask[1] = 0;
677            sFP2.filter.filter[2] = 0;
678            sFP2.filter.mask[2] = 0;
679            memcpy(sFP2.filter.filter + 3, filt + 1, 16 - 3);
680            memcpy(sFP2.filter.mask + 3, mask + 1, 16 - 3);
681            //DeepThought: in the drivers of the dgs/cubestation and neumo images,
682            //dvbapi 1 and 3 are somehow mixed. In the kernel drivers, the DMX_SET_FILTER
683            //ioctl expects to receive a dmx_sct_filter_params structure (DVBAPI 3) but
684            //due to a bug its sets the "positive mask" wrongly (they should be all 0).
685            //On the other hand, the DMX_SET_FILTER1 ioctl also uses the dmx_sct_filter_params
686            //structure, which is incorrect (it should be  dmxSctFilterParams).
687            //The only way to get it right is to call DMX_SET_FILTER1 with the argument
688            //expected by DMX_SET_FILTER. Otherwise, the timeout parameter is not passed correctly.
689            ret = dvbapi_ioctl(filterfd, DMX_SET_FILTER1, &sFP2);
690        }
691        else
692        {
693            memcpy(sFP2.filter.filter, filt, 16);
694            memcpy(sFP2.filter.mask, mask, 16);
695            if (cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
696                ret = dvbapi_net_send(DVBAPI_DMX_SET_FILTER, demux[demux_id].socket_fd, demux_id, n, (unsigned char *) &sFP2, NULL, NULL);
697            else
698                ret = dvbapi_ioctl(filterfd, DMX_SET_FILTER, &sFP2);
699        }
700        break;
701
702    case DVBAPI_1:
703        ret = filterfd = dvbapi_open_device(0, demux[demux_id].demux_index, demux[demux_id].adapter_index);
704        if(ret < 0) { return ret; }  // return if device cant be opened!
705        struct dmxSctFilterParams sFP1;
706
707        memset(&sFP1, 0, sizeof(sFP1));
708
709        sFP1.pid            = pid;
710        sFP1.timeout        = timeout;
711        sFP1.flags          = DMX_IMMEDIATE_START;
712        memcpy(sFP1.filter.filter, filt, 16);
713        memcpy(sFP1.filter.mask, mask, 16);
714        ret = dvbapi_ioctl(filterfd, DMX_SET_FILTER1, &sFP1);
715
716        break;
717#if defined(WITH_STAPI) || defined(WITH_STAPI5)
718    case STAPI:
719        ret = filterfd = stapi_set_filter(demux_id, pid, filt, mask, n, demux[demux_id].pmt_file);
720        if(ret <= 0)
721        { 
722            ret = -1; // error setting filter!
723        }
724        break;
725#endif
726#if defined WITH_COOLAPI || defined WITH_COOLAPI2
727    case COOLAPI:
728        ret = filterfd = coolapi_open_device(demux[demux_id].demux_index, demux_id);
729        if(ret > 0)
730        { 
731            ret = coolapi_set_filter(filterfd, n, pid, filt, mask, type);
732        }
733        else
734        {
735            ret = -1; // fail
736        }
737        break;
738#endif
739    default:
740        break;
741    }
742    if(ret != -1)  // filter set successful
743    {
744        // only register if filter was set successful
745        demux[demux_id].demux_fd[n].fd       = filterfd;
746        demux[demux_id].demux_fd[n].pidindex = pidindex;
747        demux[demux_id].demux_fd[n].pid      = pid;
748        demux[demux_id].demux_fd[n].caid     = caid;
749        demux[demux_id].demux_fd[n].provid   = provid;
750        demux[demux_id].demux_fd[n].type     = type;
751        memcpy(demux[demux_id].demux_fd[n].filter, filt, 16); // copy filter to check later on if receiver delivered accordingly
752        memcpy(demux[demux_id].demux_fd[n].mask, mask, 16); // copy mask to check later on if receiver delivered accordingly
753        cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d started successfully (caid %04X provid %06X pid %04X)", demux_id, n + 1, caid, provid, pid);
754        if(type == TYPE_EMM && add_to_emm_list){ 
755            add_emmfilter_to_list(demux_id, filt, caid, provid, pid, n + 1, true);
756        }
757    }
758    else
759    {
760        cs_log("ERROR: Could not start demux filter (api: %d errno=%d %s)", selected_api, errno, strerror(errno));
761    }
762   
763    return ret;
764}
765
766static int32_t dvbapi_detect_api(void)
767{
768#if defined WITH_COOLAPI || defined WITH_COOLAPI2
769    selected_api = COOLAPI;
770    selected_box = BOX_INDEX_COOLSTREAM;
771    disable_pmt_files = 1;
772    cfg.dvbapi_listenport = 0;
773    cs_log("Detected Coolstream API");
774    return 1;
775#else
776    if (cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX || cfg.dvbapi_boxtype == BOXTYPE_PC ) {
777        selected_api = DVBAPI_3;
778        selected_box = BOX_INDEX_DREAMBOX_DVBAPI3;
779        if (cfg.dvbapi_listenport)
780        {
781            cs_log("Using TCP listen socket, API forced to DVBAPIv3 (%d), userconfig boxtype: %d", selected_api, cfg.dvbapi_boxtype);
782        }
783        else
784        {
785            cs_log("Using %s listen socket, API forced to DVBAPIv3 (%d), userconfig boxtype: %d", devices[selected_box].cam_socket_path, selected_api, cfg.dvbapi_boxtype);
786        }
787        return 1;
788    }
789    else if(cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
790    {
791        selected_api = DVBAPI_3;
792        selected_box = BOX_INDEX_QBOXHD;
793        cfg.dvbapi_listenport = 0;
794        disable_pmt_files = 1;
795        cs_log("Using SamyGO dvbapi v0.1");
796        return 1;
797    } 
798    else
799    {
800        cfg.dvbapi_listenport = 0;
801    }
802   
803    int32_t i = 0, n = 0, devnum = -1, dmx_fd = 0, ret = 0;
804    char device_path[128], device_path2[128];
805
806    while (i < BOX_COUNT)
807    {
808        snprintf(device_path2, sizeof(device_path2), devices[i].demux_device, 0);
809        snprintf(device_path, sizeof(device_path), devices[i].path, n);
810        strncat(device_path, device_path2, sizeof(device_path) - strlen(device_path) - 1);
811       
812        if((dmx_fd = open(device_path, O_RDWR | O_NONBLOCK)) > 0)
813        {
814            devnum = i;
815            ret = close(dmx_fd);
816            break;
817        }
818        /* try at least 8 adapters */
819        if ((strchr(devices[i].path, '%') != NULL) && (n < 8)) n++; else { n = 0; i++; }
820    }
821
822    if(devnum == -1) { return 0; }
823    selected_box = devnum;
824    if(selected_box > -1)
825        { selected_api = devices[selected_box].api; }
826   
827    if(ret < 0) { cs_log("ERROR: Could not close demuxer fd (errno=%d %s)", errno, strerror(errno)); } // log it here since some needed var are not inited before!
828
829#if defined(WITH_STAPI) || defined(WITH_STAPI5)
830    if(selected_api == STAPI && stapi_open() == 0)
831    {
832        cs_log("ERROR: stapi: setting up stapi failed.");
833        return 0;
834    }
835#endif
836    if(cfg.dvbapi_boxtype == BOXTYPE_NEUMO)
837    {
838        selected_api = DVBAPI_3; //DeepThought
839    }
840    cs_log("Detected %s Api: %d, userconfig boxtype: %d", device_path, selected_api, cfg.dvbapi_boxtype);
841#endif
842    return 1;
843}
844
845static int32_t dvbapi_read_device(int32_t dmx_fd, unsigned char *buf, uint32_t length)
846{
847    int32_t readed;
848    uint32_t count = 0;
849    struct pollfd pfd[1];
850
851    pfd[0].fd = dmx_fd;
852    pfd[0].events = (POLLIN | POLLPRI);
853
854    while (count < length ) 
855    {
856        if (poll(pfd,1,0)) // fd ready for reading?
857        {
858            if (pfd[0].revents & (POLLIN | POLLPRI)) // is there data to read?
859            {
860                readed = read(dmx_fd, &buf[count], length-count);
861                if(readed < 0) // error occured while reading
862                {
863                    if(errno == EINTR || errno == EAGAIN) { continue; }  // try again in case of interrupt
864                    cs_log("ERROR: Read error on fd %d (errno=%d %s)", dmx_fd, errno, strerror(errno));
865                    return (errno == EOVERFLOW ? 0 : -1);
866                }
867                if(readed > 0) // succesfull read
868                {
869                    count += readed;
870                }
871                if(readed == 0 && count > 0) // nothing to read left
872                {
873                    break;
874                }
875            }
876            else return -1; // other events than pollin/pri means bad news -> abort!
877        }
878        else break;
879    }
880    cs_log_dump_dbg(D_TRACE, buf, count, "Received:");
881    return count;
882}
883
884int32_t dvbapi_open_device(int32_t type, int32_t num, int32_t adapter)
885{
886    int32_t dmx_fd, ret;
887    int32_t ca_offset = 0;
888    char device_path[128], device_path2[128];
889
890    if(cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
891        return DUMMY_FD;
892   
893    if(type == 0)
894    {
895        snprintf(device_path2, sizeof(device_path2), devices[selected_box].demux_device, num);
896        snprintf(device_path, sizeof(device_path), devices[selected_box].path, adapter);
897
898        strncat(device_path, device_path2, sizeof(device_path) - strlen(device_path) - 1);
899    }
900    else
901    {
902        if(cfg.dvbapi_boxtype == BOXTYPE_DUCKBOX || cfg.dvbapi_boxtype == BOXTYPE_DBOX2 || cfg.dvbapi_boxtype == BOXTYPE_UFS910)
903            { ca_offset = 1; }
904
905        if(cfg.dvbapi_boxtype == BOXTYPE_QBOXHD)
906            { num = 0; }
907
908        if(cfg.dvbapi_boxtype == BOXTYPE_PC)
909            { num = 0; }
910
911        if(cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
912            { num = 0; }
913
914        snprintf(device_path2, sizeof(device_path2), devices[selected_box].ca_device, num + ca_offset);
915        snprintf(device_path, sizeof(device_path), devices[selected_box].path, adapter);
916
917        strncat(device_path, device_path2, sizeof(device_path) - strlen(device_path) - 1);
918    }
919
920    if (cfg.dvbapi_boxtype == BOXTYPE_SAMYGO) {
921       
922        if(type == 0)
923        {
924            struct sockaddr_un saddr;
925            memset(&saddr, 0, sizeof(saddr));
926            saddr.sun_family = AF_UNIX;
927            strncpy(saddr.sun_path, device_path, sizeof(saddr.sun_path) - 1);
928            dmx_fd = socket(AF_UNIX, SOCK_STREAM, 0);
929            ret = connect(dmx_fd, (struct sockaddr *)&saddr, sizeof(saddr));
930            if (ret < 0)
931                { close(dmx_fd); }
932        }
933        else if(type == 1)
934        {
935            int32_t udp_port = 9000;
936            struct sockaddr_in saddr;
937            memset(&saddr, 0, sizeof(saddr));           
938            saddr.sin_family = AF_INET;
939            saddr.sin_port = htons(udp_port + adapter);
940            saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
941            dmx_fd = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
942            set_nonblock(dmx_fd, true);
943            ret = connect(dmx_fd, (struct sockaddr *) &saddr, sizeof(saddr));
944            if(ret < 0)
945                { close(dmx_fd); }
946       
947            cs_log_dbg(D_DVBAPI, "NET DEVICE open (port = %d) fd %d", udp_port + adapter, dmx_fd); 
948        }
949        else
950        {
951            ret = -1;
952        }
953    } else {
954        dmx_fd = ret = open(device_path, O_RDWR | O_NONBLOCK);
955    }
956
957    if(ret < 0)
958    {
959        cs_log("ERROR: Can't open device %s (errno=%d %s)", device_path, errno, strerror(errno));
960        return -1;
961    }
962
963    cs_log_dbg(D_DVBAPI, "Open device %s (fd %d)", device_path, dmx_fd);
964
965    return dmx_fd;
966}
967
968uint16_t tunemm_caid_map(uint8_t direct, uint16_t caid, uint16_t srvid)
969{
970    int32_t i;
971    struct s_client *cl = cur_client();
972    TUNTAB *ttab = &cl->ttab;
973
974    if (!ttab->ttnum)
975        return caid;
976
977    if(direct)
978    {
979        for(i = 0; i < ttab->ttnum; i++)
980        {
981            if(caid == ttab->ttdata[i].bt_caidto
982                    && (srvid == ttab->ttdata[i].bt_srvid || ttab->ttdata[i].bt_srvid == 0xFFFF || !ttab->ttdata[i].bt_srvid))
983                { return ttab->ttdata[i].bt_caidfrom; }
984        }
985    }
986    else
987    {
988        for(i = 0; i < ttab->ttnum; i++)
989        {
990            if(caid == ttab->ttdata[i].bt_caidfrom
991                    && (srvid == ttab->ttdata[i].bt_srvid || ttab->ttdata[i].bt_srvid == 0xFFFF || !ttab->ttdata[i].bt_srvid))
992                { return ttab->ttdata[i].bt_caidto; }
993        }
994    }
995    return caid;
996}
997
998int32_t dvbapi_stop_filter(int32_t demux_index, int32_t type)
999{
1000    int32_t g, error = 0;
1001
1002    for(g = 0; g < MAX_FILTER; g++) // just stop them all, we dont want to risk leaving any stale filters running due to lowering of maxfilters
1003    {
1004        if(demux[demux_index].demux_fd[g].type == type)
1005        {
1006            if(dvbapi_stop_filternum(demux_index, g) == -1)
1007            { 
1008                error = 1;
1009            } 
1010        }
1011    }
1012    return !error; // on error return 0, all ok 1
1013}
1014
1015int32_t dvbapi_stop_filternum(int32_t demux_index, int32_t num)
1016{
1017    int32_t retfilter = -1, retfd = -1, fd = demux[demux_index].demux_fd[num].fd, try = 0;
1018    if(fd > 0)
1019    {
1020        do
1021        {
1022            if(try)
1023            {
1024                cs_sleepms(50);
1025            }
1026            try++;
1027            cs_log_dbg(D_DVBAPI, "Demuxer %d stop filter %d try %d (fd: %d api: %d, caid: %04X, provid: %06X, %spid: %04X)", demux_index, num + 1, try,
1028                        fd, selected_api, demux[demux_index].demux_fd[num].caid, demux[demux_index].demux_fd[num].provid,
1029                        (demux[demux_index].demux_fd[num].type == TYPE_ECM ? "ecm" : "emm"), demux[demux_index].demux_fd[num].pid);
1030
1031            switch(selected_api)
1032            {
1033            case DVBAPI_3:
1034                if (cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
1035                    retfilter = dvbapi_net_send(DVBAPI_DMX_STOP, demux[demux_index].socket_fd, demux_index, num, NULL, NULL, NULL);
1036                else
1037                    retfilter = dvbapi_ioctl(fd, DMX_STOP, NULL);
1038                break;
1039
1040            case DVBAPI_1:
1041                retfilter = dvbapi_ioctl(fd, DMX_STOP, NULL);
1042                break;
1043
1044#if defined(WITH_STAPI) || defined(WITH_STAPI5)
1045            case STAPI:
1046                retfilter = stapi_remove_filter(demux_index, num, demux[demux_index].pmt_file);
1047                if(retfilter != 1)   // stapi returns 0 for error, 1 for all ok
1048                {
1049                    retfilter = -1;
1050                }
1051                break;
1052#endif
1053#if defined WITH_COOLAPI || defined WITH_COOLAPI2
1054            case COOLAPI:
1055                retfilter = coolapi_remove_filter(fd, num);
1056                if(retfilter >=0 )
1057                {
1058                    retfd = coolapi_close_device(fd);
1059                }
1060                break;
1061#endif
1062            default:
1063                break;
1064            }
1065        } while (retfilter < 0 && try < 10);
1066       
1067#if !defined WITH_COOLAPI && !defined WITH_COOLAPI2 // no fd close for coolapi and stapi, all others do close fd!
1068        try = 0;
1069        do
1070        {
1071            if(try)
1072            {
1073                cs_sleepms(50);
1074            }
1075            try++;
1076            if (!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX)
1077            {
1078                if(selected_api == STAPI)
1079                { 
1080                    retfd = 0;  // stapi closes its own filter fd!
1081                } 
1082                else
1083                {
1084                    flush_read_fd(demux_index, num, fd); // flush filter input buffer in attempt to avoid overflow receivers internal buffer
1085                    retfd = close(fd);
1086                    if(errno == 9) { retfd = 0; }  // no error on bad file descriptor
1087                }
1088            }
1089            else
1090                retfd = 0;
1091           
1092        } while (retfd < 0 && try < 10);
1093#endif
1094    }
1095    else // fd <=0
1096    {
1097        return 1; // filter was already killed!
1098    }
1099   
1100    if(retfilter < 0) // error on remove filter
1101    {
1102        cs_log("ERROR: Demuxer %d could not stop Filter %d (fd:%d api:%d errno=%d %s)", demux_index, num + 1, fd, selected_api, errno, strerror(errno));
1103        return retfilter;
1104    }
1105   
1106    if(retfd < 0) // error on close filter fd
1107    { 
1108        cs_log("ERROR: Demuxer %d could not close fd of Filter %d (fd=%d api:%d errno=%d %s)", demux_index, num + 1, fd,
1109            selected_api, errno, strerror(errno));
1110        return retfd;
1111    }
1112   
1113    // code below runs only if nothing has gone wrong
1114   
1115    if(demux[demux_index].demux_fd[num].type == TYPE_ECM)   //ecm filter stopped: reset index!
1116    {
1117        int32_t oldpid = demux[demux_index].demux_fd[num].pidindex;
1118        int32_t curpid = demux[demux_index].pidindex;
1119        int32_t idx = demux[demux_index].ECMpids[oldpid].index;
1120        demux[demux_index].ECMpids[oldpid].index = 0;
1121       
1122        // workaround: below dont run on stapi since it handles it own pids.... stapi need to be better integrated in oscam dvbapi.
1123       
1124        if(idx && selected_api != STAPI) // if in use
1125        {
1126            int32_t i;
1127            for(i = 0; i < demux[demux_index].STREAMpidcount; i++)
1128            {
1129                int8_t match = 0;
1130                // check streams of old disabled ecmpid
1131                if(!demux[demux_index].ECMpids[oldpid].streams || ((demux[demux_index].ECMpids[oldpid].streams & (1 << i)) == (uint) (1 << i)))
1132                {
1133                    // check if new ecmpid is using same streams
1134                    if(curpid != -1 && (!demux[demux_index].ECMpids[curpid].streams || ((demux[demux_index].ECMpids[curpid].streams & (1 << i)) == (uint) (1 << i))))
1135                    {
1136                        continue; // found same stream on old and new ecmpid -> skip! (and leave it enabled!)
1137                    }
1138                   
1139                    int32_t pidtobestopped = demux[demux_index].STREAMpids[i];
1140                    int32_t j, k, otherdemuxpid, otherdemuxidx;
1141                   
1142                    for(j = 0; j < MAX_DEMUX; j++) // check other demuxers for same streampid with same index
1143                    {
1144                        if(demux[j].program_number == 0) { continue; }                      // skip empty demuxers
1145                        if(demux_index == j) { continue; }                                  // skip same demuxer
1146                        if(demux[j].ca_mask != demux[demux_index].ca_mask) { continue;}     // skip streampid running on other ca device
1147                       
1148                        otherdemuxpid = demux[j].pidindex;
1149                        if(otherdemuxpid == -1) { continue; }                               // Other demuxer not descrambling yet
1150                        otherdemuxidx = demux[j].ECMpids[otherdemuxpid].index;
1151                        if(!otherdemuxidx || otherdemuxidx != idx) { continue; }            // Other demuxer has no index yet, or index is different
1152                           
1153                        for(k = 0; k < demux[j].STREAMpidcount; k++)
1154                        {
1155                            if(!demux[j].ECMpids[otherdemuxpid].streams || ((demux[j].ECMpids[otherdemuxpid].streams & (1 << k)) == (uint) (1 << k)))
1156                            {
1157                                if(demux[j].STREAMpids[k] == pidtobestopped)
1158                                {
1159                                    continue; // found same streampid enabled with same index on one or more other demuxers -> skip! (and leave it enabled!)
1160                                }
1161                            }
1162                            match = 1; // matching stream found
1163                        }
1164                    }
1165                       
1166                    if(!match)
1167                    {
1168                        dvbapi_set_pid(demux_index, i, idx - 1, false); // disable streampid since its not used by this pid (or by the new ecmpid or any other demuxer!)
1169                    }
1170                }
1171            }
1172        }
1173    }
1174
1175    if(demux[demux_index].demux_fd[num].type == TYPE_EMM)   // If emm type remove from emm filterlist
1176    {
1177        remove_emmfilter_from_list(demux_index, demux[demux_index].demux_fd[num].caid, demux[demux_index].demux_fd[num].provid, demux[demux_index].demux_fd[num].pid, num + 1);
1178    }
1179    demux[demux_index].demux_fd[num].type = 0;
1180    demux[demux_index].demux_fd[num].fd = 0;
1181    return 1; // all ok!
1182}
1183
1184void dvbapi_start_filter(int32_t demux_id, int32_t pidindex, uint16_t pid, uint16_t caid, uint32_t provid, uchar table, uchar mask, int32_t timeout, int32_t type)
1185{
1186    int32_t o;
1187    for(o = 0; o < maxfilter; o++)    // check if ecmfilter is in use & stop all ecmfilters of lower status pids
1188    {
1189        if(demux[demux_id].demux_fd[o].fd > 0 &&
1190            demux[demux_id].demux_fd[o].pid == pid &&
1191            demux[demux_id].demux_fd[o].type == type && type == TYPE_ECM)   
1192        {
1193            return;
1194        }
1195    }
1196    uchar filter[32];
1197    memset(filter, 0, 32);
1198
1199    filter[0] = table;
1200    filter[16] = mask;
1201
1202    cs_log_dbg(D_DVBAPI, "Demuxer %d try to start new filter for caid: %04X, provid: %06X, pid: %04X", demux_id, caid, provid, pid);
1203    dvbapi_set_filter(demux_id, selected_api, pid, caid, provid, filter, filter + 16, timeout, pidindex, type, 0);
1204}
1205
1206void dvbapi_start_sdt_filter(int32_t demux_index)
1207{
1208    dvbapi_start_filter(demux_index, demux[demux_index].pidindex, 0x11, 0x001, 0x01, 0x42, 0xFF, 0, TYPE_SDT);
1209    demux[demux_index].sdt_filter = 0;
1210}
1211
1212void dvbapi_start_emm_filter(int32_t demux_index)
1213{
1214    unsigned int j;
1215    if(!demux[demux_index].EMMpidcount)
1216        { return; }
1217
1218    //if (demux[demux_index].emm_filter)
1219    //  return;
1220
1221
1222    struct s_csystem_emm_filter *dmx_filter = NULL;
1223    unsigned int filter_count = 0;
1224    uint16_t caid, ncaid;
1225    uint32_t provid;
1226
1227    struct s_reader *rdr = NULL;
1228    struct s_client *cl = cur_client();
1229    if(!cl || !cl->aureader_list)
1230        { return; }
1231
1232    LL_ITER itr = ll_iter_create(cl->aureader_list);
1233    while((rdr = ll_iter_next(&itr)))
1234    {
1235        if(!(rdr->grp & cl->grp)) 
1236            { continue; }
1237        if(rdr->audisabled || !rdr->enable || (!is_network_reader(rdr) && rdr->card_status != CARD_INSERTED))
1238            { continue; }
1239
1240        const struct s_cardsystem *csystem;
1241        uint16_t c, match;
1242        cs_log_dbg(D_DVBAPI, "Demuxer %d matching reader %s against available emmpids -> START!", demux_index, rdr->label);
1243        for(c = 0; c < demux[demux_index].EMMpidcount; c++)
1244        {
1245            caid = ncaid = demux[demux_index].EMMpids[c].CAID;
1246            if(!caid) continue;
1247
1248            if(chk_is_betatunnel_caid(caid) == 2)
1249            {
1250                ncaid = tunemm_caid_map(FROM_TO, caid, demux[demux_index].program_number);
1251            }
1252            provid = demux[demux_index].EMMpids[c].PROVID;
1253            if (caid == ncaid)
1254            {
1255                match = emm_reader_match(rdr, caid, provid);
1256            }
1257            else
1258            {
1259                match = emm_reader_match(rdr, ncaid, provid);
1260            }
1261            if(match)
1262            {
1263                csystem = get_cardsystem_by_caid(caid);
1264                if(csystem)
1265                {
1266                    if(caid != ncaid)
1267                    {
1268                        csystem = get_cardsystem_by_caid(ncaid);
1269                        if(csystem && csystem->get_tunemm_filter)
1270                        {
1271                            csystem->get_tunemm_filter(rdr, &dmx_filter, &filter_count);
1272                            cs_log_dbg(D_DVBAPI, "Demuxer %d setting emm filter for betatunnel: %04X -> %04X", demux_index, ncaid, caid);
1273                        }
1274                        else
1275                        {
1276                            cs_log_dbg(D_DVBAPI, "Demuxer %d cardsystem for emm filter for caid %04X of reader %s not found", demux_index, ncaid, rdr->label);
1277                            continue;
1278                        }
1279                    }
1280                    else if (csystem->get_emm_filter)
1281                    {
1282                        csystem->get_emm_filter(rdr, &dmx_filter, &filter_count);
1283                    }
1284                }
1285                else
1286                {
1287                    cs_log_dbg(D_DVBAPI, "Demuxer %d cardsystem for emm filter for caid %04X of reader %s not found", demux_index, caid, rdr->label);
1288                    continue;
1289                }
1290
1291                for(j = 0; j < filter_count ; j++)
1292                {
1293                    if(dmx_filter[j].enabled == 0)
1294                    { continue; }
1295
1296                    uchar filter[32];
1297                    memset(filter, 0, sizeof(filter));  // reset filter
1298                    uint32_t usefilterbytes = 16; // default use all filters
1299                    memcpy(filter, dmx_filter[j].filter, usefilterbytes);
1300                    memcpy(filter + 16, dmx_filter[j].mask, usefilterbytes);
1301                    int32_t emmtype = dmx_filter[j].type;
1302
1303                    if(filter[0] && (((1 << (filter[0] % 0x80)) & rdr->b_nano) && !((1 << (filter[0] % 0x80)) & rdr->s_nano)))
1304                    { 
1305                        cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d blocked by userconfig -> SKIP!", demux_index, rdr->label, j+1, filter_count);
1306                        continue; 
1307                    }
1308
1309                    if((rdr->blockemm & emmtype) && !(((1 << (filter[0] % 0x80)) & rdr->s_nano) || (rdr->saveemm & emmtype)))
1310                    { 
1311                        cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d blocked by userconfig -> SKIP!", demux_index, rdr->label, j+1, filter_count);
1312                        continue;
1313                    }
1314               
1315                    if(demux[demux_index].EMMpids[c].type & emmtype)
1316                    {
1317                        cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d type match -> ENABLE!", demux_index, rdr->label, j+1, filter_count);
1318                        check_add_emmpid(demux_index, filter, c, emmtype);
1319                    }
1320                    else
1321                    {
1322                        cs_log_dbg(D_DVBAPI, "Demuxer %d reader %s emmfilter %d/%d type mismatch -> SKIP!", demux_index, rdr->label, j+1, filter_count);
1323                    }
1324                }
1325                   
1326                // dmx_filter not use below this point;
1327                NULLFREE(dmx_filter);
1328            }
1329        }
1330        cs_log_dbg(D_DVBAPI, "Demuxer %d matching reader %s against available emmpids -> DONE!", demux_index, rdr->label);
1331    }
1332    if(demux[demux_index].emm_filter == -1) // first run -1
1333    {
1334        demux[demux_index].emm_filter = 0;
1335    }
1336    cs_log_dbg(D_DVBAPI, "Demuxer %d handles %i emm filters", demux_index, demux[demux_index].emm_filter);
1337}
1338
1339void dvbapi_add_ecmpid_int(int32_t demux_id, uint16_t caid, uint16_t ecmpid, uint32_t provid, char *txt) 
1340{
1341    int32_t n, added = 0;
1342   
1343    if(demux[demux_id].ECMpidcount >= ECM_PIDS)
1344        { return; }
1345
1346    int32_t stream = demux[demux_id].STREAMpidcount - 1;
1347    for(n = 0; n < demux[demux_id].ECMpidcount; n++)
1348    {
1349        if(stream > -1 && demux[demux_id].ECMpids[n].CAID == caid && demux[demux_id].ECMpids[n].ECM_PID == ecmpid && demux[demux_id].ECMpids[n].PROVID == provid)
1350        {
1351            if(!demux[demux_id].ECMpids[n].streams)
1352            {
1353                //we already got this caid/ecmpid as global, no need to add the single stream
1354                cs_log("Demuxer %d skipped stream CAID: %04X ECM_PID: %04X PROVID: %06X (Same as ECMPID %d)", demux_id, caid, ecmpid, provid, n);
1355                continue;
1356            }
1357            added = 1;
1358            demux[demux_id].ECMpids[n].streams |= (1 << stream);
1359            cs_log("Demuxer %d added stream to ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X", demux_id, n, caid, ecmpid, provid);
1360        }
1361    }
1362
1363    if(added == 1)
1364        { return; }
1365    for(n = 0; n < demux[demux_id].ECMpidcount; n++)  // check for existing pid
1366    {
1367        if(demux[demux_id].ECMpids[n].CAID == caid && demux[demux_id].ECMpids[n].ECM_PID == ecmpid && demux[demux_id].ECMpids[n].PROVID == provid)
1368            { return; } // found same pid -> skip
1369    }
1370    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].ECM_PID = ecmpid;
1371    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].CAID = caid;
1372    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].PROVID = provid;
1373    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].CHID = 0x10000; // reset CHID
1374    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].checked = 0;
1375    //demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].index = 0;
1376    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].status = 0;
1377    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].tries = 0xFE;
1378    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].streams = 0; // reset streams!
1379    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].irdeto_curindex = 0xFE; // reset
1380    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].irdeto_maxindex = 0; // reset
1381    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].irdeto_cycle = 0xFE; // reset
1382    demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].table = 0;
1383
1384    cs_log("Demuxer %d ecmpid %d CAID: %04X ECM_PID: %04X PROVID: %06X %s", demux_id, demux[demux_id].ECMpidcount, caid, ecmpid, provid, txt);
1385    if(caid_is_irdeto(caid)) { demux[demux_id].emmstart.time = 1; }  // marker to fetch emms early irdeto needs them!
1386
1387    demux[demux_id].ECMpidcount++;
1388}
1389
1390void dvbapi_add_ecmpid(int32_t demux_id, uint16_t caid, uint16_t ecmpid, uint32_t provid, char *txt)
1391{
1392    dvbapi_add_ecmpid_int(demux_id, caid, ecmpid, provid, txt);
1393    struct s_dvbapi_priority *joinentry;
1394
1395    for(joinentry = dvbapi_priority; joinentry != NULL; joinentry = joinentry->next)
1396    {
1397        if((joinentry->type != 'j')
1398                || (joinentry->caid && joinentry->caid != caid)
1399                || (joinentry->provid && joinentry->provid != provid)
1400                || (joinentry->ecmpid && joinentry->ecmpid  != ecmpid)
1401                || (joinentry->srvid && joinentry->srvid != demux[demux_id].program_number))
1402            { continue; }
1403        cs_log_dbg(D_DVBAPI, "Join ecmpid %04X@%06X:%04X to %04X@%06X:%04X",
1404                      caid, provid, ecmpid, joinentry->mapcaid, joinentry->mapprovid, joinentry->mapecmpid);
1405        dvbapi_add_ecmpid_int(demux_id, joinentry->mapcaid, joinentry->mapecmpid, joinentry->mapprovid, txt);
1406    }
1407}
1408
1409void dvbapi_add_emmpid(int32_t demux_id, uint16_t caid, uint16_t emmpid, uint32_t provid, uint8_t type)
1410{
1411    char typetext[40];
1412    cs_strncpy(typetext, ":", sizeof(typetext));
1413
1414    if(type & 0x01) { strcat(typetext, "UNIQUE:"); }
1415    if(type & 0x02) { strcat(typetext, "SHARED:"); }
1416    if(type & 0x04) { strcat(typetext, "GLOBAL:"); }
1417    if(type & 0xF8) { strcat(typetext, "UNKNOWN:"); }
1418
1419    uint16_t i;
1420    for(i = 0; i < demux[demux_id].EMMpidcount; i++)
1421    {
1422        if(demux[demux_id].EMMpids[i].PID == emmpid && demux[demux_id].EMMpids[i].CAID == caid && demux[demux_id].EMMpids[i].PROVID == provid)
1423        {
1424            if(!(demux[demux_id].EMMpids[i].type&type)){
1425                demux[demux_id].EMMpids[i].type |= type; // register this emm kind to this emmpid
1426                cs_log_dbg(D_DVBAPI, "Added to existing emmpid %d additional emmtype %s", demux[demux_id].EMMpidcount - 1, typetext);
1427            }
1428            return;
1429        }
1430    }
1431    demux[demux_id].EMMpids[demux[demux_id].EMMpidcount].PID = emmpid;
1432    demux[demux_id].EMMpids[demux[demux_id].EMMpidcount].CAID = caid;
1433    demux[demux_id].EMMpids[demux[demux_id].EMMpidcount].PROVID = provid;
1434    demux[demux_id].EMMpids[demux[demux_id].EMMpidcount++].type = type;
1435    cs_log_dbg(D_DVBAPI, "Added new emmpid %d CAID: %04X EMM_PID: %04X PROVID: %06X TYPE %s", demux[demux_id].EMMpidcount - 1, caid, emmpid, provid, typetext);
1436}
1437
1438void dvbapi_parse_cat(int32_t demux_id, uchar *buf, int32_t len)
1439{
1440#if defined WITH_COOLAPI  || defined WITH_COOLAPI2
1441    // driver sometimes reports error if too many emm filter
1442    // but adding more ecm filter is no problem
1443    // ... so ifdef here instead of limiting MAX_FILTER
1444    demux[demux_id].max_emm_filter = 14;
1445#else
1446    if(cfg.dvbapi_requestmode == 1)
1447    {
1448        uint16_t ecm_filter_needed = 0, n;
1449        for(n = 0; n < demux[demux_id].ECMpidcount; n++)
1450        {
1451            if(demux[demux_id].ECMpids[n].status > -1)
1452                { ecm_filter_needed++; }
1453        }
1454        if(maxfilter - ecm_filter_needed <= 0)
1455            { demux[demux_id].max_emm_filter = 0; }
1456        else
1457            { demux[demux_id].max_emm_filter = maxfilter - ecm_filter_needed; }
1458    }
1459    else
1460    {
1461        demux[demux_id].max_emm_filter = maxfilter - 1;
1462    }
1463#endif
1464    uint16_t i, k;
1465
1466    cs_log_dump_dbg(D_DVBAPI, buf, len, "cat:");
1467
1468    for(i = 8; i < (b2i(2, buf + 1)&0xFFF) - 1; i += buf[i + 1] + 2)
1469    {
1470        if(buf[i] != 0x09) { continue; }
1471        if(demux[demux_id].EMMpidcount >= ECM_PIDS) { break; }
1472
1473        uint16_t caid = b2i(2, buf + i + 2);
1474        uint16_t emm_pid = b2i(2, buf + i +4)&0x1FFF;
1475        uint32_t emm_provider = 0;
1476
1477        switch(caid >> 8)
1478        {
1479            case 0x01:
1480                dvbapi_add_emmpid(demux_id, caid, emm_pid, 0, EMM_UNIQUE | EMM_GLOBAL);
1481                for(k = i + 7; k < i + buf[i + 1] + 2; k += 4)
1482                {
1483                    emm_provider = b2i(2, buf + k + 2);
1484                    emm_pid = b2i(2, buf + k)&0xFFF;
1485                    dvbapi_add_emmpid(demux_id, caid, emm_pid, emm_provider, EMM_SHARED);
1486                }
1487                break;
1488            case 0x05:
1489                for(k = i + 6; k < i + buf[i + 1] + 2; k += buf[k + 1] + 2)
1490                {
1491                    if (buf[k] == 0x14)
1492                    {
1493                        emm_provider = (b2i(3, buf + k + 2) & 0xFFFFF0); // viaccess fixup last digit is a dont care!
1494                        dvbapi_add_emmpid(demux_id, caid, emm_pid, emm_provider, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
1495                    }
1496                }
1497                break;
1498            case 0x18:
1499                if(buf[i + 1] == 0x07 || buf[i + 1] == 0x0B)
1500                {
1501                    for(k = i + 7; k < i + 7 + buf[i + 6]; k += 2)
1502                    {
1503                        emm_provider = b2i(2, buf + k);
1504                        dvbapi_add_emmpid(demux_id, caid, emm_pid, emm_provider, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
1505                    }
1506                }
1507                else
1508                {
1509                    dvbapi_add_emmpid(demux_id, caid, emm_pid, emm_provider, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
1510                }
1511                break;
1512            default:
1513                dvbapi_add_emmpid(demux_id, caid, emm_pid, 0, EMM_UNIQUE | EMM_SHARED | EMM_GLOBAL);
1514                break;
1515        }
1516    }
1517    return;
1518}
1519
1520static pthread_mutex_t lockindex;
1521int32_t dvbapi_get_descindex(int32_t demux_index)
1522{
1523    int32_t i, j, idx = 1, fail = 1;
1524   
1525    static int8_t init_mutex = 0;
1526    if(init_mutex == 0)
1527    {
1528        SAFE_MUTEX_INIT(&lockindex, NULL);
1529        init_mutex = 1; 
1530    }
1531   
1532    if(cfg.dvbapi_boxtype == BOXTYPE_NEUMO)
1533    {
1534        idx = 0;
1535        sscanf(demux[demux_index].pmt_file, "pmt%3d.tmp", &idx);
1536        idx++; // fixup
1537        return idx;
1538    }
1539    SAFE_MUTEX_LOCK(&lockindex); // to avoid race when readers become responsive!
1540   
1541    while(fail)
1542    {
1543        fail = 0;
1544        for(i = 0; i < MAX_DEMUX && !fail; i++)
1545        {
1546            if(demux[i].program_number == 0) { continue; }  // skip empty demuxers
1547           
1548            if(demux[i].ca_mask != demux[demux_index].ca_mask && (!(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)))
1549            {
1550                continue; // skip demuxer using other ca device
1551            }
1552           
1553            for(j = 0; j < demux[i].ECMpidcount && !fail; j++) // search for new unique index
1554            {
1555                if(demux[i].ECMpids[j].index == idx) 
1556                {
1557                    fail = 1;
1558                    idx++;
1559                }
1560            }
1561        }
1562        cs_sleepms(1);
1563    }
1564   
1565    SAFE_MUTEX_UNLOCK(&lockindex); // and release it!
1566    return idx;
1567}
1568
1569void dvbapi_set_pid(int32_t demux_id, int32_t num, int32_t idx, bool enable)
1570{
1571    int32_t i, currentfd, newidx = 0xFF;
1572    if(demux[demux_id].pidindex == -1 && enable) return; // no current pid on enable? --> exit
1573
1574    switch(selected_api)
1575    {
1576#if defined(WITH_STAPI) || defined(WITH_STAPI5)
1577    case STAPI:
1578        if(!enable) idx = -1;
1579        stapi_set_pid(demux_id, num, idx, demux[demux_id].STREAMpids[num], demux[demux_id].pmt_file); // only used to disable pids!!!
1580        break;
1581#endif
1582#if defined WITH_COOLAPI || defined WITH_COOLAPI2
1583    case COOLAPI:
1584        break;
1585#endif
1586    default:
1587        for(i = 0; i < MAX_DEMUX; i++)
1588        {
1589            if(((demux[demux_id].ca_mask & (1 << i)) == (uint) (1 << i)))
1590            {   
1591                int8_t action = 0;
1592                if(enable){
1593                    action = update_streampid_list(i, demux[demux_id].STREAMpids[num], idx);
1594                }
1595                if(!enable){
1596                    action = remove_streampid_from_list(i, demux[demux_id].STREAMpids[num], idx);
1597                }
1598               
1599                if(action != NO_STREAMPID_LISTED && action != FOUND_STREAMPID_INDEX && action != ADDED_STREAMPID_INDEX)
1600                {
1601                    ca_pid_t ca_pid2;
1602                    memset(&ca_pid2, 0, sizeof(ca_pid2));
1603                    ca_pid2.pid = demux[demux_id].STREAMpids[num];
1604                   
1605                    // removed last of this streampid on ca? -> disable this pid with -1 on this ca
1606                    if((action == REMOVED_STREAMPID_LASTINDEX) && (is_ca_used(i, ca_pid2.pid) == CA_IS_CLEAR)) idx = -1; 
1607                   
1608                    // removed index of streampid that is used to decode on ca -> get a fresh one
1609                    if(action == REMOVED_DECODING_STREAMPID_INDEX)
1610                    {
1611                        newidx = is_ca_used(i, demux[demux_id].STREAMpids[num]); // get an active index for this pid and enable it on ca device
1612                        idx = -1;
1613                    }
1614
1615                    while (idx !=0xFF || newidx !=0xFF)
1616                    {
1617                        if(idx !=0xFF)
1618                        {
1619                            ca_pid2.index = idx;
1620                            cs_log_dbg(D_DVBAPI, "Demuxer %d %s stream %d pid=0x%04x index=%d on ca%d", demux_id,
1621                                (enable ? "enable" : "disable"), num + 1, ca_pid2.pid, ca_pid2.index, i);
1622                            idx = 0xFF; // flag this index as handled
1623                        }
1624                        else if (newidx !=0xFF)
1625                        {
1626                            ca_pid2.index = newidx;
1627                            cs_log_dbg(D_DVBAPI, "Demuxer %d takeover stream %d pid=0x%04x by index=%d on ca%d", demux_id, num + 1,
1628                                ca_pid2.pid, ca_pid2.index, i);
1629                            newidx = 0xFF; // flag this takeover / new index as handled
1630                        }
1631
1632                        if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)
1633                            dvbapi_net_send(DVBAPI_CA_SET_PID, demux[demux_id].socket_fd, demux_id, -1 /*unused*/, (unsigned char *) &ca_pid2, NULL, NULL);
1634                        else
1635                        {
1636                            currentfd = ca_fd[i];
1637                            if(currentfd <= 0)
1638                            {
1639                                currentfd = dvbapi_open_device(1, i, demux[demux_id].adapter_index);
1640                                ca_fd[i] = currentfd; // save fd of this ca
1641                            }
1642                            if(currentfd > 0)
1643                            {
1644                                if(dvbapi_ioctl(currentfd, CA_SET_PID, &ca_pid2) == -1)
1645                                {
1646                                    cs_log_dbg(D_TRACE | D_DVBAPI,"CA_SET_PID ioctl error (errno=%d %s)", errno, strerror(errno));
1647                                    remove_streampid_from_list(i, ca_pid2.pid, ca_pid2.index);
1648                                }
1649                                int8_t result = is_ca_used(i,0); // check if in use by any pid
1650                                if(result == CA_IS_CLEAR)
1651                                {
1652                                    cs_log_dbg(D_DVBAPI, "Demuxer %d close now unused CA%d device", demux_id, i);
1653                                    int32_t ret = close(currentfd);
1654                                    if(ret < 0) { cs_log("ERROR: Could not close demuxer fd (errno=%d %s)", errno, strerror(errno)); }
1655                                    currentfd = ca_fd[i] = 0;
1656                                }
1657                            }
1658                        }
1659                    }
1660                }
1661            }
1662        }
1663        break;
1664    }
1665    return;
1666}
1667
1668void dvbapi_stop_all_descrambling(void)
1669{
1670    int32_t j;
1671    for(j = 0; j < MAX_DEMUX; j++)
1672    {
1673        if(demux[j].program_number == 0) { continue; }
1674        dvbapi_stop_descrambling(j);
1675    }
1676}
1677
1678void dvbapi_stop_descrambling(int32_t demux_id)
1679{
1680    int32_t i;
1681    if(demux[demux_id].program_number == 0) { return; }
1682    char channame[CS_SERVICENAME_SIZE];
1683    i = demux[demux_id].pidindex;
1684    if(i < 0) { i = 0; }
1685    demux[demux_id].pidindex = -1; // no ecmpid is to be descrambling since we start stop descrambling!
1686    get_servicename(dvbapi_client, demux[demux_id].program_number, demux[demux_id].ECMpidcount > 0 ? demux[demux_id].ECMpids[i].PROVID : 0, demux[demux_id].ECMpidcount > 0 ? demux[demux_id].ECMpids[i].CAID : 0, channame, sizeof(channame));
1687    cs_log_dbg(D_DVBAPI, "Demuxer %d stop descrambling program number %04X (%s)", demux_id, demux[demux_id].program_number, channame);
1688   
1689    dvbapi_stop_filter(demux_id, TYPE_EMM);
1690    dvbapi_stop_filter(demux_id, TYPE_SDT);
1691   
1692    if(demux[demux_id].ECMpidcount > 0)
1693    {
1694        dvbapi_stop_filter(demux_id, TYPE_ECM);
1695    }
1696   
1697    if(selected_api == STAPI) // just disable all streams since stapi enables them all while writing first found cw too!
1698    {
1699        for(i = 0; i < demux[demux_id].STREAMpidcount; i++)
1700        {
1701            dvbapi_set_pid(demux_id, i, -1, false); // disable streampid
1702        }
1703    }
1704   
1705    memset(&demux[demux_id], 0 , sizeof(DEMUXTYPE));
1706    demux[demux_id].pidindex = -1;
1707    demux[demux_id].curindex = -1;
1708    if (!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX)
1709        unlink(ECMINFO_FILE);
1710    return;
1711}
1712
1713int32_t dvbapi_start_descrambling(int32_t demux_id, int32_t pid, int8_t checked)
1714{
1715    int32_t started = 0; // in case ecmfilter started = 1
1716    int32_t fake_ecm = 0;
1717    ECM_REQUEST *er;
1718    struct s_reader *rdr;
1719    if(!(er = get_ecmtask())) { return started; }
1720    demux[demux_id].ECMpids[pid].checked = checked + 1; // mark this pid as checked!
1721
1722    struct s_dvbapi_priority *p;
1723    for(p = dvbapi_priority; p != NULL ; p = p->next)
1724    {
1725        if((p->type != 'p')
1726                || (p->caid && p->caid != demux[demux_id].ECMpids[pid].CAID)
1727                || (p->provid && p->provid != demux[demux_id].ECMpids[pid].PROVID)
1728                || (p->ecmpid && p->ecmpid != demux[demux_id].ECMpids[pid].ECM_PID)
1729                || (p->srvid && p->srvid != demux[demux_id].program_number)
1730                || (p->pidx && p->pidx-1 != pid))
1731            { continue; }
1732        // if found chid and first run apply chid filter, on forced pids always apply!
1733        if(p->type == 'p' && p->chid < 0x10000 && (demux[demux_id].ECMpids[pid].checked == 1 || (p && p->force)))
1734        {
1735            if(demux[demux_id].ECMpids[pid].CHID < 0x10000)   // channelcache delivered chid
1736            {
1737                er->chid = demux[demux_id].ECMpids[pid].CHID;
1738            }
1739            else
1740            {
1741                er->chid = p->chid; // no channelcache or no chid in use, so use prio chid
1742                demux[demux_id].ECMpids[pid].CHID = p->chid;
1743            }
1744            //cs_log("********* CHID %04X **************", demux[demux_id].ECMpids[pid].CHID);
1745            break; // we only accept one!
1746        }
1747        else
1748        {
1749            if(demux[demux_id].ECMpids[pid].CHID < 0x10000)   // channelcache delivered chid
1750            {
1751                er->chid = demux[demux_id].ECMpids[pid].CHID;
1752            }
1753            else   // no channelcache or no chid in use
1754            {
1755                er->chid = 0;
1756                demux[demux_id].ECMpids[pid].CHID = 0x10000;
1757            }
1758        }
1759    }
1760    er->srvid = demux[demux_id].program_number;
1761    er->caid  = demux[demux_id].ECMpids[pid].CAID;
1762    er->pid   = demux[demux_id].ECMpids[pid].ECM_PID;
1763    er->prid  = demux[demux_id].ECMpids[pid].PROVID;
1764    er->vpid  = demux[demux_id].ECMpids[pid].VPID;
1765    er->pmtpid  = demux[demux_id].pmtpid;
1766
1767#ifdef WITH_STAPI5
1768    cs_strncpy(er->dev_name, dev_list[demux[demux_id].dev_index].name, sizeof(dev_list[demux[demux_id].dev_index].name));
1769#endif 
1770
1771    struct timeb now;
1772    cs_ftime(&now);
1773    for(rdr = first_active_reader; rdr != NULL ; rdr = rdr->next)
1774    {
1775        int8_t match = matching_reader(er, rdr); // check for matching reader
1776        int64_t gone = comp_timeb(&now, &rdr->emm_last);
1777        if(gone > 3600*1000 && rdr->needsemmfirst && caid_is_irdeto(er->caid))
1778        {
1779            cs_log("Warning reader %s received no emms for the last %d seconds -> skip, this reader needs emms first!", rdr->label,
1780                   (int)(gone/1000));
1781            continue; // skip this card needs to process emms first before it can be used for descramble
1782        }
1783        if(p && p->force) { match = 1; }  // forced pid always started!
1784
1785        if(!match) // if this reader does not match, check betatunnel for it
1786            match = lb_check_auto_betatunnel(er, rdr);
1787
1788        if(!match && chk_is_betatunnel_caid(er->caid))  // these caids might be tunneled invisible by peers
1789            { match = 1; } // so make it a match to try it!
1790
1791        if(config_enabled(CS_CACHEEX) && (!match && (cacheex_is_match_alias(dvbapi_client, er))))   // check if cache-ex is matching
1792        {
1793            match = 1; // so make it a match to try it!
1794        }
1795
1796        // BISS or FAKE CAID
1797        // ecm stream pid is fake, so send out one fake ecm request
1798        // special treatment: if we asked the cw first without starting a filter the cw request will be killed due to no ecmfilter started
1799        if(caid_is_fake(demux[demux_id].ECMpids[pid].CAID) || caid_is_biss(demux[demux_id].ECMpids[pid].CAID))
1800        {
1801            int32_t j, n;
1802            er->ecmlen = 5;
1803            er->ecm[0] = 0x80; // to pass the cache check it must be 0x80 or 0x81
1804            er->ecm[1] = 0x00;
1805            er->ecm[2] = 0x02;
1806            i2b_buf(2, er->srvid, er->ecm + 3);
1807
1808            for(j = 0, n = 5; j < demux[demux_id].STREAMpidcount; j++, n += 2)
1809            {
1810                i2b_buf(2, demux[demux_id].STREAMpids[j], er->ecm + n);
1811                er->ecm[2] += 2;
1812                er->ecmlen += 2;
1813            }
1814
1815            cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X ANY CHID PMTPID %04X VPID %04X", demux_id, pid,
1816                   demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].PROVID, demux[demux_id].ECMpids[pid].ECM_PID,
1817                   demux[demux_id].pmtpid, demux[demux_id].ECMpids[pid].VPID);
1818
1819            demux[demux_id].curindex = pid; // set current pid to the fresh started one
1820
1821            dvbapi_start_filter(demux_id, pid, demux[demux_id].ECMpids[pid].ECM_PID, demux[demux_id].ECMpids[pid].CAID,
1822                                demux[demux_id].ECMpids[pid].PROVID, 0x80, 0xF0, 3000, TYPE_ECM);
1823            started = 1;
1824
1825            request_cw(dvbapi_client, er, demux_id, 0); // do not register ecm since this try!
1826            fake_ecm = 1;
1827            break; // we started an ecmfilter so stop looking for next matching reader!
1828        }
1829        if(match)   // if matching reader found check for irdeto cas if local irdeto card check if it received emms in last 60 minutes
1830        {
1831
1832            if(caid_is_irdeto(er->caid))   // irdeto cas init irdeto_curindex to wait for first index (00)
1833            {
1834                if(demux[demux_id].ECMpids[pid].irdeto_curindex == 0xFE) { demux[demux_id].ECMpids[pid].irdeto_curindex = 0x00; }
1835            }
1836
1837            if(p && p->chid < 0x10000)  // do we prio a certain chid?
1838            {
1839                cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X CHID %04X PMTPID %04X VPID %04X", demux_id, pid,
1840                       demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].PROVID, demux[demux_id].ECMpids[pid].ECM_PID,
1841                       demux[demux_id].ECMpids[pid].CHID, demux[demux_id].pmtpid, demux[demux_id].ECMpids[pid].VPID);
1842            }
1843            else
1844            {
1845                cs_log("Demuxer %d trying to descramble PID %d CAID %04X PROVID %06X ECMPID %04X ANY CHID PMTPID %04X VPID %04X", demux_id, pid,
1846                       demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].PROVID, demux[demux_id].ECMpids[pid].ECM_PID,
1847                       demux[demux_id].pmtpid, demux[demux_id].ECMpids[pid].VPID);
1848            }
1849
1850            demux[demux_id].curindex = pid; // set current pid to the fresh started one
1851
1852            dvbapi_start_filter(demux_id, pid, demux[demux_id].ECMpids[pid].ECM_PID, demux[demux_id].ECMpids[pid].CAID,
1853                                demux[demux_id].ECMpids[pid].PROVID, 0x80, 0xF0, 3000, TYPE_ECM);
1854            started = 1;
1855            break; // we started an ecmfilter so stop looking for next matching reader!
1856        }
1857    }
1858    if(demux[demux_id].curindex != pid)
1859    {
1860        cs_log("Demuxer %d impossible to descramble PID %d CAID %04X PROVID %06X ECMPID %04X PMTPID %04X (NO MATCHING READER)", demux_id, pid,
1861               demux[demux_id].ECMpids[pid].CAID, demux[demux_id].ECMpids[pid].PROVID, demux[demux_id].ECMpids[pid].ECM_PID, demux[demux_id].pmtpid);
1862        demux[demux_id].ECMpids[pid].checked = 4; // flag this pid as checked
1863        demux[demux_id].ECMpids[pid].status = -1; // flag this pid as unusable
1864        dvbapi_edit_channel_cache(demux_id, pid, 0); // remove this pid from channelcache
1865    }
1866    if(!fake_ecm) { NULLFREE(er); }
1867    return started;
1868}
1869
1870struct s_dvbapi_priority *dvbapi_check_prio_match_emmpid(int32_t demux_id, uint16_t caid, uint32_t provid, char type)
1871{
1872    struct s_dvbapi_priority *p;
1873    int32_t i;
1874
1875    uint16_t ecm_pid = 0;
1876    for(i = 0; i < demux[demux_id].ECMpidcount; i++)
1877    {
1878        if((demux[demux_id].ECMpids[i].CAID == caid) && (demux[demux_id].ECMpids[i].PROVID == provid))
1879        {
1880            ecm_pid = demux[demux_id].ECMpids[i].ECM_PID;
1881            break;
1882        }
1883    }
1884
1885    if(!ecm_pid)
1886        { return NULL; }
1887
1888    for(p = dvbapi_priority; p != NULL; p = p->next)
1889    {
1890        if(p->type != type
1891                || (p->caid && p->caid != caid)
1892                || (p->provid && p->provid != provid)
1893                || (p->ecmpid && p->ecmpid != ecm_pid)
1894                || (p->srvid && p->srvid != demux[demux_id].program_number)
1895                || (p->pidx && p->pidx-1 !=i)
1896                || (p->type == 'i' && (p->chid < 0x10000)))
1897            { continue; }
1898        return p;
1899    }
1900    return NULL;
1901}
1902
1903struct s_dvbapi_priority *dvbapi_check_prio_match(int32_t demux_id, int32_t pidindex, char type)
1904{   
1905    if(!dvbapi_priority)
1906    {
1907        return NULL;
1908    }
1909    struct s_dvbapi_priority *p;
1910    struct s_ecmpids *ecmpid = &demux[demux_id].ECMpids[pidindex];
1911
1912    for(p = dvbapi_priority; p != NULL; p = p->next)
1913    {
1914        if(p->type != type
1915                || (p->caid && p->caid != ecmpid->CAID)
1916                || (p->provid && p->provid != ecmpid->PROVID)
1917                || (p->ecmpid && p->ecmpid != ecmpid->ECM_PID)
1918                || (p->srvid && p->srvid != demux[demux_id].program_number)
1919                || (p->pidx && p->pidx-1 != pidindex)
1920                || (p->chid < 0x10000 && p->chid != ecmpid->CHID))
1921            { continue; }
1922        return p;
1923    }
1924    return NULL;
1925}
1926
1927void dvbapi_process_emm(int32_t demux_index, int32_t filter_num, unsigned char *buffer, uint32_t len)
1928{
1929    EMM_PACKET epg;
1930
1931    struct s_emm_filter *filter = get_emmfilter_by_filternum(demux_index, filter_num+1); // 0 is used for pending emmfilters, so everything increase 1
1932
1933    if(!filter)
1934    {
1935        cs_log_dbg(D_DVBAPI, "Demuxer %d Filter %d no filter matches -> SKIP!", demux_index, filter_num +1);
1936        return;
1937    }
1938
1939    uint32_t provider = filter->provid;
1940    uint16_t caid = filter->caid;
1941
1942    struct s_dvbapi_priority *mapentry = dvbapi_check_prio_match_emmpid(filter->demux_id, filter->caid, filter->provid, 'm');
1943    if(mapentry)
1944    {
1945        cs_log_dbg(D_DVBAPI, "Demuxer %d mapping EMM from %04X@%06X to %04X@%06X", demux_index, caid, provider, mapentry->mapcaid,
1946                      mapentry->mapprovid);
1947        caid = mapentry->mapcaid;
1948        provider = mapentry->mapprovid;
1949    }
1950
1951    memset(&epg, 0, sizeof(epg));
1952
1953    i2b_buf(2, caid, epg.caid);
1954    i2b_buf(4, provider, epg.provid);
1955
1956    epg.emmlen = len > sizeof(epg.emm) ? sizeof(epg.emm) : len;
1957    memcpy(epg.emm, buffer, epg.emmlen);
1958
1959    if(config_enabled(READER_IRDETO) && chk_is_betatunnel_caid(caid) == 2)
1960    {
1961        uint16_t ncaid = tunemm_caid_map(FROM_TO, caid, demux[demux_index].program_number);
1962        if(caid != ncaid)
1963        {
1964            irdeto_add_emm_header(&epg);
1965            i2b_buf(2, ncaid, epg.caid);
1966        }
1967    }
1968
1969    do_emm(dvbapi_client, &epg);
1970}
1971
1972void dvbapi_read_priority(void)
1973{
1974    FILE *fp;
1975    char token[128], str1[128];
1976    char type;
1977    int32_t i, ret, count = 0;
1978
1979    const char *cs_prio = "oscam.dvbapi";
1980
1981    fp = fopen(get_config_filename(token, sizeof(token), cs_prio), "r");
1982
1983    if(!fp)
1984    {
1985        cs_log_dbg(D_DVBAPI, "ERROR: Can't open priority file %s", token);
1986        return;
1987    }
1988
1989    if(dvbapi_priority)
1990    {
1991        cs_log_dbg(D_DVBAPI, "reread priority file %s", cs_prio);
1992        struct s_dvbapi_priority *o, *p;
1993        for(p = dvbapi_priority; p != NULL; p = o)
1994        {
1995            o = p->next;
1996            NULLFREE(p);
1997        }
1998        dvbapi_priority = NULL;
1999    }
2000
2001    while(fgets(token, sizeof(token), fp))
2002    {
2003        // Ignore comments and empty lines
2004        if(token[0] == '#' || token[0] == '/' || token[0] == '\n' || token[0] == '\r' || token[0] == '\0')
2005            { continue; }
2006        if(strlen(token) > 100) { continue; }
2007
2008        memset(str1, 0, 128);
2009
2010        for(i = 0; i < (int)strlen(token) && token[i] == ' '; i++) { ; }
2011        if(== (int)strlen(token) - 1)  //empty line or all spaces
2012            { continue; }
2013
2014        for(i = 0; i < (int)strlen(token); i++)
2015        {
2016            if(token[i] == '@')
2017            {
2018                token[i] = ':';
2019            }   
2020        }
2021       
2022        for(i = 0; i < (int)strlen(token); i++)
2023        {
2024            if((token[i] == ':' || token[i] == ' ') && token[i + 1] == ':')  // if "::" or " :"
2025            {
2026                memmove(token + i + 2, token + i + 1, strlen(token) - i + 1); //insert extra position
2027                token[i + 1] = '0'; //and fill it with NULL
2028            }
2029            if(token[i] == '#' || token[i] == '/')
2030            {
2031                token[i] = '\0';
2032                break;
2033            }
2034        }
2035
2036        type = 0;
2037#if defined(WITH_STAPI) || defined(WITH_STAPI5)
2038        uint32_t disablefilter = 0;
2039        ret = sscanf(trim(token), "%c: %63s %63s %d", &type, str1, str1 + 64, &disablefilter);
2040#else
2041        ret = sscanf(trim(token), "%c: %63s %63s", &type, str1, str1 + 64);
2042#endif
2043        type = tolower((uchar)type);
2044
2045        if(ret < 1 || (type != 'p' && type != 'i' && type != 'm' && type != 'd' && type != 's' && type != 'l'
2046                       && type != 'j' && type != 'a' && type != 'x'))
2047        {
2048            //fprintf(stderr, "Warning: line containing %s in %s not recognized, ignoring line\n", token, cs_prio);
2049            //fprintf would issue the warning to the command line, which is more consistent with other config warnings
2050            //however it takes OSCam a long time (>4 seconds) to reach this part of the program, so the warnings are reaching tty rather late
2051            //which leads to confusion. So send the warnings to log file instead
2052            cs_log_dbg(D_DVBAPI, "WARN: line containing %s in %s not recognized, ignoring line\n", token, cs_prio);
2053            continue;
2054        }
2055
2056        struct s_dvbapi_priority *entry;
2057        if(!cs_malloc(&entry, sizeof(struct s_dvbapi_priority)))
2058        {
2059            ret = fclose(fp);
2060            if(ret < 0) { cs_log("ERROR: Could not close oscam.dvbapi fd (errno=%d %s)", errno, strerror(errno)); }
2061            return;
2062        }
2063
2064        entry->type = type;
2065        entry->next = NULL;
2066
2067        count++;
2068
2069#if defined(WITH_STAPI) || defined(WITH_STAPI5)
2070        if(type == 's')
2071        {
2072            strncpy(entry->devname, str1, 29);
2073            strncpy(entry->pmtfile, str1 + 64, 29);
2074
2075            entry->disablefilter = disablefilter;
2076
2077            cs_log_dbg(D_DVBAPI, "stapi prio: ret=%d | %c: %s %s | disable %d",
2078                          ret, type, entry->devname, entry->pmtfile, disablefilter);
2079
2080            if(!dvbapi_priority)
2081            {
2082                dvbapi_priority = entry;
2083            }
2084            else
2085            {
2086                struct s_dvbapi_priority *p;
2087                for(p = dvbapi_priority; p->next != NULL; p = p->next) { ; }
2088                p->next = entry;
2089            }
2090            continue;
2091        }
2092#endif
2093
2094        char c_srvid[34];
2095        c_srvid[0] = '\0';
2096        uint32_t caid = 0, provid = 0, srvid = 0, ecmpid = 0;
2097        uint32_t chid = 0x10000; //chid=0 is a valid chid
2098        ret = sscanf(str1, "%4x:%6x:%33[^:]:%4x:%4x"SCNx16, &caid, &provid, c_srvid, &ecmpid, &chid);
2099        if(ret < 1)
2100        {
2101            cs_log("Error in oscam.dvbapi: ret=%d | %c: %04X %06X %s %04X %04X",
2102                   ret, type, caid, provid, c_srvid, ecmpid, chid);
2103            continue; // skip this entry!
2104        }
2105        else
2106        {
2107            cs_log_dbg(D_DVBAPI, "Parsing rule: ret=%d | %c: %04X %06X %s %04X %04X",
2108                          ret, type, caid, provid, c_srvid, ecmpid, chid);
2109        }
2110
2111        entry->caid = caid;
2112        entry->provid = provid;
2113        entry->ecmpid = ecmpid;
2114        entry->chid = chid;
2115
2116        uint32_t delay = 0, force = 0, mapcaid = 0, mapprovid = 0, mapecmpid = 0, pidx = 0;
2117        switch(type)
2118        {
2119        case 'i':
2120            ret = sscanf(str1 + 64, "%1d", &pidx);
2121            entry->pidx = pidx+1;
2122            if(ret < 1) entry->pidx = 0;
2123            break;
2124        case 'd':
2125            sscanf(str1 + 64, "%4d", &delay);
2126            entry->delay = delay;
2127            break;
2128        case 'l':
2129            entry->delay = dyn_word_atob(str1 + 64);
2130            if(entry->delay == -1) { entry->delay = 0; }
2131            break;
2132        case 'p':
2133            ret = sscanf(str1 + 64, "%1d:%1d", &force, &pidx);
2134            entry->force = force;
2135            entry->pidx = pidx+1;
2136            if(ret < 2) entry->pidx = 0;
2137            break;
2138        case 'm':
2139            sscanf(str1 + 64, "%4x:%6x", &mapcaid, &mapprovid);
2140            if(!mapcaid) { mapcaid = 0xFFFF; }
2141            entry->mapcaid = mapcaid;
2142            entry->mapprovid = mapprovid;
2143            break;
2144        case 'a':
2145        case 'j':
2146            sscanf(str1 + 64, "%4x:%6x:%4x", &mapcaid, &mapprovid, &mapecmpid);
2147            if(!mapcaid) { mapcaid = 0xFFFF; }
2148            entry->mapcaid = mapcaid;
2149            entry->mapprovid = mapprovid;
2150            entry->mapecmpid = mapecmpid;
2151            break;
2152        }
2153
2154        if(c_srvid[0] == '=')
2155        {
2156            struct s_srvid *this;
2157
2158            for(i = 0; i < 16; i++)
2159                for(this = cfg.srvid[i]; this != NULL; this = this->next)
2160                {
2161                    if(this->name && strcmp(this->name, c_srvid + 1) == 0)
2162                    {
2163                        struct s_dvbapi_priority *entry2;
2164                        if(!cs_malloc(&entry2, sizeof(struct s_dvbapi_priority)))
2165                            { continue; }
2166                        memcpy(entry2, entry, sizeof(struct s_dvbapi_priority));
2167
2168                        entry2->srvid = this->srvid;
2169
2170                        cs_log_dbg(D_DVBAPI, "prio srvid: ret=%d | %c: %04X %06X %04X %04X %04X -> map %04X %06X %04X | prio %d | delay %d",
2171                                      ret, entry2->type, entry2->caid, entry2->provid, entry2->srvid, entry2->ecmpid, entry2->chid,
2172                                      entry2->mapcaid, entry2->mapprovid, entry2->mapecmpid, entry2->force, entry2->delay);
2173
2174                        if(!dvbapi_priority)
2175                        {
2176                            dvbapi_priority = entry2;
2177                        }
2178                        else
2179                        {
2180                            struct s_dvbapi_priority *p;
2181                            for(p = dvbapi_priority; p->next != NULL; p = p->next) { ; }
2182                            p->next = entry2;
2183                        }
2184                    }
2185                }
2186            NULLFREE(entry);
2187            continue;
2188        }
2189        else
2190        {
2191            sscanf(c_srvid, "%4x", &srvid);
2192            entry->srvid = srvid;
2193        }
2194
2195        cs_log_dbg(D_DVBAPI, "prio: ret=%d | %c: %04X %06X %04X %04X %04X -> map %04X %06X %04X | prio %d | delay %d",
2196                      ret, entry->type, entry->caid, entry->provid, entry->srvid, entry->ecmpid, entry->chid, entry->mapcaid,
2197                      entry->mapprovid, entry->mapecmpid, entry->force, entry->delay);
2198
2199        if(!dvbapi_priority)
2200        {
2201            dvbapi_priority = entry;
2202        }
2203        else
2204        {
2205            struct s_dvbapi_priority *p;
2206            for(p = dvbapi_priority; p->next != NULL; p = p->next) { ; }
2207            p->next = entry;
2208        }
2209    }
2210
2211    cs_log_dbg(D_DVBAPI, "Read %d entries from %s", count, cs_prio);
2212
2213    ret = fclose(fp);
2214    if(ret < 0) { cs_log("ERROR: Could not close oscam.dvbapi fd (errno=%d %s)", errno, strerror(errno)); }
2215    return;
2216}
2217
2218void dvbapi_resort_ecmpids(int32_t demux_index)
2219{
2220    int32_t n, cache = 0, matching_done = 0, found = -1, match_reader_count = 0, total_reader = 0;
2221    uint16_t btun_caid = 0;
2222    struct timeb start,end;
2223    cs_ftime(&start);
2224    for(n = 0; n < demux[demux_index].ECMpidcount; n++)
2225    {
2226        demux[demux_index].ECMpids[n].status = 0;
2227        demux[demux_index].ECMpids[n].checked = 0;
2228        demux[demux_index].ECMpids[n].irdeto_curindex = 0xFE;
2229        demux[demux_index].ECMpids[n].irdeto_maxindex = 0;
2230        demux[demux_index].ECMpids[n].irdeto_cycle = 0xFE;
2231        demux[demux_index].ECMpids[n].tries = 0xFE;
2232        demux[demux_index].ECMpids[n].table = 0;
2233    }
2234
2235    demux[demux_index].max_status = 0;
2236    demux[demux_index].curindex = -1;
2237    demux[demux_index].pidindex = -1;
2238
2239
2240    struct s_reader *rdr;
2241       
2242    int32_t p_order = demux[demux_index].ECMpidcount+1;
2243    struct s_dvbapi_priority *prio;
2244   
2245    // handle prio order in oscam.dvbapi + ignore all chids
2246   
2247    for(rdr = first_active_reader; rdr ; rdr = rdr->next)
2248    {
2249        total_reader++; // only need to calculate once!
2250    }
2251   
2252    ECM_REQUEST *er;
2253    if(!cs_malloc(&er, sizeof(ECM_REQUEST)))
2254        { return; }
2255   
2256    for(prio = dvbapi_priority; prio != NULL; prio = prio->next)
2257    {
2258        if(prio->type != 'p' && prio->type != 'i' )
2259            { continue; }
2260        for(n = 0; n < demux[demux_index].ECMpidcount; n++)
2261        {
2262            if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2263            er->caid = er->ocaid = demux[demux_index].ECMpids[n].CAID;
2264            er->prid = demux[demux_index].ECMpids[n].PROVID;
2265            er->pid = demux[demux_index].ECMpids[n].ECM_PID;
2266            er->srvid = demux[demux_index].program_number;
2267            er->client = cur_client();
2268            btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
2269            if(prio->type == 'p' && btun_caid)
2270            {
2271                er->caid = btun_caid;
2272            }
2273           
2274            if(prio->caid && (prio->caid != er->caid && prio->caid != er->ocaid)) { continue; }
2275            if(prio->provid && prio->provid != er->prid) { continue; }
2276            if(prio->srvid && prio->srvid != er->srvid) { continue; }
2277            if(prio->ecmpid && prio->ecmpid != er->pid) { continue; }
2278            if(prio->pidx && prio->pidx-1 != n) { continue; }
2279           
2280            if(prio->type == 'p') // check for prio
2281            {
2282                if(prio->chid < 0x10000) { demux[demux_index].ECMpids[n].CHID = prio->chid; }
2283                if(prio->force)
2284                {
2285                    int32_t j;
2286                    for(j = 0; j < demux[demux_index].ECMpidcount; j++)
2287                    {
2288                        demux[demux_index].ECMpids[j].status = -1;
2289                    }
2290                    demux[demux_index].ECMpids[n].status = 1;
2291                    demux[demux_index].ECMpids[n].checked = 0;
2292                    demux[demux_index].max_status = 1;
2293                    demux[demux_index].max_emm_filter = maxfilter - 1;
2294                    cs_log_dbg(D_DVBAPI, "Demuxer %d prio forced%s ecmpid %d %04X@%06X:%04X:%04X (file)", demux_index, 
2295                        ((prio->caid == er->caid && prio->caid != er->ocaid) ? " betatunneled" : ""), n, demux[demux_index].ECMpids[n].CAID,
2296                        demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID, (uint16_t) prio->chid);
2297                    NULLFREE(er);
2298                    return; // go start descrambling since its forced by user!
2299                }
2300                else
2301                {
2302                    if(!demux[demux_index].ECMpids[n].status) // only accept first matching prio from oscam.dvbapi
2303                    {
2304                        demux[demux_index].ECMpids[n].status = total_reader + p_order--;
2305                        matching_done = 1;
2306                        cs_log_dbg(D_DVBAPI, "Demuxer %d prio%s ecmpid %d %04X@%06X:%04X:%04X weight: %d (file)", demux_index,
2307                            ((prio->caid == er->caid && prio->caid != er->ocaid) ? " betatunneled" : ""), n, demux[demux_index].ECMpids[n].CAID,
2308                            demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID, (uint16_t) prio->chid, demux[demux_index].ECMpids[n].status);
2309                    }
2310                    continue; // evaluate next ecmpid
2311                }
2312            }
2313            if(prio->type == 'i' && prio->chid == 0x10000 && demux[demux_index].ECMpids[n].status == 0) // check for ignore all chids
2314            {
2315                cs_log_dbg(D_DVBAPI, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X all chids (file)", demux_index, n, demux[demux_index].ECMpids[n].CAID,
2316                    demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID);
2317                demux[demux_index].ECMpids[n].status = -1;
2318                continue; // evaluate next ecmpid
2319            }
2320        }
2321    }
2322   
2323    p_order = demux[demux_index].ECMpidcount+1;
2324   
2325    for(n = 0; n < demux[demux_index].ECMpidcount; n++)
2326    {   
2327        if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2328       
2329        int32_t nr;
2330        SIDTAB *sidtab;
2331        er->caid = er->ocaid = demux[demux_index].ECMpids[n].CAID;
2332        er->prid = demux[demux_index].ECMpids[n].PROVID;
2333        er->pid = demux[demux_index].ECMpids[n].ECM_PID;
2334        er->srvid = demux[demux_index].program_number;
2335        er->client = cur_client();
2336        btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
2337       
2338        if(btun_caid)
2339        { 
2340            er->caid = btun_caid;
2341        }
2342       
2343        match_reader_count = 0;
2344        for(rdr = first_active_reader; rdr ; rdr = rdr->next)
2345        {
2346            if(matching_reader(er, rdr))
2347            {
2348                match_reader_count++;
2349            }
2350        }
2351       
2352        if(match_reader_count == 0)
2353        {
2354            cs_log_dbg(D_DVBAPI, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X:%04X (no matching reader)", demux_index, n, demux[demux_index].ECMpids[n].CAID,
2355                demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID, demux[demux_index].ECMpids[n].CHID);
2356            demux[demux_index].ECMpids[n].status = -1;
2357            continue; // evaluate next ecmpid
2358        }   
2359        else
2360        {       
2361            for(nr = 0, sidtab = cfg.sidtab; sidtab; sidtab = sidtab->next, nr++)
2362            {
2363                if(sidtab->num_caid | sidtab->num_provid | sidtab->num_srvid)
2364                {
2365                    if((cfg.dvbapi_sidtabs.no & ((SIDTABBITS)1 << nr)) && (chk_srvid_match(er, sidtab)))
2366                    {
2367                        demux[demux_index].ECMpids[n].status = -1; //ignore
2368                        cs_log_dbg(D_DVBAPI, "Demuxer %d ignore ecmpid %d %04X@%06X:%04X (service %s pos %d)", demux_index,
2369                                  n, demux[demux_index].ECMpids[n].CAID, demux[demux_index].ECMpids[n].PROVID,
2370                                  demux[demux_index].ECMpids[n].ECM_PID, sidtab->label, nr);
2371                        continue; // evaluate next ecmpid
2372                    }
2373                    if((cfg.dvbapi_sidtabs.ok & ((SIDTABBITS)1 << nr)) && (chk_srvid_match(er, sidtab)))
2374                    {
2375                        demux[demux_index].ECMpids[n].status++; //priority
2376                        cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (service %s pos %d)", demux_index,
2377                                  n, demux[demux_index].ECMpids[n].CAID, demux[demux_index].ECMpids[n].PROVID,
2378                                  demux[demux_index].ECMpids[n].ECM_PID, demux[demux_index].ECMpids[n].status, sidtab->label,nr);
2379                    }
2380                }
2381            }
2382        }
2383   
2384        // ecmpids with no matching readers are disabled and matching sidtabbits have now highest status
2385       
2386    }
2387    // ecmpid with highest prio from oscam.dvbapi has now highest status
2388   
2389    // check all ecmpids and get the highest amount cache-ex and local readers
2390    int32_t max_local_matching_reader = 0, max_cacheex_reader = 0;
2391    for(n = 0; n < demux[demux_index].ECMpidcount; n++)
2392    {
2393        int32_t count_matching_cacheex_reader = 0, count_matching_local_reader = 0;
2394       
2395        if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2396       
2397        er->caid = er->ocaid = demux[demux_index].ECMpids[n].CAID;
2398        er->prid = demux[demux_index].ECMpids[n].PROVID;
2399        er->pid = demux[demux_index].ECMpids[n].ECM_PID;
2400        er->srvid = demux[demux_index].program_number;
2401        er->client = cur_client();
2402        btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
2403       
2404        if(btun_caid)
2405        { 
2406            er->caid = btun_caid;
2407        }
2408       
2409        for(rdr = first_active_reader; rdr ; rdr = rdr->next)
2410        {
2411            if(matching_reader(er, rdr))
2412            {
2413                if(cacheex_reader(rdr))
2414                {
2415                    count_matching_cacheex_reader++;
2416                }
2417                else if(is_localreader(rdr, er))
2418                {
2419                    count_matching_local_reader++;
2420                }
2421            }
2422        }
2423       
2424        if(max_local_matching_reader < count_matching_local_reader)
2425        {
2426            max_local_matching_reader = count_matching_local_reader;
2427        }
2428        if(max_cacheex_reader < count_matching_cacheex_reader)
2429        {
2430            max_cacheex_reader = count_matching_cacheex_reader;
2431        }
2432    }
2433   
2434    if(max_local_matching_reader != 0 || max_cacheex_reader != 0)
2435    {
2436        p_order = demux[demux_index].ECMpidcount*2;
2437       
2438        for(n = 0; n < demux[demux_index].ECMpidcount; n++)
2439        {
2440            int32_t count_matching_cacheex_reader = 0, count_matching_local_reader = 0;
2441            int32_t localprio = 1, cacheexprio = 1;
2442           
2443            if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2444           
2445            if(cfg.preferlocalcards == 2) // ecmpids with local reader get highest prio
2446            {
2447                localprio = max_cacheex_reader+p_order+1;
2448            }
2449            else if(cfg.preferlocalcards == 1) // ecmpids with cacheex reader get highest prio
2450            {
2451                cacheexprio = max_local_matching_reader+p_order+1;
2452            }
2453           
2454            er->caid = er->ocaid = demux[demux_index].ECMpids[n].CAID;
2455            er->prid = demux[demux_index].ECMpids[n].PROVID;
2456            er->pid = demux[demux_index].ECMpids[n].ECM_PID;
2457            er->srvid = demux[demux_index].program_number;
2458            er->client = cur_client();
2459            btun_caid = chk_on_btun(SRVID_MASK, er->client, er);
2460       
2461            if(btun_caid)
2462            { 
2463                er->caid = btun_caid;
2464            }
2465            int32_t oldstatus = demux[demux_index].ECMpids[n].status;
2466            int32_t anyreader = 0;
2467            for(rdr = first_active_reader; rdr ; rdr = rdr->next)
2468            {
2469                if(matching_reader(er, rdr))
2470                {
2471                    if(cfg.preferlocalcards == 0)
2472                    {
2473                        if(!matching_done) {demux[demux_index].ECMpids[n].status++;}
2474                        anyreader++;
2475                        continue;
2476                    }
2477                    if(cacheex_reader(rdr))
2478                    {
2479                        demux[demux_index].ECMpids[n].status += cacheexprio;
2480                        count_matching_cacheex_reader++;
2481                        cacheexprio=1;
2482                    }
2483                    if(is_localreader(rdr, er))
2484                    {
2485                        demux[demux_index].ECMpids[n].status += localprio;
2486                        count_matching_local_reader++;
2487                        localprio=1;
2488                    }
2489                }
2490            }
2491           
2492            if(oldstatus != demux[demux_index].ECMpids[n].status)
2493            {
2494                if(anyreader)
2495                {
2496                    cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X:%04X weight: %d (%d readers)", demux_index, n, demux[demux_index].ECMpids[n].CAID,
2497                    demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID, demux[demux_index].ECMpids[n].CHID, demux[demux_index].ECMpids[n].status, anyreader);
2498                }
2499                else
2500                {
2501                    cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X:%04X weight: %d (%d local and %d cacheex readers)", demux_index, n, demux[demux_index].ECMpids[n].CAID,
2502                        demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID, demux[demux_index].ECMpids[n].CHID, demux[demux_index].ECMpids[n].status,
2503                        count_matching_local_reader, count_matching_cacheex_reader);
2504                }
2505            }
2506        }
2507    }
2508   
2509    struct s_channel_cache *c = NULL;
2510
2511    for(n = 0; n < demux[demux_index].ECMpidcount && matching_done == 0; n++)
2512    {
2513        if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2514       
2515        c = dvbapi_find_channel_cache(demux_index, n, 0); // find exact channel match
2516        if(c != NULL)
2517        {
2518            found = n;
2519            cache = 2; //found cache entry with higher priority
2520            demux[demux_index].ECMpids[n].status++; // prioritize CAIDs which already decoded same caid:provid:srvid
2521            if(c->chid < 0x10000) { demux[demux_index].ECMpids[n].CHID = c->chid; } // if chid registered in cache -> use it!
2522            cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (found caid/provid/srvid in cache)", demux_index, n,
2523                demux[demux_index].ECMpids[n].CAID, demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID, demux[demux_index].ECMpids[n].status);
2524            break;
2525        }
2526    }
2527   
2528    if(found == -1)
2529    {
2530        // prioritize CAIDs which already decoded same caid:provid
2531        for(n = 0; n < demux[demux_index].ECMpidcount && matching_done == 0; n++)
2532        {
2533            if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2534           
2535            c = dvbapi_find_channel_cache(demux_index, n, 1);
2536            if(c != NULL)
2537            {
2538                cache = 1; //found cache entry
2539                demux[demux_index].ECMpids[n].status++;
2540                cs_log_dbg(D_DVBAPI, "Demuxer %d prio ecmpid %d %04X@%06X:%04X weight: %d (found caid/provid in cache)", demux_index, n,
2541                    demux[demux_index].ECMpids[n].CAID, demux[demux_index].ECMpids[n].PROVID, demux[demux_index].ECMpids[n].ECM_PID, demux[demux_index].ECMpids[n].status);
2542            }
2543        }
2544    }
2545   
2546    int32_t max_status = 0;
2547    int32_t highest_priopid = -1;
2548   
2549    for(n = 0; n < demux[demux_index].ECMpidcount; n++)
2550    {
2551        if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2552       
2553        if(demux[demux_index].ECMpids[n].status > max_status) // find highest prio pid
2554        { 
2555            max_status = demux[demux_index].ECMpids[n].status;
2556            highest_priopid = n;
2557        }       
2558        if(demux[demux_index].ECMpids[n].status == 0) { demux[demux_index].ECMpids[n].checked = 2; }  // set pids with no status to no prio run
2559    }
2560   
2561    demux[demux_index].max_status = max_status; // register maxstatus
2562    if(highest_priopid != -1 && found == highest_priopid && cache == 2) // Found entry in channelcache that is valid and has exact match on srvid
2563    {
2564        for(n = 0; n < demux[demux_index].ECMpidcount; n++)
2565        {
2566            if(demux[demux_index].ECMpids[n].status == -1) continue; // skip ignores!
2567           
2568            if(n != found)
2569            {
2570                // disable non matching pid
2571                demux[demux_index].ECMpids[n].status = -1;
2572            }
2573            else
2574            {
2575                demux[demux_index].ECMpids[n].status = 1;
2576            }
2577        }
2578        demux[demux_index].max_emm_filter = maxfilter - 1;
2579        demux[demux_index].max_status = 1;
2580        cs_log("Demuxer %d found channel in cache and matching prio -> start descrambling ecmpid %d ", demux_index, found);
2581    }
2582   
2583    NULLFREE(er);
2584   
2585    cs_ftime(&end);
2586    int64_t gone = comp_timeb(&end, &start);
2587    cs_log_dbg(D_DVBAPI, "Demuxer %d sorting the ecmpids took %"PRId64" ms", demux_index, gone);
2588    return;
2589}
2590
2591void dvbapi_parse_descriptor(int32_t demux_id, uint32_t info_length, unsigned char *buffer)
2592{
2593    // int32_t ca_pmt_cmd_id = buffer[i + 5];
2594    uint32_t descriptor_length = 0;
2595    uint32_t j, u;
2596    uint8_t skip_border = cfg.dvbapi_boxtype == BOXTYPE_SAMYGO ? 0x05 : 0x02; // skip input values <0x05 on samygo
2597
2598    if(info_length < 1)
2599        { return; }
2600
2601    if((buffer[0] < skip_border) && info_length > 0) // skip input values like 0x00 and 0x01
2602    {
2603        buffer++;
2604        info_length--;
2605    }
2606
2607    for(j = 0; j < info_length; j += descriptor_length + 2)
2608    {
2609        descriptor_length = buffer[j + 1];
2610
2611        if(buffer[j] == 0x81 && descriptor_length == 8)    // private descriptor of length 8, assume enigma/tvh
2612        {
2613            demux[demux_id].enigma_namespace = b2i(4, buffer + j + 2);
2614            demux[demux_id].tsid = b2i(2, buffer + j + 6);
2615            demux[demux_id].onid = b2i(2, buffer + j + 8);
2616            cs_log_dbg(D_DVBAPI, "Demuxer %d found pmt type: %02x length: %d (assuming enigma private descriptor: namespace %04x tsid %02x onid %02x)", demux_id,
2617                          buffer[j], descriptor_length, demux[demux_id].enigma_namespace, demux[demux_id].tsid, demux[demux_id].onid);
2618        }
2619        else if (descriptor_length !=0)
2620        {
2621            cs_log_dbg(D_TRACE, "Demuxer %d found pmt type: %02x length: %d", demux_id, buffer[j], descriptor_length);
2622        }
2623
2624        if(buffer[j] != 0x09) { continue; }
2625       
2626        if(demux[demux_id].ECMpidcount >= ECM_PIDS) { break; }
2627
2628        int32_t descriptor_ca_system_id = b2i(2, buffer + j + 2);
2629        int32_t descriptor_ca_pid = b2i(2, buffer + j + 4)&0x1FFF;
2630        int32_t descriptor_ca_provider = 0;
2631        char txt[40]; // room for PBM: 8 byte pbm and DATE: date
2632        memset(txt, 0x00, sizeof(txt));
2633
2634        if(descriptor_ca_system_id >> 8 == 0x01)
2635        {
2636            for(u = 2; u < descriptor_length; u += 15)
2637            {
2638                descriptor_ca_pid = b2i(2, buffer + j + u + 2)&0x1FFF;
2639                descriptor_ca_provider = b2i(2, buffer + j + u + 4);
2640                int8_t year = buffer[j + u + 15] >> 1;
2641                int8_t month = (((buffer[j + u + 15]&0x01) << 3) | (buffer[j + u + 16] >> 5));
2642                int8_t day = buffer[j + u + 16]&0x1F;
2643                snprintf(txt, sizeof(txt), "PBM: "); 
2644                cs_hexdump(0, buffer + j + u + 7, 8, txt+5, (2*8)+1); // hexdump 8 byte pbm
2645                snprintf(txt+20, sizeof(txt)-20, " DATE: %d-%d-%d", day, month, year+1990); 
2646                dvbapi_add_ecmpid(demux_id, descriptor_ca_system_id, descriptor_ca_pid, descriptor_ca_provider, txt);
2647            }
2648        }
2649        else
2650        {
2651            if(caid_is_viaccess(descriptor_ca_system_id) && descriptor_length == 0x0F && buffer[j + 12] == 0x14)
2652                { descriptor_ca_provider = b2i(3, buffer + j + 14) &0xFFFFF0; }
2653
2654            if(caid_is_nagra(descriptor_ca_system_id) && descriptor_length == 0x07)
2655                { descriptor_ca_provider = b2i(2, buffer + j + 7); }
2656           
2657            if((descriptor_ca_system_id >> 8 == 0x4A || descriptor_ca_system_id == 0x2710) && descriptor_length > 0x04 )
2658                { descriptor_ca_provider = buffer[j + 6]; }
2659
2660            dvbapi_add_ecmpid(demux_id, descriptor_ca_system_id, descriptor_ca_pid, descriptor_ca_provider, txt);
2661           
2662        }
2663    }
2664
2665    // Apply mapping:
2666    if(dvbapi_priority)
2667    {
2668        struct s_dvbapi_priority *mapentry;
2669        for(j = 0; (int32_t)j < demux[demux_id].ECMpidcount; j++)
2670        {
2671            mapentry = dvbapi_check_prio_match(demux_id, j, 'm');
2672            if(mapentry)
2673            {
2674                cs_log_dbg(D_DVBAPI, "Demuxer %d mapping ecmpid %d from %04X@%06X to %04X@%06X", demux_id, j,
2675                              demux[demux_id].ECMpids[j].CAID, demux[demux_id].ECMpids[j].PROVID,
2676                              mapentry->mapcaid, mapentry->mapprovid);
2677                demux[demux_id].ECMpids[j].CAID = mapentry->mapcaid;
2678                demux[demux_id].ECMpids[j].PROVID = mapentry->mapprovid;
2679            }
2680        }
2681    }
2682}
2683
2684void request_cw(struct s_client *client, ECM_REQUEST *er, int32_t demux_id, uint8_t delayed_ecm_check)
2685{
2686    if(!er)
2687    {
2688        return;
2689    }
2690   
2691    if(!USE_OPENXCAS)
2692    {   
2693        int32_t filternum = dvbapi_set_section_filter(demux_id, er, -1); // set ecm filter to odd -> even and visaversa
2694        if(filternum < 0)
2695        {
2696            cs_log_dbg(D_DVBAPI, "Demuxer %d not requesting cw -> ecm filter was killed!", demux_id);
2697            NULLFREE(er);
2698            return;
2699        }   
2700       
2701        if(!delayed_ecm_check) // no delayed ecm check for this filter
2702        {
2703            memset(demux[demux_id].demux_fd[filternum].lastecmd5, 0, CS_ECMSTORESIZE); // no ecm delay check: zero it!
2704        }
2705        else
2706        {
2707            unsigned char md5tmp[MD5_DIGEST_LENGTH];
2708            MD5(er->ecm, er->ecmlen, md5tmp);
2709            if(!memcmp(demux[demux_id].demux_fd[filternum].prevecmd5, md5tmp, CS_ECMSTORESIZE))
2710            {
2711                if(demux[demux_id].demux_fd[filternum].prevresult < E_NOTFOUND)
2712                {
2713                    cs_log_dbg(D_DVBAPI, "Demuxer %d not requesting same ecm again! -> SKIP!", demux_id);
2714                    NULLFREE(er);
2715                    return;
2716                }
2717                else
2718                {
2719                    cs_log_dbg(D_DVBAPI, "Demuxer %d requesting same ecm again (previous result was not found!)", demux_id);
2720                }
2721            }
2722            else if(!memcmp(demux[demux_id].demux_fd[filternum].lastecmd5, md5tmp, CS_ECMSTORESIZE))
2723            {
2724                if(demux[demux_id].demux_fd[filternum].lastresult < E_NOTFOUND)
2725                {
2726                    cs_log_dbg(D_DVBAPI, "Demuxer %d not requesting same ecm again! -> SKIP!", demux_id);
2727                    NULLFREE(er);
2728                    return;
2729                }
2730                else
2731                {
2732                    cs_log_dbg(D_DVBAPI, "Demuxer %d requesting same ecm again (previous result was not found!)", demux_id);
2733                }
2734            }
2735            memcpy(demux[demux_id].demux_fd[filternum].prevecmd5, demux[demux_id].demux_fd[filternum].lastecmd5, CS_ECMSTORESIZE);
2736            demux[demux_id].demux_fd[filternum].prevresult = demux[demux_id].demux_fd[filternum].lastresult;
2737            memcpy(demux[demux_id].demux_fd[filternum].lastecmd5, md5tmp, CS_ECMSTORESIZE);
2738            demux[demux_id].demux_fd[filternum].lastresult = 0xFF;
2739        }
2740    }
2741
2742    cs_log_dbg(D_DVBAPI, "Demuxer %d get controlword!", demux_id);
2743    get_cw(client, er);
2744
2745#ifdef WITH_DEBUG
2746    char buf[ECM_FMT_LEN];
2747    format_ecm(er, buf, ECM_FMT_LEN);
2748    cs_log_dbg(D_DVBAPI, "Demuxer %d request controlword for ecm %s", demux_id, buf);
2749#endif
2750}
2751
2752void dvbapi_try_next_caid(int32_t demux_id, int8_t checked)
2753{
2754
2755    int32_t n, j, found = -1, started = 0;
2756
2757    int32_t status = demux[demux_id].max_status;
2758
2759    for(j = status; j >= 0; j--)    // largest status first!
2760    {
2761
2762        for(n = 0; n < demux[demux_id].ECMpidcount; n++)
2763        {
2764            //cs_log_dbg(D_DVBAPI,"Demuxer %d PID %d checked = %d status = %d (searching for pid with status = %d)", demux_id, n,
2765            //  demux[demux_id].ECMpids[n].checked, demux[demux_id].ECMpids[n].status, j);
2766            if(demux[demux_id].ECMpids[n].checked == checked && demux[demux_id].ECMpids[n].status == j)
2767            {
2768                found = n;
2769
2770                openxcas_set_provid(demux[demux_id].ECMpids[found].PROVID);
2771                openxcas_set_caid(demux[demux_id].ECMpids[found].CAID);
2772                openxcas_set_ecm_pid(demux[demux_id].ECMpids[found].ECM_PID);
2773
2774                // fixup for cas that need emm first!
2775                if(caid_is_irdeto(demux[demux_id].ECMpids[found].CAID)) { demux[demux_id].emmstart.time = 0; }
2776                started = dvbapi_start_descrambling(demux_id, found, checked);
2777                if(cfg.dvbapi_requestmode == 0 && started == 1) { return; }  // in requestmode 0 we only start 1 ecm request at the time
2778            }
2779        }
2780    }
2781
2782    if(found == -1 && demux[demux_id].pidindex == -1)
2783    {
2784        cs_log("Demuxer %d no suitable readers found that can be used for decoding!", demux_id);
2785        return;
2786    }
2787}
2788
2789static void getDemuxOptions(int32_t demux_id, unsigned char *buffer, uint16_t *ca_mask, uint16_t *demux_index, uint16_t *adapter_index, uint16_t *pmtpid)
2790{
2791    *ca_mask = 0x01, *demux_index = 0x00, *adapter_index = 0x00, *pmtpid = 0x00;
2792
2793    if(buffer[17] == 0x82 && buffer[18] == 0x02)
2794    {
2795        // enigma2
2796        *ca_mask = buffer[19];
2797        uint32_t demuxid = buffer[20];
2798        if (demuxid == 0xff) demuxid = 0; // tryfix prismcube (0xff -> "demux-1" = error! )
2799        *demux_index = demuxid;
2800        if (buffer[21]==0x84 && buffer[22]==0x02) *pmtpid = b2i(2, buffer+23);
2801        if (buffer[25]==0x83 && buffer[26]==0x01) *adapter_index=buffer[27]; // from code cahandler.cpp 0x83 index of adapter
2802    }
2803
2804    if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX_PMT)
2805    {
2806        *ca_mask = demux_id + 1;
2807        *demux_index = demux_id;
2808    }
2809
2810    if(cfg.dvbapi_boxtype == BOXTYPE_QBOXHD && buffer[17] == 0x82 && buffer[18] == 0x03)
2811    {
2812        // ca_mask = buffer[19]; // with STONE 1.0.4 always 0x01
2813        *demux_index = buffer[20]; // with STONE 1.0.4 always 0x00
2814        *adapter_index = buffer[21]; // with STONE 1.0.4 adapter index can be 0,1,2
2815        *ca_mask = (1 << *adapter_index); // use adapter_index as ca_mask (used as index for ca_fd[] array)
2816    }
2817
2818    if((cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
2819         && buffer[7] == 0x82 && buffer[8] == 0x02)
2820    {
2821        *demux_index = buffer[9]; // it is always 0 but you never know
2822        *adapter_index = buffer[10]; // adapter index can be 0,1,2
2823        *ca_mask = (1 << *adapter_index); // use adapter_index as ca_mask (used as index for ca_fd[] array)
2824    }
2825}
2826
2827static void dvbapi_capmt_notify(struct demux_s *dmx)
2828{
2829    struct s_client *cl;
2830    for(cl = first_client->next; cl ; cl = cl->next)
2831    {
2832        if((cl->typ == 'p' || cl->typ == 'r') && cl->reader && cl->reader->ph.c_capmt)
2833        {
2834            struct demux_s *curdemux;
2835            if(cs_malloc(&curdemux, sizeof(struct demux_s)))
2836            {
2837                memcpy(curdemux, dmx, sizeof(struct demux_s));
2838                add_job(cl, ACTION_READER_CAPMT_NOTIFY, curdemux, sizeof(struct demux_s));
2839            }
2840        }
2841    }
2842}
2843
2844int32_t dvbapi_parse_capmt(unsigned char *buffer, uint32_t length, int32_t connfd, char *pmtfile)
2845{
2846    uint32_t i = 0, start_descrambling = 0;
2847    int32_t j = 0;
2848    int32_t demux_id = -1;
2849    uint16_t ca_mask, demux_index, adapter_index, pmtpid;
2850
2851#define LIST_MORE 0x00    //*CA application should append a 'MORE' CAPMT object to the list and start receiving the next object
2852#define LIST_FIRST 0x01   //*CA application should clear the list when a 'FIRST' CAPMT object is received, and start receiving the next object
2853#define LIST_LAST 0x02   //*CA application should append a 'LAST' CAPMT object to the list and start working with the list
2854#define LIST_ONLY 0x03   //*CA application should clear the list when an 'ONLY' CAPMT object is received, and start working with the object
2855#define LIST_ADD 0x04    //*CA application should append an 'ADD' CAPMT object to the current list and start working with the updated list
2856#define LIST_UPDATE 0x05 //*CA application should replace an entry in the list with an 'UPDATE' CAPMT object, and start working with the updated list
2857
2858#if defined WITH_COOLAPI || defined WITH_COOLAPI2
2859    int32_t ca_pmt_list_management = LIST_ONLY;
2860#else
2861    int32_t ca_pmt_list_management = buffer[0];
2862#endif
2863    uint32_t program_number = b2i(2, buffer + 1);
2864    uint32_t program_info_length = b2i(2, buffer + 4) &0xFFF;
2865   
2866    cs_log_dump_dbg(D_DVBAPI, buffer, length, "capmt:");
2867    cs_log_dbg(D_DVBAPI, "Receiver sends PMT command %d for channel %04X", ca_pmt_list_management, program_number);
2868   
2869    if(!pmt_stopmarking && (ca_pmt_list_management == LIST_FIRST || ca_pmt_list_management == LIST_ONLY))
2870    {
2871        for(i = 0; i < MAX_DEMUX; i++) 
2872        {
2873            if(demux[i].program_number == 0) { continue; }  // skip empty demuxers
2874            if(demux[i].socket_fd != connfd) { continue; }  // skip demuxers belonging to other ca pmt connection
2875            if((demux[i].socket_fd == -1) && (strcmp(demux[i].pmt_file, pmtfile) != 0)) { continue; } // skip demuxers handled by other pmt files
2876            demux[i].stopdescramble = 1; // Mark for deletion if not used again by following pmt objects.
2877            cs_log_dbg(D_DVBAPI, "Marked demuxer %d/%d (srvid = %04X fd = %d) to stop decoding", i, MAX_DEMUX, demux[i].program_number, connfd);
2878        }
2879        pmt_stopmarking = 1; // only stop demuxing for first pmt record
2880    }
2881   
2882    getDemuxOptions(i, buffer, &ca_mask, &demux_index, &adapter_index, &pmtpid);
2883    cs_log_dbg(D_DVBAPI,"Receiver wants to demux srvid %04X on adapter %04X camask %04X index %04X pmtpid %04X",
2884        program_number, adapter_index, ca_mask, demux_index, pmtpid);
2885   
2886    for(i = 0; i < MAX_DEMUX; i++)    // search current demuxers for running the same program as the one we received in this PMT object
2887    {
2888        if(demux[i].program_number == 0) { continue; }
2889        if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX_PMT) demux_index = i; // fixup for ipbox
2890
2891        bool full_check = 1, matched = 0;
2892        if (config_enabled(WITH_COOLAPI) || config_enabled(WITH_COOLAPI2) || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
2893            full_check = 0;
2894
2895        if (full_check)
2896            matched = (connfd > 0 && demux[i].socket_fd == connfd) && demux[i].program_number == program_number;
2897        else
2898            matched = connfd > 0 && demux[i].program_number == program_number;
2899
2900        if(matched)
2901        {
2902            if (full_check) {
2903                if (demux[i].adapter_index != adapter_index) continue; // perhaps next demuxer matches?
2904                if (demux[i].ca_mask != ca_mask) continue; // perhaps next demuxer matches?
2905                if (demux[i].demux_index != demux_index) continue; // perhaps next demuxer matches?
2906            }
2907            if(ca_pmt_list_management == LIST_UPDATE){
2908                cs_log("Demuxer %d PMT update for decoding of SRVID %04X! ", i, program_number);
2909            }
2910
2911            demux_id = i;
2912           
2913            cs_log("Demuxer %d continue decoding of SRVID %04X", i, demux[i].program_number);
2914
2915            openxcas_set_sid(program_number);
2916
2917            demux[i].stopdescramble = 0; // dont stop current demuxer!
2918            break; // no need to explore other demuxers since we have a found!
2919        }
2920    }
2921
2922    // start using the new list
2923    if(ca_pmt_list_management != LIST_FIRST && ca_pmt_list_management != LIST_MORE)
2924    {
2925        for(j = 0; j < MAX_DEMUX; j++)
2926        {
2927            if(demux[j].program_number == 0) { continue; }
2928            if(demux[j].stopdescramble == 1) { dvbapi_stop_descrambling(j); }// Stop descrambling and remove all demuxer entries not in new PMT.
2929        }
2930        start_descrambling = 1; // flag that demuxer descrambling is to be executed!
2931        pmt_stopmarking = 0; // flag that demuxers may be marked for stop decoding again
2932    }
2933
2934    if(demux_id == -1)
2935    {
2936        for(demux_id = 0; demux_id < MAX_DEMUX && demux[demux_id].program_number > 0; demux_id++) { ; }
2937    }
2938
2939    if(demux_id >= MAX_DEMUX)
2940    {
2941        cs_log("ERROR: No free id (MAX_DEMUX)");
2942        return -1;
2943    }
2944   
2945    demux[demux_id].program_number = program_number; // do this early since some prio items use them!
2946
2947    demux[demux_id].enigma_namespace = 0;
2948    demux[demux_id].tsid = 0;
2949    demux[demux_id].onid = 0;
2950    demux[demux_id].pmtpid = pmtpid;
2951
2952    if(pmtfile)
2953    {
2954        cs_strncpy(demux[demux_id].pmt_file, pmtfile, sizeof(demux[demux_id].pmt_file));
2955    }
2956   
2957    for(j = 0; j < demux[demux_id].ECMpidcount; j++) // cleanout demuxer from possible stale info
2958    { 
2959        demux[demux_id].ECMpids[j].streams = 0; // reset streams of each ecmpid!
2960    }
2961    demux[demux_id].STREAMpidcount = 0; // reset number of streams
2962    demux[demux_id].ECMpidcount = 0; // reset number of ecmpids
2963   
2964    if(program_info_length > 1 && program_info_length < length)
2965    {
2966        dvbapi_parse_descriptor(demux_id, program_info_length - 1, buffer + 6);
2967    }
2968
2969    uint32_t es_info_length = 0, vpid = 0;
2970    struct s_dvbapi_priority *addentry;
2971
2972    const char *stream_in_text = NULL;
2973   
2974    for(i = program_info_length + 6; i < length; i += es_info_length + 5)
2975    {
2976        uint32_t stream_type = buffer[i];
2977        uint16_t elementary_pid = b2i(2, buffer + i + 1)&0x1FFF;
2978        es_info_length = b2i(2, buffer + i +3)&0x0FFF;
2979        if(stream_type < (sizeof(streamtxt) / sizeof(const char *)))
2980        {
2981            stream_in_text = streamtxt[stream_type];
2982        }
2983        else
2984        {
2985            stream_in_text = "";
2986        }
2987        cs_log_dbg(D_DVBAPI, "Demuxer %d stream %s(type: %02x pid: %04x length: %d)", demux_id, stream_in_text, stream_type, elementary_pid, es_info_length);
2988
2989        if(demux[demux_id].STREAMpidcount >= ECM_PIDS)
2990        {
2991            break;
2992        }
2993
2994        demux[demux_id].STREAMpids[demux[demux_id].STREAMpidcount++] = elementary_pid;
2995        // find and register videopid
2996        if(!vpid && (stream_type == 01 || stream_type == 02 || stream_type == 0x10 || stream_type == 0x1B)) { vpid = elementary_pid; }
2997
2998        if(es_info_length != 0 && es_info_length < length)
2999        {
3000            dvbapi_parse_descriptor(demux_id, es_info_length, buffer + i + 5);
3001        }
3002        else
3003        {
3004            for(addentry = dvbapi_priority; addentry != NULL; addentry = addentry->next)
3005            {
3006                if(addentry->type != 'a'
3007                        || (addentry->ecmpid && pmtpid && addentry->ecmpid != pmtpid) // ecmpid is misused to hold pmtpid in case of A: rule
3008                        || (addentry->ecmpid && !pmtpid && addentry->ecmpid != vpid) // some receivers dont forward pmtpid, use vpid instead
3009                        || (addentry->srvid != demux[demux_id].program_number))
3010                    { continue; }
3011                cs_log_dbg(D_DVBAPI, "Demuxer %d fake ecmpid %04X@%06X:%04x for unencrypted stream on srvid %04X", demux_id, addentry->mapcaid, addentry->mapprovid,
3012                    addentry->mapecmpid, demux[demux_id].program_number);
3013                dvbapi_add_ecmpid(demux_id, addentry->mapcaid, addentry->mapecmpid, addentry->mapprovid, " (fake ecmpid)");
3014                break;
3015            }
3016        }
3017    }
3018    for(j = 0; j < demux[demux_id].ECMpidcount; j++)
3019    {
3020        demux[demux_id].ECMpids[j].VPID = vpid; // register found vpid on all ecmpids of this demuxer
3021    }
3022    cs_log("Demuxer %d found %d ECMpids and %d STREAMpids in PMT", demux_id, demux[demux_id].ECMpidcount, demux[demux_id].STREAMpidcount);
3023
3024    getDemuxOptions(demux_id, buffer, &ca_mask, &demux_index, &adapter_index, &pmtpid);
3025    char channame[CS_SERVICENAME_SIZE];
3026    get_servicename(dvbapi_client, demux[demux_id].program_number, demux[demux_id].ECMpidcount > 0 ? demux[demux_id].ECMpids[0].PROVID : 0 , demux[demux_id].ECMpidcount > 0 ? demux[demux_id].ECMpids[0].CAID : NO_CAID_VALUE, channame, sizeof(channame));
3027    cs_log("Demuxer %d serving srvid %04X (%s) on adapter %04X camask %04X index %04X pmtpid %04X", demux_id,
3028           demux[demux_id].program_number, channame, adapter_index, ca_mask, demux_index, pmtpid); 
3029
3030    demux[demux_id].adapter_index = adapter_index;
3031    demux[demux_id].ca_mask = ca_mask;
3032    demux[demux_id].rdr = NULL;
3033    demux[demux_id].demux_index = demux_index;
3034    demux[demux_id].socket_fd = connfd;
3035    demux[demux_id].stopdescramble = 0; // remove deletion mark!
3036
3037    // remove from unassoc_fd when necessary
3038    for (j = 0; j < MAX_DEMUX; j++)
3039            if (unassoc_fd[j] == connfd)
3040                    unassoc_fd[j] = 0;
3041
3042    dvbapi_capmt_notify(&demux[demux_id]);
3043
3044    struct s_dvbapi_priority *xtraentry;
3045    int32_t k, l, m, xtra_demux_id;
3046
3047    for(xtraentry = dvbapi_priority; xtraentry != NULL; xtraentry = xtraentry->next)
3048    {
3049        if(xtraentry->type != 'x') { continue; }
3050
3051        for(j = 0; j <= demux[demux_id].ECMpidcount; ++j)
3052        {
3053            if((xtraentry->caid && xtraentry->caid != demux[demux_id].ECMpids[j].CAID)
3054                    || (xtraentry->provid && xtraentry->provid  != demux[demux_id].ECMpids[j].PROVID)
3055                    || (xtraentry->ecmpid && xtraentry->ecmpid  != demux[demux_id].ECMpids[j].ECM_PID)
3056                    || (xtraentry->srvid && xtraentry->srvid != demux[demux_id].program_number))
3057                { continue; }
3058
3059            cs_log("Mapping ecmpid %04X@%06X:%04X:%04X to xtra demuxer/ca-devices", xtraentry->caid, xtraentry->provid, xtraentry->ecmpid, xtraentry->srvid);
3060
3061            for(xtra_demux_id = 0; xtra_demux_id < MAX_DEMUX && demux[xtra_demux_id].program_number > 0; xtra_demux_id++)
3062                { ; }
3063
3064            if(xtra_demux_id >= MAX_DEMUX)
3065            {
3066                cs_log("Found no free demux device for xtra streams.");
3067                continue;
3068            }
3069            // copy to new demuxer
3070            getDemuxOptions(demux_id, buffer, &ca_mask, &demux_index, &adapter_index, &pmtpid);
3071            demux[xtra_demux_id].ECMpids[0] = demux[demux_id].ECMpids[j];
3072            demux[xtra_demux_id].ECMpidcount = 1;
3073            demux[xtra_demux_id].STREAMpidcount = 0;
3074            demux[xtra_demux_id].program_number = demux[demux_id].program_number;
3075            demux[xtra_demux_id].pmtpid = demux[demux_id].pmtpid;
3076            demux[xtra_demux_id].demux_index = demux_index;
3077            demux[xtra_demux_id].adapter_index = adapter_index;
3078            demux[xtra_demux_id].ca_mask = ca_mask;
3079            demux[xtra_demux_id].socket_fd = connfd;
3080            demux[xtra_demux_id].stopdescramble = 0; // remove deletion mark!
3081            demux[xtra_demux_id].rdr = NULL;
3082            demux[xtra_demux_id].curindex = -1;
3083
3084            // add streams to xtra demux
3085            for(k = 0; k < demux[demux_id].STREAMpidcount; ++k)
3086            {
3087                if(!demux[demux_id].ECMpids[j].streams || (demux[demux_id].ECMpids[j].streams & (1 << k)))
3088                {
3089                    demux[xtra_demux_id].ECMpids[0].streams |= (1 << demux[xtra_demux_id].STREAMpidcount);
3090                    demux[xtra_demux_id].STREAMpids[demux[xtra_demux_id].STREAMpidcount] = demux[demux_id].STREAMpids[k];
3091                    ++demux[xtra_demux_id].STREAMpidcount;
3092
3093                    // shift stream associations in normal demux because we will remove the stream entirely
3094                    for(l = 0; l < demux[demux_id].ECMpidcount; ++l)
3095                    {
3096                        for(m = k; m < demux[demux_id].STREAMpidcount - 1; ++m)
3097                        {
3098                            if(demux[demux_id].ECMpids[l].streams & (1 << (m + 1)))
3099                            {
3100                                demux[demux_id].ECMpids[l].streams |= (1 << m);
3101                            }
3102                            else
3103                            {
3104                                demux[demux_id].ECMpids[l].streams &= ~(1 << m);
3105                            }
3106                        }
3107                    }
3108
3109                    // remove stream association from normal demux device
3110                    for(l = k; l < demux[demux_id].STREAMpidcount - 1; ++l)
3111                    {
3112                        demux[demux_id].STREAMpids[l] = demux[demux_id].STREAMpids[l + 1];
3113                    }
3114                    --demux[demux_id].STREAMpidcount;
3115                    --k;
3116                }
3117            }
3118
3119            // remove ecmpid from normal demuxer
3120            for(k = j; k < demux[demux_id].ECMpidcount; ++k)
3121            {
3122                demux[demux_id].ECMpids[k] = demux[demux_id].ECMpids[k + 1];
3123            }
3124            --demux[demux_id].ECMpidcount;
3125            --j;
3126
3127            if(demux[xtra_demux_id].STREAMpidcount <= 0)
3128            {
3129                cs_log("Found no streams for xtra demuxer. Not starting additional decoding on it.");
3130                demux[xtra_demux_id].program_number = 0;
3131                demux[xtra_demux_id].stopdescramble = 1;
3132            }
3133
3134            if(demux[demux_id].STREAMpidcount < 1)
3135            {
3136                cs_log("Found no streams for normal demuxer. Not starting additional decoding on it.");
3137            }
3138        }
3139    }
3140
3141    demux[demux_id].sdt_filter = -1;
3142
3143    if(cfg.dvbapi_au > 0 && demux[demux_id].EMMpidcount == 0) // only do emm setup if au enabled and not running!
3144    {
3145        demux[demux_id].emm_filter = -1; // to register first run emmfilter start
3146        if(demux[demux_id].emmstart.time == 1)   // irdeto fetch emm cat direct!
3147        {
3148            cs_ftime(&demux[demux_id].emmstart); // trick to let emm fetching start after 30 seconds to speed up zapping
3149            dvbapi_start_filter(demux_id, demux[demux_id].pidindex, 0x001, 0x001, 0x01, 0x01, 0xFF, 0, TYPE_EMM); //CAT
3150        }
3151        else { cs_ftime(&demux[demux_id].emmstart); } // for all other caids delayed start!
3152    }
3153
3154    if(start_descrambling)
3155    {
3156        for(j = 0; j < MAX_DEMUX; j++)
3157        {
3158            if(demux[j].program_number == 0) { continue; }
3159            if(demux[j].socket_fd != connfd) { continue; }  // skip demuxers belonging to other ca pmt connection
3160            if((demux[j].socket_fd == -1) && (strcmp(demux[j].pmt_file, pmtfile) != 0)) { continue; } // skip demuxers handled by other pmt files
3161           
3162            if(demux[j].running && demux_id == j) disable_unused_streampids(j); // disable all streampids not in use anymore
3163           
3164            if(demux[j].running == 0 && demux[j].ECMpidcount != 0 )   // only start demuxer if it wasnt running
3165            {
3166                cs_log_dbg(D_DVBAPI, "Demuxer %d/%d lets start descrambling (srvid = %04X fd = %d ecmpids = %d)", j, MAX_DEMUX,
3167                    demux[j].program_number, connfd, demux[j].ECMpidcount);
3168                demux[j].running = 1;  // mark channel as running
3169                openxcas_set_sid(demux[j].program_number);
3170                demux[j].decodingtries = -1;
3171                dvbapi_resort_ecmpids(j);
3172                dvbapi_try_next_caid(j, 0);
3173                cs_sleepms(1);
3174            }
3175            else if(demux[j].ECMpidcount == 0) //fta do logging and part of ecmhandler since there will be no ecms asked!
3176            {
3177                cs_log_dbg(D_DVBAPI, "Demuxer %d/%d no descrambling needed (srvid = %04X fd = %d ecmpids = %d)", j, MAX_DEMUX,
3178                    demux[j].program_number, connfd, demux[j].ECMpidcount);
3179                demux[j].running = 0; // reset running flag
3180                demux[demux_id].pidindex = -1; // reset ecmpid used for descrambling
3181                dvbapi_stop_filter(j, TYPE_ECM);
3182                if(cfg.usrfileflag) { cs_statistics(dvbapi_client);} // add to user log previous channel + time on channel
3183                dvbapi_client->last_srvid = demux[demux_id].program_number; // set new channel srvid
3184                dvbapi_client->last_caid = NO_CAID_VALUE; // FTA channels have no caid!
3185                dvbapi_client->last_provid = NO_PROVID_VALUE; // FTA channels have no provid!               
3186                dvbapi_client->lastswitch = dvbapi_client->last = time((time_t *)0); // reset idle-Time & last switch
3187            }
3188        }
3189    }
3190    return demux_id;
3191}
3192
3193static uint32_t dvbapi_extract_sdt_string(char *buf, uint32_t buflen, uint8_t* source, uint32_t sourcelen)
3194{
3195    uint32_t i, j, offset = 0;
3196    int8_t iso_mode = -1;
3197    char *tmpbuf;
3198    const unsigned char *ptr_in;
3199    unsigned char *ptr_out;
3200    size_t in_bytes, out_bytes;
3201
3202    if(sourcelen == 0)
3203    {
3204        buf[0] = '\0';
3205        return 1;   
3206    }
3207   
3208    if(!cs_malloc(&tmpbuf, buflen))
3209    {
3210        return 0;   
3211    }
3212   
3213    if((sourcelen + 1) > buflen)
3214        { sourcelen = buflen - 1; }
3215       
3216    if(sourcelen > 0 && source[0] < 0x20)
3217    {
3218        //ISO-8859
3219        if(source[0] >= 0x01 && source[0] <= 0x0B && source[0] != 0x08)
3220            { offset = 1; iso_mode = 4+source[0]; }
3221       
3222        //ISO-8859
3223        else if(source[0] == 0x10 && source[1] == 0x00
3224                    && source[2] >= 0x01 && source[2] <= 0x0F && source[2] != 0x0C)
3225            { offset = 3; iso_mode = source[2]; }
3226           
3227        //Unicode
3228        else if(source[0] == 0x11)
3229            { offset = 1; iso_mode = -2;}
3230           
3231        //missing: 0x12 Korean Character Set KSC5601-1987
3232        //missing: 0x13 Simplified Chinese Character Set GB-2312-1980
3233        //missing: 0x14 Big5 subset of ISO/IEC 10646-1 (Traditional Chinese)
3234
3235        //Unicode as UTF-8
3236        else if(source[0] == 0x15)
3237            { offset = 1; iso_mode = -3;}
3238       
3239        //missing: 0x1F Described by encoding_type_id *standard not finished yet*
3240       
3241        //Reserved for future use
3242        else
3243            { NULLFREE(tmpbuf); return 0; }
3244    }
3245
3246    if(offset >= sourcelen)
3247        { NULLFREE(tmpbuf); return 0; }
3248
3249    if(iso_mode >= -1)
3250    {
3251        for(i=0, j=0; i<(sourcelen-offset); i++)
3252        {
3253            if(((uint8_t)source[offset+i]) >= 0x80 && ((uint8_t)source[offset+i]) <= 0x9F)
3254            {
3255                continue;
3256            }
3257           
3258            tmpbuf[j] = source[offset+i];
3259            j++;
3260        }
3261        tmpbuf[j] = '\0';
3262    }
3263
3264    ptr_in = (const unsigned char *)tmpbuf;
3265    in_bytes = strlen(tmpbuf);
3266    ptr_out = (unsigned char *)buf;
3267    out_bytes = buflen;
3268       
3269#ifdef READ_SDT_CHARSETS
3270    if(iso_mode >= -1)
3271    {
3272        memset(buf, 0, buflen);
3273               
3274        cs_log_dbg(D_DVBAPI, "sdt-info dbg: iso_mode: %d offset: %u", iso_mode, offset);
3275        cs_log_dump_dbg(D_DVBAPI, (uint8_t*)tmpbuf, in_bytes, "sdt-info dbg: raw string: ");
3276       
3277        if(iso_mode == -1)
3278        {
3279            if(ISO6937toUTF8(&ptr_in, &in_bytes, &ptr_out, &out_bytes) == (size_t)(-1))
3280            {
3281                cs_log_dbg(D_DVBAPI, "sdt-info error: ISO6937toUTF8 failed");
3282                NULLFREE(tmpbuf);
3283                return 0;
3284            }
3285        }
3286        else
3287        {
3288            if(ISO8859toUTF8(iso_mode, &ptr_in, &in_bytes, &ptr_out, &out_bytes) == (size_t)(-1))
3289            {
3290                cs_log_dbg(D_DVBAPI, "sdt-info error: ISO8859toUTF8 failed");
3291                NULLFREE(tmpbuf);
3292                return 0;
3293            }
3294        }
3295    }
3296#else
3297    if(iso_mode >= -1)
3298    {
3299        cs_strncpy(buf, tmpbuf, buflen);
3300        cs_log_dbg(D_DVBAPI, "sdt-info warning: your build of oscam does not support iso-to-utf8 conversion, special chars may be corrupted!");
3301    }
3302#endif
3303
3304    else if(iso_mode == -2)
3305    {
3306        memset(buf, 0, buflen);
3307               
3308        cs_log_dbg(D_DVBAPI, "sdt-info dbg: iso_mode: %d offset: %u", iso_mode, offset);
3309
3310        if(UnicodetoUTF8(&ptr_in, &in_bytes, &ptr_out, &out_bytes) == (size_t)(-1))
3311        {
3312            cs_log_dbg(D_DVBAPI, "sdt-info error: UnicodetoUTF8 failed");
3313            NULLFREE(tmpbuf);
3314            return 0;
3315        }       
3316    }
3317   
3318    else if(iso_mode == -3)
3319    {
3320        memcpy(buf, source+offset, sourcelen-offset);
3321        buf[sourcelen-offset] = '\0';   
3322       
3323        cs_log_dbg(D_DVBAPI, "sdt-info dbg: iso_mode: -3 offset: %u", offset);     
3324    }
3325   
3326    cs_log_dump_dbg(D_DVBAPI, (uint8_t*)buf, strlen(buf), "sdt-info dbg: encoded string: ");
3327   
3328    NULLFREE(tmpbuf);
3329    return 1;
3330}
3331
3332static void dvbapi_create_srvid_line(int32_t demux_id, char *buffer, uint32_t buflen)
3333{
3334    int32_t i, j;
3335    uint16_t caid_done[32], cur_caid;
3336    uint8_t caid_done_count = 0, skip_caid;
3337    int32_t pos = 0;
3338   
3339    if(demux[demux_id].ECMpidcount == 0)
3340    {
3341        snprintf(buffer, buflen, "%04X@%06X", NO_CAID_VALUE, NO_PROVID_VALUE);
3342        return; 
3343    }
3344   
3345    for(i=0; i < demux[demux_id].ECMpidcount && i < 32; i++)
3346    {
3347        skip_caid = 0;
3348       
3349        for(j=0; j < caid_done_count; j++)
3350        {
3351            if(caid_done[j] == demux[demux_id].ECMpids[i].CAID)
3352            {
3353                skip_caid = 1;
3354                break;
3355            }
3356        }
3357       
3358        if(skip_caid)
3359        {
3360            continue;   
3361        }
3362       
3363        cur_caid = demux[demux_id].ECMpids[i].CAID;
3364        pos += snprintf(buffer+pos, buflen-pos, "%s%04X", caid_done_count > 0 ? "," : "", cur_caid == 0 ? NO_CAID_VALUE : cur_caid);
3365       
3366        for(j=i; j < demux[demux_id].ECMpidcount; j++)
3367        {
3368            if(demux[demux_id].ECMpids[j].PROVID == 0)
3369            {
3370                continue;
3371            }
3372           
3373            if(cur_caid == demux[demux_id].ECMpids[j].CAID)
3374            {
3375                pos += snprintf(buffer+pos, buflen-pos, "@%06X", demux[demux_id].ECMpids[j].PROVID);   
3376            }
3377        }
3378       
3379        caid_done[caid_done_count] = demux[demux_id].ECMpids[i].CAID;
3380        caid_done_count++;
3381    }   
3382}
3383
3384static const char *dvbapi_get_service_type(uint8_t service_type_id)
3385{
3386    switch(service_type_id)
3387    {
3388        case 0x01:
3389        case 0x11:
3390        default:
3391            return "TV";
3392           
3393        case 0x02:
3394        case 0x07:
3395        case 0x0A:
3396            return "Radio";
3397           
3398        case 0x03:
3399            return "Teletext";
3400       
3401        case 0x0C:
3402            return "Data";
3403    }
3404}
3405
3406static void dvbapi_parse_sdt(int32_t demux_id, unsigned char *buffer, uint32_t length)
3407{
3408    uint8_t tag, data_length = 0, provider_name_length, service_name_length, service_type;
3409    uint16_t service_id, descriptor_length, dpos;
3410    int32_t provid, caid;
3411    uint32_t section_length, pos;
3412    int32_t pidindex;
3413    char provider_name[64],  service_name[64], tmp[256], srvid_line[1024];
3414    const char *type;
3415    FILE *fpsave = NULL;
3416    int8_t did_save_srvid = 0;
3417   
3418    cs_log_dump_dbg(D_DVBAPI, buffer, length, "sdt-info dbg: sdt data: ");
3419   
3420    if(length < 3)
3421        { return; }
3422       
3423    if(buffer[0] != 0x42)
3424        { return; }
3425   
3426    section_length = b2i(2, buffer + 1) &0xFFF;
3427   
3428    if(section_length+3 != length)
3429        { return; }
3430   
3431    for(pos = 11; pos+5 < length; pos += descriptor_length)
3432    {
3433        service_id = b2i(2, buffer + pos);     
3434        descriptor_length = b2i(2, buffer + pos + 3) &0xFFF;
3435       
3436        if((pos+5+descriptor_length) >= length)
3437            { return; }
3438       
3439        pos += 5;
3440       
3441        if(service_id != demux[demux_id].program_number)
3442            { continue; }   
3443       
3444        for(dpos = 0; dpos+1 < descriptor_length; dpos += (2 + data_length))
3445        {
3446            tag = buffer[pos+dpos];
3447            data_length = buffer[pos+dpos+1];
3448
3449            if(dpos+1+data_length >= descriptor_length)
3450                { break; }     
3451       
3452            if(tag != 0x48)
3453                { continue; }
3454
3455            if(dpos+3 >= descriptor_length)
3456                { break; }
3457           
3458            service_type = buffer[pos+dpos+2];
3459           
3460            provider_name_length = buffer[pos+dpos+3];
3461            if((dpos+4+provider_name_length+1) > descriptor_length)
3462                { break; }
3463           
3464            service_name_length = buffer[pos+dpos+4+provider_name_length];
3465            if((dpos+4+provider_name_length+1+service_name_length) > descriptor_length)
3466                { break; }
3467           
3468            pidindex = demux[demux_id].pidindex;
3469           
3470            if (pidindex !=-1)
3471            {
3472                provid = demux[demux_id].ECMpids[pidindex].PROVID;
3473                caid = demux[demux_id].ECMpids[pidindex].CAID;
3474            }
3475            else
3476            {
3477                if(demux[demux_id].ECMpidcount == 0 || demux[demux_id].ECMpids[0].CAID == 0)
3478                {
3479                    caid = NO_CAID_VALUE;
3480                    provid = NO_PROVID_VALUE;
3481                }
3482                else
3483                {
3484                    caid = demux[demux_id].ECMpids[0].CAID;
3485                    provid = demux[demux_id].ECMpids[0].PROVID; 
3486                }
3487            }
3488           
3489            if(!dvbapi_extract_sdt_string(provider_name, sizeof(provider_name), buffer+pos+dpos+4, provider_name_length))
3490                { break; }
3491               
3492            if(!dvbapi_extract_sdt_string(service_name, sizeof(service_name), buffer+pos+dpos+4+provider_name_length+1, service_name_length))
3493                { break; }
3494                       
3495            cs_log("sdt-info (provider: %s - channel: %s)", provider_name, service_name);
3496
3497            dvbapi_stop_filter(demux_id, TYPE_SDT);
3498           
3499            if(strlen(provider_name) && caid != NO_CAID_VALUE)
3500            {
3501                get_providername_or_null(provid, caid, tmp, sizeof(tmp));
3502               
3503                if(tmp[0] == '\0')
3504                {
3505                    get_config_filename(tmp, sizeof(tmp), "oscam.provid");
3506                   
3507                    if((fpsave = fopen(tmp, "a")))
3508                    {
3509                        fprintf(fpsave, "\n%04X@%06X|%s|", caid, provid, provider_name);
3510                        fclose(fpsave);
3511                       
3512                        init_provid();
3513                    }
3514                }
3515            }
3516
3517            if(strlen(service_name))
3518            {
3519                get_servicename_or_null(cur_client(), service_id, provid, caid, tmp, sizeof(tmp));
3520               
3521                if(tmp[0] == '\0')
3522                {
3523                    type = dvbapi_get_service_type(service_type);
3524                   
3525                    get_config_filename(tmp, sizeof(tmp), "oscam.srvid2");
3526                   
3527                    if(!access(tmp, F_OK) && (fpsave = fopen(tmp, "a")))
3528                    {
3529                        if((caid != NO_CAID_VALUE) || (cfg.dvbapi_read_sdt > 1))
3530                        {
3531                            dvbapi_create_srvid_line(demux_id, srvid_line, sizeof(srvid_line));
3532                           
3533                            if(cfg.dvbapi_write_sdt_prov)
3534                                { fprintf(fpsave, "\n%04X:%s|%s|%s||%s", service_id, srvid_line, service_name, type, provider_name); }
3535                            else
3536                                { fprintf(fpsave, "\n%04X:%s|%s|%s", service_id, srvid_line, service_name, type); }
3537                               
3538                            did_save_srvid = 1;
3539                        }
3540                    }
3541                    else
3542                    {
3543                        get_config_filename(tmp, sizeof(tmp), "oscam.srvid");
3544                       
3545                        if((fpsave = fopen(tmp, "a")))
3546                        {
3547                            if((caid != NO_CAID_VALUE) || (cfg.dvbapi_read_sdt > 1))
3548                            {
3549                                dvbapi_create_srvid_line(demux_id, srvid_line, sizeof(srvid_line));
3550                               
3551                                if(cfg.dvbapi_write_sdt_prov)
3552                                    { fprintf(fpsave, "\n%s:%04X|%s|%s|%s", srvid_line, service_id, provider_name, service_name, type); }
3553                               
3554                                else 
3555                                    { fprintf(fpsave, "\n%s:%04X||%s|%s", srvid_line, service_id, service_name, type); }
3556                                   
3557                                did_save_srvid = 1;
3558                            }
3559                        }
3560                    }
3561                   
3562                    if(fpsave)
3563                        { fclose(fpsave); }
3564               
3565                    if(did_save_srvid)
3566                        { init_srvid(); }
3567                }
3568            }
3569           
3570            return;
3571        }
3572    }
3573}
3574
3575void dvbapi_handlesockmsg(unsigned char *buffer, uint32_t len, int32_t connfd)
3576{
3577    uint32_t val = 0, size = 0, i, k;
3578
3579    for(k = 0; k < len; k += 3 + size + val)
3580    {
3581        if(buffer[0 + k] != 0x9F || buffer[1 + k] != 0x80)
3582        {
3583            cs_log_dbg(D_DVBAPI, "Received unknown PMT command: %02x", buffer[0 + k]);
3584            break;
3585        }
3586
3587        if(k > 0)
3588            cs_log_dump_dbg(D_DVBAPI, buffer + k, len - k, "Parsing next PMT object:");
3589
3590        if(buffer[3 + k] & 0x80)
3591        {
3592            val = 0;
3593            size = buffer[3 + k] & 0x7F;
3594            for(i = 0; i < size; i++)
3595                { val = (val << 8) | buffer[i + 1 + 3 + k]; }
3596            size++;
3597        }
3598        else
3599        {
3600            val = buffer[3 + k] & 0x7F;
3601            size = 1;
3602        }
3603        switch(buffer[2 + k])
3604        {
3605        case 0x32:
3606            dvbapi_parse_capmt(buffer + size + 3 + k, val, connfd, NULL);
3607            break;
3608        case 0x3f:
3609            // 9F 80 3f 04 83 02 00 <demux index>
3610            cs_log_dump_dbg(D_DVBAPI, buffer, len, "capmt 3f:");
3611            // ipbox fix
3612            if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX || cfg.dvbapi_listenport)
3613            {
3614                int32_t demux_index = buffer[7 + k];
3615                for(i = 0; i < MAX_DEMUX; i++)
3616                {
3617                    // 0xff demux_index is a wildcard => close all related demuxers
3618                    if (demux_index == 0xff)
3619                    {
3620                        if (demux[i].socket_fd == connfd)
3621                            dvbapi_stop_descrambling(i);
3622                    }
3623                    else if (demux[i].demux_index == demux_index)
3624                    {
3625                        dvbapi_stop_descrambling(i);
3626                        break;
3627                    }
3628                }
3629                if (cfg.dvbapi_boxtype == BOXTYPE_IPBOX)
3630                {
3631                    // check do we have any demux running on this fd
3632                    int16_t execlose = 1;
3633                    for(i = 0; i < MAX_DEMUX; i++)
3634                    {
3635                        if(demux[i].socket_fd == connfd)
3636                        {
3637                            execlose = 0;
3638                            break;
3639                        }
3640                    }
3641                    if(execlose)
3642                    {
3643                        int32_t ret = close(connfd);
3644                        if(ret < 0) { cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno)); }
3645                    }
3646                }
3647            }
3648            else
3649            {
3650                if(cfg.dvbapi_pmtmode != 6)
3651                {
3652                    int32_t ret = close(connfd);
3653                    if(ret < 0) { cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno)); }
3654                }
3655            }
3656            break;
3657        default:
3658            cs_log_dbg(D_DVBAPI, "handlesockmsg() unknown command");
3659            cs_log_dump(buffer, len, "unknown command:");
3660            break;
3661        }
3662    }
3663}
3664
3665int32_t dvbapi_init_listenfd(void)
3666{
3667    int32_t clilen, listenfd;
3668    struct sockaddr_un servaddr;
3669
3670    memset(&servaddr, 0, sizeof(struct sockaddr_un));
3671    servaddr.sun_family = AF_UNIX;
3672    cs_strncpy(servaddr.sun_path, devices[selected_box].cam_socket_path, sizeof(servaddr.sun_path));
3673    clilen = sizeof(servaddr.sun_family) + strlen(servaddr.sun_path);
3674
3675    if((unlink(devices[selected_box].cam_socket_path) < 0) && (errno != ENOENT))
3676        { return 0; }
3677    if((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
3678        { return 0; }
3679    if(bind(listenfd, (struct sockaddr *)&servaddr, clilen) < 0)
3680        { return 0; }
3681    if(listen(listenfd, 5) < 0)
3682        { return 0; }
3683
3684    // change the access right on the camd.socket
3685    // this will allow oscam to run as root if needed
3686    // and still allow non root client to connect to the socket
3687    chmod(devices[selected_box].cam_socket_path, S_IRWXU | S_IRWXG | S_IRWXO);
3688
3689    return listenfd;
3690}
3691
3692int32_t dvbapi_net_init_listenfd(void)
3693{
3694    int32_t listenfd;
3695    struct SOCKADDR servaddr;
3696
3697    memset(&servaddr, 0, sizeof(servaddr));
3698    SIN_GET_FAMILY(servaddr) = DEFAULT_AF;
3699    SIN_GET_ADDR(servaddr) = ADDR_ANY;
3700    SIN_GET_PORT(servaddr) = htons((uint16_t)cfg.dvbapi_listenport);
3701
3702    if((listenfd = socket(DEFAULT_AF, SOCK_STREAM, 0)) < 0)
3703        { return 0; }
3704
3705    int32_t opt = 0;
3706#ifdef IPV6SUPPORT
3707
3708    // azbox toolchain do not have this define
3709#ifndef IPV6_V6ONLY
3710#define IPV6_V6ONLY 26
3711#endif
3712
3713    // set the server socket option to listen on IPv4 and IPv6 simultaneously
3714    setsockopt(listenfd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&opt, sizeof(opt));
3715#endif
3716
3717    opt = 1;
3718    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (void *)&opt, sizeof(opt));
3719    set_so_reuseport(listenfd);
3720
3721    if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
3722        { return 0; }
3723    if(listen(listenfd, 5) < 0)
3724        { return 0; }
3725
3726    return listenfd;
3727}
3728
3729static pthread_mutex_t event_handler_lock;
3730
3731void event_handler(int32_t UNUSED(signal))
3732{
3733    struct stat pmt_info;
3734    char dest[1024];
3735    DIR *dirp;
3736    struct dirent entry, *dp = NULL;
3737    int32_t i, pmt_fd;
3738    uchar mbuf[2048]; // dirty fix: larger buffer needed for CA PMT mode 6 with many parallel channels to decode
3739    if(dvbapi_client != cur_client()) { return; }
3740
3741    SAFE_MUTEX_LOCK(&event_handler_lock);
3742
3743    if(cfg.dvbapi_boxtype == BOXTYPE_PC || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX || cfg.dvbapi_boxtype == BOXTYPE_SAMYGO)
3744        { pausecam = 0; }
3745    else
3746    {
3747        int32_t standby_fd = open(STANDBY_FILE, O_RDONLY);
3748        pausecam = (standby_fd > 0) ? 1 : 0;
3749        if(standby_fd > 0)
3750        {
3751            int32_t ret = close(standby_fd);
3752            if(ret < 0) { cs_log("ERROR: Could not close standby fd (errno=%d %s)", errno, strerror(errno)); }
3753        }
3754    }
3755
3756    if(cfg.dvbapi_boxtype == BOXTYPE_IPBOX || cfg.dvbapi_pmtmode == 1)
3757    {
3758        SAFE_MUTEX_UNLOCK(&event_handler_lock);
3759        return;
3760    }
3761
3762    for(i = 0; i < MAX_DEMUX; i++)
3763    {
3764        if(demux[i].pmt_file[0] != 0)
3765        {
3766            snprintf(dest, sizeof(dest), "%s%s", TMPDIR, demux[i].pmt_file);
3767            pmt_fd = open(dest, O_RDONLY);
3768            if(pmt_fd > 0)
3769            {
3770                if(fstat(pmt_fd, &pmt_info) != 0)
3771                {
3772                    int32_t ret = close(pmt_fd);
3773                    if(ret < 0) { cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno)); }
3774                    continue;
3775                }
3776
3777                if((time_t)pmt_info.st_mtime != demux[i].pmt_time)
3778                {
3779                    dvbapi_stop_descrambling(i);
3780                }
3781
3782                int32_t ret = close(pmt_fd);
3783                if(ret < 0) { cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno)); }
3784                continue;
3785            }
3786            else
3787            {
3788                cs_log("Demuxer %d Unable to open PMT file %s -> stop descrambling!", i, dest);
3789                dvbapi_stop_descrambling(i);
3790            }
3791        }
3792    }
3793
3794    if(disable_pmt_files)
3795    {
3796        SAFE_MUTEX_UNLOCK(&event_handler_lock);
3797        return;
3798    }
3799
3800    dirp = opendir(TMPDIR);
3801    if(!dirp)
3802    {
3803        cs_log_dbg(D_DVBAPI, "opendir failed (errno=%d %s)", errno, strerror(errno));
3804        SAFE_MUTEX_UNLOCK(&event_handler_lock);
3805        return;
3806    }
3807
3808    while(!cs_readdir_r(dirp, &entry, &dp))
3809    {
3810        if(!dp) { break; }
3811
3812        if(strlen(dp->d_name) < 7)
3813            { continue; }
3814        if(strncmp(dp->d_name, "pmt", 3) != 0 || strncmp(dp->d_name + strlen(dp->d_name) - 4, ".tmp", 4) != 0)
3815            { continue; }
3816#if defined(WITH_STAPI) || defined(WITH_STAPI5)
3817        struct s_dvbapi_priority *p;
3818        for(p = dvbapi_priority; p != NULL; p = p->next)  // stapi: check if there is a device connected to this pmt file!
3819        {
3820            if(p->type != 's') { continue; }  // stapi rule?
3821            if(strcmp(dp->d_name, p->pmtfile) != 0) { continue; }  // same file?
3822            break; // found match!
3823        }
3824        if(p == NULL)
3825        {
3826            cs_log_dbg(D_DVBAPI, "No matching S: line in oscam.dvbapi for pmtfile %s -> skip!", dp->d_name);
3827            continue;
3828        }
3829#endif
3830        snprintf(dest, sizeof(dest), "%s%s", TMPDIR, dp->d_name);
3831        pmt_fd = open(dest, O_RDONLY);
3832        if(pmt_fd < 0)
3833            { continue; }
3834
3835        if(fstat(pmt_fd, &pmt_info) != 0)
3836        {
3837            int32_t ret = close(pmt_fd);
3838            if(ret < 0) { cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno)); }
3839            continue;
3840        }
3841
3842        int32_t found = 0;
3843        for(i = 0; i < MAX_DEMUX; i++)
3844        {
3845            if(strcmp(demux[i].pmt_file, dp->d_name) == 0)
3846            {
3847                if((time_t)pmt_info.st_mtime == demux[i].pmt_time)
3848                {
3849                    found = 1;
3850                    break;
3851                }
3852            }
3853        }
3854        if(found)
3855        {
3856            int32_t ret = close(pmt_fd);
3857            if(ret < 0) { cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno)); }
3858            continue;
3859        }
3860
3861        cs_log_dbg(D_DVBAPI, "found pmt file %s", dest);
3862        cs_sleepms(100);
3863
3864        uint32_t len = read(pmt_fd, mbuf, sizeof(mbuf));
3865        int32_t ret = close(pmt_fd);
3866        if(ret < 0) { cs_log("ERROR: Could not close PMT fd (errno=%d %s)", errno, strerror(errno)); }
3867
3868        if(len < 1)
3869        {
3870            cs_log_dbg(D_DVBAPI, "pmt file %s have invalid len!", dest);
3871            continue;
3872        }
3873
3874        int32_t pmt_id;
3875
3876#ifdef QBOXHD
3877        uint32_t j1, j2;
3878        // QboxHD pmt.tmp is the full capmt written as a string of hex values
3879        // pmt.tmp must be longer than 3 bytes (6 hex chars) and even length
3880        if((len < 6) || ((len % 2) != 0) || ((len / 2) > sizeof(dest)))
3881        {
3882            cs_log_dbg(D_DVBAPI, "error parsing QboxHD pmt.tmp, incorrect length");
3883            continue;
3884        }
3885
3886        for(j2 = 0, j1 = 0; j2 < len; j2 += 2, j1++)
3887        {
3888            unsigned int tmp;
3889            if(sscanf((char *)mbuf + j2, "%02X", &tmp) != 1)
3890            {
3891                cs_log_dbg(D_DVBAPI, "error parsing QboxHD pmt.tmp, data not valid in position %d", j2);
3892                SAFE_MUTEX_UNLOCK(&event_handler_lock);
3893                return;
3894            }
3895            else
3896            {
3897                memcpy(dest + j1, &tmp, 4);
3898            }
3899        }
3900
3901        cs_log_dump_dbg(D_DVBAPI, (unsigned char *)dest, len / 2, "QboxHD pmt.tmp:");
3902        pmt_id = dvbapi_parse_capmt((unsigned char *)dest + 4, (len / 2) - 4, -1, dp->d_name);
3903#else
3904        if(len > sizeof(dest))
3905        {
3906            cs_log_dbg(D_DVBAPI, "event_handler() dest buffer is to small for pmt data!");
3907            continue;
3908        }
3909        if(len < 16)
3910        {
3911            cs_log_dbg(D_DVBAPI, "event_handler() received pmt is too small! (%d < 16 bytes!)", len);
3912            continue;
3913        }
3914        cs_log_dump_dbg(D_DVBAPI, mbuf, len, "pmt:");
3915
3916        dest[0] = 0x03;
3917        dest[1] = mbuf[3];
3918        dest[2] = mbuf[4];
3919        uint32_t pmt_program_length = b2i(2, mbuf + 10)&0xFFF;
3920        i2b_buf(2, pmt_program_length + 1, (uchar *) dest + 4);
3921        dest[6] = 0;
3922
3923        memcpy(dest + 7, mbuf + 12, len - 12 - 4);
3924
3925        pmt_id = dvbapi_parse_capmt((uchar *)dest, 7 + len - 12 - 4, -1, dp->d_name);
3926#endif
3927
3928        if(pmt_id >= 0)
3929        {
3930            cs_strncpy(demux[pmt_id].pmt_file, dp->d_name, sizeof(demux[pmt_id].pmt_file));
3931            demux[pmt_id].pmt_time = (time_t)pmt_info.st_mtime;
3932        }
3933
3934        if(cfg.dvbapi_pmtmode == 3)
3935        {
3936            disable_pmt_files = 1;
3937            break;
3938        }
3939    }
3940    closedir(dirp);
3941    SAFE_MUTEX_UNLOCK(&event_handler_lock);
3942}
3943
3944void *dvbapi_event_thread(void *cli)
3945{
3946    struct s_client *client = (struct s_client *) cli;
3947    SAFE_SETSPECIFIC(getclient, client);
3948    set_thread_name(__func__);
3949    while(!exit_oscam)
3950    {
3951        cs_sleepms(750);
3952        event_handler(0);
3953    }
3954
3955    return NULL;
3956}
3957
3958void dvbapi_process_input(int32_t demux_id, int32_t filter_num, uchar *buffer, int32_t len)
3959{   
3960   
3961    struct s_ecmpids *curpid = NULL;
3962    int32_t pid = demux[demux_id].demux_fd[filter_num].pidindex;
3963    uint16_t filtertype = demux[demux_id].demux_fd[filter_num].type;
3964    uint32_t sctlen = SCT_LEN(buffer);
3965   
3966    if((uint) len  < sctlen) // invalid CAT length
3967    {
3968        cs_log_dbg(D_DVBAPI, "Received filterdata with total length 0x%03X but section length is 0x%03X -> invalid length!", len, sctlen);
3969        return;
3970    }
3971   
3972    if(pid != -1 && filtertype == TYPE_ECM)
3973    {
3974        curpid = &demux[demux_id].ECMpids[pid];
3975    }
3976   
3977    if(!USE_OPENXCAS)
3978    {
3979        int32_t filt_match = filtermatch(buffer, filter_num, demux_id, sctlen); // acts on all filters (sdt/emm/ecm)
3980        if(!filt_match)
3981        {
3982           
3983            cs_log_dbg(D_DVBAPI,"Demuxer %d receiver returned data that was not matching to the filter -> delivered filter data discarded!", demux_id);
3984            return;
3985        }
3986       
3987        if(curpid && curpid->tries <= 0xF0 && filtertype == TYPE_ECM)
3988        {
3989            curpid->irdeto_maxindex = 0;
3990            curpid->irdeto_curindex = 0xFE;
3991            curpid->tries = 0xFE; // reset timeout retry flag
3992            curpid->irdeto_cycle = 0xFE; // reset irdetocycle
3993            curpid->table = 0;
3994            curpid->checked = 4; // flag ecmpid as checked
3995            curpid->status = -1; // flag ecmpid as unusable
3996            if(pid == demux[demux_id].pidindex)
3997            {
3998                demux[demux_id].pidindex = -1; // current pid delivered problems so this pid isnt being used to descramble any longer-> clear pidindex
3999                dvbapi_edit_channel_cache(demux_id, pid, 0); // remove this pid from channelcache since we had no founds on any ecmpid!
4000            }
4001            dvbapi_stop_filternum(demux_id, filter_num); // stop this ecm filter!
4002            return;
4003        }
4004    }
4005   
4006    if(filtertype == TYPE_ECM)
4007    {
4008        uint32_t chid = 0x10000;
4009        ECM_REQUEST *er;
4010       
4011        if(len != 0)  // len = 0 receiver encountered an internal bufferoverflow!
4012        {
4013            cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d Filter %d fetched ECM data (ecmlength = 0x%03X):", demux_id, filter_num + 1, sctlen);
4014           
4015            if(sctlen > MAX_ECM_SIZE) // ecm too long to handle!
4016            {
4017                cs_log_dbg(D_DVBAPI, "Received data with total length 0x%03X but maximum ECM length oscam can handle is 0x%03X -> Please report!", sctlen, MAX_ECM_SIZE);
4018                if(curpid)
4019                { 
4020                    curpid->tries-=0x0E;
4021                }
4022                return;
4023            }           
4024
4025            if(!(buffer[0] == 0x80 || buffer[0] == 0x81))
4026            {
4027                cs_log_dbg(D_DVBAPI, "Received an ECM with invalid ecmtable ID %02X -> ignoring!", buffer[0]);
4028                if(curpid)
4029                { 
4030                    curpid->tries--;
4031                }
4032                return;
4033            }
4034
4035            if(curpid->table == buffer[0] && !caid_is_irdeto(curpid->CAID))  // wait for odd / even ecm change (only not for irdeto!)
4036            { 
4037               
4038                if(!(er = get_ecmtask()))
4039                { 
4040                    return;
4041                }
4042
4043                er->srvid = demux[demux_id].program_number;
4044
4045#ifdef WITH_STAPI5
4046                cs_strncpy(er->dev_name, dev_list[demux[demux_id].dev_index].name, sizeof(dev_list[demux[demux_id].dev_index].name));
4047#endif 
4048
4049                er->tsid = demux[demux_id].tsid;
4050                er->onid = demux[demux_id].onid;
4051                er->pmtpid = demux[demux_id].pmtpid;
4052                er->ens = demux[demux_id].enigma_namespace;
4053
4054                er->caid  = curpid->CAID;
4055                er->pid   = curpid->ECM_PID;
4056                er->prid  = curpid->PROVID;
4057                er->vpid  = curpid->VPID;
4058                er->ecmlen = sctlen;
4059                memcpy(er->ecm, buffer, er->ecmlen);
4060                chid = get_subid(er); // fetch chid or fake chid
4061                er->chid = chid;
4062                dvbapi_set_section_filter(demux_id, er, filter_num);
4063                NULLFREE(er);
4064                return; 
4065            }
4066
4067            if(caid_is_irdeto(curpid->CAID))
4068            {
4069                // 80 70 39 53 04 05 00 88
4070                // 81 70 41 41 01 06 00 13 00 06 80 38 1F 52 93 D2
4071                //if (buffer[5]>20) return;
4072                if(curpid->irdeto_maxindex != buffer[5])    //6, register max irdeto index
4073                {
4074                    cs_log_dbg(D_DVBAPI, "Found %d IRDETO ECM CHIDs", buffer[5] + 1);
4075                    curpid->irdeto_maxindex = buffer[5]; // numchids = 7 (0..6)
4076                }
4077            }
4078        }
4079       
4080        if(!(er = get_ecmtask()))
4081        { 
4082            return;
4083        }
4084
4085        er->srvid = demux[demux_id].program_number;
4086
4087#ifdef WITH_STAPI5
4088        cs_strncpy(er->dev_name, dev_list[demux[demux_id].dev_index].name, sizeof(dev_list[demux[demux_id].dev_index].name));
4089#endif 
4090
4091        er->tsid = demux[demux_id].tsid;
4092        er->onid = demux[demux_id].onid;
4093        er->pmtpid = demux[demux_id].pmtpid;
4094        er->ens = demux[demux_id].enigma_namespace;
4095
4096        er->caid  = curpid->CAID;
4097        er->pid   = curpid->ECM_PID;
4098        er->prid  = curpid->PROVID;
4099        er->vpid  = curpid->VPID;
4100        er->ecmlen = sctlen;
4101        memcpy(er->ecm, buffer, er->ecmlen);
4102
4103        chid = get_subid(er); // fetch chid or fake chid
4104        uint32_t fixedprovid = chk_provid(er->ecm, er->caid);
4105        if(fixedprovid && fixedprovid != er->prid)
4106        {
4107            cs_log_dbg(D_DVBAPI, "Fixing provid ecmpid %d from %06X -> %06X", pid, curpid->PROVID, fixedprovid);
4108            curpid->PROVID = fixedprovid;
4109            if(!USE_OPENXCAS)
4110            {
4111                cs_log_dbg(D_DVBAPI, "Fixing provid filter %d from %06X -> %06X", filter_num+1, demux[demux_id].demux_fd[filter_num].provid, fixedprovid);
4112                demux[demux_id].demux_fd[filter_num].provid = fixedprovid;
4113            }
4114            cs_log_dbg(D_DVBAPI, "Fixing provid ecmrequest from %06X -> %06X", er->prid, fixedprovid);
4115            er->prid = fixedprovid;
4116        }
4117        er->chid = chid;
4118       
4119        if(len == 0) // only used on receiver internal bufferoverflow to get quickly fresh ecm filterdata otherwise freezing!
4120        {
4121            curpid->table = 0;
4122            dvbapi_set_section_filter(demux_id, er, filter_num);
4123            NULLFREE(er);
4124            return;
4125        }
4126
4127        if(caid_is_irdeto(curpid->CAID))
4128        {
4129
4130            if(curpid->irdeto_curindex != buffer[4])   // old style wrong irdeto index
4131            {   
4132                if(curpid->irdeto_curindex == 0xFE)  // check if this ecmfilter just started up
4133                {
4134                    curpid->irdeto_curindex = buffer[4]; // on startup set the current index to the irdeto index of the ecm
4135                }
4136                else   // we are already running and not interested in this ecm
4137                {
4138                    if(curpid->table != buffer[0]) curpid->table = 0; // fix for receivers not supporting section filtering
4139                    dvbapi_set_section_filter(demux_id, er, filter_num); // set ecm filter to odd + even since this ecm doesnt match with current irdeto index
4140                    NULLFREE(er);
4141                    return;
4142                }
4143            }
4144            else //fix for receivers not supporting section filtering
4145            {
4146                if(curpid->table == buffer[0]){
4147                    NULLFREE(er);
4148                    return;
4149                }
4150            }
4151            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", demux_id, er->ecm[0], er->caid, er->prid, er->pid, er->ecm[4], er->ecm[5], er->chid, curpid->irdeto_cycle, er->vpid);
4152        }
4153        else
4154        {
4155            cs_log_dbg(D_DVBAPI, "Demuxer %d ECMTYPE %02X CAID %04X PROVID %06X ECMPID %04X FAKECHID %04X (unique part in ecm)",
4156                          demux_id, er->ecm[0], er->caid, er->prid, er->pid, er->chid);
4157        }
4158
4159        // check for matching chid (unique ecm part in case of non-irdeto cas) + added fix for seca2 monthly changing fakechid
4160        if((curpid->CHID < 0x10000) && !((chid == curpid->CHID) || ((curpid->CAID >> 8 == 0x01) && (chid&0xF0FF) == (curpid->CHID&0xF0FF)) ) ) 
4161        {
4162            if(caid_is_irdeto(curpid->CAID))
4163            {
4164           
4165                if((curpid->irdeto_cycle < 0xFE) && (curpid->irdeto_cycle == curpid->irdeto_curindex))   // if same: we cycled all indexes but no luck!
4166                {
4167                    struct s_dvbapi_priority *forceentry = dvbapi_check_prio_match(demux_id, pid, 'p');
4168                    if(!forceentry || !forceentry->force)   // forced pid? keep trying the forced ecmpid, no force kill ecm filter
4169                    {
4170                        if(curpid->checked == 2) { curpid->checked = 4; }
4171                        if(curpid->checked == 1)
4172                        {
4173                            curpid->checked = 2;
4174                            curpid->CHID = 0x10000;
4175                        }
4176                        dvbapi_stop_filternum(demux_id, filter_num); // stop this ecm filter!
4177                        NULLFREE(er);
4178                        return;
4179                    }
4180                }
4181               
4182                curpid->irdeto_curindex++; // set check on next index
4183                if(curpid->irdeto_cycle == 0xFE) curpid->irdeto_cycle = buffer[4]; // on startup set to current irdeto index
4184                if(curpid->irdeto_curindex > curpid->irdeto_maxindex) { curpid->irdeto_curindex = 0; }  // check if we reached max irdeto index, if so reset to 0
4185
4186                curpid->table = 0;
4187                dvbapi_set_section_filter(demux_id, er, filter_num); // set ecm filter to odd + even since this ecm doesnt match with current irdeto index
4188                NULLFREE(er);
4189                return;
4190            }
4191            else  // all nonirdeto cas systems
4192            {
4193                struct s_dvbapi_priority *forceentry = dvbapi_check_prio_match(demux_id, pid, 'p');
4194                curpid->table = 0;
4195                dvbapi_set_section_filter(demux_id, er, filter_num); // set ecm filter to odd + even since this ecm doesnt match with current irdeto index
4196                if(forceentry && forceentry->force)
4197                {
4198                    NULLFREE(er);
4199                    return; // forced pid? keep trying the forced ecmpid!
4200                }
4201                if(curpid->checked == 2) { curpid->checked = 4; }
4202                if(curpid->checked == 1)
4203                {
4204                    curpid->checked = 2;
4205                    curpid->CHID = 0x10000;
4206                }
4207                dvbapi_stop_filternum(demux_id, filter_num); // stop this ecm filter!
4208                NULLFREE(er);
4209                return;
4210            }
4211        }
4212
4213        struct s_dvbapi_priority *p;
4214
4215        for(p = dvbapi_priority; p != NULL; p = p->next)
4216        {
4217            if(p->type != 'l'
4218                    || (p->caid && p->caid != curpid->CAID)
4219                    || (p->provid && p->provid != curpid->PROVID)
4220                    || (p->ecmpid && p->ecmpid != curpid->ECM_PID)
4221                    || (p->srvid && p->srvid != demux[demux_id].program_number))
4222                { continue; }
4223
4224            if((uint)p->delay == sctlen && p->force < 6)
4225            {
4226                p->force++;
4227                NULLFREE(er);
4228                return;
4229            }
4230            if(p->force >= 6)
4231                { p->force = 0; }
4232        }
4233
4234        if(!curpid->PROVID)
4235            { curpid->PROVID = chk_provid(buffer, curpid->CAID); }
4236
4237        if(caid_is_irdeto(curpid->CAID))   // irdeto: wait for the correct index
4238        {
4239            if(buffer[4] != curpid->irdeto_curindex)
4240            {
4241                curpid->table = 0;
4242                dvbapi_set_section_filter(demux_id, er, filter_num); // set ecm filter to odd + even since this ecm doesnt match with current irdeto index
4243                NULLFREE(er);
4244                return;
4245            }
4246        }
4247        // we have an ecm with the correct irdeto index (or fakechid)
4248        for(p = dvbapi_priority; p != NULL ; p = p->next)  // check for ignore!
4249        {
4250            if((p->type != 'i')
4251                    || (p->caid && p->caid != curpid->CAID)
4252                    || (p->provid && p->provid != curpid->PROVID)
4253                    || (p->ecmpid && p->ecmpid != curpid->ECM_PID)
4254                    || (p->pidx && p->pidx-1 != pid) 
4255                    || (p->srvid && p->srvid != demux[demux_id].program_number))
4256                { continue; }
4257
4258            if(p->type == 'i' && (p->chid < 0x10000 && p->chid == chid))    // found a ignore chid match with current ecm -> ignoring this irdeto index
4259            {
4260                curpid->irdeto_curindex++;
4261                if(curpid->irdeto_cycle == 0xFE) curpid->irdeto_cycle = buffer[4]; // on startup set to current irdeto index
4262                if(curpid->irdeto_curindex > curpid->irdeto_maxindex)    // check if curindex is over the max
4263                {
4264                    curpid->irdeto_curindex = 0;
4265                }
4266                curpid->table = 0;
4267                if(caid_is_irdeto(curpid->CAID) && (curpid->irdeto_cycle != curpid->irdeto_curindex))   // irdeto: wait for the correct index + check if we cycled all
4268                {
4269                    dvbapi_set_section_filter(demux_id, er, filter_num); // set ecm filter to odd + even since this chid has to be ignored!
4270                }
4271                else // this fakechid has to be ignored, kill this filter!
4272                {
4273                    if(curpid->checked == 2) { curpid->checked = 4; }
4274                    if(curpid->checked == 1)
4275                    {
4276                        curpid->checked = 2;
4277                        curpid->CHID = 0x10000;
4278                    }
4279                    dvbapi_stop_filternum(demux_id, filter_num); // stop this ecm filter!
4280                }
4281                NULLFREE(er);
4282                return;
4283            }
4284        }
4285       
4286        if(er) curpid->table = er->ecm[0];
4287        request_cw(dvbapi_client, er, demux_id, 1); // register this ecm for delayed ecm response check
4288        return; // end of ecm filterhandling!
4289    }
4290
4291    if(filtertype == TYPE_EMM)
4292    {
4293        if(len != 0)  // len = 0 receiver encountered an internal bufferoverflow!
4294        {
4295            cs_log_dump_dbg(D_DVBAPI, buffer, sctlen, "Demuxer %d Filter %d fetched EMM data (emmlength = 0x%03X):", demux_id, filter_num + 1, sctlen);
4296           
4297            if(sctlen > MAX_EMM_SIZE) // emm too long to handle!
4298            {
4299                cs_log_dbg(D_DVBAPI, "Received data with total length 0x%03X but maximum EMM length oscam can handle is 0x%03X -> Please report!", sctlen, MAX_EMM_SIZE);
4300                return;
4301            }
4302        }
4303        else
4304        {
4305            return; // just skip on internal bufferoverflow
4306        }
4307       
4308       
4309        if(demux[demux_id].demux_fd[filter_num].pid == 0x01) // CAT
4310        {
4311            cs_log_dbg(D_DVBAPI, "receiving cat");
4312            dvbapi_parse_cat(demux_id, buffer, sctlen);
4313
4314            dvbapi_stop_filternum(demux_id, filter_num);
4315            return;
4316        }
4317        dvbapi_process_emm(demux_id, filter_num, buffer, sctlen);
4318    }
4319   
4320    if(filtertype == TYPE_SDT)
4321    {   
4322        dvbapi_parse_sdt(demux_id, buffer, sctlen);
4323    }   
4324}
4325
4326static void *dvbapi_main_local(void *cli)
4327{
4328    int32_t i, j;
4329    struct s_client *client = (struct s_client *) cli;
4330    client->thread = pthread_self();
4331    SAFE_SETSPECIFIC(getclient, cli);
4332
4333    dvbapi_client = cli;
4334
4335    int32_t maxpfdsize = (MAX_DEMUX * maxfilter) + MAX_DEMUX + 2;
4336    struct pollfd pfd2[maxpfdsize];
4337    struct timeb start, end;  // start time poll, end time poll
4338#define PMT_SERVER_SOCKET "/tmp/.listen.camd.socket"
4339    struct sockaddr_un saddr;
4340    saddr.sun_family = AF_UNIX;
4341    strncpy(saddr.sun_path, PMT_SERVER_SOCKET, 107);
4342    saddr.sun_path[107] = '\0';
4343
4344    int32_t rc, pfdcount, g, connfd, clilen;
4345    int32_t ids[maxpfdsize], fdn[maxpfdsize], type[maxpfdsize];
4346    struct SOCKADDR servaddr;
4347    ssize_t len = 0;
4348    uchar mbuf[2048];
4349
4350    struct s_auth *account;
4351    int32_t ok = 0;
4352    for(account = cfg.account; account != NULL; account = account->next)
4353    {
4354        if((ok = is_dvbapi_usr(account->usr)))
4355            { break; }
4356    }
4357    cs_auth_client(client, ok ? account : (struct s_auth *)(-1), "dvbapi");
4358
4359    memset(demux, 0, sizeof(struct demux_s) * MAX_DEMUX);
4360    memset(ca_fd, 0, sizeof(ca_fd));
4361    memset(unassoc_fd, 0, sizeof(unassoc_fd));
4362
4363    dvbapi_read_priority();
4364    dvbapi_load_channel_cache();
4365    dvbapi_detect_api();
4366
4367    if(selected_box == -1 || selected_api == -1)
4368    {
4369        cs_log("ERROR: Could not detect DVBAPI version.");
4370        return NULL;
4371    }
4372   
4373    if(cfg.dvbapi_pmtmode == 1)
4374        { disable_pmt_files = 1; }
4375
4376    int32_t listenfd = -1;
4377    if(cfg.dvbapi_boxtype != BOXTYPE_IPBOX_PMT && cfg.dvbapi_pmtmode != 2 && cfg.dvbapi_pmtmode != 5 && cfg.dvbapi_pmtmode != 6)
4378    {
4379        if (!cfg.dvbapi_listenport)
4380            listenfd = dvbapi_init_listenfd();
4381        else
4382            listenfd = dvbapi_net_init_listenfd();
4383        if(listenfd < 1)
4384        {
4385            cs_log("ERROR: Could not init socket: (errno=%d: %s)", errno, strerror(errno));
4386            return NULL;
4387        }
4388    }
4389
4390    SAFE_MUTEX_INIT(&event_handler_lock, NULL);
4391
4392    for(i = 0; i < MAX_DEMUX; i++)  // init all demuxers!
4393    {
4394        demux[i].pidindex = -1;
4395        demux[i].curindex = -1;
4396    }
4397
4398    if(cfg.dvbapi_pmtmode != 4 && cfg.dvbapi_pmtmode != 5 && cfg.dvbapi_pmtmode != 6)
4399    {
4400        struct sigaction signal_action;
4401        signal_action.sa_handler = event_handler;
4402        sigemptyset(&signal_action.sa_mask);
4403        signal_action.sa_flags = SA_RESTART;
4404        sigaction(SIGRTMIN + 1, &signal_action, NULL);
4405
4406        dir_fd = open(TMPDIR, O_RDONLY);
4407        if(dir_fd >= 0)
4408        {
4409            fcntl(dir_fd, F_SETSIG, SIGRTMIN + 1);
4410            fcntl(dir_fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_DELETE | DN_MULTISHOT);
4411            event_handler(SIGRTMIN + 1);
4412        }
4413    }
4414    else
4415    {
4416        int32_t ret = start_thread("dvbapi event", dvbapi_event_thread, (void *) dvbapi_client, NULL, 1, 0);
4417        if(ret)
4418        {
4419            return NULL;
4420        }
4421    }
4422
4423    if(listenfd != -1)
4424    {
4425        pfd2[0].fd = listenfd;
4426        pfd2[0].events = (POLLIN | POLLPRI);
4427        type[0] = 1;
4428    }
4429
4430#if defined WITH_COOLAPI || defined WITH_COOLAPI2
4431    system("pzapit -rz");
4432#endif
4433    cs_ftime(&start); // register start time
4434    while(!exit_oscam)
4435    {
4436        if(pausecam)  // for dbox2, STAPI or PC in standby mode dont parse any ecm/emm or try to start next filter
4437            { continue; }
4438
4439        if(cfg.dvbapi_pmtmode == 6)
4440        {
4441            if(listenfd < 0)
4442            {
4443                cs_log("PMT6: Trying connect to enigma CA PMT listen socket...");
4444                /* socket init */
4445                if((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
4446                {
4447                   
4448                    cs_log("socket error (errno=%d %s)", errno, strerror(errno));
4449                    listenfd = -1;
4450                }
4451                else if(connect(listenfd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
4452                {
4453                    cs_log("socket connect error (errno=%d %s)", errno, strerror(errno));
4454                    close(listenfd);
4455                    listenfd = -1;
4456                }
4457                else
4458                {
4459                    pfd2[0].fd = listenfd;
4460                    pfd2[0].events = (POLLIN | POLLPRI);
4461                    type[0] = 1;
4462                    cs_log("PMT6 CA PMT Server connected on fd %d!", listenfd);
4463                }
4464            }
4465            if(listenfd == -1) // not connected!
4466            {
4467                cs_sleepms(1000);
4468                continue; // start fresh connect attempt!
4469            }
4470
4471        }
4472        pfdcount = (listenfd > -1) ? 1 : 0;
4473
4474        for(i = 0; i < MAX_DEMUX; i++)
4475        {   
4476            // add client fd's which are not yet associated with the demux but needs to be polled for data
4477            if (unassoc_fd[i]) {
4478                pfd2[pfdcount].fd = unassoc_fd[i];
4479                pfd2[pfdcount].events = (POLLIN | POLLPRI);
4480                type[pfdcount++] = 1;
4481            }
4482
4483            if(demux[i].program_number == 0) { continue; }  // only evalutate demuxers that have channels assigned
4484           
4485            uint32_t ecmcounter = 0, emmcounter = 0;
4486            for(g = 0; g < maxfilter; g++)
4487            {
4488                if(demux[i].demux_fd[g].fd <= 0) continue; // deny obvious invalid fd!
4489               
4490                if(!cfg.dvbapi_listenport && cfg.dvbapi_boxtype != BOXTYPE_PC_NODMX && selected_api != STAPI && selected_api != COOLAPI)
4491                {
4492                    pfd2[pfdcount].fd = demux[i].demux_fd[g].fd;
4493                    pfd2[pfdcount].events = (POLLIN | POLLPRI);
4494                    ids[pfdcount] = i;
4495                    fdn[pfdcount] = g;
4496                    type[pfdcount++] = 0;
4497                }
4498                if(demux[i].demux_fd[g].type == TYPE_ECM) { ecmcounter++; }  // count ecm filters to see if demuxing is possible anyway
4499                if(demux[i].demux_fd[g].type == TYPE_EMM) { emmcounter++; }  // count emm filters also
4500            }
4501            if(ecmcounter != demux[i].old_ecmfiltercount || emmcounter != demux[i].old_emmfiltercount)   // only produce log if something changed
4502            {
4503                cs_log_dbg(D_DVBAPI, "Demuxer %d has %d ecmpids, %d streampids, %d ecmfilters and %d of max %d emmfilters", i, demux[i].ECMpidcount,
4504                              demux[i].STREAMpidcount, ecmcounter, emmcounter, demux[i].max_emm_filter);
4505                demux[i].old_ecmfiltercount = ecmcounter; // save new amount of ecmfilters
4506                demux[i].old_emmfiltercount = emmcounter; // save new amount of emmfilters
4507            }
4508
4509            // delayed emm start for non irdeto caids, start emm cat if not already done for this demuxer!
4510           
4511            struct timeb now;
4512            cs_ftime(&now);
4513            int64_t gone;
4514            int8_t do_emm_start = (cfg.dvbapi_au > 0 && demux[i].emm_filter == -1 && demux[i].EMMpidcount == 0 && emmcounter == 0);
4515            int8_t do_sdt_start = (cfg.dvbapi_read_sdt && demux[i].sdt_filter == -1 && cfg.dvbapi_boxtype != BOXTYPE_SAMYGO);
4516           
4517            if(do_emm_start || do_sdt_start)
4518            {
4519                gone = comp_timeb(&now, &demux[i].emmstart);   
4520           
4521                if(gone > 30*1000){
4522                   
4523                    if(do_emm_start) {
4524                        cs_ftime(&demux[i].emmstart); // trick to let emm fetching start after 30 seconds to speed up zapping
4525                        dvbapi_start_filter(i, demux[i].pidindex, 0x001, 0x001, 0x01, 0x01, 0xFF, 0, TYPE_EMM); //CAT
4526                    }
4527                }
4528               
4529                if(gone > 10*1000){
4530                    if(do_sdt_start)
4531                    {
4532                        dvbapi_start_sdt_filter(i);
4533                    }
4534                }
4535            }
4536
4537            //early start for irdeto since they need emm before ecm (pmt emmstart = 1 if detected caid 0x06)
4538            int32_t emmstarted = demux[i].emm_filter;
4539            if(cfg.dvbapi_au && demux[i].EMMpidcount > 0)   // check every time since share readers might give us new filters due to hexserial change
4540            {
4541                if(!emmcounter && emmstarted == -1)
4542                {
4543                    demux[i].emmstart = now;
4544                    dvbapi_start_emm_filter(i); // start emmfiltering if emmpids are found
4545                }
4546                else
4547                {
4548                    gone = comp_timeb(&now, &demux[i].emmstart);
4549                    if(gone > 30*1000)
4550                    {
4551                        demux[i].emmstart = now;
4552                        dvbapi_start_emm_filter(i); // start emmfiltering delayed if filters already were running
4553                        rotate_emmfilter(i); // rotate active emmfilters
4554                    }
4555                }
4556            }
4557
4558            if(ecmcounter == 0 && demux[i].ECMpidcount > 0)   // Restart decoding all caids we have ecmpids but no ecm filters!
4559            {
4560
4561                int32_t started = 0;
4562
4563                for(g = 0; g < demux[i].ECMpidcount; g++)  // avoid race: not all pids are asked and checked out yet!
4564                {
4565                    if(demux[i].ECMpids[g].checked == 0 && demux[i].ECMpids[g].status >= 0)  // check if prio run is done
4566                    {
4567                        dvbapi_try_next_caid(i, 0); // not done, so start next prio pid
4568                        started = 1;
4569                        break;
4570                    }
4571                }
4572                if(started) { continue; }  // if started a filter proceed with next demuxer
4573
4574                if(g == demux[i].ECMpidcount)   // all usable pids (with prio) are tried, lets start over again without prio!
4575                {
4576                    for(g = 0; g < demux[i].ECMpidcount; g++)  // avoid race: not all pids are asked and checked out yet!
4577                    {
4578                        if(demux[i].ECMpids[g].checked == 2 && demux[i].ECMpids[g].status >= 0)  // check if noprio run is done
4579                        {
4580                            demux[i].ECMpids[g].irdeto_curindex = 0xFE;
4581                            demux[i].ECMpids[g].irdeto_maxindex = 0;
4582                            demux[i].ECMpids[g].irdeto_cycle = 0xFE;
4583                            demux[i].ECMpids[g].tries = 0xFE;
4584                            demux[i].ECMpids[g].table = 0;
4585                            demux[i].ECMpids[g].CHID = 0x10000; // remove chid prio
4586                            dvbapi_try_next_caid(i, 2); // not done, so start next no prio pid
4587                            started = 1;
4588                            break;
4589                        }
4590                    }
4591                }
4592                if(started) { continue; }  // if started a filter proceed with next demuxer
4593
4594                if(g == demux[i].ECMpidcount)   // all usable pids are tried, lets start over again!
4595                {
4596                    if(demux[i].decodingtries == -1) // first redecoding attempt?
4597                    {
4598                        cs_ftime(&demux[i].decstart);
4599                        for(g = 0; g < demux[i].ECMpidcount; g++)  // reinit some used things from second run (without prio)
4600                        {
4601                            demux[i].ECMpids[g].checked = 0;
4602                            demux[i].ECMpids[g].irdeto_curindex = 0xFE;
4603                            demux[i].ECMpids[g].irdeto_maxindex = 0;
4604                            demux[i].ECMpids[g].irdeto_cycle = 0xFE;
4605                            demux[i].ECMpids[g].table = 0;
4606                            demux[i].decodingtries = 0;
4607                            dvbapi_edit_channel_cache(i, g, 0); // remove this pid from channelcache since we had no founds on any ecmpid!
4608                        }
4609                    }
4610                    uint8_t number_of_enabled_pids = 0;
4611                    demux[i].decodingtries++;
4612                    dvbapi_resort_ecmpids(i);
4613                   
4614                    for(g = 0; g < demux[i].ECMpidcount; g++)  // count number of enabled pids!
4615                    {
4616                        if(demux[i].ECMpids[g].status >= 0) number_of_enabled_pids++;
4617                    }
4618                    if(!number_of_enabled_pids)
4619                    {
4620                        if(demux[i].decodingtries == 10)
4621                        {
4622                            demux[i].decodingtries = 0;
4623                            cs_log("Demuxer %d no enabled matching ecmpids -> decoding is waiting for matching readers!",i);
4624                        }
4625                    }
4626                    else
4627                    {
4628                        cs_ftime(&demux[i].decend);
4629                        demux[i].decodingtries = -1; // reset to first run again!
4630                        gone = comp_timeb(&demux[i].decend, &demux[i].decstart);
4631                        cs_log("Demuxer %d restarting decodingrequests after %"PRId64" ms with %d enabled and %d disabled ecmpids!", i, gone, number_of_enabled_pids,
4632                            (demux[i].ECMpidcount-number_of_enabled_pids));
4633                        dvbapi_try_next_caid(i, 0);
4634                    }
4635                }
4636            }
4637
4638            if(demux[i].socket_fd > 0 && cfg.dvbapi_pmtmode != 6)
4639            {
4640                rc = 0;
4641                for(j = 0; j < pfdcount; j++)
4642                {
4643                    if(pfd2[j].fd == demux[i].socket_fd)
4644                    {
4645                        rc = 1;
4646                        break;
4647                    }
4648                }
4649                if(rc == 1) { continue; }
4650
4651                pfd2[pfdcount].fd = demux[i].socket_fd;
4652                pfd2[pfdcount].events = (POLLIN | POLLPRI);
4653                ids[pfdcount] = i;
4654                type[pfdcount++] = 1;
4655            }
4656        }
4657
4658        rc = 0;
4659        while(!(listenfd == -1 && cfg.dvbapi_pmtmode == 6))
4660        {
4661            rc = poll(pfd2, pfdcount, 500);
4662            if(rc < 0) // error occured while polling for fd's with fresh data
4663            { 
4664                if(errno == EINTR || errno == EAGAIN) // try again in case of interrupt
4665                { 
4666                    continue; 
4667                }
4668                cs_log("ERROR: error on poll of %d fd's (errno=%d %s)", pfdcount, errno, strerror(errno));
4669                break;
4670            }
4671            else
4672            {
4673                break;
4674            }
4675        }
4676
4677        if(rc > 0)
4678        {
4679            cs_ftime(&end); // register end time
4680            int64_t timeout = comp_timeb(&end, &start);
4681            if (timeout < 0) {
4682                cs_log("*** WARNING: BAD TIME AFFECTING WHOLE OSCAM ECM HANDLING ****");
4683            }
4684            cs_log_dbg(D_TRACE, "New events occurred on %d of %d handlers after %"PRId64" ms inactivity", rc, pfdcount, timeout);
4685            cs_ftime(&start); // register new start time for next poll
4686        }
4687
4688        for(i = 0; i < pfdcount && rc > 0; i++)
4689        {
4690            if(pfd2[i].revents == 0) { continue; }  // skip sockets with no changes
4691            rc--; //event handled!
4692            cs_log_dbg(D_TRACE, "Now handling fd %d that reported event %d", pfd2[i].fd, pfd2[i].revents);
4693
4694            if(pfd2[i].revents & (POLLHUP | POLLNVAL | POLLERR))
4695            {
4696                if(type[i] == 1)
4697                {
4698                    for(j = 0; j < MAX_DEMUX; j++)
4699                    {
4700                        if(demux[j].socket_fd == pfd2[i].fd)  // if listenfd closes stop all assigned decoding!
4701                        {
4702                            dvbapi_stop_descrambling(j);
4703                        }
4704                    }
4705                    int32_t ret = close(pfd2[i].fd);
4706                    if(ret < 0 && errno != 9) { cs_log("ERROR: Could not close demuxer socket fd (errno=%d %s)", errno, strerror(errno)); }
4707                    if(pfd2[i].fd == listenfd && cfg.dvbapi_pmtmode == 6)
4708                    {
4709                        listenfd = -1;
4710                    }
4711                }
4712                else   // type = 0
4713                {
4714                    int32_t demux_index = ids[i];
4715                    int32_t n = fdn[i];
4716                   
4717                    if(cfg.dvbapi_boxtype != BOXTYPE_SAMYGO)
4718                    {
4719                        dvbapi_stop_filternum(demux_index, n); // stop filter since its giving errors and wont return anything good.
4720                    }
4721                    else
4722                    {
4723                        int32_t ret, pid;
4724                        uchar filter[32];
4725                        struct dmx_sct_filter_params sFP;
4726           
4727                        cs_log_dbg(D_DVBAPI, "re-opening connection to demux socket");
4728                        close(demux[demux_index].demux_fd[n].fd);
4729                        demux[demux_index].demux_fd[n].fd  = -1;
4730                       
4731                        ret = dvbapi_open_device(0, demux[demux_index].demux_index, demux[demux_index].adapter_index);
4732                        if(ret != -1)
4733                        {
4734                            demux[demux_index].demux_fd[n].fd = ret;
4735                                           
4736                            pid = demux[demux_index].curindex;
4737
4738                            memset(filter, 0, 32);
4739                            memset(&sFP, 0, sizeof(sFP));
4740                           
4741                            filter[0] = 0x80;
4742                            filter[16] = 0xF0;
4743                           
4744                            sFP.pid            = demux[demux_index].ECMpids[pid].ECM_PID;
4745                            sFP.timeout        = 3000;
4746                            sFP.flags          = DMX_IMMEDIATE_START;           
4747                            memcpy(sFP.filter.filter, filter, 16);
4748                            memcpy(sFP.filter.mask, filter + 16, 16);
4749                            ret = dvbapi_ioctl(demux[demux_index].demux_fd[n].fd, DMX_SET_FILTER, &sFP);
4750                        }
4751                       
4752                        if(ret == -1)
4753                            dvbapi_stop_filternum(demux_index, n); // stop filter since its giving errors and wont return anything good.
4754                    }
4755                }
4756                continue; // continue with other events
4757            }
4758
4759            if(pfd2[i].revents & (POLLIN | POLLPRI))
4760            {
4761                if(type[i] == 1 && pmthandling == 0)
4762                {
4763                    pmthandling = 1;     // pmthandling in progress!
4764                    connfd = -1;         // initially no socket to read from
4765                    int add_to_poll = 0; // we may need to additionally poll this socket when no PMT data comes in
4766
4767                    if (pfd2[i].fd == listenfd)
4768                    {
4769                        if (cfg.dvbapi_pmtmode == 6) {
4770                            connfd = listenfd;
4771                            disable_pmt_files = 1;
4772                        } else {
4773                            clilen = sizeof(servaddr);
4774                            connfd = accept(listenfd, (struct sockaddr *)&servaddr, (socklen_t *)&clilen);
4775                            cs_log_dbg(D_DVBAPI, "new socket connection fd: %d", connfd);
4776                            if (cfg.dvbapi_listenport)
4777                            {
4778                                //update webif data
4779                                client->ip = SIN_GET_ADDR(servaddr);
4780                                client->port = ntohs(SIN_GET_PORT(servaddr));
4781                            }
4782                            add_to_poll = 1;
4783
4784                            if(cfg.dvbapi_pmtmode == 3 || cfg.dvbapi_pmtmode == 0) { disable_pmt_files = 1; }
4785
4786                            if(connfd <= 0)
4787                                cs_log_dbg(D_DVBAPI, "accept() returns error on fd event %d (errno=%d %s)", pfd2[i].revents, errno, strerror(errno));
4788                        }
4789                    }
4790                    else
4791                    {
4792                        cs_log_dbg(D_DVBAPI, "PMT Update on socket %d.", pfd2[i].fd);
4793                        connfd = pfd2[i].fd;
4794                    }
4795
4796                    //reading and completing data from socket
4797                    if (connfd > 0) {
4798                        uint32_t pmtlen = 0, chunks_processed = 0;
4799
4800                        int8_t tries = 1;
4801                        do {
4802                            if(tries > 1)
4803                            {
4804                                cs_sleepms(50);
4805                            }
4806                            cs_log_dbg(D_DVBAPI, "%s to read from connection fd %d try %d", ((chunks_processed == 0 && pmtlen == 0) ? "Trying":"Continue"), connfd , tries);
4807                            len = cs_recv(connfd, mbuf + pmtlen, sizeof(mbuf) - pmtlen, MSG_DONTWAIT);
4808                            if (len > 0)
4809                                pmtlen += len;
4810                            if (len == -1 && (errno != EINTR && errno != EAGAIN))
4811                            {
4812                                //client disconnects, stop all assigned decoding
4813                                cs_log_dbg(D_DVBAPI, "Socket %d reported connection close", connfd);
4814                                int active_conn = 0; //other active connections counter
4815                               
4816                                for (j = 0; j < MAX_DEMUX; j++)
4817                                {
4818                                    if (demux[j].socket_fd == connfd)
4819                                        dvbapi_stop_descrambling(j);
4820                                    else if (demux[j].socket_fd)
4821                                        active_conn++;
4822                                    // remove from unassoc_fd when necessary
4823                                    if (unassoc_fd[j] == connfd)
4824                                        unassoc_fd[j] = 0;
4825                                }
4826                                close(connfd);
4827                                connfd = -1;
4828                                add_to_poll = 0;
4829                                if (!active_conn && (cfg.dvbapi_listenport || cfg.dvbapi_boxtype == BOXTYPE_PC_NODMX)) //last connection closed
4830                                {
4831                                    client_proto_version = 0;
4832                                    if (client_name)
4833                                    {
4834                                        free(client_name);
4835                                        client_name = NULL;
4836                                    }
4837                                    if (cfg.dvbapi_listenport)
4838                                    {
4839                                        //update webif data
4840                                        client->ip = get_null_ip();
4841                                        client->port = 0;
4842                                    }
4843                                }
4844                                break;
4845                            }
4846                            if (pmtlen >= 8) //if we received less then 8 bytes, than it's not complete for sure
4847                            {
4848                                // check and try to process complete PMT objects and filter data by chunks to avoid PMT buffer overflows
4849                                uint32_t opcode_ptr;
4850                                memcpy(&opcode_ptr, &mbuf[0], 4);                     //used only to silent compiler warning about dereferencing type-punned pointer
4851                                uint32_t opcode = ntohl(opcode_ptr);                  //get the client opcode (4 bytes)
4852                                uint32_t chunksize = 0;                               //size of complete chunk in the buffer (an opcode with the data)
4853                                uint32_t data_len = 0;                                //variable for internal data length (eg. for the filter data size, PMT len)
4854
4855                                //detect the opcode, its size (chunksize) and its internal data size (data_len)
4856                                if ((opcode & 0xFFFFF000) == DVBAPI_AOT_CA)
4857                                {
4858                                    // parse packet size (ASN.1)
4859                                    uint32_t size = 0;
4860                                    if (mbuf[3] & 0x80)
4861                                    {
4862                                        data_len = 0;
4863                                        size = mbuf[3] & 0x7F;
4864                                        if (pmtlen > 4 + size)
4865                                        {
4866                                            uint32_t k;
4867                                            for (k = 0; k < size; k++)
4868                                                data_len = (data_len << 8) | mbuf[3 + 1 + k];
4869                                            size++;
4870                                        }
4871                                    }
4872                                    else
4873                                    {
4874                                        data_len = mbuf[3] & 0x7F;
4875                                        size = 1;
4876                                    }
4877                                    chunksize = 3 + size + data_len;
4878                                }
4879                                else switch (opcode)
4880                                {
4881                                    case DVBAPI_FILTER_DATA:
4882                                    {
4883                                        data_len = b2i(2, mbuf + 7) & 0x0FFF;
4884                                        chunksize = 6 + 3 + data_len;
4885                                        break;
4886                                    }
4887                                    case DVBAPI_CLIENT_INFO:
4888                                    {
4889                                        data_len = mbuf[6];
4890                                        chunksize = 6 + 1 + data_len;
4891                                        break;
4892                                    }
4893                                    default:
4894                                        cs_log("Unknown socket command received: 0x%08X", opcode);
4895                                }
4896
4897                                //processing the complete data according to type
4898                                if (chunksize < sizeof(mbuf) && chunksize <= pmtlen) // only handle if we fetched a complete chunksize!
4899                                {
4900                                    chunks_processed++;
4901                                    tries = 1;
4902                                    if ((opcode & 0xFFFFF000) == DVBAPI_AOT_CA)
4903                                    {
4904                                        cs_log_dump_dbg(D_DVBAPI, mbuf, chunksize, "Parsing PMT object %d:", chunks_processed);
4905                                        dvbapi_handlesockmsg(mbuf, chunksize, connfd);
4906                                        add_to_poll = 0;
4907                                        if (cfg.dvbapi_listenport && opcode == DVBAPI_AOT_CA_STOP)
4908                                            add_to_poll = 1;
4909                                    }
4910                                    else switch (opcode)
4911                                    {
4912                                        case DVBAPI_FILTER_DATA:
4913                                        {
4914                                            int32_t demux_index = mbuf[4];
4915                                            int32_t filter_num = mbuf[5];
4916                                            dvbapi_process_input(demux_index, filter_num, mbuf + 6, data_len + 3);
4917                                            break;
4918                                        }
4919                                        case DVBAPI_CLIENT_INFO:
4920                                        {
4921                                            uint16_t client_proto_ptr;
4922                                            memcpy(&client_proto_ptr, &mbuf[4], 2);
4923                                            uint16_t client_proto = ntohs(client_proto_ptr);
4924                                            if (client_name)
4925                                                free(client_name);
4926                                            if (cs_malloc(&client_name, data_len + 1))
4927                                            {
4928                                                memcpy(client_name, &mbuf[7], data_len);
4929                                                client_name[data_len] = 0;
4930                                                cs_log("Client connected: '%s' (protocol version = %d)", client_name, client_proto);
4931                                            }
4932                                            client_proto_version = client_proto; //setting the global var according to the client
4933
4934                                            // as a response we are sending our info to the client:
4935                                            dvbapi_net_send(DVBAPI_SERVER_INFO, connfd, -1, -1, NULL, NULL, NULL);
4936                                            break;
4937                                        }
4938                                    }
4939
4940                                    if (pmtlen == chunksize) // if we fetched and handled the exact chunksize reset buffer counter!
4941                                        pmtlen = 0;
4942
4943                                    // if we read more data then processed, move it to beginning
4944                                    if (pmtlen > chunksize)
4945                                    {
4946                                        memmove(mbuf, mbuf + chunksize, pmtlen - chunksize);
4947                                        pmtlen -= chunksize;
4948                                    }
4949                                    continue;
4950                                }
4951                            }
4952                            //cs_log_dbg(D_DVBAPI, "len = %d, pmtlen = %d, chunks_processed = %d", len, pmtlen, chunks_processed);
4953                            if(len == -1 && pmtlen == 0 && chunks_processed > 0) // did we receive and process complete pmt already?
4954                            {
4955                                cs_log_dbg(D_DVBAPI, "Seems we received and parsed all PMT objects!");
4956                                break;
4957                            }
4958                            tries++;
4959                        } while (pmtlen < sizeof(mbuf) && tries < 10); //wait for data become available and try again
4960
4961                        // if the connection is new and we read no PMT data, then add it to the poll,
4962                        // otherwise this socket will not be checked with poll when data arives
4963                        // because fd it is not yet assigned with the demux
4964                        if (add_to_poll) {
4965                            for (j = 0; j < MAX_DEMUX; j++) {
4966                                if (!unassoc_fd[j]) {
4967                                    unassoc_fd[j] = connfd;
4968                                    break;
4969                                }
4970                            }
4971                        }
4972
4973                        if (pmtlen > 0) {
4974                            if (pmtlen < 3)
4975                                cs_log_dbg(D_DVBAPI, "CA PMT server message too short!");
4976                            else {
4977                                if (pmtlen >= sizeof(mbuf))
4978                                    cs_log("***** WARNING: PMT BUFFER OVERFLOW, PLEASE REPORT! ****** ");
4979                                cs_log_dump_dbg(D_DVBAPI, mbuf, pmtlen, "New PMT info from socket (total size: %d)", pmtlen);
4980                                dvbapi_handlesockmsg(mbuf, pmtlen, connfd);
4981                            }
4982                        }
4983                    }
4984                    pmthandling = 0; // pmthandling done!
4985                    continue; // continue with other events!
4986                }
4987                else     // type==0
4988                {
4989                    int32_t demux_index = ids[i];
4990                    int32_t n = fdn[i];
4991                   
4992                    if((int)demux[demux_index].demux_fd[n].fd != pfd2[i].fd) { continue; } // filter already killed, no need to process this data!
4993                   
4994                    len = dvbapi_read_device(pfd2[i].fd, mbuf, sizeof(mbuf));
4995                    if(len < 0) // serious filterdata read error
4996                    {
4997                        dvbapi_stop_filternum(demux_index, n); // stop filter since its giving errors and wont return anything good.
4998                        maxfilter--; // lower maxfilters to avoid this with new filter setups!
4999                        continue;
5000                    }
5001                    if(!len) // receiver internal filterbuffer overflow
5002                    {
5003                        memset(mbuf, 0, sizeof(mbuf));
5004                    }
5005
5006                    dvbapi_process_input(demux_index, n, mbuf, len);
5007                }
5008                continue; // continue with other events!
5009            }
5010        }
5011    }
5012    return NULL;
5013}
5014
5015void dvbapi_write_cw(int32_t demux_id, uchar *cw, int32_t pid)
5016{
5017    int32_t n;
5018    int8_t cwEmpty = 0;
5019    unsigned char nullcw[8];
5020    memset(nullcw, 0, 8);
5021    ca_descr_t ca_descr;
5022
5023    memset(&ca_descr, 0, sizeof(ca_descr));
5024   
5025    if(memcmp(demux[demux_id].lastcw[0], nullcw, 8) == 0
5026            && memcmp(demux[demux_id].lastcw[1], nullcw, 8) == 0)
5027        { cwEmpty = 1; } // to make sure that both cws get written on constantcw
5028
5029
5030    for(n = 0; n < 2; n++)
5031    {
5032        char lastcw[9 * 3];
5033        char newcw[9 * 3];
5034        cs_hexdump(0, demux[demux_id].lastcw[n], 8, lastcw, sizeof(lastcw));
5035        cs_hexdump(0, cw + (n * 8), 8, newcw, sizeof(newcw));
5036
5037        if((memcmp(cw + (