reader-common.c

   1 #include "globals.h"
   2 #include "reader-common.h"
   3
   4 char oscam_device[128];
   5 int  oscam_card_detect;
   6 int  mhz;
   7 int  reader_irdeto_mode;
   8
   9 uchar cta_cmd[272], cta_res[260], atr[64];
  10 ushort cta_lr, atr_size=0;
  11 static int cs_ptyp_orig; //reinit=1,
  12 static int card_status=0;
  13
  14 #define SC_IRDETO 1
  15 #define SC_CRYPTOWORKS 2
  16 #define SC_VIACCESS 3
  17 #define SC_CONAX 4
  18 #define SC_SECA 5
  19 #define SC_VIDEOGUARD2 6
  20
  21 static int reader_device_type(char *device, int typ)
  22 {
  23   int rc=PORT_STD;
  24 #ifdef TUXBOX
  25   struct stat sb;
  26 #endif
  27
  28   switch(reader[ridx].typ)
  29   {
  30     case R_MOUSE:
  31       rc=PORT_STD;
  32 #ifdef TUXBOX
  33       if (!stat(device, &sb))
  34       {
  35         if (S_ISCHR(sb.st_mode))
  36         {
  37           int dev_major, dev_minor;
  38           dev_major=major(sb.st_rdev);
  39           dev_minor=minor(sb.st_rdev);
  40           if ((cs_hw==CS_HW_DBOX2) && ((dev_major==4) || (dev_major==5)))
  41             switch(dev_minor & 0x3F)
  42             {
  43               case 0: rc=PORT_DB2COM1; break;
  44               case 1: rc=PORT_DB2COM2; break;
  45             }
  46           cs_debug("device is major: %d, minor: %d, typ=%d", dev_major, dev_minor, rc);
  47         }
  48       }
  49 #endif
  50       break;
  51     case R_INTERN:
  52       rc=PORT_SCI;
  53       break;
  54   }
  55   return(rc);
  56 }
  57
  58 static void reader_nullcard(void)
  59 {
  60   reader[ridx].card_system=0;
  61   memset(reader[ridx].hexserial, 0   , sizeof(reader[ridx].hexserial));
  62   memset(reader[ridx].prid     , 0xFF, sizeof(reader[ridx].prid     ));
  63   memset(reader[ridx].caid     , 0   , sizeof(reader[ridx].caid     ));
  64   memset(reader[ridx].availkeys, 0   , sizeof(reader[ridx].availkeys));
  65   reader[ridx].acs=0;
  66   reader[ridx].nprov=0;
  67 }
  68
  69 int reader_doapi(uchar dad, uchar *buf, int l, int dbg)
  70 {
  71   int rc;
  72   uchar sad;
  73
  74 //  oscam_card_inserted=4;
  75   sad=2;
  76   cta_lr=sizeof(cta_res)-1;
  77   cs_ptyp_orig=cs_ptyp;
  78   cs_ptyp=dbg;
  79   //cs_ddump(buf, l, "send %d bytes to ctapi", l);
  80   rc=CT_data(1, &dad, &sad, l, buf, &cta_lr, cta_res);
  81   //cs_ddump(cta_res, cta_lr, "received %d bytes from ctapi with rc=%d", cta_lr, rc);
  82   cs_ptyp=cs_ptyp_orig;
  83   return(rc);
  84 }
  85
  86 int reader_chkicc(uchar *buf, int l)
  87 {
  88   return(reader_doapi(1, buf, l, D_WATCHDOG));
  89 }
  90
  91 int reader_cmd2api(uchar *buf, int l)
  92 {
  93   return(reader_doapi(1, buf, l, D_DEVICE));
  94 }
  95
  96 int reader_cmd2icc(uchar *buf, int l)
  97 {
  98 //  int rc;
  99 //  if ((rc=reader_doapi(0, buf, l, D_DEVICE))<0)
 100     return(reader_doapi(0, buf, l, D_DEVICE));
 101 //  else
 102 //    return(rc);
 103 }
 104
 105 static int reader_activate_card()
 106 {
 107   int i;
 108   char ret;
 109
 110   cta_cmd[0] = CTBCS_INS_RESET;
 111   cta_cmd[1] = CTBCS_P2_RESET_GET_ATR;
 112   cta_cmd[2] = 0x00;
 113
 114   ret = reader_cmd2api(cta_cmd, 3);
 115   if (ret!=OK)
 116   {
 117     cs_log("Error reset terminal: %d", ret);
 118     return(0);
 119   }
 120
 121   cta_cmd[0] = CTBCS_CLA;
 122   cta_cmd[1] = CTBCS_INS_STATUS;
 123   cta_cmd[2] = CTBCS_P1_CT_KERNEL;
 124   cta_cmd[3] = CTBCS_P2_STATUS_ICC;
 125   cta_cmd[4] = 0x00;
 126
 127 //  ret=reader_cmd2api(cmd, 11); warum 11 ??????
 128   ret=reader_cmd2api(cta_cmd, 5);
 129   if (ret!=OK)
 130   {
 131     cs_log("Error getting status of terminal: %d", ret);
 132     return(0);
 133   }
 134   if (cta_res[0]!=CTBCS_DATA_STATUS_CARD_CONNECT)
 135     return(0);
 136
 137   /* Activate card */
 138 //  for (i=0; (i<5) && ((ret!=OK)||(cta_res[cta_lr-2]!=0x90)); i++)
 139   for (i=0; i<5; i++)
 140   {
 141     reader_irdeto_mode = i%2 == 1;
 142     cta_cmd[0] = CTBCS_CLA;
 143     cta_cmd[1] = CTBCS_INS_REQUEST;
 144     cta_cmd[2] = CTBCS_P1_INTERFACE1;
 145     cta_cmd[3] = CTBCS_P2_REQUEST_GET_ATR;
 146     cta_cmd[4] = 0x00;
 147
 148     ret=reader_cmd2api(cta_cmd, 5);
 149     if ((ret==OK)||(cta_res[cta_lr-2]==0x90))
 150     {
 151       i=100;
 152       break;
 153     }
 154     cs_log("Error activating card: %d", ret);
 155     cs_sleepms(500);
 156   }
 157   if (i<100) return(0);
 158
 159   /* Store ATR */
 160   atr_size=cta_lr-2;
 161   memcpy(atr, cta_res, atr_size);
 162 #ifdef CS_RDR_INIT_HIST
 163   reader[ridx].init_history_pos=0;
 164   memset(reader[ridx].init_history, 0, sizeof(reader[ridx].init_history));
 165 #endif
 166   cs_ri_log("ATR: %s", cs_hexdump(1, atr, atr_size));
 167   sleep(1);
 168   return(1);
 169 }
 170
 171 void reader_card_info()
 172 {
 173   int rc=-1;
 174   if (rc=reader_checkhealth())
 175   {
 176     client[cs_idx].last=time((time_t)0);
 177     cs_ri_brk(0);
 178     switch(reader[ridx].card_system)
 179     {
 180       case SC_IRDETO:
 181         rc=irdeto_card_info(); break;
 182       case SC_CRYPTOWORKS:
 183         rc=cryptoworks_card_info(); break;
 184       case SC_VIACCESS:
 185         rc=viaccess_card_info(); break;
 186       case SC_VIDEOGUARD2:
 187         rc=videoguard_card_info(); break;
 188       default: rc=0;
 189     }
 190   }
 191 //  return(rc);
 192 }
 193
 194 static int reader_get_cardsystem(void)
 195 {
 196   if (irdeto_card_init(atr, atr_size))  reader[ridx].card_system=SC_IRDETO;
 197   if (conax_card_init(atr, atr_size))   reader[ridx].card_system=SC_CONAX;
 198   if (cryptoworks_card_init(atr, atr_size))     reader[ridx].card_system=SC_CRYPTOWORKS;
 199   if (seca_card_init(atr, atr_size))    reader[ridx].card_system=SC_SECA;
 200   if (viaccess_card_init(atr, atr_size))        reader[ridx].card_system=SC_VIACCESS;
 201   if (videoguard_card_init(atr, atr_size))  reader[ridx].card_system=SC_VIDEOGUARD2;
 202   if (!reader[ridx].card_system)        cs_ri_log("card system not supported");
 203   cs_ri_brk(1);
 204   return(reader[ridx].card_system);
 205 }
 206
 207 static int reader_reset(void)
 208 {
 209   reader_nullcard();
 210   if (!reader_activate_card()) return(0);
 211   return(reader_get_cardsystem());
 212 }
 213
 214 static int reader_card_inserted(void)
 215 {
 216   cta_cmd[0]=CTBCS_CLA;
 217   cta_cmd[1]=CTBCS_INS_STATUS;
 218   cta_cmd[2]=CTBCS_P1_INTERFACE1;
 219   cta_cmd[3]=CTBCS_P2_STATUS_ICC;
 220   cta_cmd[4]=0x00;
 221
 222   return(reader_chkicc(cta_cmd, 5) ? 0 : cta_res[0]);
 223 }
 224
 225 int reader_device_init(char *device, int typ)
 226 {
 227   int rc;
 228   oscam_card_detect=reader[ridx].detect;
 229   mhz=reader[ridx].mhz;
 230   cs_ptyp_orig=cs_ptyp;
 231   cs_ptyp=D_DEVICE;
 232   snprintf(oscam_device, sizeof(oscam_device), "%s", device);
 233   if ((rc=CT_init(1, reader_device_type(device, typ)))!=OK)
 234     cs_log("Cannot open device: %s", device);
 235   cs_debug("ct_init on %s: %d", device, rc);
 236   cs_ptyp=cs_ptyp_orig;
 237   return((rc!=OK) ? 2 : 0);
 238 }
 239
 240 int reader_checkhealth(void)
 241 {
 242   if (reader_card_inserted())
 243   {
 244     if (!(card_status & CARD_INSERTED))
 245     {
 246       cs_log("card detected");
 247       card_status=CARD_INSERTED | (reader_reset() ? 0 : CARD_FAILURE);
 248       if (card_status & CARD_FAILURE)
 249         cs_log("card initializing error");
 250       else
 251       {
 252         client[cs_idx].au=ridx;
 253         reader[ridx].online=1;
 254         reader_card_info();
 255       }
 256
 257       int i;
 258       for( i=1; i<CS_MAXPID; i++ ) {
 259         if( client[i].pid && client[i].typ=='c' && client[i].usr[0] ) {
 260           kill(client[i].pid, SIGQUIT);
 261         }
 262       }
 263     }
 264   }
 265   else
 266   {
 267     if (card_status&CARD_INSERTED)
 268     {
 269       reader_nullcard();
 270       client[cs_idx].lastemm=0;
 271       client[cs_idx].lastecm=0;
 272       client[cs_idx].au=-1;
 273       extern int io_serial_need_dummy_char;
 274       io_serial_need_dummy_char=0;
 275       cs_log("card ejected");
 276     }
 277     card_status=0;
 278     reader[ridx].online=0;
 279   }
 280   return(card_status==CARD_INSERTED);
 281 }
 282
 283 int reader_ecm(ECM_REQUEST *er)
 284 {
 285   int rc=-1;
 286   if( (rc=reader_checkhealth()) )
 287   {
 288     if( (reader[ridx].caid[0]>>8)==((er->caid>>8)&0xFF) )
 289     {
 290       client[cs_idx].last_srvid=er->srvid;
 291       client[cs_idx].last_caid=er->caid;
 292       client[cs_idx].last=time((time_t)0);
 293       switch(reader[ridx].card_system)
 294       {
 295         case SC_IRDETO:
 296           rc=(irdeto_do_ecm(er)) ? 1 : 0; break;
 297         case SC_CRYPTOWORKS:
 298           rc=(cryptoworks_do_ecm(er)) ? 1 : 0; break;
 299         case SC_VIACCESS:
 300           rc=(viaccess_do_ecm(er)) ? 1 : 0; break;
 301         case SC_CONAX:
 302           rc=(conax_do_ecm(er)) ? 1 : 0; break;
 303         case SC_SECA:
 304           rc=(seca_do_ecm(er)) ? 1 : 0; break;
 305         case SC_VIDEOGUARD2:
 306           rc=(videoguard_do_ecm(er)) ? 1 : 0; break;
 307         default: rc=0;
 308       }
 309     }
 310     else
 311       rc=0;
 312   }
 313   return(rc);
 314 }
 315
 316 int reader_emm(EMM_PACKET *ep)
 317 {
 318   int rc=-1;
 319   if (rc=reader_checkhealth())
 320   {
 321     client[cs_idx].last=time((time_t)0);
 322     switch(reader[ridx].card_system)
 323     {
 324       case SC_IRDETO:
 325         rc=irdeto_do_emm(ep); break;
 326       case SC_CRYPTOWORKS:
 327         rc=cryptoworks_do_emm(ep); break;
 328       case SC_VIACCESS:
 329         rc=viaccess_do_emm(ep); break;
 330       case SC_CONAX:
 331         rc=conax_do_emm(ep); break;
 332       case SC_SECA:
 333         rc=seca_do_emm(ep); break;
 334       case SC_VIDEOGUARD2:
 335         rc=videoguard_do_emm(ep); break;
 336       default: rc=0;
 337     }
 338   }
 339   return(rc);
 340 }
 341