module-ird-guess.c

   1 #define MODULE_LOG_PREFIX "irdguess"
   2
   3 #include "globals.h"
   4
   5 #ifdef IRDETO_GUESSING
   6 #include "module-ird-guess.h"
   7 #include "oscam-string.h"
   8 #include "oscam-conf.h"
   9
  10 struct s_irdeto_quess
  11 {
  12         int32_t         b47;
  13         uint16_t        caid;
  14         uint16_t        sid;
  15         struct s_irdeto_quess *next;
  16 };
  17
  18 static struct s_irdeto_quess **itab;
  19
  20 int32_t init_irdeto_guess_tab(void)
  21 {
  22         FILE *fp = open_config_file("oscam.ird");
  23         if(!fp)
  24                 { return 1; }
  25
  26         int32_t i, j, skip;
  27         int32_t b47;
  28         char token[128], *ptr, *saveptr1 = NULL;
  29         char zSid[5];
  30         uchar b3;
  31         uint16_t caid, sid;
  32         struct s_irdeto_quess *ird_row, *head;
  33
  34         if(!cs_malloc(&itab, sizeof(struct s_irdeto_quess *) * 0xff))
  35         {
  36                 fclose(fp);
  37                 return 0;
  38         }
  39
  40         while(fgets(token, sizeof(token), fp))
  41         {
  42                 if(strlen(token) < 20) { continue; }
  43                 for(i = b3 = b47 = caid = sid = skip = 0, ptr = strtok_r(token, ":", &saveptr1); (i < 4) && (ptr); ptr = strtok_r(NULL, ":", &saveptr1), i++)
  44                 {
  45                         trim(ptr);
  46                         if(*ptr == ';' || *ptr == '#' || *ptr == '-')
  47                         {
  48                                 skip = 1;
  49                                 break;
  50                         }
  51                         switch(i)
  52                         {
  53                         case 0:
  54                                 b3   = a2i(ptr, 2);
  55                                 break;
  56                         case 1:
  57                                 b47  = a2i(ptr, 8);
  58                                 break;
  59                         case 2:
  60                                 caid = a2i(ptr, 4);
  61                                 break;
  62                         case 3:
  63                                 for(j = 0; j < 4; j++)
  64                                         { zSid[j] = ptr[j]; }
  65                                 zSid[4] = 0;
  66                                 sid  = a2i(zSid, 4);
  67                                 break;
  68                         }
  69                 }
  70                 if(!skip)
  71                 {
  72                         if(!cs_malloc(&ird_row, sizeof(struct s_irdeto_quess)))
  73                         {
  74                                 fclose(fp);
  75                                 return (1);
  76                         }
  77                         ird_row->b47  = b47;
  78                         ird_row->caid = caid;
  79                         ird_row->sid  = sid;
  80
  81                         head = itab[b3];
  82                         if(head)
  83                         {
  84                                 while(head->next)
  85                                         { head = head->next; }
  86                                 head->next = ird_row;
  87                         }
  88                         else
  89                                 { itab[b3] = ird_row; }
  90                         //cs_log_dbg(D_CLIENT, "%02X:%08X:%04X:%04X", b3, b47, caid, sid);
  91                 }
  92         }
  93         fclose(fp);
  94
  95         for(i = 0; i < 0xff; i++)
  96         {
  97                 head = itab[i];
  98                 while(head)
  99                 {
 100                         cs_log_dbg(D_CLIENT, "itab[%02X]: b47=%08X, caid=%04X, sid=%04X",
 101                                                   i, head->b47, head->caid, head->sid);
 102                         head = head->next;
 103                 }
 104         }
 105         return (0);
 106 }
 107
 108 void free_irdeto_guess_tab(void)
 109 {
 110         uint8_t i;
 111         if(!itab)
 112                 { return; }
 113         for(i = 0; i < 0xff; i++)
 114         {
 115                 struct s_irdeto_quess *head = itab[i];
 116                 while(head)
 117                 {
 118                         void *next = head->next;
 119                         NULLFREE(head);
 120                         head = next;
 121                 }
 122         }
 123         NULLFREE(itab);
 124 }
 125
 126 void guess_irdeto(ECM_REQUEST *er)
 127 {
 128         uchar  b3;
 129         int32_t    b47;
 130         //uint16_t chid;
 131         struct s_irdeto_quess *ptr;
 132
 133         if(!itab)
 134                 { return; }
 135         b3  = er->ecm[3];
 136         ptr = itab[b3];
 137         if(!ptr)
 138         {
 139                 cs_log_dbg(D_TRACE, "unknown irdeto byte 3: %02X", b3);
 140                 return;
 141         }
 142         b47  = b2i(4, er->ecm + 4);
 143         //chid = b2i(2, er->ecm+6);
 144         //cs_log_dbg(D_TRACE, "ecm: b47=%08X, ptr->b47=%08X, ptr->caid=%04X", b47, ptr->b47, ptr->caid);
 145         while(ptr)
 146         {
 147                 if(b47 == ptr->b47)
 148                 {
 149                         if(er->srvid && (er->srvid != ptr->sid))
 150                         {
 151                                 cs_log_dbg(D_TRACE, "sid mismatched (ecm: %04X, guess: %04X), wrong oscam.ird file?",
 152                                                           er->srvid, ptr->sid);
 153                                 return;
 154                         }
 155                         er->caid = ptr->caid;
 156                         er->srvid = ptr->sid;
 157                         er->chid = (uint16_t)ptr->b47;
 158                         //      cs_log_dbg(D_TRACE, "quess_irdeto() found caid=%04X, sid=%04X, chid=%04X",
 159                         //               er->caid, er->srvid, er->chid);
 160                         return;
 161                 }
 162                 ptr = ptr->next;
 163         }
 164 }
 165
 166 #endif