Changeset 1806


Ignore:
Timestamp:
Mar 7, 2010, 5:04:02 PM (10 years ago)
Author:
_network
Message:

new version of dvbapi module

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/module-dvbapi.c

    r1772 r1806  
    1616 *
    1717 */
    18 
    19 #include "globals.h"  //HAVE_DVBAPI is set here so must be included before ifdef
     18#include "globals.h"
    2019
    2120#ifdef HAVE_DVBAPI
    2221
    2322#include <sys/un.h>
    24 
    2523
    2624#define BUFSIZE 512
     
    2826#define MAX_CAID 50
    2927#define ECM_PIDS 20
     28#define MAX_FILTER 10
     29
     30#define TYPE_ECM 0
     31#define TYPE_EMM 1
    3032
    3133static int listenfd = -1;
     34int global_support_pip = 0;
     35int global_merged_capmt = 0;
    3236
    3337typedef struct ECMPIDS
     
    3640    unsigned short CA_System_ID;
    3741    unsigned short EMM_PID;
     42    unsigned short checked;
    3843} ECMPIDSTYPE;
     44
     45typedef struct filter_s
     46{
     47    int fd;
     48    ushort pid;
     49    ushort caid;
     50    ushort type;
     51} FILTERTYPE;
    3952
    4053typedef struct demux_s
    4154{
    4255    unsigned short demux_index;
    43     unsigned short demux_ecm_fd;
    44     unsigned short demux_emm_fd;
     56    FILTERTYPE demux_fd[MAX_FILTER];
    4557    unsigned short cadev_index;
    4658    unsigned short ca_fd;
     
    5567    unsigned short STREAMpidcount;
    5668    unsigned short STREAMpids[ECM_PIDS];
    57     unsigned char buffer_cache_dmx[12];
     69    unsigned char buffer_cache_dmx[CS_ECMSTORESIZE];
    5870    unsigned char lastcw0[8];
    5971    unsigned char lastcw1[8];
     
    146158int selected_api=-1;
    147159
    148 int dvbapi_set_filter(int dmx_fd, int api, unsigned short pid, unsigned char filt, unsigned char mask, int timeout)
    149 {
     160int dvbapi_set_filter(int dmx_fd, int api, unsigned short pid, unsigned char filt, unsigned char mask, int timeout) {
    150161    int ret=-1;
    151162
     
    193204
    194205
    195 int dvbapi_check_array(unsigned short *array, int len, unsigned short match)
    196 {
     206int dvbapi_check_array(unsigned short *array, int len, unsigned short match) {
    197207    int i;
    198208    for (i=0; i<len; i++) {
     
    204214}
    205215
    206 int dvbapi_detect_api()
    207 {
     216int dvbapi_detect_api() {
    208217    int num_apis=2;
    209218    int i,devnum=-1;
     
    238247    close(dmx_fd);
    239248
     249    if (ret < 0) return 0;
     250
    240251    selected_box=devnum;
    241252    selected_api=apinum;
     
    245256}
    246257
    247 int dvbapi_read_device(int dmx_fd, unsigned char *buf, int length, int debug)
    248 {
     258int dvbapi_read_device(int dmx_fd, unsigned char *buf, int length, int debug) {
    249259    int len, rc;
    250260    struct pollfd pfd[1];
     
    253263    pfd[0].events = (POLLIN | POLLPRI);
    254264
    255     rc = poll(pfd, 1, 5000);
     265    rc = poll(pfd, 1, 1000);
    256266    if (rc<1)
    257267        return -1;
     
    268278}
    269279
    270 int dvbapi_open_device(int index_demux, int type)
    271 {
     280int dvbapi_open_device(int index_demux, int type) {
    272281    int dmx_fd,i;
    273282    int ca_offset=0;
     
    276285    if (type==0)
    277286        sprintf(device_path, devices[selected_box].demux_device_path, demux[index_demux].demux_index);
    278     else
    279     {
     287    else {
    280288        if (strcmp(cfg->dvbapi_boxtype, "ufs910")==0 || strcmp(cfg->dvbapi_boxtype, "dbox2")==0)
    281289            ca_offset=1;
     
    298306}
    299307
    300 int dvbapi_stop_filter(int demux_index, int type)
    301 {
    302     int dmx_fd;
    303 
    304     if (type==0) {
    305         dmx_fd=demux[demux_index].demux_ecm_fd;
    306     } else {
    307         dmx_fd=demux[demux_index].demux_emm_fd;
    308     }
    309 
    310     ioctl(dmx_fd,DMX_STOP);
     308int dvbapi_stop_filter(int demux_index, int type) {
     309    int g;
     310
     311    for (g=0;g<MAX_FILTER;g++) {
     312        if (demux[demux_index].demux_fd[g].fd>0 && demux[demux_index].demux_fd[g].type==type) {
     313            ioctl(demux[demux_index].demux_fd[g].fd,DMX_STOP);
     314            close(demux[demux_index].demux_fd[g].fd);
     315            demux[demux_index].demux_fd[g].fd=0;
     316        }
     317    }
     318
    311319    return 1;
    312320}
    313321
    314 unsigned long dvbapi_get_provid(int demux_index, unsigned short pid)
    315 {
    316     unsigned char buf[BUFSIZE];
    317     int dmx_fd, len;
    318 
    319     dmx_fd=demux[demux_index].demux_emm_fd;
    320 
    321     dvbapi_set_filter(dmx_fd, selected_api, pid, 0x80, 0xF0, 4000);
    322 
    323     len=dvbapi_read_device(dmx_fd, buf, BUFSIZE, 1);
    324 
    325     if (len > 0) {
    326         unsigned long provid = (buf[10] << 8) | buf[11];
    327         return provid;
    328     }
    329 
    330     return 0;
    331 }
    332 
    333 unsigned short dvbapi_get_single_ecm(int demux_index, unsigned short caid, unsigned short pid, unsigned long provid)
    334 {
    335     unsigned char buf[BUFSIZE];
    336     int dmx_fd, len;
    337 
    338     dmx_fd=demux[demux_index].demux_ecm_fd;
    339 
    340     dvbapi_set_filter(dmx_fd, selected_api, pid, 0x80, 0xF0, 2000);
    341 
    342     len=dvbapi_read_device(dmx_fd, buf, BUFSIZE, 1);
    343 
    344     if (len > 0) {
    345         ECM_REQUEST *er;
    346 
    347         if (!(er=get_ecmtask()))
    348             return 0;
    349 
    350         er->srvid = demux[demux_index].program_number;
    351         er->caid  = caid;
    352         er->pid   = pid;
    353         er->prid  = provid;
    354 
    355         er->l=len;
    356         memcpy(er->ecm, buf, er->l);
    357 
    358         get_cw(er);
    359 
    360         memcpy(demux[demux_index].buffer_cache_dmx, buf, 12);
    361     }
    362     return 0;
    363 }
    364 
    365 void dvbapi_parse_cat(int demux_index)
    366 {
    367     unsigned char buf[BUFSIZE];
     322void dvbapi_start_filter(int demux_index, ushort caid, unsigned short pid, ushort table, ushort mask, int type) {
     323    int dmx_fd,i,n=-1;
     324
     325    for (i=0;i<MAX_FILTER;i++) {
     326        if (demux[demux_index].demux_fd[i].fd<=0) {
     327            n=i;
     328            break;
     329        }
     330    }
     331
     332    if (n==-1) {
     333        cs_log("dvbapi: no free filter");
     334        return;
     335    }
     336
     337    dmx_fd=dvbapi_open_device(demux_index, 0);
     338
     339    demux[demux_index].demux_fd[n].fd=dmx_fd;
     340    demux[demux_index].demux_fd[n].caid=caid;
     341    demux[demux_index].demux_fd[n].type=type;
     342
     343    dvbapi_set_filter(dmx_fd, selected_api, pid, table, mask, 4000);
     344}
     345
     346void dvbapi_parse_cat(int demux_index, uchar *buf, int len) {
    368347    unsigned short i, j;
    369     int dmx_fd, len;
    370 
    371     dmx_fd=demux[demux_index].demux_emm_fd;
    372 
    373     dvbapi_set_filter(dmx_fd, selected_api, 0x0001, 0x01, 0xFF, 2000);
    374 
    375     len=dvbapi_read_device(dmx_fd, buf, BUFSIZE, 1);
    376 
    377     if (len<=0)
    378         return;
    379348
    380349    cs_ddump(buf, len, "cat:");
     
    393362        }
    394363    }
    395 
    396     dvbapi_stop_filter(demux_index, 1);
    397 
    398364    return;
    399365}
    400366
    401 void dvbapi_stop_descrambling(int demux_id)
    402 {
     367void dvbapi_stop_descrambling(int demux_id) {
    403368    int i;
    404369
     
    412377    demux[demux_id].program_number=0;
    413378
    414     if (demux[demux_id].demux_ecm_fd>0) {
    415         dvbapi_stop_filter(demux_id, 0);
    416         close(demux[demux_id].demux_ecm_fd);
    417         demux[demux_id].demux_ecm_fd=0;
    418     }
    419 
    420     if (demux[demux_id].demux_emm_fd>0) {
    421         dvbapi_stop_filter(demux_id, 1);
    422         close(demux[demux_id].demux_emm_fd);
    423         demux[demux_id].demux_emm_fd=0;
    424     }
     379    dvbapi_stop_filter(demux_id, 0);
     380    dvbapi_stop_filter(demux_id, 1);
     381
     382    memset(demux[demux_id].buffer_cache_dmx, 0, CS_ECMSTORESIZE);
    425383
    426384    if (demux[demux_id].ca_fd>0) {
    427         for (i=0;i<demux[demux_id].STREAMpidcount;i++)
    428         {
     385        for (i=0;i<demux[demux_id].STREAMpidcount;i++) {
    429386            ca_pid_t ca_pid2;
    430387            memset(&ca_pid2,0,sizeof(ca_pid2));
     
    450407}
    451408
    452 void dvbapi_stop_descrambling_all(int demux_index)
    453 {
     409void dvbapi_stop_descrambling_all(int demux_index) {
    454410    int j;
    455411    for (j=0;j<MAX_DEMUX;j++) {
     
    463419}
    464420
    465 void dvbapi_start_descrambling(int demux_index, unsigned short caid, unsigned short capid, unsigned long provider_id)
    466 {
     421void dvbapi_start_descrambling(int demux_index, unsigned short caid, unsigned short capid, unsigned long provider_id) {
    467422    int i;
    468423
     
    473428    demux[demux_index].provider_id=provider_id;
    474429
    475     int camfd=dvbapi_open_device(demux_index,1);
    476     if (camfd<=0) {
     430    demux[demux_index].ca_fd = dvbapi_open_device(demux_index,1);
     431    if (demux[demux_index].ca_fd<=0)
    477432        return;
    478     }
    479 
    480     demux[demux_index].ca_fd=camfd;
    481 
    482     for (i=0;i<demux[demux_index].STREAMpidcount;i++)
    483     {
     433
     434    for (i=0;i<demux[demux_index].STREAMpidcount;i++) {
    484435        ca_pid_t ca_pid2;
    485436        memset(&ca_pid2,0,sizeof(ca_pid2));
    486437        ca_pid2.pid = demux[demux_index].STREAMpids[i];
    487438        ca_pid2.index = demux_index;
    488         if (ioctl(camfd, CA_SET_PID, &ca_pid2)==-1)
     439        if (ioctl(demux[demux_index].ca_fd, CA_SET_PID, &ca_pid2)==-1)
    489440            cs_debug("dvbapi: Error Stream SET_PID");
    490441    }
    491442
    492 }
    493 
    494 void dvbapi_try_descrambling (int demux_index)
    495 {
    496     int n;
    497     unsigned int program_number;
    498 
    499     program_number=demux[demux_index].program_number;
    500     for (n=0; n<demux[demux_index].ECMpidcount; n++) {
    501 
    502         if (demux[demux_index].ca_system_id!=0) // got valid cw -> stop trying
    503             break;
    504 
    505         if (program_number!=demux[demux_index].program_number) //channel change -> stop trying
    506             break;
    507 
    508         dvbapi_stop_filter(demux_index,0);
    509 
    510         cs_debug("dvbapi: trying CA_System_ID: %04x CA_PID: %04x EEM_PID: %04x", demux[demux_index].ECMpids[n].CA_System_ID, demux[demux_index].ECMpids[n].CA_PID, demux[demux_index].ECMpids[n].EMM_PID);
    511 
    512         //grep emm provid
    513         unsigned long provid=0;
    514 
    515         int pid=dvbapi_check_array(prioritytab.caid, CS_MAXCAIDTAB, demux[demux_index].ECMpids[n].CA_System_ID);
    516         if (pid>=0) {
    517             if (prioritytab.mask[pid]>0)
    518                 provid=prioritytab.mask[pid];
    519         }
    520 
    521         if (cfg->dvbapi_au==1) {
    522             dvbapi_stop_filter(demux_index,1);
    523             if (demux[demux_index].ECMpids[n].EMM_PID>0)
    524                 provid=dvbapi_get_provid(demux_index, demux[demux_index].ECMpids[n].EMM_PID);
    525         }
    526 
    527         //grep ecm
    528         dvbapi_get_single_ecm(demux_index, demux[demux_index].ECMpids[n].CA_System_ID, demux[demux_index].ECMpids[n].CA_PID, provid);
    529 
    530         cs_sleepms(3000); //try next if no cw for .. secs
    531     }
    532443}
    533444
     
    546457    epg.caid[1] = (uchar)(demux[demux_index].ca_system_id);
    547458
    548     epg.provid[1] = (uchar)(demux[demux_index].provider_id>>16);
    549     epg.provid[2] = (uchar)(demux[demux_index].provider_id>>8);
    550     epg.provid[3] = (uchar)(demux[demux_index].provider_id);
     459    unsigned long provid = (buffer[10] << 8) | buffer[11];
     460    int pid=dvbapi_check_array(prioritytab.caid, CS_MAXCAIDTAB, demux[demux_index].ca_system_id);
     461    if (pid>=0) {
     462        if (prioritytab.mask[pid]>0)
     463            provid=prioritytab.mask[pid];
     464    }
     465
     466    epg.provid[1] = (uchar)(provid>>16);
     467    epg.provid[2] = (uchar)(provid>>8);
     468    epg.provid[3] = (uchar)(provid);
    551469
    552470    epg.l=len;
    553471    memcpy(epg.emm, buffer, epg.l);
    554472
     473    int found=0;
    555474    for (i=0;i<CS_MAXREADER;i++) {
    556475        if (reader[i].caid[0] == demux[demux_index].ca_system_id) {
    557476            client[cs_idx].au=i;
    558 //          memcpy(epg.hexserial, reader[client[cs_idx].au].hexserial, 8);
    559         }
    560     }
    561     do_emm(&epg);
    562 }
    563 
    564 void *thread_descrambling(void *di)
    565 {
    566     int demux_index=(int)di;
    567     int dmx1_fd,dmx2_fd=0,n=30,k=0;
    568     unsigned int program_number;
    569 
    570     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    571     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    572 
    573     cs_debug("dvbapi: Start descrambling Thread %d", demux_index);
    574 
    575     dmx1_fd = dvbapi_open_device(demux_index,0); //ECM
    576     demux[demux_index].demux_ecm_fd=dmx1_fd;
    577    
    578     if (cfg->dvbapi_au==1) {
    579         dmx2_fd = dvbapi_open_device(demux_index,0); //EMM,CAT
    580         demux[demux_index].demux_emm_fd=dmx2_fd;
    581         dvbapi_parse_cat(demux_index);
    582     }
    583 
    584     program_number=demux[demux_index].program_number;
    585 
    586     while(1) {
    587         if (demux[demux_index].ca_system_id!=0) // got valid cw -> stop trying
    588             break;
    589 
    590         if (program_number!=demux[demux_index].program_number) //channel change -> new thread
    591             return 0;
    592 
    593         if (n>=30)
    594         {
    595             if (demux[demux_index].ca_system_id==0)
    596                 dvbapi_try_descrambling(demux_index);
    597             n=0;
    598             k++;
    599             continue;
    600         }
    601         n++;
    602 
    603         if (k==5) // give up
    604             return 0;
    605 
    606         cs_sleepms(10000);
    607     }
    608 
    609     struct pollfd pfd2[2];
    610     int rc,len,i,pfdcount;
    611     unsigned char buffer[BUFSIZE];
    612 
    613     while(1) {
    614         pfdcount=0;
    615 
    616         if (program_number!=demux[demux_index].program_number || demux[demux_index].ca_system_id==0) //channel change -> new thread
    617             break;
    618 
    619         if (demux[demux_index].demux_ecm_fd>0) {
    620             pfd2[pfdcount].fd = demux[demux_index].demux_ecm_fd;
    621             pfd2[pfdcount].events = (POLLIN | POLLPRI);
    622             pfdcount++;
    623         } else break;
    624         if (cfg->dvbapi_au==1) {
    625             if (demux[demux_index].demux_emm_fd>0) {
    626                 pfd2[pfdcount].fd = demux[demux_index].demux_emm_fd;
    627                 pfd2[pfdcount].events = (POLLIN | POLLPRI);
    628                 pfdcount++;
    629             } else break;
    630         }
    631 
    632         rc=poll(pfd2, pfdcount, 3000);
    633 
    634         if (rc<0)
    635             break;
    636 
    637         for (i = 0; i < pfdcount; i++) {
    638             if (pfd2[i].revents & (POLLIN | POLLPRI)) {
    639 
    640                 if ((len=dvbapi_read_device(pfd2[i].fd, buffer, BUFSIZE, 0)) <= 0)
    641                     continue;
    642 
    643                 if (pfd2[i].fd==demux[demux_index].demux_ecm_fd) {
    644                     //ECM
    645 
    646                     if (len != (((buffer[1] & 0xf) << 8) | buffer[2]) + 3) //invaild CAT length
    647                         continue;
    648 
    649                     if (buffer[0] == 0x80 || buffer[0] == 0x81)
    650                     {
    651                         if (memcmp(buffer, demux[demux_index].buffer_cache_dmx, 12) != 0) {
    652                             memcpy(demux[demux_index].buffer_cache_dmx, buffer, 12);
    653                             cs_debug("Read %d bytes\tTable-id: %02x\tCA section length: %d", len, buffer[0], len);
    654 
    655                             ECM_REQUEST *er;
    656 
    657                             if (!(er=get_ecmtask()))
    658                                 continue;
    659 
    660                             er->srvid = demux[demux_index].program_number;
    661                             er->caid  = demux[demux_index].ca_system_id;
    662                             er->prid  = demux[demux_index].provider_id;
    663 
    664                             er->l=len;
    665                             memcpy(er->ecm, buffer, er->l);
    666 
    667                             get_cw(er);
    668                         }
    669                     }
    670                 }
    671                 if (pfd2[i].fd==demux[demux_index].demux_emm_fd) {
    672                     dvbapi_process_emm(demux_index, buffer, len);
    673                 }
    674             }
    675         }
    676     }
    677 
    678     cs_debug("dvbapi: Stop descrambling Thread %d", demux_index);
    679 
    680     pthread_detach(pthread_self());
    681     pthread_exit(0);
    682 }
    683 
    684 
    685 
    686 void dvbapi_resort_ecmpids(int demux_index)
    687 {
    688     ECMPIDSTYPE tmppids[ECM_PIDS];
    689     ECMPIDSTYPE tmppids2[ECM_PIDS];
    690 
    691     int tmppidcount=0,tmppid2count=0,n;
    692 
    693     int i,k,j;
     477            found=1;
     478            break;
     479        }
     480    }
     481    if (found==1 && reader[client[cs_idx].au].card_system>0)
     482        do_emm(&epg);
     483}
     484
     485void dvbapi_resort_ecmpids(int demux_index) {
     486    ECMPIDSTYPE tmppids[ECM_PIDS],tmppids2[ECM_PIDS];
     487    int tmppidcount=0,tmppid2count=0,n,i,k,j;
    694488
    695489    for (i=0;i<MAX_CAID;i++)
     
    767561
    768562// from tuxbox camd
    769 int dvbapi_parse_capmt(unsigned char *buffer, unsigned int length)
    770 {
     563int dvbapi_parse_capmt(unsigned char *buffer, unsigned int length) {
    771564    unsigned short i, u;
    772565    unsigned short ca_mask=0x01, demux_index2=0x00;
    773566
    774     int ca_pmt_list_management = buffer[0];
     567    //int ca_pmt_list_management = buffer[0];
    775568    unsigned int program_number = (buffer[1] << 8) | buffer[2];
    776569    int program_info_length = ((buffer[4] & 0x0F) << 8) | buffer[5];
    777 
     570/*
    778571    switch (ca_pmt_list_management)
    779572    {
     
    791584            break;
    792585    }
    793 
     586*/
    794587    if (buffer[17]==0x82 && buffer[18]==0x02) {
    795588        //enigma2
     
    798591    } else {
    799592        //neutrino workaround
    800         dvbapi_stop_descrambling_all(0);
     593        //dvbapi_stop_descrambling_all(0);
    801594    }
    802595
    803596    for (i=0;i<MAX_DEMUX;i++) {
    804597        if (demux[i].demux_index==demux_index2 && demux[i].program_number==((buffer[1] << 8) | buffer[2])) { // already descrambling prog on this device
     598            global_support_pip=1;
    805599            if (demux[i].active==1) {
    806600                //remove any inactive program
     
    816610    }
    817611
     612    if (global_support_pip != 1 && global_merged_capmt != 1) {
     613        dvbapi_stop_descrambling_all(0);
     614    }
     615
    818616    //get free id
    819617    int demux_id=-1;
    820618    for (i=0;i<MAX_DEMUX;i++) {
    821         if (demux[i].program_number==0)
    822         {
     619        if (demux[i].program_number==0) {
    823620            demux_id=i;
    824621            break;
     
    851648    cs_debug("dvbapi: demux index: %d ca index: %d", demux[demux_id].demux_index, demux[demux_id].cadev_index);
    852649
    853     //CA_PIDS for all streams
    854650    if (program_info_length != 0) {
    855651        dvbapi_parse_descriptor(demux_id, 1, program_info_length, buffer);
    856652    }
    857653
    858     //CA_PIDs for a single stream
    859654    unsigned int es_info_length=0;
    860     for (i = program_info_length + 6; i < length; i += es_info_length + 5)
    861     {
     655    for (i = program_info_length + 6; i < length; i += es_info_length + 5) {
    862656        int stream_type = buffer[i];
    863657        unsigned short elementary_pid = ((buffer[i + 1] & 0x1F) << 8) | buffer[i + 2];
     
    874668    }
    875669
    876     cs_debug("dvbapi: Found %d ECMpids and %d STREAMpids in PMT", demux[demux_id].ECMpidcount);
     670    cs_debug("dvbapi: Found %d ECMpids and %d STREAMpids in PMT", demux[demux_id].ECMpidcount, demux[demux_id].STREAMpidcount);
    877671
    878672    if (demux[demux_id].ECMpidcount>0) {
    879673        dvbapi_resort_ecmpids(demux_id);
    880674        if (demux[demux_id].ECMpidcount>0) {
    881             pthread_t p3;
    882             if (pthread_create(&p3, NULL, thread_descrambling, (void*)demux_id))
    883                 cs_log("dvbapi: pthread error");
     675            int demux_index=demux_id;
     676            int n=0;
     677
     678            //dvbapi_stop_descrambling(demux_id);
     679            cs_debug("dvbapi: trying CA_System_ID: %04x CA_PID: %04x EEM_PID: %04x", demux[demux_index].ECMpids[n].CA_System_ID, demux[demux_index].ECMpids[n].CA_PID, demux[demux_index].ECMpids[n].EMM_PID);
     680
     681            //grep ecm
     682            dvbapi_start_filter(demux_index, demux[demux_index].ECMpids[n].CA_System_ID, demux[demux_index].ECMpids[n].CA_PID, 0x80, 0xF0, TYPE_ECM);
     683            if (cfg->dvbapi_au==1) {
     684                dvbapi_start_filter(demux_index, demux[demux_index].ECMpids[n].CA_System_ID, 0x001, 0x01, 0xFF, TYPE_EMM); //CAT
     685            }
     686            demux[demux_id].ECMpids[0].checked=1;
    884687        }
    885688    }
     
    898701            return;
    899702        }
     703
     704        global_merged_capmt=0;
     705        if (k>0) global_merged_capmt=1;
    900706
    901707        if (buffer[3+k] & 0x80) {
     
    909715            size = 1;
    910716        }
    911 
    912717        switch(buffer[2+k]) {
    913718            case 0x32:
    914                 dvbapi_parse_capmt(buffer + 3 + size, val);
     719                dvbapi_parse_capmt(buffer + size + 3 + k, val);
    915720                break;
    916721            case 0x3f:
     
    925730                break;
    926731        }
     732   
    927733    }
    928734}
     
    950756
    951757void *thread_check_zap(void *arg) {
    952     unsigned char buffer[BUFSIZE];
    953758    struct sockaddr_un servaddr;
    954759    ssize_t len;
    955760    int connfd,clilen;
    956761
    957     while(1)
    958     {
    959         cs_sleepms(500);
     762    while(1) {
    960763        //cs_debug("dvbapi: check zap");
    961764
     
    967770        }
    968771
    969         len = read(connfd, buffer, sizeof(buffer));
     772        len = read(connfd, mbuf, sizeof(mbuf));
    970773
    971774        if (len < 3) {
     
    975778
    976779        // if message begins with an apdu_tag and is longer than three bytes
    977         if ((buffer[0] == 0x9F) && ((buffer[1] >> 7) == 0x01) && ((buffer[2] >> 7) == 0x00)) {
    978             dvbapi_handlesockmsg(buffer, len);
     780        if ((mbuf[0] == 0x9F) && ((mbuf[1] >> 7) == 0x01) && ((mbuf[2] >> 7) == 0x00)) {
     781            dvbapi_handlesockmsg(mbuf, len);
    979782        } else {
    980783            cs_debug("dvbapi: invaild capmt");
     
    982785
    983786        close(connfd);
    984 
     787        cs_sleepms(500);
    985788    }
    986789
     
    990793
    991794void dvbapi_chk_caidtab(char *caidasc, CAIDTAB *ctab) {
    992 
    993795    char *ptr1, *ptr3;
    994796    int i;
    995797
    996     for (i=0, ptr1=strtok(caidasc, ","); (i<CS_MAXCAIDTAB) && (ptr1); ptr1=strtok(NULL, ","))
    997     {
     798    for (i=0, ptr1=strtok(caidasc, ","); (i<CS_MAXCAIDTAB) && (ptr1); ptr1=strtok(NULL, ",")) {
    998799        unsigned long caid, prov;
    999800        if( (ptr3=strchr(trim(ptr1), ':')) )
     
    1011812}
    1012813
    1013 int dvbapi_main_local()
    1014 {
    1015     struct pollfd pfd2[1];
    1016     int i,rc;
     814int dvbapi_main_local() {
     815    struct pollfd pfd2[(MAX_FILTER*MAX_FILTER)+1];
     816    int i,rc,pfdcount,g,len;
    1017817    pthread_t p1;
     818    unsigned char md5buf[CS_ECMSTORESIZE];
     819    int ids[MAX_FILTER+1], fdn[MAX_FILTER+1];
     820    unsigned char *buffer;
     821    struct timeb tp;
    1018822
    1019823    if (cfg->dvbapi_usr[0]==0) {
     
    1027831        cs_log("dvbapi: boxtype=%s.", cfg->dvbapi_boxtype);
    1028832
    1029     for (i=0;i<MAX_DEMUX;i++)
    1030     {
     833    for (i=0;i<MAX_DEMUX;i++) {
    1031834        demux[i].program_number=0;
    1032         demux[i].demux_ecm_fd=0;
    1033         demux[i].demux_emm_fd=0;
    1034835        demux[i].ca_system_id=0;
    1035836        demux[i].ca_pid=0;
     
    1038839        demux[i].ca_fd=0;
    1039840        demux[i].demux_index=-1;
    1040         memset(demux[i].buffer_cache_dmx,0 ,12);
     841        memset(demux[i].buffer_cache_dmx, 0, CS_ECMSTORESIZE);
     842        for (rc=0;rc<MAX_FILTER;rc++) demux[i].demux_fd[rc].fd=0;
    1041843    }
    1042844
     
    1048850    }
    1049851
    1050     if (!dvbapi_init_listenfd())
    1051     {
     852    if (!dvbapi_init_listenfd()) {
    1052853        cs_log("dvbapi: could not init camd.socket.");
    1053854        return 1;
     
    1057858    dvbapi_chk_caidtab(cfg->dvbapi_ignore, &ignoretab);
    1058859
     860    pthread_create (&p1, NULL, thread_check_zap, NULL);
     861
     862    cs_ftime(&tp);
     863    tp.time+=500;
     864
     865    buffer = malloc(BUFSIZE);
     866
    1059867    pfd2[0].fd = fd_m2c;
    1060868    pfd2[0].events = (POLLIN | POLLPRI);
    1061 
    1062     pthread_create (&p1, NULL, thread_check_zap, NULL);
    1063 
    1064     struct timeb tp;
    1065     cs_ftime(&tp);
    1066     tp.time+=500;
    1067869
    1068870    while (1) {
     
    1070872            cs_exit(0);
    1071873
     874        pfdcount=1;
     875
    1072876        chk_pending(tp);
    1073877
    1074         rc=poll(pfd2, 1, 1000);
    1075 
    1076         if (rc<0)
    1077             break;
    1078 
    1079         if (pfd2[0].revents & (POLLIN | POLLPRI)) {
    1080             chk_dcw(fd_m2c);
    1081 
    1082         }
    1083 
    1084     }
     878        for (i=0;i<MAX_DEMUX;i++) {
     879            for (g=0;g<MAX_FILTER;g++) {
     880                if (demux[i].demux_fd[g].fd>0) {
     881                    pfd2[pfdcount].fd = demux[i].demux_fd[g].fd;
     882                    pfd2[pfdcount].events = (POLLIN | POLLPRI);
     883                    ids[pfdcount]=i;
     884                    fdn[pfdcount]=g;
     885                    pfdcount++;
     886                }
     887            }
     888        }
     889
     890        rc = poll(pfd2, pfdcount, 500);
     891   
     892        if (rc<1) continue;
     893
     894        for (i = 0; i < pfdcount; i++) {
     895            if (pfd2[i].revents & (POLLIN | POLLPRI)) {
     896
     897                if (pfd2[i].fd==fd_m2c) {
     898                    chk_dcw(fd_m2c);
     899                    continue;
     900                }
     901
     902                if ((len=dvbapi_read_device(pfd2[i].fd, buffer, BUFSIZE, 0)) <= 0)
     903                    continue;
     904
     905                int demux_index=ids[i];
     906                int n=fdn[i];
     907
     908                if (pfd2[i].fd==demux[demux_index].demux_fd[n].fd) {
     909                    if (demux[demux_index].demux_fd[n].type==TYPE_ECM) {
     910                        if (len != (((buffer[1] & 0xf) << 8) | buffer[2]) + 3) //invaild CAT length
     911                            continue;
     912
     913                        if (buffer[0] != 0x80 && buffer[0] != 0x81)
     914                            continue;
     915
     916                        memcpy(md5buf, MD5(buffer, len, NULL), CS_ECMSTORESIZE);
     917
     918                        if (memcmp(md5buf, demux[demux_index].buffer_cache_dmx, CS_ECMSTORESIZE) != 0) {
     919                            //cs_dump(md5buf,CS_ECMSTORESIZE,"MD5 ECM:");
     920                            memcpy(demux[demux_index].buffer_cache_dmx, md5buf, CS_ECMSTORESIZE);
     921                            cs_debug("dvbapi: Read %d bytes\tTable-id: %02x\tCA section length: %d", len, buffer[0], len);
     922
     923                            //grep emm provid
     924                            unsigned long provid=0;
     925
     926                            int pid=dvbapi_check_array(prioritytab.caid, CS_MAXCAIDTAB, demux[demux_index].demux_fd[n].caid);
     927                            if (pid>=0) {
     928                                if (prioritytab.mask[pid]>0)
     929                                    provid=prioritytab.mask[pid];
     930                            }
     931
     932                            ECM_REQUEST *er;
     933                            if (!(er=get_ecmtask()))
     934                                continue;
     935
     936                            er->srvid = demux[demux_index].program_number;
     937                            er->caid  = demux[demux_index].demux_fd[n].caid;
     938                            er->prid  = provid;
     939
     940                            er->l=len;
     941                            memcpy(er->ecm, buffer, er->l);
     942                            get_cw(er);
     943                        }
     944               
     945                    }
     946                    if (demux[demux_index].demux_fd[n].type==TYPE_EMM) {
     947                        if (buffer[0]==0x01) {
     948                            cs_debug("dvbapi: receiving cat");
     949                            dvbapi_parse_cat(demux_index, buffer, len);
     950                            dvbapi_stop_filter(demux_index, TYPE_EMM);
     951                            if (cfg->dvbapi_au==1) {
     952                                for (g=0;g<demux[demux_index].ECMpidcount;g++) {
     953                                    if (demux[demux_index].demux_fd[n].caid == demux[demux_index].ECMpids[g].CA_System_ID && demux[demux_index].ECMpids[g].EMM_PID>0)
     954                                        dvbapi_start_filter(demux_index, demux[demux_index].ECMpids[g].CA_System_ID, demux[demux_index].ECMpids[g].EMM_PID, 0x80, 0xF0, TYPE_EMM);
     955                                }
     956                            }
     957                            continue;
     958                        }
     959                        dvbapi_process_emm(demux_index, buffer, len);
     960                    }
     961                }
     962            }
     963        }
     964    }
     965    free(buffer);
    1085966    return 0;
    1086967}
    1087968
    1088 
    1089 void dvbapi_send_dcw(ECM_REQUEST *er)
    1090 {
     969void dvbapi_send_dcw(ECM_REQUEST *er) {
    1091970    unsigned char cw_0[8], cw_1[8];
    1092971    int i;
    1093972    unsigned char nullcw[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
     973    ca_descr_t ca_descr;
    1094974
    1095975    cs_debug("dvbapi: ECM rc: %d", er->rc);
     
    1109989            }
    1110990
     991            if (er->rc>3 && demux[i].ca_system_id==0) {
     992                cs_debug("dvbapi: cw not found");
     993                int n;
     994                for (n=0; n<demux[i].ECMpidcount; n++) {
     995                    if (demux[i].ECMpids[n].checked==0) {
     996                        dvbapi_stop_filter(i, 0);
     997                        cs_debug("dvbapi: trying CA_System_ID: %04x CA_PID: %04x EEM_PID: %04x", demux[i].ECMpids[n].CA_System_ID, demux[i].ECMpids[n].CA_PID, demux[i].ECMpids[n].EMM_PID);
     998
     999                        //grep ecm
     1000                        dvbapi_start_filter(i, demux[i].ECMpids[n].CA_System_ID, demux[i].ECMpids[n].CA_PID, 0x80,0xF0,TYPE_ECM); //ECM
     1001                        demux[i].ECMpids[n].checked=1;
     1002                        break;
     1003                    }
     1004                }
     1005                return;
     1006            }
     1007
    11111008            if (er->rc>3) {
    11121009                cs_debug("dvbapi: cw not found");
     
    11141011            }
    11151012
    1116             ca_descr_t ca_descr;
    11171013            memset(&ca_descr,0,sizeof(ca_descr));
    11181014
    11191015            if (demux[i].ca_fd<=0) {
    11201016                cs_log("dvbapi: could not write cw.");
    1121                 return;
     1017                demux[i].ca_fd = dvbapi_open_device(i,1);
     1018                if (demux[i].ca_fd<=0)
     1019                    return;
    11221020            }
    11231021
     
    11451043}
    11461044
    1147 static void dvbapi_handler(int idx)
    1148 {
     1045static void dvbapi_handler(int idx) {
    11491046    static struct s_auth *account=0;
    11501047
     
    11561053    //cs_log("dvbapi loaded fd=%d", idx);
    11571054
    1158     switch(cs_fork(0, idx))
    1159     {
     1055    switch(cs_fork(0, idx)) {
    11601056        case  0: //master
    11611057        case -1:
     
    11661062
    11671063    int ok=0;
    1168     if( !account )
    1169     {
     1064    if (!account) {
    11701065        client[cs_idx].usr[0]=0;
    11711066        for (ok=0, account=cfg->account; (account) && (!ok); account=account->next)
Note: See TracChangeset for help on using the changeset viewer.