5 #include "module-gbox.h"
6 #include "module-led.h"
8 #include "oscam-client.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"
19 extern const struct s_cardsystem
*cardsystems
[];
20 extern char *RDR_CD_TXT
[];
22 int32_t check_sct_len(const uchar
*data
, int32_t off
)
24 int32_t len
= SCT_LEN(data
);
25 if(len
+ off
> MAX_LEN
)
27 cs_log_dbg(D_TRACE
| D_READER
, "check_sct_len(): smartcard section too long %d > %d", len
, MAX_LEN
- off
);
33 static void reader_nullcard(struct s_reader
*reader
)
35 reader
->csystem_active
= false;
36 reader
->csystem
= NULL
;
37 memset(reader
->hexserial
, 0 , sizeof(reader
->hexserial
));
38 memset(reader
->prid
, 0xFF, sizeof(reader
->prid
));
41 cs_clear_entitlement(reader
);
44 int32_t reader_cmd2icc(struct s_reader
*reader
, const uchar
*buf
, const int32_t l
, uchar
*cta_res
, uint16_t *p_cta_lr
)
47 *p_cta_lr
= CTA_RES_LEN
- 1; //FIXME not sure whether this one is necessary
48 rdr_log_dump_dbg(reader
, D_READER
, buf
, l
, "write to cardreader");
49 rc
= ICC_Async_CardWrite(reader
, (uchar
*)buf
, (uint16_t)l
, cta_res
, p_cta_lr
);
55 int32_t card_write(struct s_reader
*reader
, const uchar
*cmd
, const uchar
*data
, uchar
*response
, uint16_t *response_length
)
57 int32_t datalen
= MAX_ECM_SIZE
; // default datalen is max ecm size defined
58 uchar buf
[MAX_ECM_SIZE
+ CMD_LEN
];
59 // always copy to be able to be able to use const buffer without changing all code
60 memcpy(buf
, cmd
, CMD_LEN
); // copy command
68 memcpy(buf
+ CMD_LEN
, data
, datalen
);
69 return (reader_cmd2icc(reader
, buf
, CMD_LEN
+ datalen
, response
, response_length
));
72 { return (reader_cmd2icc(reader
, buf
, CMD_LEN
, response
, response_length
)); }
75 static inline int reader_use_gpio(struct s_reader
*reader
)
77 return reader
->use_gpio
&& reader
->detect
> 4;
80 static int32_t reader_card_inserted(struct s_reader
*reader
)
82 if(!reader_use_gpio(reader
) && (reader
->detect
& 0x7f) > 3)
86 if(ICC_Async_GetStatus(reader
, &card
))
88 rdr_log(reader
, "Error getting card status.");
89 return 0; //corresponds with no card inside!!
94 static int32_t reader_activate_card(struct s_reader
*reader
, ATR
*atr
, uint16_t deprecated
)
98 if(reader
->card_status
!= CARD_NEED_INIT
)
102 for(i
= 0; i
< 3; i
++)
104 ret
= ICC_Async_Activate(reader
, atr
, deprecated
);
107 rdr_log(reader
, "Error activating card.");
108 led_status_card_activation_error();
111 if(ret
) { return (0); }
113 // rdr_log("ATR: %s", cs_hexdump(1, atr, atr_size, tmp, sizeof(tmp)));//FIXME
118 void cardreader_get_card_info(struct s_reader
*reader
)
120 if((reader
->card_status
== CARD_NEED_INIT
) || (reader
->card_status
== CARD_INSERTED
))
122 struct s_client
*cl
= reader
->client
;
124 { cl
->last
= time((time_t *)0); }
126 if(reader
->csystem_active
&& reader
->csystem
&& reader
->csystem
->card_info
)
128 reader
->csystem
->card_info(reader
);
133 void cardreader_poll_status(struct s_reader
*reader
)
135 if (reader
&& reader
->card_status
== CARD_INSERTED
)
137 if (reader
->csystem_active
&& reader
->csystem
&& reader
->csystem
->poll_status
)
138 { reader
->csystem
->poll_status(reader
); }
142 static int32_t reader_get_cardsystem(struct s_reader
*reader
, ATR
*atr
)
145 for(i
= 0; cardsystems
[i
]; i
++)
147 NULLFREE(reader
->csystem_data
);
148 const struct s_cardsystem
*csystem
= cardsystems
[i
];
149 if(csystem
->card_init(reader
, atr
))
151 rdr_log(reader
, "found card system %s", csystem
->desc
);
152 reader
->csystem
= csystem
;
153 reader
->csystem_active
= true;
154 led_status_found_cardsystem();
159 // On error free allocated card system data if any
160 if(csystem
->card_done
)
161 csystem
->card_done(reader
);
162 NULLFREE(reader
->csystem_data
);
166 if(!reader
->csystem_active
)
168 rdr_log(reader
, "card system not supported");
169 led_status_unsupported_card_system();
172 return (reader
->csystem_active
);
175 void cardreader_do_reset(struct s_reader
*reader
)
177 reader_nullcard(reader
);
182 if (reader
->typ
== R_SMART
&& reader
->smartdev_found
>= 4) j
= 1; else j
= 1; // back to a single start
184 for (i
= 0; i
< j
; i
++) {
186 ret
= ICC_Async_Reset(reader
, &atr
, reader_activate_card
, reader_get_cardsystem
);
195 if (reader
->typ
== R_SMART
&& reader
->smartdev_found
>= 4) y
= 2; else y
= 2;
196 // rdr_log(reader, "the restart atempts in deprecated is %u", y);
197 for(deprecated
= reader
->deprecated
; deprecated
< y
; deprecated
++)
199 if(!reader_activate_card(reader
, &atr
, deprecated
)) { break; }
200 ret
= reader_get_cardsystem(reader
, &atr
);
204 { rdr_log(reader
, "Normal mode failed, reverting to Deprecated Mode"); }
208 rdr_log(reader
,"THIS WAS A SUCCESSFUL START ATTEMPT No %u out of max alloted of %u", (i
+1), j
);
209 gbx_local_card_changed();
213 rdr_log(reader
, "THIS WAS A FAILED START ATTEMPT No %u out of max alloted of %u", (i
+1), j
);
218 reader
->card_status
= CARD_FAILURE
;
219 rdr_log(reader
, "card initializing error");
220 ICC_Async_DisplayMsg(reader
, "AER");
221 led_status_card_activation_error();
225 cardreader_get_card_info(reader
);
226 reader
->card_status
= CARD_INSERTED
;
227 do_emm_from_file(reader
);
228 ICC_Async_DisplayMsg(reader
, "AOK");
234 static int32_t cardreader_device_init(struct s_reader
*reader
)
236 int32_t rc
= -1; //FIXME
237 if(ICC_Async_Device_Init(reader
))
238 { rdr_log(reader
, "Cannot open device: %s", reader
->device
); }
241 return ((rc
!= OK
) ? 2 : 0); //exit code 2 means keep retrying, exit code 0 means all OK
244 int32_t cardreader_do_checkhealth(struct s_reader
*reader
)
246 struct s_client
*cl
= reader
->client
;
247 if(reader_card_inserted(reader
))
249 if(reader
->card_status
== NO_CARD
|| reader
->card_status
== UNKNOWN
)
251 rdr_log(reader
, "card detected");
252 led_status_card_detected();
253 reader
->card_status
= CARD_NEED_INIT
;
254 add_job(cl
, ACTION_READER_RESET
, NULL
, 0);
259 rdr_log_dbg(reader
, D_READER
, "%s: !reader_card_inserted", __func__
);
260 if(reader
->card_status
== CARD_INSERTED
|| reader
->card_status
== CARD_NEED_INIT
)
262 rdr_log(reader
, "card ejected");
263 reader_nullcard(reader
);
264 if(reader
->csystem
&& reader
->csystem
->card_done
)
265 reader
->csystem
->card_done(reader
);
266 NULLFREE(reader
->csystem_data
);
272 led_status_card_ejected();
273 gbx_local_card_changed();
275 reader
->card_status
= NO_CARD
;
277 rdr_log_dbg(reader
, D_READER
, "%s: reader->card_status = %d, ret = %d", __func__
,
278 reader
->card_status
, reader
->card_status
== CARD_INSERTED
);
279 return reader
->card_status
== CARD_INSERTED
;
282 // Check for card inserted or card removed on pysical reader
283 void cardreader_checkhealth(struct s_client
*cl
, struct s_reader
*rdr
)
285 if(!rdr
|| !rdr
->enable
|| !rdr
->active
)
287 add_job(cl
, ACTION_READER_CHECK_HEALTH
, NULL
, 0);
290 void cardreader_reset(struct s_client
*cl
)
292 add_job(cl
, ACTION_READER_RESET
, NULL
, 0);
295 void cardreader_init_locks(void)
297 ICC_Async_Init_Locks();
300 bool cardreader_init(struct s_reader
*reader
)
302 struct s_client
*client
= reader
->client
;
305 set_localhost_ip(&client
->ip
);
306 while((cardreader_device_init(reader
) == 2) && i
< 10)
309 if(!ll_contains(configured_readers
, reader
) || !is_valid_client(client
) || reader
->enable
!= 1)
315 reader
->card_status
= READER_DEVICE_ERROR
;
316 cardreader_close(reader
);
322 if(reader
->typ
== R_INTERNAL
)
324 if(boxtype_is("dm8000") || boxtype_is("dm800") || boxtype_is("dm800se"))
325 {reader
->cardmhz
= 2700;}
326 if(boxtype_is("dm500") || boxtype_is("dm600pvr"))
327 {reader
->cardmhz
= 3150;}
328 if(boxtype_is("dm7025"))
329 {reader
->cardmhz
= 8300;}
330 if((!strncmp(boxtype_get(), "vu", 2 ))||(boxtype_is("ini-8000am")))
331 {reader
->cardmhz
= 2700; reader
->mhz
= 450;} // only one speed for vu+ and Atemio Nemesis due to usage of TDA8024
333 if((reader
->cardmhz
> 2000) && (reader
->typ
!= R_SMART
))
335 rdr_log(reader
, "Reader initialized (device=%s, detect=%s%s, pll max=%.2f MHz, wanted mhz=%.2f MHz)",
337 reader
->detect
& 0x80 ? "!" : "",
338 RDR_CD_TXT
[reader
->detect
& 0x7f],
339 (float)reader
->cardmhz
/ 100,
340 (float)reader
->mhz
/ 100);
341 rdr_log(reader
,"Reader sci internal, detected box type: %s", boxtype_get());
345 if (reader
->typ
== R_SMART
|| is_smargo_reader(reader
))
347 rdr_log_dbg(reader
, D_IFD
, "clocking for smartreader with smartreader or smargo protocol");
348 if (reader
->cardmhz
>= 2000) reader
->cardmhz
= 369; else
349 if (reader
->cardmhz
>= 1600) reader
->cardmhz
= 1600; else
350 if (reader
->cardmhz
>= 1200) reader
->cardmhz
= 1200; else
351 if (reader
->cardmhz
>= 961) reader
->cardmhz
= 961; else
352 if (reader
->cardmhz
>= 800) reader
->cardmhz
= 800; else
353 if (reader
->cardmhz
>= 686) reader
->cardmhz
= 686; else
354 if (reader
->cardmhz
>= 600) reader
->cardmhz
= 600; else
355 if (reader
->cardmhz
>= 534) reader
->cardmhz
= 534; else
356 if (reader
->cardmhz
>= 480) reader
->cardmhz
= 480; else
357 if (reader
->cardmhz
>= 436) reader
->cardmhz
= 436; else
358 if (reader
->cardmhz
>= 400) reader
->cardmhz
= 400; else
359 if (reader
->cardmhz
>= 369) reader
->cardmhz
= 369; else
360 if (reader
->cardmhz
== 357) reader
->cardmhz
= 369; else // 357 not a default smartreader setting
361 if (reader
->cardmhz
>= 343) reader
->cardmhz
= 343; else
362 reader
->cardmhz
= 320;
363 if (reader
->mhz
>= 1600) reader
->mhz
= 1600; else
364 if (reader
->mhz
>= 1200) reader
->mhz
= 1200; else
365 if (reader
->mhz
>= 961) reader
->mhz
= 961; else
366 if (reader
->mhz
>= 900) reader
->mhz
= 900; else
367 if (reader
->mhz
>= 800) reader
->mhz
= 800; else
368 if (reader
->mhz
>= 686) reader
->mhz
= 686; else
369 if (reader
->mhz
>= 600) reader
->mhz
= 600; else
370 if (reader
->mhz
>= 534) reader
->mhz
= 534; else
371 if (reader
->mhz
>= 480) reader
->mhz
= 480; else
372 if (reader
->mhz
>= 436) reader
->mhz
= 436; else
373 if (reader
->mhz
>= 400) reader
->mhz
= 369; else
374 if (reader
->mhz
>= 369) reader
->mhz
= 369; else
375 if (reader
->mhz
== 357) reader
->mhz
= 369; else // 357 not a default smartreader setting
376 if (reader
->mhz
>= 343) reader
->mhz
= 343; else
379 if ((reader
->typ
== R_SMART
|| is_smargo_reader(reader
)) && reader
->autospeed
== 1)
381 rdr_log(reader
, "Reader initialized (device=%s, detect=%s%s, mhz= AUTO, cardmhz=%d)",
383 reader
->detect
& 0x80 ? "!" : "",
384 RDR_CD_TXT
[reader
->detect
& 0x7f],
387 rdr_log(reader
, "Reader initialized (device=%s, detect=%s%s, mhz=%d, cardmhz=%d)",
389 reader
->detect
& 0x80 ? "!" : "",
390 RDR_CD_TXT
[reader
->detect
& 0x7f],
393 if (reader
->typ
== R_INTERNAL
&& !(reader
->cardmhz
> 2000))
394 rdr_log(reader
,"Reader sci internal, detected box type: %s", boxtype_get());
401 void cardreader_close(struct s_reader
*reader
)
403 ICC_Async_Close(reader
);
406 void reader_post_process(struct s_reader
*reader
)
408 // some systems eg. nagra2/3 needs post process after receiving cw from card
409 // To save ECM/CW time we added this function after writing ecm answer
410 if(reader
->csystem_active
&& reader
->csystem
&& reader
->csystem
->post_process
)
412 reader
->csystem
->post_process(reader
);
416 int32_t cardreader_do_ecm(struct s_reader
*reader
, ECM_REQUEST
*er
, struct s_ecm_answer
*ea
)
419 if((rc
= cardreader_do_checkhealth(reader
)))
421 rdr_log_dbg(reader
, D_READER
, "%s: cardreader_do_checkhealth returned rc=%d", __func__
, rc
);
422 struct s_client
*cl
= reader
->client
;
425 cl
->last_srvid
= er
->srvid
;
426 cl
->last_caid
= er
->caid
;
427 cl
->last_provid
= er
->prid
;
428 cl
->last
= time((time_t *)0);
431 if(reader
->csystem_active
&& reader
->csystem
&& reader
->csystem
->do_ecm
)
433 rc
= reader
->csystem
->do_ecm(reader
, er
, ea
);
434 rdr_log_dbg(reader
, D_READER
, "%s: after csystem->do_ecm rc=%d", __func__
, rc
);
439 rdr_log_dbg(reader
, D_READER
, "%s: ret rc=%d", __func__
, rc
);
443 int32_t cardreader_do_emm(struct s_reader
*reader
, EMM_PACKET
*ep
)
446 if (reader
->typ
== R_SMART
) { // check health does not work with new card status check but is actually not needed for emm.
450 rc
= cardreader_do_checkhealth(reader
);
454 if((1 << (ep
->emm
[0] % 0x80)) & reader
->b_nano
)
457 if(reader
->csystem_active
&& reader
->csystem
&& reader
->csystem
->do_emm
)
458 { rc
= reader
->csystem
->do_emm(reader
, ep
); }
462 if(rc
> 0) { cs_ftime(&reader
->emm_last
); } // last time emm written is now!
466 void cardreader_process_ecm(struct s_reader
*reader
, struct s_client
*cl
, ECM_REQUEST
*er
)
469 cs_log_dump_dbg(D_ATR
, er
->ecm
, er
->ecmlen
, "ecm:");
471 struct timeb tps
, tpe
;
472 struct s_ecm_answer ea
;
473 memset(&ea
, 0, sizeof(struct s_ecm_answer
));
476 int32_t rc
= cardreader_do_ecm(reader
, er
, &ea
);
479 rdr_log_dbg(reader
, D_READER
, "%s: cardreader_do_ecm returned rc=%d (ERROR=%d)", __func__
, rc
, ERROR
);
481 ea
.rc
= E_FOUND
; //default assume found
482 ea
.rcEx
= 0; //no special flag
486 char buf
[CS_SERVICENAME_SIZE
];
487 rdr_log_dbg(reader
, D_READER
, "Error processing ecm for caid %04X, provid %06X, srvid %04X, servicename: %s",
488 er
->caid
, er
->prid
, er
->srvid
, get_servicename(cl
, er
->srvid
, er
->prid
, er
->caid
, buf
, sizeof(buf
)));
491 ICC_Async_DisplayMsg(reader
, "Eer");
496 char buf
[CS_SERVICENAME_SIZE
];
497 rdr_log_dbg(reader
, D_READER
, "Error processing ecm for caid %04X, provid %06X, srvid %04X, servicename: %s",
498 er
->caid
, er
->prid
, er
->srvid
, get_servicename(cl
, er
->srvid
, er
->prid
, er
->caid
, buf
, sizeof(buf
)));
500 ea
.rcEx
= E2_WRONG_CHKSUM
; //flag it as wrong checksum
501 memcpy(ea
.msglog
, "Invalid ecm type for card", 25);
504 write_ecm_answer(reader
, er
, ea
.rc
, ea
.rcEx
, ea
.cw
, ea
.msglog
, ea
.tier
, &ea
.cw_ex
);
506 cl
->lastecm
= time((time_t *)0);
508 cs_hexdump(0, er
->ecmd5
, 16, ecmd5
, sizeof(ecmd5
));
510 rdr_log_dbg(reader
, D_READER
, "ecm hash: %s real time: %"PRId64
" ms", ecmd5
, comp_timeb(&tpe
, &tps
));
512 reader_post_process(reader
);