Changeset 1877


Ignore:
Timestamp:
03/21/10 20:50:33 (14 years ago)
Author:
_network
Message:

dvbapi: fix selection of caid and descrambling with multiple ecmpids for one caid

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/module-dvbapi.c

    r1874 r1877  
    1 /*
    2  *
    3  * This program is free software; you can redistribute it and/or modify
    4  * it under the terms of the GNU General Public License as published by
    5  * the Free Software Foundation; either version 2 of the License, or
    6  * (at your option) any later version.
    7  *
    8  * This program is distributed in the hope that it will be useful,
    9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    11  * GNU General Public License for more details.
    12  *
    13  * You should have received a copy of the GNU General Public License
    14  * along with this program; if not, write to the Free Software
    15  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    16  *
    17  */
    181#include "globals.h"
    192
     
    225#include <sys/un.h>
    236
    24 #define BUFSIZE 512
    257#define MAX_DEMUX 5
    268#define MAX_CAID 50
     
    3618    unsigned short CA_System_ID;
    3719    unsigned short EMM_PID;
     20    //unsigned int provider_id;
    3821    unsigned short checked;
    3922} ECMPIDSTYPE;
     
    4225{
    4326    int fd;
    44     ushort pid;
    45     ushort caid;
     27    ushort PID;
     28    ushort CA_System_ID;
    4629    ushort type;
    4730} FILTERTYPE;
     
    5639    unsigned short ECMpidcount;
    5740    ECMPIDSTYPE ECMpids[ECM_PIDS];
     41    int pidindex;
    5842    unsigned short program_number;
    59     unsigned short ca_system_id;
    60     unsigned short ca_pid;
    61     unsigned int provider_id;
    62     unsigned short emm_pid;
    6343    unsigned short STREAMpidcount;
    6444    unsigned short STREAMpids[ECM_PIDS];
    6545    unsigned char buffer_cache_dmx[CS_ECMSTORESIZE];
    66     unsigned char lastcw0[8];
    67     unsigned char lastcw1[8];
     46    unsigned char lastcw[2][8];
    6847} DEMUXTYPE;
    6948#define DMX_FILTER_SIZE 16
     
    154133int selected_api=-1;
    155134
    156 int dvbapi_set_filter(int dmx_fd, int api, unsigned short pid, unsigned char filt, unsigned char mask, int timeout) {
     135int emm_count[]={0,0,0,0};
     136
     137#if 0
     138extern uchar *nagra2_get_emm_filter(struct s_reader*, int);
     139extern uchar *irdeto_get_emm_filter(struct s_reader*, int);
     140#endif
     141
     142int dvbapi_set_filter(int dmx_fd, int api, unsigned short pid, uchar *filt, uchar *mask, int timeout) {
    157143    int ret=-1;
    158144
    159     cs_debug("dvbapi: set filter pid:%04x, value:%04x",pid, filt);
     145    cs_debug("dvbapi: set filter pid:%04x", pid);
    160146
    161147    switch(api)
     
    170156            sFP2.timeout            = timeout;
    171157            sFP2.flags          = DMX_IMMEDIATE_START;
    172             sFP2.filter.filter[0]   = filt;
    173             sFP2.filter.mask[0]     = mask;
     158            memcpy(sFP2.filter.filter,filt,16);
     159            memcpy(sFP2.filter.mask,mask,16);
    174160            ret=ioctl(dmx_fd, DMX_SET_FILTER, &sFP2);
    175161
     
    184170            sFP1.timeout            = timeout;
    185171            sFP1.flags          = DMX_IMMEDIATE_START;
    186             sFP1.filter.filter[0]   = filt;
    187             sFP1.filter.mask[0]     = mask;
     172            memcpy(sFP1.filter.filter,filt,16);
     173            memcpy(sFP1.filter.mask,mask,16);
    188174            ret=ioctl(dmx_fd, DMX_SET_FILTER1, &sFP1);
    189175
     
    198184    return ret;
    199185}
    200 
    201186
    202187int dvbapi_check_array(unsigned short *array, int len, unsigned short match) {
     
    215200    int apinum=-1;
    216201    int dmx_fd=0;
     202    uchar filter[16], filtermask[16];
     203
     204    memset(filter,0,16);
     205    memset(filtermask,0,16);
     206    filter[0]=0x01;
     207    filtermask[0]=0xFF;
    217208
    218209    char device_path[128];
    219210
    220     for (i=0;i<BOX_COUNT;i++)
    221     {
     211    for (i=0;i<BOX_COUNT;i++) {
    222212        sprintf(device_path, devices[i].demux_device_path, 0);
    223213        if ((dmx_fd = open(device_path, O_RDWR)) > 0) {
     
    229219    if (dmx_fd < 0) return 0;
    230220
    231     int ret=0;
    232 
    233     for (i=0;i<num_apis;i++)
    234     {
    235         ret=dvbapi_set_filter(dmx_fd, i, 0x0001, 0x01, 0xFF, 1);
     221    int ret=-1;
     222
     223    for (i=0;i<num_apis;i++) {
     224        ret=dvbapi_set_filter(dmx_fd, i, 0x0001, filter, filtermask, 1);
    236225
    237226        if (ret >= 0)
     
    265254    len = read(dmx_fd, buf, length);
    266255
    267     if (len==-1 && errno!=75) //FIXME: read error 75, reason unknown (dbox2?)
    268         cs_log("dvbapi: read error %d", errno);
     256    if (len==-1)
     257        cs_log("dvbapi: read error %d on fd %d", errno, dmx_fd);
    269258
    270259    if (debug==1)
     
    298287    }
    299288
    300     cs_debug("dvbapi: DEVICE open (%s)", device_path);
     289    cs_debug("dvbapi: DEVICE open (%s) fd %d", device_path, dmx_fd);
    301290    return dmx_fd;
    302291}
     
    316305}
    317306
    318 void dvbapi_start_filter(int demux_index, ushort caid, unsigned short pid, ushort table, ushort mask, int type) {
     307void dvbapi_start_filter(int demux_index, ushort caid, unsigned short pid, uchar table, uchar mask, int type) {
    319308    int dmx_fd,i,n=-1;
     309    uchar filter[32];
    320310
    321311    for (i=0;i<MAX_FILTER;i++) {
     
    334324
    335325    demux[demux_index].demux_fd[n].fd=dmx_fd;
    336     demux[demux_index].demux_fd[n].caid=caid;
    337     demux[demux_index].demux_fd[n].pid=pid;
     326    demux[demux_index].demux_fd[n].CA_System_ID=caid;
     327    demux[demux_index].demux_fd[n].PID=pid;
    338328    demux[demux_index].demux_fd[n].type=type;
    339329
    340     dvbapi_set_filter(dmx_fd, selected_api, pid, table, mask, 4000);
     330    memset(filter,0,32);
     331
     332    filter[0]=table;
     333    filter[16]=mask;
     334
     335    dvbapi_set_filter(dmx_fd, selected_api, pid, filter, filter+16, 4000);
     336}
     337
     338void dvbapi_start_emm_filter(int demux_index, int emmtype, int type) {
     339    int dmx_fd,i,n=-1;
     340    uchar filter[32];
     341
     342    if (demux[demux_index].pidindex==-1) return;
     343
     344    ushort caid = demux[demux_index].ECMpids[demux[demux_index].pidindex].CA_System_ID;
     345    ushort pid  = demux[demux_index].ECMpids[demux[demux_index].pidindex].EMM_PID;
     346
     347    int found=0;
     348    for (i=0;i<CS_MAXREADER;i++) {
     349        if (reader[i].caid[0] == demux[demux_index].ECMpids[demux[demux_index].pidindex].CA_System_ID) {
     350            client[cs_idx].au=i;
     351            found=1;
     352            break;
     353        }
     354    }
     355
     356#ifndef NOT_MODULAR
     357#define SC_IRDETO 1 //reader-common.c
     358#define SC_NAGRA 8
     359    switch(reader[client[cs_idx].au].card_system) {
     360#if 0
     361        case SC_IRDETO:
     362            i=0;
     363            uchar *filter1 = irdeto_get_emm_filter(&reader[client[cs_idx].au], emmtype);
     364            memcpy(filter,filter1,32);
     365            break;
     366        case SC_NAGRA:
     367            i=0;
     368            uchar *filter1 = nagra2_get_emm_filter(&reader[client[cs_idx].au], emmtype);
     369            memcpy(filter,filter1,32);
     370            break;
     371#endif
     372        default:
     373            if (emmtype!=GLOBAL) return;
     374            memset(filter,0,32);
     375            filter[0]=0x80;
     376            filter[0+16]=0xF0;
     377            break;
     378    }
     379#else
     380    if (cardsystem[reader[client[cs_idx].au].card_system-1].get_emm_filter) {
     381        uchar *filter1 = cardsystem[reader[client[cs_idx].au].card_system-1].get_emm_filter(&reader[client[cs_idx].au], emmtype);
     382        memcpy(filter,filter1,32);
     383    } else {
     384        if (emmtype!=GLOBAL) return;
     385        memset(filter,0,32);
     386        filter[0]=0x80;
     387        filter[0+16]=0xF0;
     388    }
     389#endif
     390
     391    for (i=0;i<MAX_FILTER;i++) {
     392        if (demux[demux_index].demux_fd[i].fd<=0) {
     393            n=i;
     394            break;
     395        }
     396    }
     397
     398    if (n==-1) {
     399        cs_log("dvbapi: no free filter");
     400        return;
     401    }
     402
     403    dmx_fd=dvbapi_open_device(demux_index, 0);
     404
     405    demux[demux_index].demux_fd[n].fd=dmx_fd;
     406    demux[demux_index].demux_fd[n].CA_System_ID=caid;
     407    demux[demux_index].demux_fd[n].PID=pid;
     408    demux[demux_index].demux_fd[n].type=type;
     409
     410    cs_ddump(filter, 32, "demux filter:");
     411    dvbapi_set_filter(dmx_fd, selected_api, pid, filter, filter+16, 0);
    341412}
    342413
     
    346417    cs_ddump(buf, len, "cat:");
    347418
    348     for (i = 8; i < (((buf[1] & 0x0F) << 8) | buf[2]) - 1; i += buf[i + 1] + 2)
    349     {
     419    for (i = 8; i < (((buf[1] & 0x0F) << 8) | buf[2]) - 1; i += buf[i + 1] + 2) {
    350420        if (buf[i] != 0x09) continue;
    351421        unsigned short cat_sys_id=(((buf[i + 2] & 0x1F) << 8) | buf[i + 3]);
     
    355425            if (demux[demux_index].ECMpids[j].CA_System_ID==(((buf[i + 2] & 0x1F) << 8) | buf[i + 3])) {
    356426                demux[demux_index].ECMpids[j].EMM_PID=emm_pid;
    357                 break;
    358427            }
    359428        }
     
    365434    int i;
    366435
    367     cs_debug("dvbapi: Stop descrambling CAID: %04x", demux[demux_id].ca_system_id);
    368 
    369     demux[demux_id].ca_system_id=0;
    370     demux[demux_id].ca_pid=0;
    371     demux[demux_id].emm_pid=0;
    372     demux[demux_id].provider_id=0;
    373436    demux[demux_id].demux_index=-1;
    374437    demux[demux_id].program_number=0;
    375438    demux[demux_id].socket_fd=0;
    376 
    377     dvbapi_stop_filter(demux_id, 0);
    378     dvbapi_stop_filter(demux_id, 1);
     439    demux[demux_id].pidindex=-1;
     440
     441    dvbapi_stop_filter(demux_id, TYPE_ECM);
     442    dvbapi_stop_filter(demux_id, TYPE_EMM);
    379443
    380444    memset(demux[demux_id].buffer_cache_dmx, 0, CS_ECMSTORESIZE);
     
    407471}
    408472
    409 void dvbapi_stop_descrambling_all(int demux_index) {
    410     int j;
    411     for (j=0;j<MAX_DEMUX;j++) {
    412         if (demux[j].demux_index != demux_index)
    413             continue;
    414 
    415         dvbapi_stop_descrambling(j);
    416     }
    417 
    418     return;
    419 }
    420 
    421 void dvbapi_start_descrambling(int demux_index, unsigned short caid, unsigned short capid, unsigned long provider_id) {
    422     int i;
     473void dvbapi_start_descrambling(int demux_index, unsigned short caid, unsigned short pid) {
     474    int i,n;
    423475
    424476    cs_log("dvbapi: Start descrambling CAID: %04x", caid);
    425477
    426     demux[demux_index].ca_pid=capid;
    427     demux[demux_index].ca_system_id=caid;
    428     demux[demux_index].provider_id=provider_id;
     478    for (n=0; n<demux[demux_index].ECMpidcount; n++) {
     479        if (demux[demux_index].ECMpids[n].CA_System_ID==caid && demux[demux_index].ECMpids[n].CA_PID==pid) {
     480            demux[demux_index].pidindex=n;
     481            break;
     482        }
     483    }
    429484
    430485    demux[demux_index].ca_fd = dvbapi_open_device(demux_index,1);
     
    441496    }
    442497
    443 }
    444 
    445 void dvbapi_process_emm (int demux_index, unsigned char *buffer, unsigned int len)
    446 {
     498    if (cfg->dvbapi_au==1)
     499        dvbapi_start_filter(demux_index, caid, 0x001, 0x01, 0xFF, TYPE_EMM); //CAT
     500}
     501
     502void dvbapi_process_emm (int demux_index, unsigned char *buffer, unsigned int len) {
    447503    int i;
    448504    EMM_PACKET epg;
    449     cs_debug("dvbapi: EMM Type: 0x%02x caid: %04x", buffer[0],demux[demux_index].ca_system_id);
    450     cs_ddump(buffer, len, "emm:");
     505
     506    if (demux[demux_index].pidindex==-1) return;
     507    cs_ddump(buffer, 16, "emm:");
    451508
    452509    //force emm output
     
    454511
    455512    memset(&epg, 0, sizeof(epg));
    456     epg.caid[0] = (uchar)(demux[demux_index].ca_system_id>>8);
    457     epg.caid[1] = (uchar)(demux[demux_index].ca_system_id);
     513    epg.caid[0] = (uchar)(demux[demux_index].ECMpids[demux[demux_index].pidindex].CA_System_ID>>8);
     514    epg.caid[1] = (uchar)(demux[demux_index].ECMpids[demux[demux_index].pidindex].CA_System_ID);
    458515
    459516    unsigned long provid = (buffer[10] << 8) | buffer[11];
    460     int pid=dvbapi_check_array(prioritytab.caid, CS_MAXCAIDTAB, demux[demux_index].ca_system_id);
     517    int pid=dvbapi_check_array(prioritytab.caid, CS_MAXCAIDTAB, demux[demux_index].ECMpids[demux[demux_index].pidindex].CA_System_ID);
    461518    if (pid>=0) {
    462519        if (prioritytab.mask[pid]>0)
     
    473530    int found=0;
    474531    for (i=0;i<CS_MAXREADER;i++) {
    475         if (reader[i].caid[0] == demux[demux_index].ca_system_id) {
     532        if (reader[i].caid[0] == demux[demux_index].ECMpids[demux[demux_index].pidindex].CA_System_ID) {
    476533            client[cs_idx].au=i;
    477534            found=1;
     
    479536        }
    480537    }
    481     if (found==1 && reader[client[cs_idx].au].card_system>0)
     538
     539    if (found==1 && reader[client[cs_idx].au].card_system>0) {
     540        /* cardsystem[reader[client[cs_idx].au].card_system-1].get_emm_type(&epg, &reader[client[cs_idx].au]);
     541        char *typtext[]={"UNKNOWN", "UNIQUE", "SHARED", "GLOBAL"};
     542        emm_count[epg.type]++;
     543        cs_debug("dvbapi: %s emm (unk/g/s/u) (%d/%d/%d/%d)", typtext[epg.type], emm_count[UNKNOWN], emm_count[GLOBAL], emm_count[SHARED], emm_count[UNIQUE]); */
    482544        do_emm(&epg);
     545    }
     546
    483547}
    484548
     
    492556    for (i=0;i<CS_MAXREADER;i++) {
    493557        for (j=0;j<CS_MAXREADER;j++) {
    494             if (reader[i].caid[j] != 0) {
     558            if (reader[i].caid[j] != 0 && reader[i].card_system > 0) {
    495559                if (k+1>=MAX_CAID) break;
    496560                global_caid_list[k++]=reader[i].caid[j];   
     
    539603            added=0;
    540604            for (n=0;n<demux[demux_id].ECMpidcount;n++) {
    541                 if (demux[demux_id].ECMpids[n].CA_System_ID==descriptor_ca_system_id)
     605                if (demux[demux_id].ECMpids[n].CA_System_ID==descriptor_ca_system_id && demux[demux_id].ECMpids[n].CA_PID==descriptor_ca_pid)
    542606                    added=1;
    543607            }
     
    545609                demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].CA_PID=descriptor_ca_pid;
    546610                demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].CA_System_ID=descriptor_ca_system_id;
     611                demux[demux_id].ECMpids[demux[demux_id].ECMpidcount].checked=0;
    547612                demux[demux_id].ECMpids[demux[demux_id].ECMpidcount++].EMM_PID=0;
    548613            }
     
    577642    if (demux_id<0) {
    578643        cs_log("dvbapi: error no free id (MAX_DEMUX)");
    579         return 0;
     644        return -1;
    580645    }
    581646
     
    625690
    626691            dvbapi_start_filter(demux_id, demux[demux_id].ECMpids[0].CA_System_ID, demux[demux_id].ECMpids[0].CA_PID, 0x80, 0xF0, TYPE_ECM);
    627             if (cfg->dvbapi_au==1)
    628                 dvbapi_start_filter(demux_id, demux[demux_id].ECMpids[0].CA_System_ID, 0x001, 0x01, 0xFF, TYPE_EMM); //CAT
    629692           
    630693            demux[demux_id].ECMpids[0].checked=1;
     
    633696        cs_log("dvbapi: new program number: %04X", program_number);
    634697
    635     return 0;
     698    return demux_id;
    636699}
    637700
     
    671734                //int demux_index=buffer[7+k];
    672735                //dvbapi_stop_descrambling_all(demux_index);
     736                close(connfd);
    673737                break;
    674738            default:
     
    720784    }
    721785}
     786
     787#if 0
     788time_t pmt_timestamp=0;
     789int pmt_id=-1, dir_fd=-1;
     790
     791void event_handler(int signal) {
     792    struct stat pmt_info;
     793    uchar inhalt[200], dest[200];
     794    int len;
     795    signal=signal;
     796    int pmt_fd = open("/tmp/pmt.tmp", O_RDONLY);
     797    if(pmt_fd>0) {
     798        if (fstat(pmt_fd, &pmt_info) == 0) {
     799            if (pmt_info.st_mtime == pmt_timestamp) {
     800                return;
     801            }
     802
     803            if (pmt_id > -1) {
     804                dvbapi_stop_descrambling(pmt_id);
     805                fcntl(dir_fd, F_NOTIFY, 0);
     806                close(dir_fd);
     807                close(pmt_fd);
     808                return;
     809            }
     810
     811            pmt_timestamp = pmt_info.st_mtime;
     812
     813            cs_sleepms(100);
     814            //02 B0 <len> <srvid1> <srvid2> ..
     815            len = read(pmt_fd,inhalt,sizeof(inhalt));
     816            if (len<1) return;
     817
     818            cs_ddump(inhalt,len,"pmt:");
     819       
     820            memcpy(dest, "\x00\xFF\xFF\x00\x00\x13\x00", 7);
     821           
     822            dest[1] = inhalt[3];
     823            dest[2] = inhalt[4];
     824            dest[5] = inhalt[11]+1;
     825       
     826            memcpy(dest + 7, inhalt + 12, len - 12 - 4);
     827
     828            pmt_id = dvbapi_parse_capmt(dest, 7 + len - 12 - 4, -1);
     829            close(pmt_fd);
     830        }
     831    } else {
     832        if (pmt_id > -1)
     833            dvbapi_stop_descrambling(pmt_id);
     834
     835        fcntl(dir_fd, F_NOTIFY, 0);
     836        close(dir_fd);
     837    }
     838}
     839#endif
    722840
    723841void dvbapi_main_local() {
     
    739857    for (i=0;i<MAX_DEMUX;i++) {
    740858        demux[i].program_number=0;
    741         demux[i].ca_system_id=0;
    742         demux[i].ca_pid=0;
    743         demux[i].emm_pid=0;
     859        demux[i].pidindex=-1;
    744860        demux[i].cadev_index=-1;
    745861        demux[i].ca_fd=0;
     
    765881    dvbapi_chk_caidtab(cfg->dvbapi_priority, &prioritytab);
    766882    dvbapi_chk_caidtab(cfg->dvbapi_ignore, &ignoretab);
    767 
     883#if 0
     884    int pmt_fd = open("/tmp/pmt.tmp", O_RDONLY);
     885    if(pmt_fd>0) {
     886        struct sigaction signal_action;
     887        signal_action.sa_handler = event_handler;
     888        sigemptyset(&signal_action.sa_mask);
     889        signal_action.sa_flags = 0;
     890        sigaction(SIGRTMIN + 1, &signal_action, NULL);
     891   
     892        dir_fd = open("/tmp/", O_RDONLY);
     893        if (dir_fd >= 0) {
     894            fcntl(dir_fd, F_SETSIG, SIGRTMIN + 1);
     895            fcntl(dir_fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_DELETE | DN_MULTISHOT);
     896            event_handler(SIGRTMIN + 1);
     897        }
     898        close(pmt_fd);
     899    }
     900#endif
    768901    cs_ftime(&tp);
    769902    tp.time+=500;
     
    808941
    809942        for (i = 0; i < pfdcount; i++) {
     943            if (pfd2[i].revents > 3)
     944                cs_debug("dvbapi: event %d on fd %d", pfd2[i].revents, pfd2[i].fd);
     945           
    810946            if (pfd2[i].revents & (POLLHUP | POLLNVAL)) {
    811947                if (type[i]==1) {
     
    827963
    828964                if (type[i]==1) {
    829                     if (pfd2[i].fd==listenfd) {
    830                         cs_debug("dvbapi: new socket connection");
     965                    if (pfd2[i].fd==listenfd) {                     
    831966                        connfd = accept(listenfd, (struct sockaddr *)&servaddr, (socklen_t *)&clilen);
    832                        
     967                        cs_debug("dvbapi: new socket connection %d", connfd);
     968
    833969                        if (connfd <= 0)
    834970                            continue;
     
    852988                    }
    853989                } else { // type==0
    854                     if ((len=dvbapi_read_device(pfd2[i].fd, mbuf, BUFSIZE, 0)) <= 0)
     990                    if ((len=dvbapi_read_device(pfd2[i].fd, mbuf, sizeof(mbuf), 0)) <= 0)
    855991                        continue;
    856992
     
    8721008                               
    8731009                                unsigned long provid=0;
    874                                 int pid=dvbapi_check_array(prioritytab.caid, CS_MAXCAIDTAB, demux[demux_index].demux_fd[n].caid);
     1010                                int pid=dvbapi_check_array(prioritytab.caid, CS_MAXCAIDTAB, demux[demux_index].demux_fd[n].CA_System_ID);
    8751011                                if (pid>=0) {
    8761012                                    if (prioritytab.mask[pid]>0)
     
    8831019
    8841020                                er->srvid = demux[demux_index].program_number;
    885                                 er->caid  = demux[demux_index].demux_fd[n].caid;
    886                                 er->pid   = demux[demux_index].demux_fd[n].pid;
     1021                                er->caid  = demux[demux_index].demux_fd[n].CA_System_ID;
     1022                                er->pid   = demux[demux_index].demux_fd[n].PID;
    8871023                                er->prid  = provid;
    8881024
     
    8931029                        }
    8941030                        if (demux[demux_index].demux_fd[n].type==TYPE_EMM) {
    895                             if (mbuf[0]==0x01) {
     1031                            if (mbuf[0]==0x01) { //CAT
    8961032                                cs_debug("dvbapi: receiving cat");
    8971033                                dvbapi_parse_cat(demux_index, mbuf, len);
     1034
     1035                                if (demux[demux_index].pidindex < 0)
     1036                                    continue;
     1037                               
    8981038                                dvbapi_stop_filter(demux_index, TYPE_EMM);
    899                                 if (cfg->dvbapi_au==1) {
    900                                     for (g=0;g<demux[demux_index].ECMpidcount;g++) {
    901                                         if (demux[demux_index].demux_fd[n].caid == demux[demux_index].ECMpids[g].CA_System_ID && demux[demux_index].ECMpids[g].EMM_PID>0)
    902                                             dvbapi_start_filter(demux_index, demux[demux_index].ECMpids[g].CA_System_ID, demux[demux_index].ECMpids[g].EMM_PID, 0x80, 0xF0, TYPE_EMM);
    903                                     }
    904                                 }
     1039                                if (cfg->dvbapi_au==0)
     1040                                    continue;
     1041                               
     1042                                dvbapi_start_emm_filter(demux_index, SHARED, TYPE_EMM);
     1043                                dvbapi_start_emm_filter(demux_index, GLOBAL, TYPE_EMM);
     1044                                //dvbapi_start_emm_filter(demux_index, UNIQUE, TYPE_EMM);
    9051045                                continue;
    9061046                            }
     1047                            cs_debug("EMM Filter fd %d", demux[demux_index].demux_fd[n].fd);
    9071048                            dvbapi_process_emm(demux_index, mbuf, len);
    9081049                        }
     
    9161057
    9171058void dvbapi_send_dcw(ECM_REQUEST *er) {
    918     unsigned char cw_0[8], cw_1[8];
    919     int i;
     1059    int i,n;
    9201060    unsigned char nullcw[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
    9211061    ca_descr_t ca_descr;
    9221062
    923     cs_debug("dvbapi: ECM rc: %d", er->rc);
    924 
    925     memcpy(cw_0, er->cw, 8);
    926     memcpy(cw_1, er->cw+8, 8);
    927 
    9281063    for (i=0;i<MAX_DEMUX;i++) {
    9291064        if (demux[i].program_number==er->srvid) {
    930             if (er->rc<=2 && demux[i].ca_system_id==0 && er->caid!=0) {
    931                 dvbapi_start_descrambling(i, er->caid, er->pid, er->prid);
     1065            if (er->rc<=3 && demux[i].pidindex==-1 && er->caid!=0) {
     1066                dvbapi_start_descrambling(i, er->caid, er->pid);
    9321067            }
    9331068
    9341069            if (er->rc==4 && cfg->dvbapi_au==1 && dvbapi_check_array(global_caid_list, MAX_CAID, er->caid)>=0) {
    9351070                //local card and not found -> maybe card need emm
    936                 dvbapi_start_descrambling(i, er->caid, er->pid, er->prid);
    937             }
    938 
    939             if (er->rc>3 && demux[i].ca_system_id==0) {
    940                 cs_debug("dvbapi: cw not found");
    941                 int n;
     1071                dvbapi_start_descrambling(i, er->caid, er->pid);
     1072            }
     1073
     1074            if (er->rc>3 && demux[i].pidindex==-1) {
    9421075                for (n=0; n<demux[i].ECMpidcount; n++) {
    9431076                    if (demux[i].ECMpids[n].checked==0) {
    944                         dvbapi_stop_filter(i, 0);
     1077                        dvbapi_stop_filter(i, TYPE_ECM);
    9451078                        cs_debug("dvbapi: trying CA_System_ID: %04x CA_PID: %04x", demux[i].ECMpids[n].CA_System_ID, demux[i].ECMpids[n].CA_PID);
    9461079
     
    9681101            }
    9691102
    970             if (memcmp(cw_0,demux[i].lastcw0,8)!=0 && memcmp(cw_0,nullcw,8)!=0) {
    971                 ca_descr.index = i;
    972                 ca_descr.parity = 0;
    973                 memcpy(demux[i].lastcw0,cw_0,8);
    974                 memcpy(ca_descr.cw,cw_0,8);
    975                 cs_debug("dvbapi: write cw1 index: %d", i);
    976                 if (ioctl(demux[i].ca_fd, CA_SET_DESCR, &ca_descr) < 0)
    977                     cs_debug("dvbapi: Error CA_SET_DESCR");
    978             }
    979 
    980             if (memcmp(cw_1,demux[i].lastcw1,8)!=0 && memcmp(cw_1,nullcw,8)!=0) {
    981                 ca_descr.index = i;
    982                 ca_descr.parity = 1;
    983                 memcpy(demux[i].lastcw1,cw_1,8);
    984                 memcpy(ca_descr.cw,cw_1,8);
    985                 cs_debug("dvbapi: write cw2 index: %d", i);
    986                 if (ioctl(demux[i].ca_fd, CA_SET_DESCR, &ca_descr) < 0)
    987                     cs_debug("dvbapi: Error CA_SET_DESCR");
     1103            for (n=0;n<2;n++) {
     1104                if (memcmp(er->cw+(n*8),demux[i].lastcw[n],8)!=0 && memcmp(er->cw+(n*8),nullcw,8)!=0) {
     1105                    ca_descr.index = i;
     1106                    ca_descr.parity = n;
     1107                    memcpy(demux[i].lastcw[n],er->cw+(n*8),8);
     1108                    memcpy(ca_descr.cw,er->cw+(n*8),8);
     1109                    cs_debug("dvbapi: write cw%d index: %d", n, i);
     1110                    if (ioctl(demux[i].ca_fd, CA_SET_DESCR, &ca_descr) < 0)
     1111                        cs_debug("dvbapi: Error CA_SET_DESCR");
     1112                }
    9881113            }
    9891114
     
    9911116            ecmtxt = fopen("/tmp/ecm.info", "w");
    9921117            if(ecmtxt != NULL) {
    993                 fprintf(ecmtxt, "caid: 0x%04X\npid: 0x%04X\nprov: %06X\n", er->caid, er->pid, (uint) er->prid);
     1118                fprintf(ecmtxt, "caid 0x%04X\npid 0x%04X\nprov 0x%06X\n", er->caid, er->pid, (uint) er->prid);
    9941119                fprintf(ecmtxt, "reader: %s\n", reader[er->reader[0]].label);
    9951120                if (reader[er->reader[0]].typ & R_IS_CASCADING)
    9961121                    fprintf(ecmtxt, "from: %s\n", reader[er->reader[0]].device);
    9971122                fprintf(ecmtxt, "protocol: %d\n", reader[er->reader[0]].typ);
    998                 fprintf(ecmtxt, "hops: %d\n", reader[er->reader[0]].cc_currenthops);
     1123                if (reader[er->reader[0]].typ == R_CCCAM)
     1124                    fprintf(ecmtxt, "hops: %d\n", reader[er->reader[0]].cc_currenthops);
    9991125                fprintf(ecmtxt, "ecm time: %.3f\n", (float) client[cs_idx].cwlastresptime/1000);
    1000                 fprintf(ecmtxt, "cw0 : %s\n", cs_hexdump(1,demux[i].lastcw0,8));
    1001                 fprintf(ecmtxt, "cw1 : %s\n", cs_hexdump(1,demux[i].lastcw1,8));
     1126                fprintf(ecmtxt, "cw0: %s\n", cs_hexdump(1,demux[i].lastcw[0],8));
     1127                fprintf(ecmtxt, "cw1: %s\n", cs_hexdump(1,demux[i].lastcw[1],8));
    10021128                fclose(ecmtxt);
    10031129                ecmtxt = NULL;
Note: See TracChangeset for help on using the changeset viewer.