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         uint8_t 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
  52                         switch(i)
  53                         {
  54                                 case 0:
  55                                         b3 = a2i(ptr, 2);
  56                                         break;
  57
  58                                 case 1:
  59                                         b47 = a2i(ptr, 8);
  60                                         break;
  61
  62                                 case 2:
  63                                         caid = a2i(ptr, 4);
  64                                         break;
  65
  66                                 case 3:
  67                                         for(j = 0; j < 4; j++)
  68                                         {
  69                                                 zSid[j] = ptr[j];
  70                                         }
  71                                         zSid[4] = 0;
  72                                         sid = a2i(zSid, 4);
  73                                         break;
  74                         }
  75                 }
  76
  77                 if(!skip)
  78                 {
  79                         if(!cs_malloc(&ird_row, sizeof(struct s_irdeto_quess)))
  80                         {
  81                                 fclose(fp);
  82                                 return (1);
  83                         }
  84
  85                         ird_row->b47 = b47;
  86                         ird_row->caid = caid;
  87                         ird_row->sid = sid;
  88
  89                         head = itab[b3];
  90                         if(head)
  91                         {
  92                                 while(head->next)
  93                                         { head = head->next; }
  94                                 head->next = ird_row;
  95                         }
  96                         else
  97                                 { itab[b3] = ird_row; }
  98                         //cs_log_dbg(D_CLIENT, "%02X:%08X:%04X:%04X", b3, b47, caid, sid);
  99                 }
 100         }
 101         fclose(fp);
 102
 103         for(i = 0; i < 0xff; i++)
 104         {
 105                 head = itab[i];
 106                 while(head)
 107                 {
 108                         cs_log_dbg(D_CLIENT, "itab[%02X]: b47=%08X, caid=%04X, sid=%04X",
 109                                 i, head->b47, head->caid, head->sid);
 110                         head = head->next;
 111                 }
 112         }
 113         return (0);
 114 }
 115
 116 void free_irdeto_guess_tab(void)
 117 {
 118         uint8_t i;
 119         if(!itab)
 120                 { return; }
 121
 122         for(i = 0; i < 0xff; i++)
 123         {
 124                 struct s_irdeto_quess *head = itab[i];
 125                 while(head)
 126                 {
 127                         void *next = head->next;
 128                         NULLFREE(head);
 129                         head = next;
 130                 }
 131         }
 132         NULLFREE(itab);
 133 }
 134
 135 void guess_irdeto(ECM_REQUEST *er)
 136 {
 137         uint8_t b3;
 138         int32_t b47;
 139         //uint16_t chid;
 140         struct s_irdeto_quess *ptr;
 141
 142         if(!itab)
 143                 { return; }
 144
 145         b3 = er->ecm[3];
 146         ptr = itab[b3];
 147         if(!ptr)
 148         {
 149                 cs_log_dbg(D_TRACE, "unknown irdeto byte 3: %02X", b3);
 150                 return;
 151         }
 152
 153         b47 = b2i(4, er->ecm + 4);
 154         //chid = b2i(2, er->ecm+6);
 155         //cs_log_dbg(D_TRACE, "ecm: b47=%08X, ptr->b47=%08X, ptr->caid=%04X", b47, ptr->b47, ptr->caid);
 156
 157         while(ptr)
 158         {
 159                 if(b47 == ptr->b47)
 160                 {
 161                         if(er->srvid && (er->srvid != ptr->sid))
 162                         {
 163                                 cs_log_dbg(D_TRACE, "sid mismatched (ecm: %04X, guess: %04X), wrong oscam.ird file?",
 164                                         er->srvid, ptr->sid);
 165                                 return;
 166                         }
 167                         er->caid = ptr->caid;
 168                         er->srvid = ptr->sid;
 169                         er->chid = (uint16_t)ptr->b47;
 170                         //cs_log_dbg(D_TRACE, "quess_irdeto() found caid=%04X, sid=%04X, chid=%04X",
 171                         //er->caid, er->srvid, er->chid);
 172                         return;
 173                 }
 174                 ptr = ptr->next;
 175         }
 176 }
 177
 178 #endif