reader-common.c

   1 #include "globals.h"
   2
   3 #ifdef WITH_CARDREADER
   4
   5 #include "module-gbox.h"
   6 #include "module-led.h"
   7 #include "oscam-chk.h"
   8 #include "oscam-client.h"
   9 #include "oscam-ecm.h"
  10 #include "oscam-emm.h"
  11 #include "oscam-net.h"
  12 #include "oscam-time.h"
  13 #include "oscam-work.h"
  14 #include "oscam-reader.h"
  15 #include "reader-common.h"
  16 //#include "csctapi/atr.h"
  17 #include "csctapi/icc_async.h"
  18 #include "readers.h" // required by the EMU reader
  19
  20 extern const struct s_cardsystem *cardsystems[];
  21 extern char *RDR_CD_TXT[];
  22
  23 int32_t check_sct_len(const uint8_t *data, int32_t off)
  24 {
  25         int32_t len = SCT_LEN(data);
  26         if(len + off > MAX_LEN)
  27         {
  28                 cs_log_dbg(D_TRACE | D_READER, "check_sct_len(): smartcard section too long %d > %d", len, MAX_LEN - off);
  29                 len = -1;
  30         }
  31         return len;
  32 }
  33
  34 static void reader_nullcard(struct s_reader *reader)
  35 {
  36         reader->csystem_active = false;
  37         reader->csystem = NULL;
  38         memset(reader->hexserial, 0, sizeof(reader->hexserial));
  39         memset(reader->prid, 0xFF, sizeof(reader->prid));
  40         reader->caid = 0;
  41         reader->nprov = 0;
  42         cs_clear_entitlement(reader);
  43 }
  44
  45 int32_t reader_cmd2icc(struct s_reader *reader, const uint8_t *buf, const int32_t l, uint8_t *cta_res, uint16_t *p_cta_lr)
  46 {
  47         int32_t rc;
  48         *p_cta_lr = CTA_RES_LEN - 1; // FIXME not sure whether this one is necessary
  49         rdr_log_dump_dbg(reader, D_READER, buf, l, "write to cardreader");
  50         rc = ICC_Async_CardWrite(reader, (uint8_t *)buf, (uint16_t)l, cta_res, p_cta_lr);
  51         return rc;
  52 }
  53
  54 #define CMD_LEN 5
  55
  56 int32_t card_write(struct s_reader *reader, const uint8_t *cmd, const uint8_t *data, uint8_t *response, uint16_t *response_length)
  57 {
  58         int32_t datalen = MAX_ECM_SIZE; // default datalen is max ecm size defined
  59         uint8_t buf[MAX_ECM_SIZE + CMD_LEN];
  60         // always copy to be able to be able to use const buffer without changing all code
  61         memcpy(buf, cmd, CMD_LEN); // copy command
  62
  63         if(data)
  64         {
  65                 if(cmd[4])
  66                 {
  67                         datalen = cmd[4];
  68                 }
  69                 memcpy(buf + CMD_LEN, data, datalen);
  70                 return (reader_cmd2icc(reader, buf, CMD_LEN + datalen, response, response_length));
  71         }
  72         else
  73                 { return (reader_cmd2icc(reader, buf, CMD_LEN, response, response_length)); }
  74 }
  75
  76 static inline int reader_use_gpio(struct s_reader *reader)
  77 {
  78         return reader->use_gpio && reader->detect > 4;
  79 }
  80
  81 static int32_t reader_card_inserted(struct s_reader *reader)
  82 {
  83         if(!reader_use_gpio(reader) && (reader->detect & 0x7f) > 3)
  84                 { return 1; }
  85
  86         int32_t card;
  87         if(ICC_Async_GetStatus(reader, &card))
  88         {
  89                 rdr_log(reader, "Error getting card status.");
  90                 return 0; // corresponds with no card inside!!
  91         }
  92         return (card);
  93 }
  94
  95 static int32_t reader_activate_card(struct s_reader *reader, ATR *atr, uint16_t deprecated)
  96 {
  97         int32_t i, ret;
  98
  99         if(reader->card_status != CARD_NEED_INIT)
 100                 { return 0; }
 101
 102         /* Activate card */
 103         for(i = 0; i < 3; i++)
 104         {
 105                 ret = ICC_Async_Activate(reader, atr, deprecated);
 106                 if(!ret)
 107                         { break; }
 108                 rdr_log(reader, "Error activating card.");
 109                 led_status_card_activation_error();
 110                 cs_sleepms(500);
 111         }
 112         if(ret) { return (0); }
 113
 114         //rdr_log("ATR: %s", cs_hexdump(1, atr, atr_size, tmp, sizeof(tmp))); // FIXME
 115         cs_sleepms(1000);
 116         return (1);
 117 }
 118
 119 void cardreader_get_card_info(struct s_reader *reader)
 120 {
 121         if((reader->card_status == CARD_NEED_INIT) || (reader->card_status == CARD_INSERTED))
 122         {
 123                 struct s_client *cl = reader->client;
 124                 if(cl)
 125                         { cl->last = time((time_t *)0); }
 126
 127                 if(reader->csystem_active && reader->csystem && reader->csystem->card_info)
 128                 {
 129                         reader->csystem->card_info(reader);
 130                 }
 131         }
 132 }
 133
 134 void cardreader_poll_status(struct s_reader *reader)
 135 {
 136         if (reader && reader->card_status == CARD_INSERTED)
 137         {
 138                 if (reader->csystem_active && reader->csystem && reader->csystem->poll_status)
 139                         { reader->csystem->poll_status(reader); }
 140         }
 141 }
 142
 143 static int32_t reader_get_cardsystem(struct s_reader *reader, ATR *atr)
 144 {
 145         int32_t i;
 146
 147 #ifdef WITH_EMU
 148         if(reader->typ == R_EMU)
 149         {
 150                 NULLFREE(reader->csystem_data);
 151                 rdr_log(reader, "found card system %s", reader_emu.desc);
 152                 reader->csystem = &reader_emu;
 153                 reader->csystem_active = true;
 154                 led_status_found_cardsystem();
 155                 return (reader->csystem_active);
 156         }
 157 #endif
 158
 159         for(i = 0; cardsystems[i]; i++)
 160         {
 161                 NULLFREE(reader->csystem_data);
 162                 const struct s_cardsystem *csystem = cardsystems[i];
 163                 if(csystem->card_init(reader, atr))
 164                 {
 165                         rdr_log(reader, "found card system %s", csystem->desc);
 166                         reader->csystem = csystem;
 167                         reader->csystem_active = true;
 168                         led_status_found_cardsystem();
 169                         break;
 170                 }
 171                 else
 172                 {
 173                         // On error free allocated card system data if any
 174                         if(csystem->card_done)
 175                                 csystem->card_done(reader);
 176                         NULLFREE(reader->csystem_data);
 177                 }
 178         }
 179
 180         if(!reader->csystem_active)
 181         {
 182                 rdr_log(reader, "card system not supported");
 183                 led_status_unsupported_card_system();
 184         }
 185
 186         return (reader->csystem_active);
 187 }
 188
 189 void cardreader_do_reset(struct s_reader *reader)
 190 {
 191         reader_nullcard(reader);
 192         ATR atr;
 193         int32_t ret = 0;
 194         int16_t i = 0;
 195         int16_t j = 0;
 196         if (reader->typ == R_SMART && reader->smartdev_found >= 4) j = 1; else j = 1; // back to a single start
 197
 198         for (i= 0; i < j; i++)
 199         {
 200                 ret = ICC_Async_Reset(reader, &atr, reader_activate_card, reader_get_cardsystem);
 201
 202                 if(ret == -1)
 203                         { return; }
 204
 205                 if(ret == 0)
 206                 {
 207                         uint16_t y;
 208                         uint16_t deprecated;
 209
 210                         if (reader->typ == R_SMART && reader->smartdev_found >= 4) y = 2; else y = 2;
 211                         //rdr_log(reader, "the restart atempts in deprecated is %u", y);
 212
 213                         for(deprecated = reader->deprecated; deprecated < y; deprecated++)
 214                         {
 215                                 if(!reader_activate_card(reader, &atr, deprecated)) { break; }
 216
 217                                 ret = reader_get_cardsystem(reader, &atr);
 218                                 if(ret)
 219                                         { break; }
 220
 221                                 if(!deprecated)
 222                                         { rdr_log(reader, "Normal mode failed, reverting to Deprecated Mode"); }
 223                         }
 224                 }
 225
 226                 if (ret)
 227                 {
 228                         rdr_log(reader,"THIS WAS A SUCCESSFUL START ATTEMPT No  %u out of max allotted of %u", (i + 1), j);
 229                         break;
 230                 }
 231                 else
 232                 {
 233                         rdr_log(reader, "THIS WAS A FAILED START ATTEMPT No %u out of max allotted of %u", (i + 1), j);
 234                 }
 235         }
 236
 237         if(!ret)
 238         {
 239                 reader->card_status = CARD_FAILURE;
 240                 rdr_log(reader, "card initializing error");
 241                 ICC_Async_DisplayMsg(reader, "AER");
 242                 led_status_card_activation_error();
 243         }
 244         else
 245         {
 246                 cardreader_get_card_info(reader);
 247                 reader->card_status = CARD_INSERTED;
 248                 do_emm_from_file(reader);
 249                 ICC_Async_DisplayMsg(reader, "AOK");
 250                 gbx_local_card_stat(2, reader->caid); // local card up
 251         }
 252
 253         return;
 254 }
 255
 256 static int32_t cardreader_device_init(struct s_reader *reader)
 257 {
 258         int32_t rc = -1; // FIXME
 259         if(ICC_Async_Device_Init(reader))
 260                 { rdr_log(reader, "Cannot open device: %s", reader->device); }
 261         else
 262                 { rc = OK; }
 263         return ((rc != OK) ? 2 : 0); // exit code 2 means keep retrying, exit code 0 means all OK
 264 }
 265
 266 int32_t cardreader_do_checkhealth(struct s_reader *reader)
 267 {
 268         struct s_client *cl = reader->client;
 269         if(reader_card_inserted(reader))
 270         {
 271                 if(reader->card_status == NO_CARD || reader->card_status == UNKNOWN)
 272                 {
 273                         rdr_log(reader, "card detected");
 274                         led_status_card_detected();
 275                         reader->card_status = CARD_NEED_INIT;
 276                         add_job(cl, ACTION_READER_RESET, NULL, 0);
 277                 }
 278         }
 279         else
 280         {
 281                 rdr_log_dbg(reader, D_READER, "%s: !reader_card_inserted", __func__);
 282                 if(reader->card_status == CARD_INSERTED || reader->card_status == CARD_NEED_INIT)
 283                 {
 284                         rdr_log(reader, "card ejected");
 285                         reader_nullcard(reader);
 286                         if(reader->csystem && reader->csystem->card_done)
 287                                 reader->csystem->card_done(reader);
 288                         NULLFREE(reader->csystem_data);
 289
 290                         if(cl)
 291                         {
 292                                 cl->lastemm = 0;
 293                                 cl->lastecm = 0;
 294                         }
 295                         led_status_card_ejected();
 296                         gbx_local_card_stat(1, reader->caid);
 297                 }
 298                 reader->card_status = NO_CARD;
 299         }
 300         rdr_log_dbg(reader, D_READER, "%s: reader->card_status = %d, ret = %d", __func__,
 301                                 reader->card_status, reader->card_status == CARD_INSERTED);
 302
 303         return reader->card_status == CARD_INSERTED;
 304 }
 305
 306 // Check for card inserted or card removed on pysical reader
 307 void cardreader_checkhealth(struct s_client *cl, struct s_reader *rdr)
 308 {
 309         if(!rdr || !rdr->enable || !rdr->active)
 310                 { return; }
 311         add_job(cl, ACTION_READER_CHECK_HEALTH, NULL, 0);
 312 }
 313
 314 void cardreader_reset(struct s_client *cl)
 315 {
 316         add_job(cl, ACTION_READER_RESET, NULL, 0);
 317 }
 318
 319 void cardreader_init_locks(void)
 320 {
 321         ICC_Async_Init_Locks();
 322 }
 323
 324 bool cardreader_init(struct s_reader *reader)
 325 {
 326         struct s_client *client = reader->client;
 327         client->typ = 'r';
 328         int8_t i = 0;
 329         set_localhost_ip(&client->ip);
 330
 331         while((cardreader_device_init(reader) == 2) && i < 10)
 332         {
 333                 cs_sleepms(2000);
 334                 if(!ll_contains(configured_readers, reader) || !is_valid_client(client) || reader->enable != 1)
 335                         { return false; }
 336                 i++;
 337         }
 338
 339         if (i >= 10)
 340         {
 341                 reader->card_status = READER_DEVICE_ERROR;
 342                 cardreader_close(reader);
 343                 reader->enable = 0;
 344                 return false;
 345         }
 346         else
 347         {
 348                 if(reader->typ == R_INTERNAL)
 349                 {
 350                         if(boxtype_is("dm8000") || boxtype_is("dm800") || boxtype_is("dm800se"))
 351                                 {reader->cardmhz = 2700;}
 352
 353                         if(boxtype_is("dm500") || boxtype_is("dm600pvr"))
 354                                 {reader->cardmhz = 3150;}
 355
 356                         if(boxtype_is("dm7025"))
 357                                 {reader->cardmhz = 8300;}
 358
 359                         if((!strncmp(boxtype_get(), "vu", 2 ))||(boxtype_is("ini-8000am")))
 360                                 {reader->cardmhz = 2700; reader->mhz = 450;} // only one speed for vu+ and Atemio Nemesis due to usage of TDA8024
 361                 }
 362
 363                 if((reader->cardmhz > 2000) && (reader->typ != R_SMART))
 364                 {
 365                         rdr_log(reader, "Reader initialized (device=%s, detect=%s%s, pll max=%.2f MHz, wanted mhz=%.2f MHz)",
 366                                         reader->device,
 367                                         reader->detect & 0x80 ? "!" : "",
 368                                         RDR_CD_TXT[reader->detect & 0x7f],
 369                                         (float)reader->cardmhz / 100,
 370                                         (float)reader->mhz / 100);
 371                         rdr_log(reader,"Reader sci internal, detected box type: %s", boxtype_get());
 372                 }
 373                 else
 374                 {
 375                         if (reader->typ == R_SMART || is_smargo_reader(reader))
 376                         {
 377                                 rdr_log_dbg(reader, D_IFD, "clocking for smartreader with smartreader or smargo protocol");
 378                                 if (reader->cardmhz >= 2000) reader->cardmhz =  369; else
 379                                 if (reader->cardmhz >= 1600) reader->cardmhz = 1600; else
 380                                 if (reader->cardmhz >= 1200) reader->cardmhz = 1200; else
 381                                 if (reader->cardmhz >= 961)  reader->cardmhz =  961; else
 382                                 if (reader->cardmhz >= 800)  reader->cardmhz =  800; else
 383                                 if (reader->cardmhz >= 686)  reader->cardmhz =  686; else
 384                                 if (reader->cardmhz >= 600)  reader->cardmhz =  600; else
 385                                 if (reader->cardmhz >= 534)  reader->cardmhz =  534; else
 386                                 if (reader->cardmhz >= 480)  reader->cardmhz =  480; else
 387                                 if (reader->cardmhz >= 436)  reader->cardmhz =  436; else
 388                                 if (reader->cardmhz >= 400)  reader->cardmhz =  400; else
 389                                 if (reader->cardmhz >= 369)  reader->cardmhz =  369; else
 390                                 if (reader->cardmhz == 357)  reader->cardmhz =  369; else // 357 not a default smartreader setting
 391                                 if (reader->cardmhz >= 343)  reader->cardmhz =  343; else
 392                                                                                          reader->cardmhz =  320;
 393
 394                                 if (reader->mhz >= 1600) reader->mhz = 1600; else
 395                                 if (reader->mhz >= 1200) reader->mhz = 1200; else
 396                                 if (reader->mhz >= 961)  reader->mhz =  961; else
 397                                 if (reader->mhz >= 900)  reader->mhz =  900; else
 398                                 if (reader->mhz >= 800)  reader->mhz =  800; else
 399                                 if (reader->mhz >= 686)  reader->mhz =  686; else
 400                                 if (reader->mhz >= 600)  reader->mhz =  600; else
 401                                 if (reader->mhz >= 534)  reader->mhz =  534; else
 402                                 if (reader->mhz >= 480)  reader->mhz =  480; else
 403                                 if (reader->mhz >= 436)  reader->mhz =  436; else
 404                                 if (reader->mhz >= 400)  reader->mhz =  369; else
 405                                 if (reader->mhz >= 369)  reader->mhz =  369; else
 406                                 if (reader->mhz == 357)  reader->mhz =  369; else // 357 not a default smartreader setting
 407                                 if (reader->mhz >= 343)  reader->mhz =  343; else
 408                                                                                  reader->mhz =  320;
 409                         }
 410
 411                         if ((reader->typ == R_SMART || is_smargo_reader(reader)) && reader->autospeed == 1)
 412                         {
 413                                 rdr_log(reader, "Reader initialized (device=%s, detect=%s%s, mhz= AUTO, cardmhz=%d)",
 414                                                 reader->device,
 415                                                 reader->detect & 0x80 ? "!" : "",
 416                                                 RDR_CD_TXT[reader->detect & 0x7f],
 417                                                 reader->cardmhz);
 418                         }
 419                         else
 420                         {
 421                                 rdr_log(reader, "Reader initialized (device=%s, detect=%s%s, mhz=%d, cardmhz=%d)",
 422                                                 reader->device,
 423                                                 reader->detect & 0x80 ? "!" : "",
 424                                                 RDR_CD_TXT[reader->detect & 0x7f],
 425                                                 reader->mhz,
 426                                                 reader->cardmhz);
 427
 428                                 if (reader->typ == R_INTERNAL && !(reader->cardmhz > 2000))
 429                                         rdr_log(reader,"Reader sci internal, detected box type: %s", boxtype_get());
 430                         }
 431                 }
 432                 return true;
 433         }
 434 }
 435
 436 void cardreader_close(struct s_reader *reader)
 437 {
 438         ICC_Async_Close(reader);
 439 }
 440
 441 void reader_post_process(struct s_reader *reader)
 442 {
 443         // some systems eg. nagra2/3 needs post process after receiving cw from card
 444         // To save ECM/CW time we added this function after writing ecm answer
 445         if(reader->csystem_active && reader->csystem && reader->csystem->post_process)
 446         {
 447                 reader->csystem->post_process(reader);
 448         }
 449 }
 450
 451 int32_t cardreader_do_ecm(struct s_reader *reader, ECM_REQUEST *er, struct s_ecm_answer *ea)
 452 {
 453         int32_t rc = -1;
 454         if((rc = cardreader_do_checkhealth(reader)))
 455         {
 456                 rdr_log_dbg(reader, D_READER, "%s: cardreader_do_checkhealth returned rc=%d", __func__, rc);
 457                 struct s_client *cl = reader->client;
 458                 if(cl)
 459                 {
 460                         cl->last_srvid = er->srvid;
 461                         cl->last_caid = er->caid;
 462                         cl->last_provid = er->prid;
 463                         cl->last = time((time_t *)0);
 464                 }
 465
 466                 if(reader->csystem_active && reader->csystem && reader->csystem->do_ecm)
 467                 {
 468                         rc = reader->csystem->do_ecm(reader, er, ea);
 469                         rdr_log_dbg(reader, D_READER, "%s: after csystem->do_ecm rc=%d", __func__, rc);
 470                 }
 471                 else
 472                         { rc = 0; }
 473         }
 474         rdr_log_dbg(reader, D_READER, "%s: ret rc=%d", __func__, rc);
 475         return (rc);
 476 }
 477
 478 int32_t cardreader_do_emm(struct s_reader *reader, EMM_PACKET *ep)
 479 {
 480         int32_t rc;
 481
 482         // check health does not work with new card status check but is actually not needed for emm.
 483         if(reader->typ == R_SMART)
 484         {
 485                 rc = 1;
 486         }
 487         else
 488         {
 489                 rc = -1;
 490                 rc = cardreader_do_checkhealth(reader);
 491         }
 492
 493         if(rc)
 494         {
 495                 if((1 << (ep->emm[0] % 0x80)) & reader->b_nano)
 496                         { return 3; }
 497
 498                 if(reader->csystem_active && reader->csystem && reader->csystem->do_emm)
 499                         { rc = reader->csystem->do_emm(reader, ep); }
 500                 else
 501                         { rc = 0; }
 502         }
 503
 504         if(rc > 0) { cs_ftime(&reader->emm_last); } // last time emm written is now!
 505         return (rc);
 506 }
 507
 508 void cardreader_process_ecm(struct s_reader *reader, struct s_client *cl, ECM_REQUEST *er)
 509 {
 510         struct timeb tps, tpe;
 511         struct s_ecm_answer ea;
 512         memset(&ea, 0, sizeof(struct s_ecm_answer));
 513
 514 #ifdef WITH_EXTENDED_CW
 515         // Correct CSA mode is CBC - default to that instead
 516         ea.cw_ex.algo_mode = CW_ALGO_MODE_CBC;
 517 #endif
 518
 519         cs_ftime(&tps);
 520         int32_t rc = cardreader_do_ecm(reader, er, &ea);
 521         cs_ftime(&tpe);
 522
 523         rdr_log_dbg(reader, D_READER, "%s: cardreader_do_ecm returned rc=%d (ERROR=%d)", __func__, rc, ERROR);
 524
 525         ea.rc = E_FOUND; // default assume found
 526         ea.rcEx = 0; // no special flag
 527
 528         if(rc == ERROR)
 529         {
 530                 char buf[CS_SERVICENAME_SIZE];
 531                 rdr_log_dbg(reader, D_READER, "Error processing ecm for caid %04X, provid %06X, srvid %04X, servicename: %s",
 532                                                 er->caid, er->prid, er->srvid, get_servicename(cl, er->srvid, er->prid, er->caid, buf, sizeof(buf)));
 533                 ea.rc = E_NOTFOUND;
 534                 ea.rcEx = 0;
 535                 ICC_Async_DisplayMsg(reader, "Eer");
 536         }
 537
 538         if(rc == E_CORRUPT)
 539         {
 540                 char buf[CS_SERVICENAME_SIZE];
 541                 rdr_log_dbg(reader, D_READER, "Error processing ecm for caid %04X, provid %06X, srvid %04X, servicename: %s",
 542                                                 er->caid, er->prid, er->srvid, get_servicename(cl, er->srvid, er->prid, er->caid, buf, sizeof(buf)));
 543                 ea.rc = E_NOTFOUND;
 544                 ea.rcEx = E2_WRONG_CHKSUM; // flag it as wrong checksum
 545                 memcpy(ea.msglog, "Invalid ecm type for card", 25);
 546         }
 547
 548         write_ecm_answer(reader, er, ea.rc, ea.rcEx, ea.cw, ea.msglog, ea.tier, &ea.cw_ex);
 549
 550         cl->lastecm = time((time_t *)0);
 551         char ecmd5[17 * 3];
 552         cs_hexdump(0, er->ecmd5, 16, ecmd5, sizeof(ecmd5));
 553
 554         rdr_log_dbg(reader, D_READER, "ecm hash: %s real time: %"PRId64" ms", ecmd5, comp_timeb(&tpe, &tps));
 555
 556         reader_post_process(reader);
 557 }
 558
 559 #endif