Changeset 1766


Ignore:
Timestamp:
Mar 4, 2010, 1:13:16 PM (10 years ago)
Author:
landlord
Message:

New EMM processing, so they can be filtered for DVB API, thanks to dingo35.

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/globals.h

    r1762 r1766  
    477477  ushort    caid[16];
    478478  uchar     b_nano[256];
     479  int       blockemm_unknown; //block EMMs that have unknown type
     480  int       blockemm_u;             //blcok Unique EMMs
     481  int       blockemm_s;             //block Shared EMMS
     482  int       blockemm_g;             //block Global EMMs
    479483  char      * emmfile;
    480484  char      pincode[5];
     
    765769  uchar caid[2];
    766770  uchar provid[4];
    767   uchar hexserial[8];
     771  uchar hexserial[8];                    //contains hexserial or SA of EMM
    768772  uchar type;
    769773  int   cidx;
    770774} GCC_PACK EMM_PACKET;
     775
     776//EMM types:
     777#define UNKNOWN 0
     778#define UNIQUE  1
     779#define SHARED  2
     780#define GLOBAL  3
    771781
    772782// oscam-simples
     
    987997extern int reader_ecm(ECM_REQUEST *);
    988998extern int reader_emm(EMM_PACKET *);
     999int reader_get_emm_type(EMM_PACKET *ep, struct s_reader * reader);
    9891000
    9901001#ifdef HAVE_PCSC
  • trunk/module-dvbapi.c

    r1743 r1766  
    532532}
    533533
    534 void dvbapi_process_emm (int demux_index, unsigned char *buffer, unsigned int len) {
     534void dvbapi_process_emm (int demux_index, unsigned char *buffer, unsigned int len)
     535{
    535536    int i;
    536537    cs_debug("dvbapi: EMM Type: 0x%02x caid: %04x", buffer[0],demux[demux_index].ca_system_id);
     
    554555        if (reader[i].caid[0] == demux[demux_index].ca_system_id) {
    555556            client[cs_idx].au=i;
    556             memcpy(epg.hexserial, reader[client[cs_idx].au].hexserial, 8);
    557         }
    558     }
    559 
    560     switch(demux[demux_index].ca_system_id >> 8) {
    561         case 0x18: // NAGRA EMM
    562             epg.l=len;
    563             int emm_shared = (buffer[7] == 0x10);
    564             uchar cam_id[4];
    565 
    566             switch(buffer[0]) {
    567                 case 0x82:
    568                     //emm-s
    569                     cs_debug("dvbapi: NAGRA shared emm");
    570                     //do_emm(&epg);
    571                     break;
    572                 case 0x83:
    573                     //emm-u/g
    574                     cam_id[0] = buffer[5]; cam_id[1] = buffer[4]; cam_id[2] = buffer[3]; cam_id[3] = buffer[6];
    575                     cs_debug("dvbapi: NAGRA %s EMM for camid: %02X %02X %02X %02X", emm_shared ? "group" : "user", cam_id[0], cam_id[1], cam_id[2], cam_id[3]);
    576                     if (epg.hexserial[2]==cam_id[0] && epg.hexserial[3]==cam_id[1] && epg.hexserial[4]==cam_id[2]) {
    577                         if (emm_shared==1) {
    578                             //do_emm(&epg);
    579                             cs_debug("dvbapi: do nagra user emm");
    580                         }
    581                         if (emm_shared==0 && epg.hexserial[5] == cam_id[3]) {
    582                             //do_emm(&epg);
    583                             cs_debug("dvbapi: do nagra group emm");
    584                         }
    585                     }
    586                     break;
    587                 default:
    588                     cs_debug("dvbapi: unknown Nagra EMM (skipped)");
    589                     break;
    590             }
    591             break;
    592         case 0x06: //Irdeto EMM
    593         case 0x01: //Seca EMM
    594             do_emm(&epg);
    595             break;
    596         case 0x0D:
    597             cs_debug("dvbapi: CrytoWorks EMM (skipped)");
    598             break;
    599         case 0x05:
    600             cs_debug("dvbapi: Viaccess EMM (skipped)");
    601             break;
    602         case 0x09:
    603             cs_debug("dvbapi: Videoguard EMM (skipped)");
    604             break;
    605         default:
    606             cs_debug("dvbapi: Unknown EMM (skipped)");
    607             break;
    608     }
     557//          memcpy(epg.hexserial, reader[client[cs_idx].au].hexserial, 8);
     558        }
     559    }
     560    do_emm(&epg);
    609561}
    610562
  • trunk/oscam-config.c

    r1762 r1766  
    26292629    }
    26302630
     2631    if (!strcmp(token, "blockemm-unknown")) { rdr->blockemm_unknown=atoi(value); return; }
     2632    if (!strcmp(token, "blockemm-u")) { rdr->blockemm_u=atoi(value); return; }
     2633    if (!strcmp(token, "blockemm-s")) { rdr->blockemm_s=atoi(value); return; }
     2634    if (!strcmp(token, "blockemm-g")) { rdr->blockemm_g=atoi(value); return; }
     2635
    26312636    if (!strcmp(token, "savenano")) {
    26322637        //wildcard is used
  • trunk/oscam-reader.c

    r1716 r1766  
    422422
    423423  cs_ftime(&tps);
    424 
    425   if (memcmp(ep->hexserial, reader[ridx].hexserial, 8))
    426     return(3);
    427424
    428425  no=0;
  • trunk/oscam.c

    r1762 r1766  
    21082108  int au;//, ephs;
    21092109  au=client[cs_idx].au;
     2110    cs_ddump_mask(D_ATR, ep->emm, ep->l, "emm:");
    21102111
    21112112  if ((au<0) || (au>=CS_MAXREADER))
    21122113    return;
     2114    if (!reader_get_emm_type(ep, &reader[au])) //decodes ep->type and ep->hexserial from the EMM
     2115        return;
     2116  cs_debug_mask(D_EMM, "Emmtype = %i. reader %s has serial %s.", ep->type, reader[au].label, cs_hexdump(0, reader[au].hexserial, 8));
     2117  cs_ddump_mask(D_EMM, ep->hexserial, 8, "emm UA/SA:");
     2118    switch (ep->type) {
     2119        case UNKNOWN:
     2120            if (reader[au].blockemm_unknown) return;
     2121        case UNIQUE:
     2122            if (reader[au].blockemm_u) return;
     2123        case SHARED:
     2124            if (reader[au].blockemm_s) return;
     2125//FIXME only camd33 delivers hexserial from the net, newcamd, camd35 copy cardreader hexserial in; reader_get_emm_type overwrites this with real SA value if known!
     2126        case GLOBAL:
     2127            if (reader[au].blockemm_g) return;
     2128    }
    21132129  client[cs_idx].lastemm=time((time_t)0);
    2114   cs_debug_mask(D_EMM,"reader %s has serial %s.", reader[au].label, cs_hexdump(0, reader[au].hexserial, 8));
    2115   cs_ddump_mask(D_EMM, ep->hexserial, 8, "emm UA:");
    21162130  cs_ddump_mask(D_EMM, ep->emm, ep->l, "emm:");
    21172131//  if ((!reader[au].fd) || (reader[au].b_nano[ep->emm[3]])) // blocknano is obsolete
    21182132  if ((!reader[au].fd) ||       // reader has no fd
    2119       (reader[au].caid[0]!=b2i(2,ep->caid)) ||    // wrong caid
    2120       (memcmp(reader[au].hexserial, ep->hexserial, 8))) /* wrong serial*/  {
     2133      (reader[au].caid[0]!=b2i(2,ep->caid))) {   // wrong caid
    21212134#ifdef WEBIF
    21222135      client[cs_idx].emmnok++;
     
    21282141#endif
    21292142  ep->cidx=cs_idx;
     2143  cs_debug_mask(D_EMM, "EMM is being sent to reader %s.", reader[au].label);
    21302144  write_to_pipe(reader[au].fd, PIP_ID_EMM, (uchar *) ep, sizeof(EMM_PACKET));
    21312145}
  • trunk/reader-common.c

    r1691 r1766  
    361361        case SC_VIDEOGUARD2:
    362362          rc=(videoguard_do_ecm(er)) ? 1 : 0; break;
    363   case SC_DRE:
    364     rc=(dre_do_ecm(er)) ? 1: 0; break;
    365         default: rc=0;
     363        case SC_DRE:
     364          rc=(dre_do_ecm(er)) ? 1: 0; break;
     365        default:
     366          rc=0;
    366367      }
    367368    }
     
    373374  if (loadbalanced_idx++ >= m) loadbalanced_idx = 1;
    374375  return(rc);
     376}
     377
     378int reader_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr)
     379{
     380    cs_debug_mask(D_EMM,"Entered reader_get_emm_type cardsystem %i",rdr->card_system);
     381    int rc;
     382    switch(rdr->card_system) {
     383    case SC_NAGRA:
     384      rc=nagra2_get_emm_type(ep); break;
     385    case SC_IRDETO:
     386      rc=irdeto_get_emm_type(ep); break;
     387    case SC_CRYPTOWORKS:
     388      rc=cryptoworks_get_emm_type(ep); break;
     389    case SC_VIACCESS:
     390      rc=viaccess_get_emm_type(ep); break;
     391    case SC_CONAX:
     392      rc=conax_get_emm_type(ep); break;
     393    case SC_SECA:
     394      rc=seca_get_emm_type(ep, rdr); break;
     395    case SC_VIDEOGUARD2:
     396      rc=videoguard_get_emm_type(ep); break;
     397    case SC_DRE:
     398      rc=dre_get_emm_type(ep); break;
     399    default:
     400      rc=0;
     401  }
     402    return rc;
    375403}
    376404
  • trunk/reader-common.h

    r1389 r1766  
    1616int irdeto_do_ecm(ECM_REQUEST *);
    1717int irdeto_do_emm(EMM_PACKET *);
     18int irdeto_get_emm_type(EMM_PACKET *);
    1819int irdeto_card_info(void);
    1920
     
    2223int viaccess_do_ecm(ECM_REQUEST *);
    2324int viaccess_do_emm(EMM_PACKET *);
     25int viaccess_get_emm_type(EMM_PACKET *);
    2426int viaccess_card_info(void);
    2527
     
    2830int videoguard_do_ecm(ECM_REQUEST *);
    2931int videoguard_do_emm(EMM_PACKET *);
     32int videoguard_get_emm_type(EMM_PACKET *);
    3033int videoguard_card_info(void);
    3134
     
    3437int cryptoworks_do_ecm(ECM_REQUEST *);
    3538int cryptoworks_do_emm(EMM_PACKET *);
     39int cryptoworks_get_emm_type(EMM_PACKET *);
    3640int cryptoworks_card_info(void);
    3741int CheckSctLen(const uchar *, int);
     
    4145int seca_do_ecm(ECM_REQUEST *);
    4246int seca_do_emm(EMM_PACKET *);
     47//FIXME int seca_get_emm_type(EMM_PACKET *);
     48int seca_get_emm_type(EMM_PACKET *, struct s_reader *);
    4349int seca_card_info(void);
    44  
     50
    4551// reader-nds
    4652int nds_card_init(ATR atr, int);
    4753int nds_do_ecm(ECM_REQUEST *);
    4854int nds_do_emm(EMM_PACKET *);
     55int nds_get_emm_type(EMM_PACKET *);
    4956int nds_card_info(void);
    5057
     
    5461int nagra2_card_info(void);
    5562int nagra2_do_emm(EMM_PACKET *);
     63int nagra2_get_emm_type(EMM_PACKET *);
    5664void nagra2_post_process();
    5765 
     
    6068int conax_do_ecm(ECM_REQUEST *);
    6169int conax_do_emm(EMM_PACKET *);
     70int conax_get_emm_type(EMM_PACKET *);
    6271int conax_card_info(void);
    6372 
     
    6675int dre_do_ecm(ECM_REQUEST *);
    6776int dre_do_emm(EMM_PACKET *);
     77int dre_get_emm_type(EMM_PACKET *);
    6878int dre_card_info(void);
    6979
  • trunk/reader-conax.c

    r1413 r1766  
    204204}
    205205
     206int conax_get_emm_type(EMM_PACKET *ep) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
     207{
     208    ep->type=ep->emm[2]+3; //FIXME not sure how this maps onto global, unique and shared!
     209    return TRUE; //FIXME let it all pass without checking serial or SA, without filling ep->hexserial
     210}
     211   
     212
    206213int conax_do_emm(EMM_PACKET *ep)
    207214{
     
    218225
    219226  int l=ep->emm[2];
    220   ep->type=l+3;
    221227
    222228  insEMM[4]=l+5;
  • trunk/reader-cryptoworks.c

    r1691 r1766  
    457457}
    458458
     459int cryptoworks_get_emm_type(EMM_PACKET *ep) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
     460{
     461  switch (ep->emm[0]) {
     462        case 0x82:
     463        if(ep->emm[3]==0xA9 && ep->emm[4]==0xFF && ep->emm[13]==0x80 && ep->emm[14]==0x05)
     464                ep->type = UNIQUE; //FIXME no ep->hexserial set
     465            else
     466                ep->type = UNKNOWN;
     467            break;
     468        case 0x84:
     469        if(ep->emm[3]==0xA9 && ep->emm[4]==0xFF && ep->emm[12]==0x80 && ep->emm[13]==0x04)
     470                ep->type = SHARED;
     471            else
     472                ep->type = UNKNOWN;
     473            break;
     474        case 0x89:
     475        if(ep->emm[3]==0xA9 && ep->emm[4]==0xFF && ep->emm[8]==0x83 && ep->emm[9]==0x01)
     476                ep->type = GLOBAL;
     477            else
     478                ep->type = UNKNOWN;
     479            break;
     480        case 0x8F://incoming via camd3.5x
     481            //ep->type=emm[4];
     482        default:
     483            ep->type = UNKNOWN;
     484    }
     485    return TRUE; //no check on serial or SA
     486}
     487   
     488
    459489int cryptoworks_do_emm(EMM_PACKET *ep)
    460490{
     
    475505  */
    476506   
    477   //by KrazyIvan
    478   ep->type=emm[0];
    479507  //cs_log("[cryptoworks-reader] EMM Dump:..: %s",cs_hexdump(1, emm, emm[2]));
    480   switch(emm[0])
     508  switch(ep->type)
    481509  {
    482510     // emm via camd3.5x
     
    484512          if(emm[3]==0xA4)
    485513          {         
    486             ep->type=emm[4];
    487514            //cs_log("[cryptoworks-reader] EMM Dump: CMD: %s", cs_hexdump(1, emm+3, 5));
    488515            //cs_log("[cryptoworks-reader] EMM Dump: DATA: %s",cs_hexdump(1, emm+8, emm[7]));
     
    497524          if(emm[3]==0xA9 && emm[4]==0xFF && emm[8]==0x83 && emm[9]==0x01)
    498525          {
    499                 ep->type=insEMM_GA[1];
    500526                insEMM_GA[4]=ep->emm[2]-2;
    501527                //cs_log("[cryptoworks-reader] EMM Dump: CMD: %s", cs_hexdump(1, insEMM_GA, 5));
     
    515541          if(emm[3]==0xA9 && emm[4]==0xFF && emm[12]==0x80 && emm[13]==0x04)
    516542          {
    517                 ep->type=insEMM_SA[1];
    518543                insEMM_SA[4]=ep->emm[2]-6;
    519544                //cs_log("[cryptoworks-reader] EMM Dump: CMD: %s", cs_hexdump(1, insEMM_SA, 5));
     
    533558        if(emm[3]==0xA9 && emm[4]==0xFF && emm[13]==0x80 && emm[14]==0x05)
    534559        {
    535             ep->type=insEMM_UA[1];
    536560            insEMM_UA[4]=ep->emm[2]-7;
    537561            //cs_log("[cryptoworks-reader] EMM Dump: CMD: %s", cs_hexdump(1, insEMM_UA, 5));
  • trunk/reader-dre.c

    r1635 r1766  
    245245      reader[ridx].sa[0][3], cs_hexdump (0, reader[ridx].hexserial + 2, 4));
    246246
    247   //reader[ridx].nprov = 1; TODO doesnt seem necessary
     247  reader[ridx].nprov = 1;
    248248
    249249  if (!dre_set_provider_info ())
     
    302302}
    303303
     304int dre_get_emm_type(EMM_PACKET *ep)
     305{
     306  switch (ep->emm[0]) {
     307        case 0x87:
     308            ep->type = UNIQUE; //FIXME no filling of ep->hexserial
     309            break;
     310        case 0x89:
     311            ep->type = SHARED; //FIXME no filling of ep->hexserial
     312            break;
     313        default:
     314            ep->type = UNKNOWN;
     315    }
     316    return TRUE; //FIXME no checking of serial or SA
     317}
     318   
     319
    304320int dre_do_emm (EMM_PACKET * ep)
    305321{
     
    334350    };
    335351        int i;
    336         switch (ep->emm[0]) {
    337             case 0x87: //unique EMM
     352        switch (ep->type) {
     353            case UNIQUE:
    338354            for (i = 0; i < 2; i++) {
    339355                    memcpy (emmcmd42 + 1, ep->emm + 42 + i*49, 48);
     
    347363                }
    348364                break;
    349             case 0x89: //shared EMM
     365            case SHARED:
    350366            default:
    351367            memcpy (emmcmd42 + 1, ep->emm + 6, 48);
  • trunk/reader-irdeto.c

    r1507 r1766  
    366366}
    367367
     368int irdeto_get_emm_type(EMM_PACKET *ep) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
     369{
     370  int i, l=(ep->emm[3]&0x07), ok=0;
     371  int mode=(ep->emm[3]>>3);
     372  if (mode&0x10) {      // Hex addressed
     373    ep->type = UNIQUE;
     374        memset(ep->hexserial,0,8);
     375        memcpy(ep->hexserial, ep->emm + 4, l);
     376    return (mode==reader[ridx].hexserial[3] &&
     377       (!l || !memcmp(ep->emm+4, reader[ridx].hexserial, l)));
     378  }
     379  else {                // Provider addressed
     380        ep->type = SHARED;
     381    for(i=0; i<reader[ridx].nprov; i++) {
     382      ok=(mode==reader[ridx].prid[i][0] &&
     383         (!l || !memcmp(ep->emm+4, &reader[ridx].prid[i][1], l)));
     384      if (ok) break;
     385    }
     386        memset(ep->hexserial,0,8);
     387        memcpy(ep->hexserial, ep->emm+4, l); //prid in hezserial instread of SA
     388        return ok;
     389  }
     390}
     391
    368392int irdeto_do_emm(EMM_PACKET *ep)
    369393{
     
    375399
    376400  uchar *emm=ep->emm;
    377   ep->type=emm[3];
    378401  if (mode&0x10)        // Hex addressed
    379402  {
  • trunk/reader-nagra.c

    r1543 r1766  
    719719}
    720720
     721int nagra2_get_emm_type(EMM_PACKET *ep) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
     722{
     723  switch (ep->emm[0]) {
     724        case 0x83:
     725            memset(ep->hexserial,0,8);
     726            ep->hexserial[0] = ep->emm[5];
     727            ep->hexserial[1] = ep->emm[4];
     728            ep->hexserial[2] = ep->emm[3];
     729            ep->hexserial[3] = ep->emm[6];
     730            if (ep->emm[7] == 0x10)
     731                ep->type = SHARED;
     732            else
     733                ep->type = UNIQUE;
     734            memcpy(ep->hexserial, ep->emm + 3, 6);
     735            return (!memcmp (reader[ridx].hexserial, ep->hexserial, 4));
     736        case 0x82:
     737            ep->type = GLOBAL;
     738            return TRUE;
     739        default:
     740            ep->type = UNKNOWN;
     741            return TRUE;
     742    }
     743}
     744
    721745int nagra2_do_emm(EMM_PACKET *ep)
    722746{
  • trunk/reader-seca.c

    r1635 r1766  
    123123}
    124124
    125 static int get_prov_index(char *provid) //returns provider id or -1 if not found
     125static int get_prov_index(struct s_reader * rdr, char *provid)  //returns provider id or -1 if not found
    126126{
    127127  int prov;
    128   for (prov=0; prov<reader[ridx].nprov; prov++) //search for provider index
    129     if (!memcmp(provid, &reader[ridx].prid[prov][2], 2))
     128  for (prov=0; prov<rdr->nprov; prov++) //search for provider index
     129    if (!memcmp(provid, &rdr->prid[prov][2], 2))
    130130      return(prov);
    131131  return(-1);
     
    138138  unsigned char ins3a[] = { 0xc1,0x3a,0x00,0x00,0x10 }; // decoding cw
    139139  int i;
    140   i=get_prov_index((char *) er->ecm+3);
     140  i=get_prov_index(&reader[ridx], (char *) er->ecm+3);
    141141  if ((i == -1) || (reader[ridx].availkeys[i][0] == 0)) //if provider not found or expired
    142142    return ERROR;
     
    159159}
    160160
     161int seca_get_emm_type(EMM_PACKET *ep, struct s_reader * rdr) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
     162{
     163    cs_debug_mask(D_EMM, "Entered seca_get_emm_type ep->emm[0]=%i",ep->emm[0]);
     164    int i;
     165  switch (ep->emm[0]) {
     166        case 0x82:
     167            ep->type = UNIQUE;
     168            memset(ep->hexserial,0,8);
     169            memcpy(ep->hexserial, ep->emm + 3, 6);
     170            cs_debug_mask(D_EMM, "SECA EMM: UNIQUE, ep->hexserial = %s", cs_hexdump(1, ep->hexserial, 6));
     171            cs_debug_mask(D_EMM, "SECA EMM: UNIQUE, rdr->hexserial = %s", cs_hexdump(1, rdr->hexserial, 6));
     172            return (!memcmp (rdr->hexserial, ep->hexserial, 6));
     173        case 0x84:
     174            ep->type = SHARED;
     175            memset(ep->hexserial,0,8);
     176            memcpy(ep->hexserial, ep->emm + 5, 3); //dont include custom byte; this way the network also knows SA
     177            i=get_prov_index(rdr, (char *) ep->emm+3);
     178            cs_debug_mask(D_EMM, "SECA EMM: SHARED, ep->hexserial = %s", cs_hexdump(1, ep->hexserial, 3));
     179            if (i== -1) //provider not found on this card
     180                return FALSE; //do not pass this EMM
     181            cs_debug_mask(D_EMM, "SECA EMM: SHARED, rdr->sa[%i] = %s", i, cs_hexdump(1, rdr->sa[i], 3));
     182            return (!memcmp (rdr->sa[i], ep->hexserial, 3));
     183        default:
     184            ep->type = UNKNOWN;
     185            return TRUE;
     186    }
     187}
     188   
    161189int seca_do_emm(EMM_PACKET *ep)
    162190{
     
    165193  int emm_length = ((ep->emm[1] & 0x0f) << 8) + ep->emm[2];
    166194
    167   cs_ddump (ep->emm, emm_length + 3, "EMM:");
    168   ep->type = ep->emm[0];
     195  cs_ddump_mask (D_EMM, ep->emm, emm_length + 3, "EMM:");
    169196  switch (ep->type) {
    170     case 0x84:  //shared EMM
     197    case SHARED:
    171198      {
    172199    //to test if SA matches
    173200    //first find out prov id
    174     i=get_prov_index((char *) ep->emm+3);
     201    i=get_prov_index(&reader[ridx], (char *) ep->emm+3);
    175202    if (i == -1)
    176203        return ERROR;
     
    188215    break;
    189216      }//end shared EMM
    190     case 0x82:  //unique EMM
     217    case UNIQUE:   
    191218      {
    192219    //first test if UA matches
     
    197224    else {
    198225        //first find out prov id
    199         i=get_prov_index((char *) ep->emm+9);
     226        i=get_prov_index(&reader[ridx], (char *) ep->emm+9);
    200227                cs_log("[seca-reader] EMM: Unique update matched EMM Serial:%02X%02X%02X%02X%02X, provider %i.", ep->emm[3], ep->emm[4], ep->emm[5], ep->emm[6], ep->emm[7], ep->emm[8], i + 1);
    201228
  • trunk/reader-viaccess.c

    r1399 r1766  
    355355}
    356356
     357int viaccess_get_emm_type(EMM_PACKET *ep) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
     358{
     359    ep->type=UNKNOWN; //FIXME not sure how this maps onto global, unique and shared!
     360    return TRUE; //FIXME let it all pass without checking serial or SA, without filling ep->hexserial
     361}
     362
    357363int viaccess_do_emm(EMM_PACKET *ep)
    358364{
  • trunk/reader-videoguard2.c

    r1733 r1766  
    943943}
    944944
     945int videoguard_get_emm_type(EMM_PACKET *ep) //returns TRUE if shared emm matches SA, unique emm matches serial, or global or unknown
     946{
     947    ep->type=UNKNOWN; //FIXME not sure how this maps onto global, unique and shared!
     948    return TRUE; //FIXME let it all pass without checking serial or SA, without filling ep->hexserial
     949}
     950
    945951int videoguard_do_emm(EMM_PACKET *ep)
    946952{
Note: See TracChangeset for help on using the changeset viewer.