Changeset 1052


Ignore:
Timestamp:
01/03/10 20:28:25 (12 years ago)
Author:
alno
Message:

Merging revisions 1042-1051 of trunk
followig warnings got from trunk (not webif related)
reader-nagra.c: In function `NegotiateSessionKey_Tiger':
reader-nagra.c:211: warning: unused variable `parte_variable'
reader-nagra.c:212: warning: unused variable `d1_rsa_modulo'
reader-nagra.c:213: warning: unused variable `rand'
reader-nagra.c:219: warning: unused variable `tmp1'

Location:
branches/monitor-improvement
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/monitor-improvement/csctapi/protocol_t1.c

    r885 r1052  
    177177  int ret;
    178178  bool more;
     179  if (APDU_Cmd_Ins(cmd) == T1_BLOCK_S_IFS_REQ)
     180    {
     181      BYTE inf = APDU_Cmd_P2(cmd);
     182
     183      /* Create an IFS request S-Block */
     184      block = T1_Block_NewSBlock (T1_BLOCK_S_IFS_REQ, 1, &inf);
     185
     186#ifdef DEBUG_PROTOCOL
     187      printf ("Protocol: Sending block S(IFS request, %d)\n", inf);
     188#endif
     189      /* Send IFSD request */
     190      ret = Protocol_T1_SendBlock (t1, block);
     191
     192      /* Delete block */
     193      T1_Block_Delete (block);
     194
     195      /* Receive a block */
     196      ret = Protocol_T1_ReceiveBlock (t1, &block);
     197
     198      if (ret == PROTOCOL_T1_OK)
     199        {
     200          rsp_type = T1_Block_GetType (block);
     201
     202          /* Positive IFS Response S-Block received */
     203          if (rsp_type == T1_BLOCK_S_IFS_RES)
     204            {
     205              /* Update IFSD value */
     206              inf = (*T1_Block_GetInf (block));
     207              t1->ifsd = inf;
     208#ifdef DEBUG_PROTOCOL
     209              printf ("Protocol: Received block S(IFS response, %d)\n", inf);
     210#endif
     211            }
     212        }
     213
     214      return ret;
     215    }
    179216
    180217  /* Calculate the number of bytes to send */
  • branches/monitor-improvement/module-dvbapi.c

    r1035 r1052  
    4040#define CAMDSOCKET  "/tmp/camd.socket"
    4141
    42 #define BUFSIZE 1024
     42#define BUFSIZE 1024
    4343#define MAX_CAID 50
    4444#define MAX_DEMUX 3
    4545
    46 
    4746static int listenfd = -1;
    48 
    4947
    5048typedef struct ECMPIDS
     
    5250    int CA_PID;
    5351    int CA_System_ID;
     52    int EMM_PID;
    5453} ECMPIDSTYPE;
    5554
     
    6665    int ca_system_id;
    6766    int ca_pid;
     67    int provider_id;
     68    int received_emm;
     69    int STREAMpidcount;
     70    short STREAMpids[20];
    6871    unsigned char buffer_cache_dmx[12];
    6972    unsigned char lastcw0[8];
     
    7982DEMUXTYPE demux[MAX_DEMUX];
    8083
    81 
    82 int dvbapi_open_demux(int index_demux)
     84int dvbapi_read_device(int dmx_fd, unsigned char *buf, int length, int debug)
     85{
     86    int len;
     87    len=read(dmx_fd, buf, length);
     88
     89    if (len==-1)
     90        cs_log("error %d", errno);
     91
     92    if (debug==1)
     93        cs_debug("Read %d bytes from demux", len);
     94
     95    return len;
     96}
     97
     98int dvbapi_open_device(int index_demux, int type)
    8399{
    84100    int dmx_fd;
    85101    char device_path[256];
    86    
    87     sprintf(device_path, DMXDEV, index_demux);
     102
     103    if (type==0)
     104        sprintf(device_path, DMXDEV, index_demux);
     105    else
     106        sprintf(device_path, CADEV, demux[index_demux].cadev_index);
    88107
    89108    if ((dmx_fd = open(device_path, O_RDWR)) < 0)
    90         cs_log("error opening demux %s", device_path);
    91 
    92     cs_debug("DEMUX open: %s", device_path);
     109        cs_log("error opening device %s", device_path);
     110
     111    cs_debug("dvbapi: DEVICE open (%s)", device_path);
    93112    return dmx_fd;
    94113}
    95114
    96 
    97 int dvbapi_open_ca(int index_demux)
    98 {
    99     int ca_fd,i;
    100     char device_path[256];
    101 
    102     sprintf(device_path, CADEV, demux[index_demux].cadev_index);
    103 
    104     if ((ca_fd = open(device_path, O_RDWR)) < 0) {
    105         cs_log("error opening ca %s", device_path);
     115int dvbapi_set_filter(int demux_index, int type, int pid, unsigned char filt, unsigned char mask, int timeout)
     116{
     117    struct dmx_sct_filter_params sFP;
     118    int dmx_fd;
     119
     120    cs_debug("dvbapi: set filter pid:%04x, value:%04x",pid, filt);
     121
     122    memset(&sFP,0,sizeof(sFP));
     123
     124    sFP.pid             = pid;
     125    sFP.timeout         = timeout;
     126    sFP.flags           = DMX_IMMEDIATE_START;
     127    sFP.filter.filter[0]        = filt;
     128    sFP.filter.mask[0]      = mask;
     129
     130    if (type==0)
     131        dmx_fd=demux[demux_index].demux_ecm_fd;
     132    else
     133        dmx_fd=demux[demux_index].demux_emm_fd;
     134
     135    if (ioctl(dmx_fd, DMX_SET_FILTER, &sFP) < 0)
     136    {
     137        cs_log("dvbapi: could not start demux filter");
    106138        return 0;
    107139    }
    108140
    109     demux[index_demux].ca_fd=ca_fd;
    110 
    111     cs_debug("CA open: %s", device_path);
    112     return ca_fd;
    113 }
    114 
    115 unsigned short dvbapi_get_single_ecm(int demux_index, int caid, int pid, unsigned char filt, unsigned char mask)
     141    ioctl(dmx_fd, DMX_START);
     142
     143    return dmx_fd;
     144}
     145
     146int dvbapi_stop_filter(int demux_index, int type)
     147{
     148    int dmx_fd;
     149
     150    if (type==0) {
     151        dmx_fd=demux[demux_index].demux_ecm_fd;
     152    } else {
     153        dmx_fd=demux[demux_index].demux_emm_fd;
     154    }
     155
     156    ioctl(dmx_fd,DMX_STOP);
     157    return 1;
     158}
     159
     160unsigned short dvbapi_get_provid(int demux_index, int pid)
    116161{
    117162    unsigned char buf[BUFSIZE];
    118163    int dmx_fd, len;
    119164
    120     struct dmx_sct_filter_params sFP;
    121 
    122     memset(&sFP, 0, sizeof(sFP));
    123     memset(buf,0,BUFSIZE);
    124 
    125     sFP.pid             = pid;
    126     sFP.timeout         = 2000;
    127     sFP.flags           = DMX_ONESHOT | DMX_CHECK_CRC | DMX_IMMEDIATE_START;
    128     sFP.filter.filter[0]        = filt;
    129     sFP.filter.mask[0]      = mask;
    130 
    131     cs_debug("dvbapi: filter for 1 ECM");
    132 
    133     dmx_fd = dvbapi_open_demux(demux_index);
    134 
    135     if (ioctl(dmx_fd, DMX_SET_FILTER, &sFP) < 0)
    136         return 0;
    137 
    138     len=read(dmx_fd, buf, BUFSIZE);
    139     cs_debug("Read %d bytes from demux", len);
    140 
    141     close(dmx_fd);
     165    dmx_fd=dvbapi_set_filter(demux_index, 1, pid, 0x80, 0xF0, 8000);
     166
     167    len=dvbapi_read_device(dmx_fd, buf, BUFSIZE, 1);
     168
     169    if (len > 0) {
     170        short int provid = (buf[10] << 8) | buf[11];
     171        return provid;
     172    }
     173
     174    return 0;
     175}
     176
     177unsigned short dvbapi_get_single_ecm(int demux_index, int caid, int pid, unsigned short provid)
     178{
     179    unsigned char buf[BUFSIZE];
     180    int dmx_fd, len;
     181
     182    dmx_fd=dvbapi_set_filter(demux_index, 0, pid, 0x80, 0xF0, 2000);
     183
     184    len=dvbapi_read_device(dmx_fd, buf, BUFSIZE, 1);
    142185
    143186    if (len > 0) {
     
    146189        if (!(er=get_ecmtask()))
    147190            return 0;
    148    
     191
    149192        er->srvid = demux[demux_index].program_number;
    150193        er->caid  = caid;
    151194        er->pid   = pid;
    152         //er->prid  = 0x3411;
     195        //er->prid  = provid;
    153196
    154197        er->l=len;
     
    160203}
    161204
    162 unsigned short dvbapi_parse_cat(int demux_index)
     205void dvbapi_parse_cat(int demux_index)
    163206{
    164207    unsigned char buf[BUFSIZE];
    165     unsigned short i, emmpid;
     208    unsigned short i, j;
    166209    int dmx_fd, len;
    167 
    168     unsigned short ca_system_id=demux[demux_index].ca_system_id;
    169 
    170     struct dmx_sct_filter_params sFP;
    171 
    172     memset(&sFP, 0, sizeof(sFP));
    173 
    174     memset(buf,0,BUFSIZE);
    175 
    176     sFP.filter.filter[0] = 0x01;
    177     sFP.filter.mask[0] = 0xFF;
    178     sFP.flags = DMX_ONESHOT | DMX_CHECK_CRC | DMX_IMMEDIATE_START;
    179     sFP.pid = 0x0001;
    180     sFP.timeout = 3000; //3secs
    181    
    182    
    183     dmx_fd = dvbapi_open_demux(demux_index);
    184 
    185     if (ioctl(dmx_fd, DMX_SET_FILTER, &sFP) < 0)
    186         return 0;
    187 
    188     len=read(dmx_fd, buf, BUFSIZE);
    189 
    190 
    191     cs_debug("Read %d bytes from demux", len);
    192 
    193     close(dmx_fd);
     210    //unsigned short ca_system_id=demux[demux_index].ca_system_id;
     211
     212    dmx_fd=dvbapi_set_filter(demux_index, 0, 0x0001, 0x01, 0xFF, 2000);
     213
     214    len=dvbapi_read_device(dmx_fd, buf, BUFSIZE, 1);
    194215
    195216    if (len<=0)
    196         return 0;
     217        return;
     218
     219    cs_ddump(buf, len, "cat:");
    197220
    198221    for (i = 8; i < (((buf[1] & 0x0F) << 8) | buf[2]) - 1; i += buf[i + 1] + 2)
    199222    {
    200         if ((buf[i] == 0x09) && ((((buf[i + 2] & 0x1F) << 8) | buf[i + 3]) == ca_system_id))
    201         {
    202             emmpid=(((buf[i + 4] & 0x1F) << 8) | buf[i + 5]);
    203             return emmpid;
    204         }
    205     }
    206 
    207     return 0;
    208 }
    209 
    210 unsigned short dvbapi_parse_ecm(int demux_index, unsigned char *buf, int len)
    211 {
    212     unsigned short provid;
    213 
    214     provid=(buf[3]<<8)|buf[4];
    215     cs_debug("Read %d bytes\tTable-id: %02x\tCA section length: %d\tProvider ID: %04x", len, buf[0], len ,provid);
    216 
    217     if (len>0) {
    218         ECM_REQUEST *er;
    219 
    220         if (!(er=get_ecmtask()))
    221             return 0;
    222 
    223         er->srvid = demux[demux_index].program_number;
    224         er->caid  =  demux[demux_index].ca_system_id;
    225         //er->prid  = 0x3411;
    226 
    227         er->l=len;
    228         memcpy(er->ecm, buf, er->l);
    229 
    230         get_cw(er);
    231     }
    232 
    233     return(provid);
    234 }
    235 
    236 int dvbapi_set_filter(int demux_index, int type, int pid, unsigned char filt, unsigned char mask)
    237 {
    238     struct dmx_sct_filter_params sFP;
    239     cs_debug("Set filter pid:%d, value:%d...",pid, filt);
    240 
    241     memset(&sFP,0,sizeof(sFP));
    242 
    243     sFP.pid             = pid;
    244     sFP.timeout         = 3000; //wait max 3 seconds for ECM message, should be repeated every 500ms
    245     sFP.flags           = DMX_CHECK_CRC | DMX_IMMEDIATE_START;
    246     sFP.filter.filter[0]        = filt;
    247     sFP.filter.mask[0]      = mask;
    248 
    249     int dmx_fd = dvbapi_open_demux(demux_index);
    250 
    251     if (ioctl(dmx_fd, DMX_SET_FILTER, &sFP) < 0)
    252     {
    253         perror(" Status");
    254         return 0;
    255     }
    256 
    257     if (type==0)
    258         demux[demux_index].demux_ecm_fd=dmx_fd;
    259 
    260     if (type==1)
    261         demux[demux_index].demux_emm_fd=dmx_fd;
    262 
    263     return 1;
    264 }
    265 
    266 void dvbapi_stop_descramble(int demux_index)
     223        if (buf[i] != 0x09) continue;
     224        unsigned short cat_sys_id=(((buf[i + 2] & 0x1F) << 8) | buf[i + 3]);
     225        unsigned short emm_pid=(((buf[i + 4] & 0x1F) << 8) | buf[i + 5]);
     226        cs_debug("cat: ca_system_id: %04x\temm_pid %04x", cat_sys_id, emm_pid);
     227        for (j=0;j<demux[demux_index].ECMpidcount;j++) {
     228            if (demux[demux_index].ECMpids[j].CA_System_ID==(((buf[i + 2] & 0x1F) << 8) | buf[i + 3])) {
     229                demux[demux_index].ECMpids[j].EMM_PID=emm_pid;
     230                break;
     231            }
     232        }
     233    }
     234
     235    return;
     236}
     237
     238void dvbapi_stop_descramble(int demux_index)
    267239{
    268240
    269241    /*
    270242    if (global_capid != 0) {
     243       
    271244        // unset pid?? (not working)
     245       
    272246        ca_pid_t ca_pid;
    273247        memset(&ca_pid,0,sizeof(ca_pid));
     
    279253
    280254    cs_log("dvbapi: Stop descrambling CAID: %04x", demux[demux_index].ca_system_id);
    281    
     255
    282256    demux[demux_index].ca_system_id=0;
    283257    demux[demux_index].ca_pid=0;
    284258    demux[demux_index].emm_pid=0;
    285 
     259    demux[demux_index].provider_id=0;
    286260
    287261    if (demux[demux_index].demux_ecm_fd>0) {
    288         ioctl(demux[demux_index].demux_ecm_fd,DMX_STOP);           
     262        ioctl(demux[demux_index].demux_ecm_fd,DMX_STOP);
    289263        close(demux[demux_index].demux_ecm_fd);
    290264        cs_debug("closing ecm dmx device");
     
    308282}
    309283
    310 void dvbapi_start_descramble(int demux_index, int caid, int capid) {
     284void dvbapi_start_descramble(int demux_index, int caid, int capid, unsigned short provider_id)
     285{
     286    int i;
    311287
    312288    cs_log("dvbapi: Start descrambling CAID: %04x", caid);
     
    314290    demux[demux_index].ca_pid=capid;
    315291    demux[demux_index].ca_system_id=caid;
    316 
    317     if (!dvbapi_set_filter(demux_index,0,capid,0x80,0xF0))  //filter on ECM pid and 0x80 or 0x81 (mask 0xF0)
    318         cs_log("Error ECM filtering");
    319 
    320     /*
    321      * get emm pid and start filter
    322      * TODO: prase_cat blocks thread */
    323 
    324     if (cfg->dvbapi_au==1) {
    325         short emmpid;
    326         emmpid=dvbapi_parse_cat(demux_index);
    327 
    328         cs_log("EMMPid: %04x", emmpid);
    329         demux[demux_index].emm_pid=emmpid;
    330         dvbapi_set_filter(demux_index,1,emmpid,0x80,0xF0);
    331     }
    332 
    333     int camfd=dvbapi_open_ca(demux_index);
     292    demux[demux_index].provider_id=provider_id;
     293
     294
     295    int camfd=dvbapi_open_device(demux_index,1);
    334296    if (camfd<=0) {
    335297        dvbapi_stop_descramble(demux_index);
     
    339301    demux[demux_index].ca_fd=camfd;
    340302
     303    /*
    341304    ca_pid_t ca_pid;
    342305    memset(&ca_pid,0,sizeof(ca_pid));
    343306    ca_pid.pid = capid;
    344     ca_pid.index = 0;
     307    ca_pid.index = demux_index;
    345308    if (ioctl(camfd, CA_SET_PID, &ca_pid)==-1)
    346         cs_log("dvbapi: Error SET_PID");
     309        cs_debug("dvbapi: Error CAPID SET_PID");
     310    */
     311
     312    for (i=0;i<demux[demux_index].STREAMpidcount;i++)
     313    {
     314
     315        ca_pid_t ca_pid2;
     316        memset(&ca_pid2,0,sizeof(ca_pid2));
     317        ca_pid2.pid = demux[demux_index].STREAMpids[i];
     318        ca_pid2.index = -1;
     319        if (ioctl(camfd, CA_SET_PID, &ca_pid2)==-1)
     320            cs_debug("dvbapi: Error Stream SET_PID");
     321
     322        memset(&ca_pid2,0,sizeof(ca_pid2));
     323        ca_pid2.pid = demux[demux_index].STREAMpids[i];
     324        ca_pid2.index = demux_index;
     325        if (ioctl(camfd, CA_SET_PID, &ca_pid2)==-1)
     326            cs_debug("dvbapi: Error Stream SET_PID");
     327    }
     328
    347329}
    348330
    349331// from tuxbox camd
     332
    350333int dvbapi_parse_capmt(unsigned char *buffer, unsigned int length)
    351334{
    352335    unsigned short i, j;
    353     int n, added, ca_mask, demux_index;
     336    int n, added, ca_mask=1, demux_index=0;
    354337
    355338    int ca_pmt_list_management = buffer[0];
     
    360343    {
    361344        case 0x01:
     345           
    362346            //FIXME?? (first)
     347           
    363348            break;
    364349        case 0x03:
     350           
    365351            //default (only)
     352           
    366353            break;
    367354        default:
     355           
    368356            //FIXME?? (unknown)
     357           
    369358            break;
    370359    }
     
    374363        demux_index = buffer[20];
    375364    }
    376    
     365
    377366    if (demux[demux_index].program_number==((buffer[1] << 8) | buffer[2]))
    378367        return 0;
     
    387376    demux[demux_index].cadev_index=ca_mask;
    388377
    389     //CA_PIDS fr alle Streams
     378    //CA_PIDS for all streams
     379
    390380    if (program_info_length != 0)
    391381    {
    392         int ca_pmt_cmd_id = buffer[6];
     382        //int ca_pmt_cmd_id = buffer[6];
    393383        //cs_debug("ca_pmt_id: %02x", ca_pmt_cmd_id);
    394384        int descriptor_length=0;
     
    404394                demux[demux_index].ECMpids[demux[demux_index].ECMpidcount].CA_PID=ca_pid;
    405395                demux[demux_index].ECMpids[demux[demux_index].ECMpidcount].CA_System_ID=ca_system_id;
     396                demux[demux_index].ECMpids[demux[demux_index].ECMpidcount].EMM_PID=0;
    406397                demux[demux_index].ECMpidcount++;
    407398            }
     
    415406    }
    416407
    417 
    418     //CA_PIDs fr einzelne Streams
     408    demux[demux_index].STREAMpidcount=0;
     409
     410    //CA_PIDs for a single stream
     411
    419412    unsigned short es_info_length=0;
    420413    for (i = program_info_length + 6; i < length; i += es_info_length + 5)
     
    426419        cs_debug("stream_type: %02x\telementary_pid: %04x\tes_info_length: %04x", stream_type, elementary_pid, es_info_length);
    427420
     421        demux[demux_index].STREAMpids[demux[demux_index].STREAMpidcount]=elementary_pid;
     422        demux[demux_index].STREAMpidcount++;
     423
    428424        if (es_info_length != 0)
    429425        {
    430             int ca_pmt_cmd_id = buffer[i + 5];
     426            //int ca_pmt_cmd_id = buffer[i + 5];
    431427            int descriptor_length=0;
    432428            for (j = 0; j < es_info_length - 1; j += descriptor_length + 2)
     
    447443                        demux[demux_index].ECMpids[demux[demux_index].ECMpidcount].CA_PID=descriptor_ca_pid;
    448444                        demux[demux_index].ECMpids[demux[demux_index].ECMpidcount].CA_System_ID=descriptor_ca_system_id;
     445                        demux[demux_index].ECMpids[demux[demux_index].ECMpidcount].EMM_PID=0;
    449446                        demux[demux_index].ECMpidcount++;
    450447                    }
     
    456453    dvbapi_stop_descramble(demux_index);
    457454
     455    int dmx1_fd,dmx2_fd;
     456
     457    if (demux[demux_index].ECMpidcount>0) {
     458        dmx1_fd = dvbapi_open_device(demux_index,0); //ECM,CAT
     459        dmx2_fd = dvbapi_open_device(demux_index,0); //EMM
     460
     461        demux[demux_index].demux_ecm_fd=dmx1_fd;
     462        demux[demux_index].demux_emm_fd=dmx2_fd;
     463
     464        dvbapi_parse_cat(demux_index);
     465    }
     466
    458467    cs_log("dvbapi: Found %d ECMpids in PMT", demux[demux_index].ECMpidcount);
     468    cs_debug("dvbapi: Found %d STREAMpids in PMT", demux[demux_index].STREAMpidcount);
    459469
    460470    for (n=0; n<demux[demux_index].ECMpidcount; n++) {
    461 
    462         cs_debug("dvbapi: trying CA_System_ID: %04x CA_PID: %04x", demux[demux_index].ECMpids[n].CA_System_ID, demux[demux_index].ECMpids[n].CA_PID);
    463471
    464472        if (demux[demux_index].ca_system_id!=0)
    465473            continue;
    466474
    467         dvbapi_get_single_ecm(demux_index, demux[demux_index].ECMpids[n].CA_System_ID,demux[demux_index].ECMpids[n].CA_PID,0x80,0xF0);
    468         sleep(3);
     475        dvbapi_stop_filter(demux_index,0);
     476        dvbapi_stop_filter(demux_index,1);
     477
     478        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);
     479
     480        //grep emm provid
     481
     482        unsigned short provid=0;
     483        //if (demux[demux_index].ECMpids[n].EMM_PID>0)
     484        //  provid=dvbapi_get_provid(demux_index, demux[demux_index].ECMpids[n].EMM_PID);
     485
     486        //cs_log("Provider ID: %04x", provid);
     487
     488        //grep ecm
     489
     490        dvbapi_get_single_ecm(demux_index, demux[demux_index].ECMpids[n].CA_System_ID,demux[demux_index].ECMpids[n].CA_PID, provid);
     491
     492
     493        sleep(3); //try next if no cw for .. secs
    469494    }
    470495
     
    480505
    481506    if (buffer[0] != 0x9F) {
    482         cs_log("handlesockmsg() unknown socket command: %02x", buffer[0]);
     507        cs_log("dvbapi: unknown socket command: %02x", buffer[0]);
    483508        return;
    484509    }
    485510
    486511    if (buffer[1] != 0x80) {
    487         cs_log("handlesockmsg() unknown apdu tag");
     512        cs_log("dvbapi: unknown apdu tag");
    488513        return;
    489514    }
     
    509534            dvbapi_parse_capmt(buffer + 3 + size, val);
    510535        else
    511             cs_log("handlesockmsg() ca_pmt invalid length");
     536            cs_log("dvbapi: ca_pmt invalid length");
    512537    }
    513538    else if (buffer[2] == 0x3f)
     
    569594
    570595        // if message begins with an apdu_tag and is longer than three bytes
     596
    571597        if ((buffer[0] == 0x9F) && ((buffer[1] >> 7) == 0x01) && ((buffer[2] >> 7) == 0x00)) {
    572598            dvbapi_handlesockmsg(buffer, len);
     
    579605}
    580606
    581 
    582607demux_search dvbapi_find_dmx_by_fd(int fd)
    583608{
    584609    int i;
    585610    demux_search s1;
     611
     612    s1.type=0;
     613    s1.index=0;
     614
    586615    for (i=0;i<MAX_DEMUX;i++) {
    587616        if (demux[i].demux_ecm_fd==fd) {
     
    596625        }
    597626    }
    598    
     627
    599628    return s1;
    600629}
     
    603632{
    604633    int i;
    605     for (i=0;i<MAX_DEMUX;i++) 
     634    for (i=0;i<MAX_DEMUX;i++)
    606635        if (demux[i].program_number==prognr)
    607636            return i;
    608    
     637
    609638    return -1;
    610639}
     
    622651        pfdcount=0;
    623652        for (i=0;i<MAX_DEMUX;i++) {
     653            if (demux[i].ca_system_id==0) continue; // ignore inactive tuner
     654
    624655            if (demux[i].demux_ecm_fd>0) {
    625656                pfd2[pfdcount].fd = demux[i].demux_ecm_fd;
     
    631662                pfd2[pfdcount].events = (POLLIN | POLLPRI);
    632663                pfdcount++;
    633             }   
    634    
     664            }
     665
    635666        }
    636667
     
    640671            if (pfd2[i].revents & (POLLIN | POLLPRI)) {
    641672                s1=dvbapi_find_dmx_by_fd(pfd2[i].fd);
     673
     674                if ((len=dvbapi_read_device(pfd2[i].fd, buffer, BUFSIZE, 0)) <= 0)
     675                    break;
     676
    642677                if (s1.type==0) {
     678                   
    643679                    //ECM
    644                     if ((len = read(pfd2[i].fd, buffer, BUFSIZE)) <= 0)
    645                         break;
    646 
     680                   
    647681                    if (len != (((buffer[1] & 0xf) << 8) | buffer[2]) + 3) //invaild CAT length
    648682                        break;
     
    652686                        if (memcmp(buffer, demux[s1.index].buffer_cache_dmx, 12) != 0) {
    653687                            memcpy(demux[s1.index].buffer_cache_dmx, buffer, 12);
    654                             if (!dvbapi_parse_ecm(s1.index,buffer,len)) { cs_log("Error while parsing ECM"); }
     688                            //if (!dvbapi_parse_ecm(s1.index,buffer,len)) { cs_log("Error while parsing ECM"); }
     689                            cs_debug("Read %d bytes\tTable-id: %02x\tCA section length: %d", len, buffer[0], len);
     690
     691                            if (len>0) {
     692                                ECM_REQUEST *er;
     693
     694                                if (!(er=get_ecmtask()))
     695                                    break;
     696
     697                                er->srvid = demux[s1.index].program_number;
     698                                er->caid  = demux[s1.index].ca_system_id;
     699                                //er->prid  = demux[s1.index].provider_id;
     700
     701                                er->l=len;
     702                                memcpy(er->ecm, buffer, er->l);
     703
     704                                get_cw(er);
     705                            }
    655706                        }
    656707                    }
    657 
    658708                }
    659709                if (s1.type==1) {
     710                   
    660711                    //EMM
    661                     if ((len = read(pfd2[i].fd, buffer, BUFSIZE)) <= 0)
     712
     713                    if (cfg->dvbapi_au!=1)
    662714                        break;
    663715
    664                     if (len != (((buffer[1] & 0xf) << 8) | buffer[2]) + 3) //invaild CAT length
    665                         break;
    666 
    667                     /*
    668                     //nagra only???
    669                     int emmtype;
    670                     if( (buffer[0]==0x82) ) emmtype = 0; // U
    671                     if( (buffer[0]==0x83) && (buffer[7]==0x10) ) emmtype = 1; // S
    672                     if( (buffer[0]==0x83) && (buffer[7]==0x00) ) emmtype = 2; // G
    673                     */
    674 
    675                     cs_log("EMM Type: 0x%02x", buffer[0]);
    676 
     716                    cs_debug("EMM Type: 0x%02x", buffer[0]);
     717
     718                    cs_ddump(buffer, len, "emm:");
     719                   
    677720                    //force emm output
     721                   
    678722                    reader[ridx].logemm=9999;
    679723
     
    682726                    epg.caid[0] = (uchar)(demux[s1.index].ca_system_id>>8);
    683727                    epg.caid[1] = (uchar)(demux[s1.index].ca_system_id);
    684                     if (reader[client[cs_idx].au].caid[0]!=b2i(2,epg.caid)) cs_log("caid %04x", b2i(2,epg.caid));
     728                    //if (reader[client[cs_idx].au].caid[0]!=b2i(2,epg.caid)) cs_log("caid %04x", b2i(2,epg.caid));
    685729                    //memcpy(epg.provid, prov, 4);
    686730
     
    689733                    memcpy(epg.hexserial, reader[client[cs_idx].au].hexserial, 8);
    690734
    691                     do_emm(&epg);
     735                    //do_emm(&epg);
    692736
    693737                }
     
    699743    return 0;
    700744}
    701 
    702745
    703746int dvbapi_main_local()
     
    711754
    712755    if (cfg->dvbapi_usr[0]==0) {
    713         //
    714     }
    715 
    716 
    717     for (i=0;i<MAX_DEMUX;i++) {
    718 
     756        //
     757    }
     758
     759    for (i=0;i<MAX_DEMUX;i++)
     760    {
    719761        demux[i].program_number=0;
    720762        demux[i].demux_ecm_fd=0;
     
    725767        demux[i].cadev_index=-1;
    726768        demux[i].ca_fd=0;
     769        demux[i].received_emm=0;
     770
    727771        memset(demux[i].buffer_cache_dmx,0 ,12);
    728 
    729         for (i=0;i<20;i++)      //clean ECMpids array
    730         {
    731             demux[i].ECMpids[i].CA_PID      = 0;
    732             demux[i].ECMpids[i].CA_System_ID = 0;
    733         }
    734        
    735     }
    736 
    737     if (!dvbapi_init_listenfd()) return 1;
     772    }
     773
     774    if (!dvbapi_init_listenfd())
     775    {
     776        cs_log("dvbapi: could not init camd.socket.");
     777        return 1;
     778    }
    738779
    739780    pfd2[0].fd = fd_m2c;
     
    745786
    746787    while (1) {
    747         if (master_pid!=getppid()) {
    748             cs_log("master died");
     788        if (master_pid!=getppid())
    749789            cs_exit(0);
    750         }
    751790
    752791        rc=poll(pfd2, 1, 500);
     
    764803
    765804
    766 void dvbapi_send_dcw(ECM_REQUEST *er) {
     805void dvbapi_send_dcw(ECM_REQUEST *er)
     806{
    767807    unsigned char cw_0[8], cw_1[8];
     808
     809    //cs_debug("dvbapi: ECM rc: %d", er->rc);
    768810
    769811    memcpy(cw_0, er->cw, 8);
    770812    memcpy(cw_1, er->cw+8, 8);
    771813
     814    //this is not working when both tuner on one channel
     815
     816    int demux_index=dvbapi_get_index_by_prgnr(er->srvid);
     817    if (demux_index>=0) {
     818        if (er->rc==0 && demux[demux_index].ca_system_id==0) {
     819            dvbapi_start_descramble(demux_index, er->caid, er->pid, er->prid);
     820        }
     821    } else {
     822        cs_log("dvbapi: error cant find demux index");
     823    }
     824
     825    if (er->rc!=0)
     826        return;
     827
    772828    ca_descr_t ca_descr;
    773829    memset(&ca_descr,0,sizeof(ca_descr));
    774830
    775     //this is not working when both tuner on one channel
    776     int demux_index=dvbapi_get_index_by_prgnr(er->srvid);
    777     if (demux_index>=0) {
    778         if (er->rc==0 && demux[demux_index].ca_system_id==0)
    779             dvbapi_start_descramble(demux_index, er->caid, er->pid);       
    780     } else {
    781         cs_log("error cant find demux index");
     831    if (demux[demux_index].ca_fd<=0)
     832    {
     833        cs_log("dvbapi: could not write cw.");
     834        return;
    782835    }
    783836
    784837    if (memcmp(cw_0,demux[demux_index].lastcw0,8))
    785838    {
    786         ca_descr.index = 0;
     839        ca_descr.index = demux_index;
    787840        ca_descr.parity = 0;
    788841        memcpy(demux[demux_index].lastcw0,cw_0,8);
    789842        memcpy(ca_descr.cw,cw_0,8);
    790         if (ioctl(demux[demux_index].ca_fd, CA_SET_DESCR, &ca_descr) < 0) perror("CA_SET_DESCR");
     843        if (ioctl(demux[demux_index].ca_fd, CA_SET_DESCR, &ca_descr) < 0) cs_debug("dvbapi: Error CA_SET_DESCR");
    791844    }
    792845
    793846    if (memcmp(cw_1,demux[demux_index].lastcw1,8))
    794847    {
    795         ca_descr.index = 0;
     848        ca_descr.index = demux_index;
    796849        ca_descr.parity = 1;
    797850        memcpy(demux[demux_index].lastcw1,cw_1,8);
    798851        memcpy(ca_descr.cw,cw_1,8);
    799         if (ioctl(demux[demux_index].ca_fd, CA_SET_DESCR, &ca_descr) < 0) perror("CA_SET_DESCR");
    800     }
    801 
    802 }
    803 
    804 static void dvbapi_handler(int idx) {
     852        if (ioctl(demux[demux_index].ca_fd, CA_SET_DESCR, &ca_descr) < 0) cs_debug("dvbapi: Error CA_SET_DESCR");
     853    }
     854
     855}
     856
     857static void dvbapi_handler(int idx)
     858{
    805859    static struct s_auth *account=0;
    806860
  • branches/monitor-improvement/module-newcamd.c

    r719 r1052  
    6464        break;
    6565    case COMMTYPE_SERVER:
    66       if( *netMsgId == 0xFFFE ) *netMsgId = 0; // ��� 0xFFFF ?
     66      if( *netMsgId == 0xFFFE ) *netMsgId = 0; // ??? 0xFFFF ?
    6767      break;
    6868    }
     
    715715            {
    716716            if (cfg->ncd_ptab.ports[client[cs_idx].port_idx].ftab.filts[0].caid != reader[au].caid[0]
    717                 &&  cfg->ncd_ptab.ports[client[cs_idx].port_idx].ftab.filts[0].caid != reader[au].ftab.filts[0].caid) 
     717                &&  cfg->ncd_ptab.ports[client[cs_idx].port_idx].ftab.filts[0].caid != reader[au].ftab.filts[0].caid)
    718718                {
    719719                cs_log("AU wont be used on this port -> disable AU");
     
    851851                    mbuf[12] = reader[au].hexserial[3];
    852852                    mbuf[13] = reader[au].hexserial[4];
     853                    }
     854                else if ((pufilt->caid >> 8) == 0x18)
     855                    {
     856                    mbuf[8] = 0x00;
     857                    mbuf[9] = 0x00;
     858                    mbuf[10] = reader[au].hexserial[0];
     859                    mbuf[11] = reader[au].hexserial[1];
     860                    mbuf[12] = reader[au].hexserial[2];
     861                    mbuf[13] = reader[au].hexserial[3];
    853862                    }
    854863                else
  • branches/monitor-improvement/reader-nagra.c

    r820 r1052  
    44#include <termios.h>
    55#include <unistd.h>
    6 #ifdef OS_LINUX
    7 #include <linux/serial.h>
    8 #endif
    96
    107IDEA_KEY_SCHEDULE ksSession;
     
    9188            return 0;
    9289        }
    93         if (is_pure_nagra==1) msg[4]+=1;
    94         if (is_tiger)
     90        if (is_pure_nagra==1)
    9591        {
    96             msg[4]--;
    97             msg[6]--;
     92            msg[4]+=1;
    9893        }
    9994        if(!reader_cmd2icc(msg,msglen))
    10095    {
    101         cs_sleepms(10);
     96        cs_sleepms(20);
    10297        if(cta_res[0]!=res)
    10398            {
     
    128123    cs_debug("[nagra-reader] IFS cmd: %s", cs_hexdump (1, buf, 5));
    129124    ret = reader_cmd2api(buf, 5);
    130     cs_debug("[nagra-reader] IFS response: %s", cs_hexdump (1, cta_res, cta_lr));
    131     if ((cta_lr!=5) || (ret!=OK))
     125    if (ret < 0)
    132126    {
    133127            cs_debug("[nagra-reader] setting IFS to %02x failed", size);
     
    190184{
    191185    do_cmd(0xC8,0x02,0xB8,0x06,NULL);
    192    
    193     /*
    194     [sci0] <- 21 00 08 a0 ca 00 00 02 c8 00 06 8f
    195     [sci0] -> 12 00 08
    196     [sci0] -> b8 04 19 90 7b f4 90 00
    197     */
    198186}
    199187
     
    213201        memcpy(camid,reader[ridx].hexserial,4);
    214202    }
     203}
     204
     205int NegotiateSessionKey_Tiger(void)
     206{
     207    unsigned char rsa_modulo[120];
     208    unsigned char idea_sig[16];
     209    unsigned char vFixed[] = {0,1,2,3,0x11};
     210    unsigned char parte_fija[120];
     211    unsigned char parte_variable[88];
     212    unsigned char d1_rsa_modulo[88];
     213    unsigned char rand[88];
     214    unsigned char d2_data[88];
     215    unsigned char sign1[8];
     216    unsigned char sessi1[8];
     217    unsigned char sessi2[8];
     218    unsigned char tmp[104];
     219    unsigned char tmp1[8];
     220                     
     221    if(!do_cmd(0xd1,0x02,0x51,0xd2,NULL))
     222    {
     223        cs_debug("[nagra-reader] CMD$D1 failed");
     224        return 0;
     225    }
     226
     227    ReverseMem(rsa_modulo, 120);
     228    ReverseMem(&cta_res[90], 120);
     229   
     230    cs_debug("[nagra-reader] crypted parte_fija: %s", cs_hexdump (0, &cta_res[90], 32));
     231    cs_debug("[nagra-reader] crypted parte_fija: %s", cs_hexdump (0, &cta_res[122], 32));
     232    cs_debug("[nagra-reader] crypted parte_fija: %s", cs_hexdump (0, &cta_res[154], 32));
     233    cs_debug("[nagra-reader] crypted parte_fija: %s", cs_hexdump (0, &cta_res[186], 24));
     234   
     235    BN_CTX *ctx = BN_CTX_new();
     236    BIGNUM *bnN = BN_CTX_get(ctx);
     237    BIGNUM *bnE = BN_CTX_get(ctx);
     238    BIGNUM *bnCT = BN_CTX_get(ctx);
     239    BIGNUM *bnPT = BN_CTX_get(ctx);
     240    BN_bin2bn(rsa_modulo, 120, bnN);
     241    BN_bin2bn(vFixed+4, 1, bnE);
     242    BN_bin2bn(&cta_res[90], 120, bnCT);
     243    BN_mod_exp(bnPT, bnCT, bnE, bnN, ctx);
     244    memset(parte_fija, 0, 120);
     245    BN_bn2bin(bnPT, parte_fija + (120-BN_num_bytes(bnPT)));
     246    BN_CTX_end(ctx);
     247    BN_CTX_free (ctx);
     248   
     249    ReverseMem(parte_fija, 120);
     250    cs_debug("[nagra-reader] decrypted parte_fija: %s", cs_hexdump (0, parte_fija, 32));
     251    cs_debug("[nagra-reader] decrypted parte_fija: %s", cs_hexdump (0, &parte_fija[32], 32));
     252    cs_debug("[nagra-reader] decrypted parte_fija: %s", cs_hexdump (0, &parte_fija[64], 32));
     253    cs_debug("[nagra-reader] decrypted parte_fija: %s", cs_hexdump (0, &parte_fija[96], 24));
     254   
     255    cs_debug("[nagra-reader] ---------- SIG CHECK ---------------------");
     256    memset(tmp,0, 104);
     257    memcpy(tmp+4, parte_fija+11, 100); //104
     258    Signature(sign1, idea_sig, tmp, 112);
     259    cs_debug("[nagra-reader] foo: %s", cs_hexdump (0, tmp, 32));
     260    cs_debug("[nagra-reader] foo: %s", cs_hexdump (0, &tmp[32], 32));
     261    cs_debug("[nagra-reader] foo: %s", cs_hexdump (0, &tmp[64], 32));
     262    cs_debug("[nagra-reader] foo: %s", cs_hexdump (0, &tmp[96], 8));
     263    cs_debug("[nagra-reader] sign1: %s", cs_hexdump (0, sign1, 8));
     264    cs_debug("[nagra-reader] sign2: %s", cs_hexdump (0, parte_fija+111, 8));
     265    if (!memcmp (parte_fija+111, sign1, 8)==0)
     266    {
     267        cs_debug("[nagra-reader] signature check nok");
     268        return 0;
     269    }
     270    cs_debug("[nagra-reader] ------------------------------------------");
     271    cs_debug("[nagra-reader] signature check ok");
     272    cs_debug("[nagra-reader] part2 of algo not implemented yet.");
     273   
     274    /*
     275    A lot of todo here.
     276    Second part of algo removed due it fails
     277    */
     278
     279    if(!do_cmd(0xd2,0x5a,0x52,0x03, d2_data))
     280    {
     281        cs_debug("[nagra-reader] CMD$D2 failed");
     282        return 0;
     283    }
     284    if (cta_res+2 == 0x00)
     285    {
     286        memcpy(sessi,sessi1,8); memcpy(sessi+8,sessi2,8);
     287        cs_ri_log("[nagra-reader] session key: %s", cs_hexdump(1, sessi, 16));
     288        return 1;
     289    }
     290    cs_ri_log("Negotiate sessionkey was not successfull! Please check rsa key and boxkey");
     291    return 0;
     292       
    215293}
    216294
     
    232310    if (is_tiger)
    233311    {
    234         unsigned char d1[] = {0xd2};
    235         if(!do_cmd(0xd1,0x03,0x51,0x42,d1))
    236         {
    237             cs_debug("[nagra-reader] CMD$D1 failed");
     312        if (!NegotiateSessionKey_Tiger())
     313        {
     314            cs_debug("[nagra-reader] NegotiateSessionKey_Tiger failed");
    238315            return 0;
    239316        }
    240     }
    241     else
    242     {
    243         if(!do_cmd(0x2a,0x02,0xaa,0x42,NULL))
    244         {
    245             cs_debug("[nagra-reader] CMD$2A failed");
    246             return 0;
    247         }
    248     }
    249 
    250         // RSA decrypt of cmd$2a data, result is stored in "negot"
    251         ReverseMem(cta_res+2, 64);
    252         //cs_debug("[nagra-reader] plainDT08RSA: %s", cs_hexdump (1, plainDT08RSA, 32));
    253         //cs_debug("[nagra-reader] plainDT08RSA: %s", cs_hexdump (1, &plainDT08RSA[32], 32));
    254         unsigned char vFixed[] = {0,1,2,3};
    255         BN_CTX *ctx = BN_CTX_new();
    256         BIGNUM *bnN = BN_CTX_get(ctx);
    257         BIGNUM *bnE = BN_CTX_get(ctx);
    258         BIGNUM *bnCT = BN_CTX_get(ctx);
    259         BIGNUM *bnPT = BN_CTX_get(ctx);
    260         BN_bin2bn(plainDT08RSA, 64, bnN);
    261         BN_bin2bn(vFixed+3, 1, bnE);
    262         BN_bin2bn(cta_res+2, 64, bnCT);
    263         BN_mod_exp(bnPT, bnCT, bnE, bnN, ctx);
    264         memset(negot, 0, 64);
    265         BN_bn2bin(bnPT, negot + (64-BN_num_bytes(bnPT)));
    266         //cs_debug("[nagra-reader] DT08 decrypted $2a data: %s", cs_hexdump (1, negot, 32));
    267         //cs_debug("[nagra-reader] DT08 decrypted $2a data: %s", cs_hexdump (1, &negot[32], 32));
    268        
    269         memcpy(tmp, negot, 64);
    270         ReverseMem(tmp, 64);
     317        return 1;
     318    }
     319    if(!do_cmd(0x2a,0x02,0xaa,0x42,NULL))
     320    {
     321        cs_debug("[nagra-reader] CMD$2A failed");
     322        return 0;
     323    }
     324
     325    // RSA decrypt of cmd$2a data, result is stored in "negot"
     326    ReverseMem(cta_res+2, 64);
     327    //cs_debug("[nagra-reader] plainDT08RSA: %s", cs_hexdump (1, plainDT08RSA, 32));
     328    //cs_debug("[nagra-reader] plainDT08RSA: %s", cs_hexdump (1, &plainDT08RSA[32], 32));
     329    unsigned char vFixed[] = {0,1,2,3};
     330    BN_CTX *ctx = BN_CTX_new();
     331    BIGNUM *bnN = BN_CTX_get(ctx);
     332    BIGNUM *bnE = BN_CTX_get(ctx);
     333    BIGNUM *bnCT = BN_CTX_get(ctx);
     334    BIGNUM *bnPT = BN_CTX_get(ctx);
     335    BN_bin2bn(plainDT08RSA, 64, bnN);
     336    BN_bin2bn(vFixed+3, 1, bnE);
     337    BN_bin2bn(cta_res+2, 64, bnCT);
     338    BN_mod_exp(bnPT, bnCT, bnE, bnN, ctx);
     339    memset(negot, 0, 64);
     340    BN_bn2bin(bnPT, negot + (64-BN_num_bytes(bnPT)));
     341    //cs_debug("[nagra-reader] DT08 decrypted $2a data: %s", cs_hexdump (1, negot, 32));
     342        //cs_debug("[nagra-reader] DT08 decrypted $2a data: %s", cs_hexdump (1, &negot[32], 32));
     343       
     344    memcpy(tmp, negot, 64);
     345    ReverseMem(tmp, 64);
     346   
     347    // build sessionkey
     348    // first halve is IDEA Hashed in chuncs of 8 bytes using the Signature1 from dt08 calc, CamID-Inv.CamID(16 bytes key) the results are the First 8 bytes of the Session key
     349    memcpy(idea1, signature, 8);
     350    memcpy(idea1+8, reader[ridx].hexserial, 4);
     351    idea1[12] = ~reader[ridx].hexserial[0]; idea1[13] = ~reader[ridx].hexserial[1]; idea1[14] = ~reader[ridx].hexserial[2]; idea1[15] = ~reader[ridx].hexserial[3];
    271352       
    272         // build sessionkey
    273         // first halve is IDEA Hashed in chuncs of 8 bytes using the Signature1 from dt08 calc, CamID-Inv.CamID(16 bytes key) the results are the First 8 bytes of the Session key
    274         memcpy(idea1, signature, 8);
    275         memcpy(idea1+8, reader[ridx].hexserial, 4);
    276         idea1[12] = ~reader[ridx].hexserial[0]; idea1[13] = ~reader[ridx].hexserial[1]; idea1[14] = ~reader[ridx].hexserial[2]; idea1[15] = ~reader[ridx].hexserial[3];
     353    Signature(sign1, idea1, tmp, 32);
     354    memcpy(idea2,sign1,8); memcpy(idea2+8,sign1,8);
     355    Signature(sign2, idea2, tmp, 32);
     356    memcpy(sessi,sign1,8); memcpy(sessi+8,sign2,8);
    277357       
    278         Signature(sign1, idea1, tmp, 32);
    279         memcpy(idea2,sign1,8); memcpy(idea2+8,sign1,8);
    280         Signature(sign2, idea2, tmp, 32);
    281         memcpy(sessi,sign1,8); memcpy(sessi+8,sign2,8);
     358    // prepare cmd$2b data
     359    BN_bin2bn(negot, 64, bnCT);
     360    BN_mod_exp(bnPT, bnCT, bnE, bnN, ctx);
     361    memset(cmd2b+10, 0, 64);
     362    BN_bn2bin(bnPT, cmd2b+10 + (64-BN_num_bytes(bnPT)));
     363    BN_CTX_end(ctx);
     364    BN_CTX_free (ctx);
     365    ReverseMem(cmd2b+10, 64);
    282366       
    283         // prepare cmd$2b data
    284         BN_bin2bn(negot, 64, bnCT);
    285         BN_mod_exp(bnPT, bnCT, bnE, bnN, ctx);
    286         memset(cmd2b+10, 0, 64);
    287         BN_bn2bin(bnPT, cmd2b+10 + (64-BN_num_bytes(bnPT)));
    288         BN_CTX_end(ctx);
    289         BN_CTX_free (ctx);
    290         ReverseMem(cmd2b+10, 64);
    291        
    292         IDEA_KEY_SCHEDULE ks;
    293         idea_set_encrypt_key(sessi,&ks);
    294         idea_set_decrypt_key(&ks,&ksSession);
    295    
    296     if (!is_tiger)
    297     {
    298         if(!do_cmd(0x2b,0x42,0xab,0x02, cmd2b+10))
    299         {
    300             cs_debug("[nagra-reader] CMD$2B failed");
    301             return 0;
    302         }
    303     }
    304     else
    305     {
    306         if(!do_cmd(0xd2,0x42,0x52,0x03, cmd2b+10))
    307         {
    308             cs_debug("[nagra-reader] CMD$D2 failed");
    309             return 0;
    310         }
    311     }
    312    
     367    IDEA_KEY_SCHEDULE ks;
     368    idea_set_encrypt_key(sessi,&ks);
     369    idea_set_decrypt_key(&ks,&ksSession);
     370   
     371    if(!do_cmd(0x2b,0x42,0xab,0x02, cmd2b+10))
     372    {
     373        cs_debug("[nagra-reader] CMD$2B failed");
     374        return 0;
     375    }
     376
    313377    cs_debug("[nagra-reader] session key: %s", cs_hexdump(1, sessi, 16));
    314378   
    315     if (!is_tiger)
    316     {
    317         if (!CamStateRequest())
    318         {
    319             cs_debug("[nagra-reader] CamStateRequest failed");
    320             return 0;
    321         }
    322         if SENDDATETIME
    323         {
    324             DateTimeCMD();
    325         }
    326         if RENEW_SESSIONKEY
    327         {
    328             cs_ri_log("Negotiate sessionkey was not successfull! Please check rsa key and boxkey");
    329             return 0;
    330         }
    331     }
     379    if (!CamStateRequest())
     380    {
     381        cs_debug("[nagra-reader] CamStateRequest failed");
     382        return 0;
     383    }
     384    if SENDDATETIME
     385    {
     386        DateTimeCMD();
     387    }
     388    if RENEW_SESSIONKEY
     389    {
     390        cs_ri_log("Negotiate sessionkey was not successfull! Please check rsa key and boxkey");
     391        return 0;
     392    }
     393
    332394    return 1;
    333395}
     
    502564    if (memcmp(atr+11, "DNASP", 5)==0)
    503565    {
    504         //if(SetIFS(0xFE) != 1) return 0;
     566        if(SetIFS(0xFE) != 1) return 0;
    505567        cs_debug("[nagra-reader] detect native nagra card T1 protocol");
    506568        memcpy(rom,atr+11,15);
     
    508570    else if (memcmp(atr+11, "TIGER", 5)==0)
    509571    {
    510         //if(SetIFS(0xFE) != 1) return 0;
     572        if(SetIFS(0xFE) != 1) return 0;
    511573        cs_debug("[nagra-reader] detect nagra tiger card");
    512574        memcpy(rom,atr+11,15);
     
    594656void nagra2_post_process(void)
    595657{
    596     //Todo: Do not block!//
    597658    CamStateRequest();
    598659    cs_sleepms(10);
     
    616677   
    617678        }
    618         cs_sleepms(5);
     679        cs_sleepms(15);
    619680        while(!CamStateRequest() && retry < 5)
    620681        {
     
    622683                    cs_sleepms(15);
    623684        }
    624         cs_sleepms(5);
     685        cs_sleepms(10);
    625686        if (HAS_CW && do_cmd(0x1C,0x02,0x9C,0x36,NULL))
    626687        {
     
    644705        if(!do_cmd(0xd3,er->ecm[4]+2,0x53,0x16, er->ecm+3+2))
    645706        {
    646             //53 14 01 00 00 00
    647             //94 8c 3e f7 49 a8 c7 23 //cw1?
    648             //9a 67 e3 e1 d4 c1 c7 83 //cw0?
    649             //90 0
    650             unsigned char v[8];
    651             memset(v,0,sizeof(v));
    652             idea_cbc_encrypt(&cta_res[14],er->cw,8,&ksSession,v,IDEA_DECRYPT);
    653             memset(v,0,sizeof(v));
    654             idea_cbc_encrypt(&cta_res[6],er->cw+8,8,&ksSession,v,IDEA_DECRYPT);
    655             return (1);
     707            if(cta_res[2] == 0x01)
     708            {
     709                unsigned char v[8];
     710                memset(v,0,sizeof(v));
     711                idea_cbc_encrypt(&cta_res[14],er->cw,8,&ksSession,v,IDEA_DECRYPT);
     712                memset(v,0,sizeof(v));
     713                idea_cbc_encrypt(&cta_res[6],er->cw+8,8,&ksSession,v,IDEA_DECRYPT);
     714                return (1);
     715            }
     716            cs_debug("[nagra-reader] can't decode ecm");
     717            return (0);
    656718        }
    657719    }
Note: See TracChangeset for help on using the changeset viewer.