Changeset 3862


Ignore:
Timestamp:
11/09/10 11:29:36 (13 years ago)
Author:
_network
Message:

dvbapi: add shared and global videoguard emm filter

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/reader-videoguard-common.c

    r3604 r3862  
    831831  return ptr;
    832832}
     833
     834
     835
     836int videoguard_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr)
     837{
     838
     839/*
     84082 30 ad 70 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 00
     841d3 02 00 22 90 20 44 02 4a 50 1d 88 ab 02 ac 79 16 6c df a1 b1 b7 77 00 ba eb 63 b5 c9 a9 30 2b 43 e9 16 a9 d5 14 00
     842d3 02 00 22 90 20 44 02 13 e3 40 bd 29 e4 90 97 c3 aa 93 db 8d f5 6b e4 92 dd 00 9b 51 03 c9 3d d0 e2 37 44 d3 bf 00
     843d3 02 00 22 90 20 44 02 97 79 5d 18 96 5f 3a 67 70 55 bb b9 d2 49 31 bd 18 17 2a e9 6f eb d8 76 ec c3 c9 cc 53 39 00
     844d2 02 00 21 90 1f 44 02 99 6d df 36 54 9c 7c 78 1b 21 54 d9 d4 9f c1 80 3c 46 10 76 aa 75 ef d6 82 27 2e 44 7b 00
     845*/
     846
     847    int i, pos;
     848    int serial_count = ((ep->emm[3] >> 4) & 3) + 1;
     849    int serial_len = (ep->emm[3] & 0x80) ? 3 : 4;
     850    uchar emmtype = (ep->emm[3] & VG_EMMTYPE_MASK) >> 6;
     851
     852    pos = 4 + (serial_len * serial_count) + 2;
     853
     854    switch(emmtype) {
     855        case VG_EMMTYPE_G:
     856            ep->type=GLOBAL;
     857            cs_debug_mask(D_EMM, "EMM: GLOBAL");
     858            return TRUE;
     859
     860        case VG_EMMTYPE_U:
     861            cs_debug_mask(D_EMM, "EMM: UNIQUE");
     862            ep->type=UNIQUE;
     863            if (ep->emm[1] == 0) // detected UNIQUE EMM from cccam (there is no serial)
     864                return TRUE;
     865
     866            for (i = 1;i <= serial_count;i++) {
     867                if (!memcmp (rdr->hexserial + 2, ep->emm + (serial_len * i), serial_len)) {
     868                    memcpy(ep->hexserial, ep->emm + (serial_len * i), serial_len);
     869                return TRUE;
     870                }
     871
     872                pos = pos + ep->emm[pos+5] + 5;
     873            }
     874            return FALSE; // if UNIQUE but no serial match return FALSE
     875
     876        case VG_EMMTYPE_S:
     877            ep->type=SHARED;
     878            cs_debug_mask(D_EMM, "EMM: SHARED");
     879
     880            for (i = 0; i < serial_count; i++) {
     881                if (!memcmp(&ep->emm[i * 4 + 4], rdr->hexserial + 2, serial_len)) {
     882                    memcpy(ep->hexserial, &ep->emm[i * 4 + 4], serial_len);
     883                    return TRUE;
     884                }
     885            }
     886
     887            return TRUE; // FIXME: no check for SA
     888
     889        default:
     890            if (ep->emm[pos-2] != 0x00 && ep->emm[pos-1] != 0x00 && ep->emm[pos-1] != 0x01) {
     891                //remote emm without serial
     892                ep->type=UNKNOWN;
     893                return TRUE;
     894            }
     895            return FALSE;
     896    }
     897}
     898
     899void videoguard_get_emm_filter(struct s_reader * rdr, uchar *filter)
     900{
     901    filter[0]=0xFF;
     902    filter[1]=5;
     903
     904    //ToDo videoguard_get_emm_filter basic construction
     905    filter[2]=UNIQUE;
     906    filter[3]=0;
     907
     908    filter[4+0]    = 0x82;
     909    filter[4+0+16] = 0xFF;
     910    filter[4+1]    = 0x40;
     911    filter[4+1+16] = 0xC0;
     912    memcpy(filter+4+2, rdr->hexserial+2, 4);
     913    memset(filter+4+2+16, 0xFF, 4);
     914
     915    filter[36]=UNIQUE;
     916    filter[37]=0;
     917
     918    filter[38+0]    = 0x82;
     919    filter[38+0+16] = 0xFF;
     920    filter[38+1]    = 0x40;
     921    filter[38+1+16] = 0xC0;
     922    memcpy(filter+38+6, rdr->hexserial+2, 4);
     923    memset(filter+38+6+16, 0xFF, 4);
     924
     925    filter[70]=UNIQUE;
     926    filter[71]=0;
     927
     928    filter[72+0]    = 0x82;
     929    filter[72+0+16] = 0xFF;
     930    filter[72+1]    = 0x40;
     931    filter[72+1+16] = 0xC0;
     932    memcpy(filter+72+10, rdr->hexserial+2, 4);
     933    memset(filter+72+10+16, 0xFF, 4);
     934
     935    // fourth serial position does not fit within the 16bytes demux filter
     936
     937
     938    filter[104]=SHARED;
     939    filter[105]=0;
     940
     941    filter[106+0]    = 0x82;
     942    filter[106+0+16] = 0xFF;
     943    filter[106+1]    = 0x80;
     944    filter[106+1+16] = 0xC0;
     945
     946
     947    filter[138]=GLOBAL;
     948    filter[139]=0;
     949
     950    filter[140+0]    = 0x82;
     951    filter[140+0+16] = 0xFF;
     952    filter[140+1]    = 0x00;
     953    filter[140+1+16] = 0xC0;
     954
     955
     956    return;
     957}
     958

  • trunk/reader-videoguard-common.h

    r3602 r3862  
    5353extern const unsigned char *payload_addr(uchar emmtype, const unsigned char *data, const unsigned char *a);
    5454
     55int videoguard_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr);
     56void videoguard_get_emm_filter(struct s_reader * rdr, uchar *filter);
     57
    5558#endif // __NDS_COMMON__
    5659

  • trunk/reader-videoguard1.c

    r3354 r3862  
    290290}
    291291
    292 static int videoguard1_get_emm_type(EMM_PACKET * ep, struct s_reader *rdr)
    293 {
    294 
    295 /*
    296 82 30 ad 70 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 00
    297 d3 02 00 22 90 20 44 02 4a 50 1d 88 ab 02 ac 79 16 6c df a1 b1 b7 77 00 ba eb 63 b5 c9 a9 30 2b 43 e9 16 a9 d5 14 00
    298 d3 02 00 22 90 20 44 02 13 e3 40 bd 29 e4 90 97 c3 aa 93 db 8d f5 6b e4 92 dd 00 9b 51 03 c9 3d d0 e2 37 44 d3 bf 00
    299 d3 02 00 22 90 20 44 02 97 79 5d 18 96 5f 3a 67 70 55 bb b9 d2 49 31 bd 18 17 2a e9 6f eb d8 76 ec c3 c9 cc 53 39 00
    300 d2 02 00 21 90 1f 44 02 99 6d df 36 54 9c 7c 78 1b 21 54 d9 d4 9f c1 80 3c 46 10 76 aa 75 ef d6 82 27 2e 44 7b 00
    301 */
    302 
    303   int i, pos;
    304   int serial_count = ((ep->emm[3] >> 4) & 3) + 1;
    305   int serial_len = (ep->emm[3] & 0x80) ? 3 : 4;
    306   uchar emmtype = (ep->emm[3] & VG_EMMTYPE_MASK) >> 6;
    307   pos = 4 + (serial_len * serial_count) + 2;
    308   switch (emmtype) {
    309   case VG_EMMTYPE_G:
    310     {
    311       ep->type = GLOBAL;
    312       cs_debug_mask(D_EMM, "VIDEOGUARD1 EMM: GLOBAL");
    313       return TRUE;
    314     }
    315   case VG_EMMTYPE_U:
    316     {
    317       cs_debug_mask(D_EMM, "VIDEOGUARD1 EMM: UNIQUE");
    318       ep->type = UNIQUE;
    319       if (ep->emm[1] == 0)  // detected UNIQUE EMM from cccam (there is no serial)
    320       {
    321     return TRUE;
    322       }
    323 
    324       for (i = 1; i <= serial_count; i++) {
    325     if (!memcmp(rdr->hexserial + 2, ep->emm + (serial_len * i), serial_len)) {
    326       memcpy(ep->hexserial, ep->emm + (serial_len * i), serial_len);
    327       return TRUE;
    328     }
    329 
    330     pos = pos + ep->emm[pos + 5] + 5;
    331       }
    332       return FALSE;     // if UNIQUE but no serial match return FALSE
    333     }
    334   case VG_EMMTYPE_S:
    335     {
    336       ep->type = SHARED;
    337       cs_debug_mask(D_EMM, "VIDEOGUARD1 EMM: SHARED");
    338       return TRUE;      // FIXME: no check for SA
    339     }
    340   default:
    341     {
    342       if (ep->emm[pos - 2] != 0x00 && ep->emm[pos - 1] != 0x00 && ep->emm[pos - 1] != 0x01) {
    343     //remote emm without serial
    344     ep->type = UNKNOWN;
    345     return TRUE;
    346       }
    347       return FALSE;
    348     }
    349   }
    350 }
    351 
    352 static void videoguard1_get_emm_filter(struct s_reader *rdr, uchar * filter)
    353 {
    354   filter[0] = 0xFF;
    355   filter[1] = 3;
    356   //ToDo videoguard1_get_emm_filter basic construction
    357   filter[2] = UNIQUE;
    358   filter[3] = 0;
    359   filter[4 + 0] = 0x82;
    360   filter[4 + 0 + 16] = 0xFF;
    361   memcpy(filter + 4 + 2, rdr->hexserial + 2, 4);
    362   memset(filter + 4 + 2 + 16, 0xFF, 4);
    363   filter[36] = UNIQUE;
    364   filter[37] = 0;
    365   filter[38 + 0] = 0x82;
    366   filter[38 + 0 + 16] = 0xFF;
    367   memcpy(filter + 38 + 6, rdr->hexserial + 2, 4);
    368   memset(filter + 38 + 6 + 16, 0xFF, 4);
    369   filter[70] = UNIQUE;
    370   filter[71] = 0;
    371   filter[72 + 0] = 0x82;
    372   filter[72 + 0 + 16] = 0xFF;
    373   memcpy(filter + 72 + 10, rdr->hexserial + 2, 4);
    374   memset(filter + 72 + 10 + 16, 0xFF, 4);
    375   /* filter[104]=UNIQUE;
    376      filter[105]=0;
    377 
    378      filter[106+0]    = 0x82;
    379      filter[106+0+16] = 0xFF;
    380 
    381      memcpy(filter+106+14, rdr->hexserial+2, 2);
    382      memset(filter+106+14+16, 0xFF, 2); */
    383   return;
    384 }
    385 
    386292static int videoguard1_do_emm(struct s_reader *reader, EMM_PACKET * ep)
    387293{
    … …  
    437343    ph->card_info=videoguard1_card_info;
    438344    ph->card_init=videoguard1_card_init;
    439     ph->get_emm_type=videoguard1_get_emm_type;
    440     ph->get_emm_filter=videoguard1_get_emm_filter;
     345    ph->get_emm_type=videoguard_get_emm_type;
     346    ph->get_emm_filter=videoguard_get_emm_filter;
    441347    ph->caids[0]=0x09;
    442348}

  • trunk/reader-videoguard12.c

    r3819 r3862  
    351351}
    352352
    353 static int videoguard12_get_emm_type(EMM_PACKET * ep, struct s_reader *rdr)
    354 {
    355 
    356 /*
    357 82 30 ad 70 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 00
    358 d3 02 00 22 90 20 44 02 4a 50 1d 88 ab 02 ac 79 16 6c df a1 b1 b7 77 00 ba eb 63 b5 c9 a9 30 2b 43 e9 16 a9 d5 14 00
    359 d3 02 00 22 90 20 44 02 13 e3 40 bd 29 e4 90 97 c3 aa 93 db 8d f5 6b e4 92 dd 00 9b 51 03 c9 3d d0 e2 37 44 d3 bf 00
    360 d3 02 00 22 90 20 44 02 97 79 5d 18 96 5f 3a 67 70 55 bb b9 d2 49 31 bd 18 17 2a e9 6f eb d8 76 ec c3 c9 cc 53 39 00
    361 d2 02 00 21 90 1f 44 02 99 6d df 36 54 9c 7c 78 1b 21 54 d9 d4 9f c1 80 3c 46 10 76 aa 75 ef d6 82 27 2e 44 7b 00
    362 */
    363 
    364   int i, pos;
    365   int serial_count = ((ep->emm[3] >> 4) & 3) + 1;
    366   int serial_len = (ep->emm[3] & 0x80) ? 3 : 4;
    367   uchar emmtype = (ep->emm[3] & VG_EMMTYPE_MASK) >> 6;
    368   pos = 4 + (serial_len * serial_count) + 2;
    369   switch (emmtype) {
    370   case VG_EMMTYPE_G:
    371     {
    372       ep->type = GLOBAL;
    373       cs_debug_mask(D_EMM,"EMM: GLOBAL");
    374       return TRUE;
    375     }
    376   case VG_EMMTYPE_U:
    377     {
    378       cs_debug_mask(D_EMM,"EMM: UNIQUE");
    379       ep->type = UNIQUE;
    380       if (ep->emm[1] == 0) {    // detected UNIQUE EMM from cccam (there is no serial)
    381         return TRUE;
    382       }
    383 
    384       for (i = 1; i <= serial_count; i++) {
    385         if (!memcmp(rdr->hexserial + 2, ep->emm + (serial_len * i), serial_len)) {
    386           memcpy(ep->hexserial, ep->emm + (serial_len * i), serial_len);
    387           return TRUE;
    388         }
    389         pos = pos + ep->emm[pos + 5] + 5;
    390       }
    391       return FALSE;     // if UNIQUE but no serial match return FALSE
    392     }
    393   case VG_EMMTYPE_S:
    394     {
    395       ep->type = SHARED;
    396       cs_debug_mask(D_EMM, "EMM: SHARED");
    397       return TRUE;      // FIXME: no check for SA
    398     }
    399   default:
    400     {
    401       if (ep->emm[pos - 2] != 0x00 && ep->emm[pos - 1] != 0x00 && ep->emm[pos - 1] != 0x01) {
    402         //remote emm without serial
    403         ep->type = UNKNOWN;
    404         return TRUE;
    405       }
    406       return FALSE;
    407     }
    408   }
    409 }
    410 
    411 static void videoguard12_get_emm_filter(struct s_reader *rdr, uchar * filter)
    412 {
    413   filter[0] = 0xFF;
    414   filter[1] = 3;
    415   //ToDo videoguard12_get_emm_filter basic construction
    416   filter[2] = UNIQUE;
    417   filter[3] = 0;
    418   filter[4 + 0] = 0x82;
    419   filter[4 + 0 + 16] = 0xFF;
    420   memcpy(filter + 4 + 2, rdr->hexserial + 2, 4);
    421   memset(filter + 4 + 2 + 16, 0xFF, 4);
    422   filter[36] = UNIQUE;
    423   filter[37] = 0;
    424   filter[38 + 0] = 0x82;
    425   filter[38 + 0 + 16] = 0xFF;
    426   memcpy(filter + 38 + 6, rdr->hexserial + 2, 4);
    427   memset(filter + 38 + 6 + 16, 0xFF, 4);
    428   filter[70] = UNIQUE;
    429   filter[71] = 0;
    430   filter[72 + 0] = 0x82;
    431   filter[72 + 0 + 16] = 0xFF;
    432   memcpy(filter + 72 + 10, rdr->hexserial + 2, 4);
    433   memset(filter + 72 + 10 + 16, 0xFF, 4);
    434   /* filter[104]=UNIQUE;
    435      filter[105]=0;
    436 
    437      filter[106+0]    = 0x82;
    438      filter[106+0+16] = 0xFF;
    439 
    440      memcpy(filter+106+14, rdr->hexserial+2, 2);
    441      memset(filter+106+14+16, 0xFF, 2); */
    442   return;
    443 }
    444 
    445353static int videoguard12_do_emm(struct s_reader *reader, EMM_PACKET * ep)
    446354{
    … …  
    496404  ph->card_info=videoguard12_card_info;
    497405  ph->card_init=videoguard12_card_init;
    498   ph->get_emm_type=videoguard12_get_emm_type;
    499   ph->get_emm_filter=videoguard12_get_emm_filter;
     406  ph->get_emm_type=videoguard_get_emm_type;
     407  ph->get_emm_filter=videoguard_get_emm_filter;
    500408  ph->caids[0]=0x09;
    501409}

  • trunk/reader-videoguard2.c

    r3819 r3862  
    655655}
    656656
    657 static int videoguard2_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr)
    658 {
    659 
    660 /*
    661 82 30 ad 70 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 XX XX XX 00 00
    662 d3 02 00 22 90 20 44 02 4a 50 1d 88 ab 02 ac 79 16 6c df a1 b1 b7 77 00 ba eb 63 b5 c9 a9 30 2b 43 e9 16 a9 d5 14 00
    663 d3 02 00 22 90 20 44 02 13 e3 40 bd 29 e4 90 97 c3 aa 93 db 8d f5 6b e4 92 dd 00 9b 51 03 c9 3d d0 e2 37 44 d3 bf 00
    664 d3 02 00 22 90 20 44 02 97 79 5d 18 96 5f 3a 67 70 55 bb b9 d2 49 31 bd 18 17 2a e9 6f eb d8 76 ec c3 c9 cc 53 39 00
    665 d2 02 00 21 90 1f 44 02 99 6d df 36 54 9c 7c 78 1b 21 54 d9 d4 9f c1 80 3c 46 10 76 aa 75 ef d6 82 27 2e 44 7b 00
    666 */
    667 
    668     int i, pos;
    669     int serial_count = ((ep->emm[3] >> 4) & 3) + 1;
    670     int serial_len = (ep->emm[3] & 0x80) ? 3 : 4;
    671     uchar emmtype = (ep->emm[3] & VG_EMMTYPE_MASK) >> 6;
    672 
    673     pos = 4 + (serial_len * serial_count) + 2;
    674 
    675     switch(emmtype) {
    676         case VG_EMMTYPE_G:
    677             ep->type=GLOBAL;
    678             cs_debug_mask(D_EMM, "EMM: GLOBAL");
    679             return TRUE;
    680 
    681         case VG_EMMTYPE_U:
    682             cs_debug_mask(D_EMM, "EMM: UNIQUE");
    683             ep->type=UNIQUE;
    684             if (ep->emm[1] == 0) // detected UNIQUE EMM from cccam (there is no serial)
    685                 return TRUE;
    686 
    687             for (i = 1;i <= serial_count;i++) {
    688                 if (!memcmp (rdr->hexserial + 2, ep->emm + (serial_len * i), serial_len)) {
    689                     memcpy(ep->hexserial, ep->emm + (serial_len * i), serial_len);
    690                 return TRUE;
    691                 }
    692 
    693                 pos = pos + ep->emm[pos+5] + 5;
    694             }
    695             return FALSE; // if UNIQUE but no serial match return FALSE
    696 
    697         case VG_EMMTYPE_S:
    698             ep->type=SHARED;
    699             cs_debug_mask(D_EMM, "EMM: SHARED");
    700             return TRUE; // FIXME: no check for SA
    701 
    702         default:
    703             if (ep->emm[pos-2] != 0x00 && ep->emm[pos-1] != 0x00 && ep->emm[pos-1] != 0x01) {
    704                 //remote emm without serial
    705                 ep->type=UNKNOWN;
    706                 return TRUE;
    707             }
    708             return FALSE;
    709     }
    710 }
    711 
    712 static void videoguard2_get_emm_filter(struct s_reader * rdr, uchar *filter)
    713 {
    714     filter[0]=0xFF;
    715     filter[1]=3;
    716 
    717     //ToDo videoguard2_get_emm_filter basic construction
    718 
    719     filter[2]=UNIQUE;
    720     filter[3]=0;
    721 
    722     filter[4+0]    = 0x82;
    723     filter[4+0+16] = 0xFF;
    724 
    725     memcpy(filter+4+2, rdr->hexserial+2, 4);
    726     memset(filter+4+2+16, 0xFF, 4);
    727 
    728     filter[36]=UNIQUE;
    729     filter[37]=0;
    730 
    731     filter[38+0]    = 0x82;
    732     filter[38+0+16] = 0xFF;
    733 
    734     memcpy(filter+38+6, rdr->hexserial+2, 4);
    735     memset(filter+38+6+16, 0xFF, 4);
    736 
    737     filter[70]=UNIQUE;
    738     filter[71]=0;
    739 
    740     filter[72+0]    = 0x82;
    741     filter[72+0+16] = 0xFF;
    742 
    743     memcpy(filter+72+10, rdr->hexserial+2, 4);
    744     memset(filter+72+10+16, 0xFF, 4);
    745 
    746     /* filter[104]=UNIQUE;
    747     filter[105]=0;
    748 
    749     filter[106+0]    = 0x82;
    750     filter[106+0+16] = 0xFF;
    751 
    752     memcpy(filter+106+14, rdr->hexserial+2, 2);
    753     memset(filter+106+14+16, 0xFF, 2); */
    754 
    755     return;
    756 }
    757 
    758657static int videoguard2_do_emm(struct s_reader * reader, EMM_PACKET *ep)
    759658{
    … …  
    806705    ph->card_info=videoguard2_card_info;
    807706    ph->card_init=videoguard2_card_init;
    808     ph->get_emm_type=videoguard2_get_emm_type;
    809     ph->get_emm_filter=videoguard2_get_emm_filter;
     707    ph->get_emm_type=videoguard_get_emm_type;
     708    ph->get_emm_filter=videoguard_get_emm_filter;
    810709    ph->caids[0]=0x09;
    811710}
Note: See TracChangeset for help on using the changeset viewer.