1 #define MODULE_LOG_PREFIX "reader"
4 #include "module-cccam.h"
5 #include "module-led.h"
6 #include "module-stat.h"
7 #include "module-dvbapi.h"
8 #include "oscam-cache.h"
10 #include "oscam-client.h"
11 #include "oscam-ecm.h"
12 #include "oscam-garbage.h"
13 #include "oscam-lock.h"
14 #include "oscam-net.h"
15 #include "oscam-reader.h"
16 #include "oscam-string.h"
17 #include "oscam-time.h"
18 #include "oscam-work.h"
19 #include "reader-common.h"
20 #include "oscam-config.h"
22 extern CS_MUTEX_LOCK system_lock
;
23 extern CS_MUTEX_LOCK ecmcache_lock
;
24 extern struct ecm_request_t
*ecmcwcache
;
25 extern const struct s_cardsystem
*cardsystems
[];
27 const char *RDR_CD_TXT
[] =
29 "cd", "dsr", "cts", "ring", "none",
30 "gpio1", "gpio2", "gpio3", "gpio4", "gpio5", "gpio6", "gpio7",
34 /* Overide ratelimit priority for dvbapi request */
35 static int32_t dvbapi_override_prio(struct s_reader
*reader
, ECM_REQUEST
*er
, int32_t maxecms
, struct timeb
*actualtime
)
37 if (!module_dvbapi_enabled() || !is_dvbapi_usr(er
->client
->account
->usr
))
40 int32_t foundspace
= -1;
43 if (reader
->lastdvbapirateoverride
.time
== 0) // fixup for first run!
44 gone
= comp_timeb(actualtime
, &reader
->lastdvbapirateoverride
);
46 if (gone
> reader
->ratelimittime
)
49 struct timeb minecmtime
= *actualtime
;
51 for (h
= 0; h
< MAXECMRATELIMIT
; h
++)
53 gone
= comp_timeb(&minecmtime
, &reader
->rlecmh
[h
].last
);
55 minecmtime
= reader
->rlecmh
[h
].last
;
59 reader
->lastdvbapirateoverride
= *actualtime
;
61 cs_log_dbg(D_CLIENT
, "prioritizing DVBAPI user %s over other watching client",
62 er
->client
->account
->usr
);
64 cs_log_dbg(D_CLIENT
, "ratelimiter forcing srvid %04X into slot %d/%d of reader %s",
65 er
->srvid
, foundspace
+ 1, maxecms
, reader
->label
);
69 cs_log_dbg(D_CLIENT
, "DVBAPI User %s is switching too fast for ratelimit and can't be prioritized!",
70 er
->client
->account
->usr
);
75 static int32_t ecm_ratelimit_findspace(struct s_reader
*reader
, ECM_REQUEST
*er
, struct ecmrl rl
, int32_t reader_mode
)
77 int32_t h
, foundspace
= -1;
78 int32_t maxecms
= MAXECMRATELIMIT
; // init maxecms
79 int32_t totalecms
= 0; // init totalecms
80 struct timeb actualtime
;
81 cs_ftime(&actualtime
);
83 for(h
= 0; h
< MAXECMRATELIMIT
; h
++) // release slots with srvid that are overtime, even if not called from reader module to maximize available slots!
85 if(reader
->rlecmh
[h
].last
.time
== -1) { continue; }
87 int64_t gone
= comp_timeb(&actualtime
, &reader
->rlecmh
[h
].last
);
88 if(gone
>= (reader
->rlecmh
[h
].ratelimittime
+ reader
->rlecmh
[h
].srvidholdtime
) || gone
< 0) // gone <0 fixup for bad systemtime on dvb receivers while changing transponders
90 cs_log_dbg(D_CLIENT
, "ratelimiter srvid %04X released from slot %d/%d of reader %s (%"PRId64
">=%d ratelimit ms + %d ms srvidhold!)",
91 reader
->rlecmh
[h
].srvid
, h
+ 1, MAXECMRATELIMIT
, reader
->label
, gone
,
92 reader
->rlecmh
[h
].ratelimittime
, reader
->rlecmh
[h
].srvidholdtime
);
94 reader
->rlecmh
[h
].last
.time
= -1;
95 reader
->rlecmh
[h
].srvid
= -1;
96 reader
->rlecmh
[h
].kindecm
= 0;
97 reader
->rlecmh
[h
].once
= 0;
100 if(reader
->rlecmh
[h
].last
.time
== -1) { continue; }
101 if(reader
->rlecmh
[h
].ratelimitecm
< maxecms
) { maxecms
= reader
->rlecmh
[h
].ratelimitecm
; } // we found a more critical ratelimit srvid
105 cs_log_dbg(D_CLIENT
, "ratelimiter found total of %d srvid for reader %s most critical is limited to %d requests",
106 totalecms
, reader
->label
, maxecms
);
108 if(reader
->cooldown
[0] && reader
->cooldownstate
!= 1) { maxecms
= MAXECMRATELIMIT
; } // dont apply ratelimits if cooldown isnt in use or not in effect
110 for(h
= 0; h
< MAXECMRATELIMIT
; h
++) // check if srvid is already in a slot
112 if(reader
->rlecmh
[h
].last
.time
== -1) { continue; }
114 if(reader
->rlecmh
[h
].srvid
== er
->srvid
&& reader
->rlecmh
[h
].caid
== rl
.caid
&& reader
->rlecmh
[h
].provid
== rl
.provid
115 && (!reader
->rlecmh
[h
].chid
|| (reader
->rlecmh
[h
].chid
== rl
.chid
)))
119 if(cs_dblevel
& D_CLIENT
)
121 gone
= comp_timeb(&actualtime
, &reader
->rlecmh
[h
].last
);
122 cs_log_dbg(D_CLIENT
, "ratelimiter found srvid %04X for %"PRId64
" ms in slot %d/%d of reader %s", er
->srvid
, gone
, h
+ 1, MAXECMRATELIMIT
, reader
->label
);
125 // check ecmunique if enabled and ecmunique time is done
126 if(reader_mode
&& reader
->ecmunique
)
128 gone
= comp_timeb(&actualtime
, &reader
->rlecmh
[h
].last
);
129 if(gone
< reader
->ratelimittime
)
131 // some boxes seem to send different ecms but asking in fact for same cw!
132 if(memcmp(reader
->rlecmh
[h
].ecmd5
, er
->ecmd5
, CS_ECMSTORESIZE
))
134 // different ecm request than one in the slot!
135 if(er
->ecm
[0] == reader
->rlecmh
[h
].kindecm
)
139 if(cs_dblevel
& D_CLIENT
)
142 cs_hexdump(0, reader
->rlecmh
[h
].ecmd5
, 16, ecmd5
, sizeof(ecmd5
));
143 cs_log_dbg(D_CLIENT
, "ratelimiter ecm %s in this slot for next %d ms!", ecmd5
,
144 (int)(reader
->rlecmh
[h
].ratelimittime
- gone
));
147 struct ecm_request_t
*erold
= NULL
;
148 if(!cs_malloc(&erold
, sizeof(struct ecm_request_t
)))
151 memcpy(erold
, er
, sizeof(struct ecm_request_t
)); // copy ecm all
152 memcpy(erold
->ecmd5
, reader
->rlecmh
[h
].ecmd5
, CS_ECMSTORESIZE
); // replace md5 hash
153 struct ecm_request_t
*ecm
= NULL
;
154 ecm
= check_cache(erold
, erold
->client
); //CHECK IF FOUND ECM IN CACHE
157 if(ecm
) // found in cache
159 // return controlword of the ecm sitting in the slot!
160 write_ecm_answer(reader
, er
, ecm
->rc
, ecm
->rcEx
, ecm
->cw
, NULL
, 0, &ecm
->cw_ex
);
164 write_ecm_answer(reader
, er
, E_NOTFOUND
, E2_RATELIMIT
, NULL
, "Ratelimiter: no slots free!", 0, NULL
);
173 if((er
->ecm
[0] != reader
->rlecmh
[h
].kindecm
) && (gone
<= reader
->ratelimittime
))
175 if(!reader
->rlecmh
[h
].once
) // 1 premature ecmtype change is allowed (useful right after zapping to a channel!)
177 reader
->rlecmh
[h
].once
= 1;
178 cs_log_dbg(D_CLIENT
, "ratelimiter changing slot %d srvid %04X ecmtype once from %s to %s!", h
+1, er
->srvid
,
179 (reader
->rlecmh
[h
].kindecm
== 0x80 ? "even":"odd"), (er
->ecm
[0] == 0x80 ? "even":"odd"));
183 cs_log_dbg(D_CLIENT
, "ratelimiter srvid %04X only allowing ecmtype %s for next %d ms in slot %d/%d of reader %s -> skipping this slot!",
184 reader
->rlecmh
[h
].srvid
, (reader
->rlecmh
[h
].kindecm
== 0x80 ? "even" : "odd"),
185 (int)(reader
->rlecmh
[h
].ratelimittime
- gone
), h
+ 1, maxecms
, reader
->label
);
193 for(foundspace
= 0; foundspace
< h
; foundspace
++) // check for free lower slot
195 if(reader
->rlecmh
[foundspace
].last
.time
== -1)
197 reader
->rlecmh
[foundspace
] = reader
->rlecmh
[h
]; // replace ecm request info
198 reader
->rlecmh
[h
].last
.time
= -1;
199 reader
->rlecmh
[h
].srvid
= -1;
200 reader
->rlecmh
[h
].kindecm
= 0;
201 reader
->rlecmh
[h
].once
= 0;
203 if(foundspace
< maxecms
)
205 cs_log_dbg(D_CLIENT
, "ratelimiter moved srvid %04X to slot %d/%d of reader %s",
206 er
->srvid
, foundspace
+ 1, maxecms
, reader
->label
);
208 return foundspace
; // moving to lower free slot!
212 cs_log_dbg(D_CLIENT
, "ratelimiter removed srvid %04X from slot %d/%d of reader %s",
213 er
->srvid
, foundspace
+ 1, maxecms
, reader
->label
);
215 reader
->rlecmh
[foundspace
].last
.time
= -1; // free this slot since we are over ratelimit!
216 return -1; // sorry, ratelimit!
222 if(h
< maxecms
) // found but cant move to lower position!
224 return h
; // return position if within ratelimits!
228 reader
->rlecmh
[h
].last
.time
= -1; // free this slot since we are over ratelimit!
229 reader
->rlecmh
[h
].srvid
= -1;
230 reader
->rlecmh
[h
].kindecm
= 0;
231 reader
->rlecmh
[h
].once
= 0;
233 cs_log_dbg(D_CLIENT
, "ratelimiter removed srvid %04X from slot %d/%d of reader %s",
234 er
->srvid
, h
+ 1, maxecms
, reader
->label
);
236 return -1; // sorry, ratelimit!
241 // srvid not found in slots!
243 // do we use cooldown at all, are we in cooldown fase?
244 if((reader
->cooldown
[0] && reader
->cooldownstate
== 1) || !reader
->cooldown
[0])
246 // we are in cooldown or no cooldown configured!
247 if(totalecms
+ 1 > maxecms
|| totalecms
+ 1 > rl
.ratelimitecm
) // check if this channel fits in!
249 cs_log_dbg(D_CLIENT
, "ratelimiter for reader %s has no free slots!", reader
->label
);
255 maxecms
= MAXECMRATELIMIT
; // no limits right now!
258 for(h
= 0; h
< maxecms
; h
++) // check for free slot
260 if(reader
->rlecmh
[h
].last
.time
== -1)
264 cs_log_dbg(D_CLIENT
, "ratelimiter added srvid %04X to slot %d/%d of reader %s",
265 er
->srvid
, h
+ 1, maxecms
, reader
->label
);
267 return h
; // free slot found -> assign it!
269 else // occupied slots
272 if(cs_dblevel
& D_CLIENT
)
274 int64_t gone
= comp_timeb(&actualtime
, &reader
->rlecmh
[h
].last
);
275 cs_log_dbg(D_CLIENT
, "ratelimiter srvid %04X for %"PRId64
" ms present in slot %d/%d of reader %s",
276 reader
->rlecmh
[h
].srvid
, gone
, h
+ 1, maxecms
, reader
->label
);
282 foundspace
= dvbapi_override_prio(reader
, er
, maxecms
, &actualtime
);
286 return (-1); // no slot found
289 static void sort_ecmrl(struct s_reader
*reader
)
294 for(i
= 0; i
< reader
->ratelimitecm
; i
++) // inspect all slots
296 if(reader
->rlecmh
[i
].last
.time
== -1) { continue; } // skip empty slots
299 tmp
= reader
->rlecmh
[i
]; // tmp is ecm in slot to evaluate
301 for(j
= i
+ 1; j
< MAXECMRATELIMIT
; j
++) // inspect all slots above the slot to be inspected
303 if(reader
->rlecmh
[j
].last
.time
== -1) { continue; } // skip empty slots
305 int32_t gone
= comp_timeb(&reader
->rlecmh
[i
].last
, &tmp
.last
);
306 if(gone
> 0) // is higher slot holding a younger ecmrequest?
308 loc
= j
; // found a younger one
309 tmp
= reader
->rlecmh
[j
]; // copy the ecm in younger slot
313 if(loc
!= i
) // Did we find a younger ecmrequest?
315 reader
->rlecmh
[loc
] = reader
->rlecmh
[i
]; // place older request in slot of younger one we found
316 reader
->rlecmh
[i
] = tmp
; // place younger request in slot of older request
320 // release all slots above ratelimit ecm
321 for(i
= reader
->ratelimitecm
; i
< MAXECMRATELIMIT
; i
++)
323 reader
->rlecmh
[i
].last
.time
= -1;
324 reader
->rlecmh
[i
].srvid
= -1;
325 reader
->rlecmh
[i
].kindecm
= 0;
326 reader
->rlecmh
[i
].once
= 0;
331 // If reader_mode is 1, ECM_REQUEST need to be assigned to reader and slot.
332 // Else just report if a free slot is available.
333 int32_t maxslots
= MAXECMRATELIMIT
;
334 int32_t ecm_ratelimit_check(struct s_reader
*reader
, ECM_REQUEST
*er
, int32_t reader_mode
)
337 if(!reader
->ratelimitecm
)
342 int32_t foundspace
= -1, h
; // init slots to oscam global maximums
345 rl
= get_ratelimit(er
);
347 if(rl
.ratelimitecm
> 0)
349 cs_log_dbg(D_CLIENT
, "ratelimit found for CAID: %04X PROVID: %06X SRVID: %04X CHID: %04X maxecms: %d cycle: %d ms srvidhold: %d ms",
350 rl
.caid
, rl
.provid
, rl
.srvid
, rl
.chid
, rl
.ratelimitecm
, rl
.ratelimittime
, rl
.srvidholdtime
);
352 else // nothing found: apply general reader limits
354 rl
.ratelimitecm
= reader
->ratelimitecm
;
355 rl
.ratelimittime
= reader
->ratelimittime
;
356 rl
.srvidholdtime
= reader
->srvidholdtime
;
358 rl
.provid
= er
->prid
;
360 rl
.srvid
= er
->srvid
;
361 cs_log_dbg(D_CLIENT
, "ratelimiter apply readerdefault for CAID: %04X PROVID: %06X SRVID: %04X CHID: %04X maxecms: %d cycle: %d ms srvidhold: %d ms",
362 rl
.caid
, rl
.provid
, rl
.srvid
, rl
.chid
, rl
.ratelimitecm
, rl
.ratelimittime
, rl
.srvidholdtime
);
365 // Below this line: rate limit functionality.
367 if(!reader
->cooldown
[0])
369 cs_log_dbg(D_CLIENT
, "ratelimiter find a slot for srvid %04X on reader %s", er
->srvid
, reader
->label
);
370 foundspace
= ecm_ratelimit_findspace(reader
, er
, rl
, reader_mode
);
377 cs_log_dbg(D_CLIENT
, "ratelimiter no free slot for srvid %04X on reader %s -> dropping!", er
->srvid
, reader
->label
);
378 write_ecm_answer(reader
, er
, E_NOTFOUND
, E2_RATELIMIT
, NULL
, "Ratelimiter: no slots free!", 0, NULL
);
382 return ERROR
; // not even trowing an error... obvious reason ;)
384 else // we are within ecmratelimits
389 //reader->rlecmh[foundspace].srvid=er->srvid; // register srvid
390 reader
->rlecmh
[foundspace
] = rl
; // register this srvid ratelimit params
391 cs_ftime(&reader
->rlecmh
[foundspace
].last
); // register request time
392 memcpy(reader
->rlecmh
[foundspace
].ecmd5
, er
->ecmd5
, CS_ECMSTORESIZE
); // register ecmhash
393 reader
->rlecmh
[foundspace
].kindecm
= er
->ecm
[0]; // register kind of ecm
400 // Below this line: rate limit functionality with cooldown option.
402 // Cooldown state cycle:
403 // state = 0: Cooldown setup phase. No rate limit set.
404 // If number of ecm request exceed reader->ratelimitecm, cooldownstate goes to 2.
405 // state = 2: Cooldown delay phase. No rate limit set.
406 // If number of ecm request still exceed reader->ratelimitecm at end of cooldown delay phase,
407 // cooldownstate goes to 1 (rate limit phase).
408 // Else return back to setup phase (state 0).
409 // state = 1: Cooldown ratelimit phase. Rate limit set.
410 // If cooldowntime reader->cooldown[1] is elapsed, return to cooldown setup phase (state 0).
413 int32_t gone
= comp_timeb(&now
, &reader
->cooldowntime
);
414 if(reader
->cooldownstate
== 1) // Cooldown in ratelimit phase
416 if(gone
<= reader
->cooldown
[1] * 1000) // check if cooldowntime is elapsed
417 { maxslots
= reader
->ratelimitecm
; } // use user defined ratelimitecm
418 else // Cooldown time is elapsed
420 reader
->cooldownstate
= 0; // set cooldown setup phase
421 reader
->cooldowntime
.time
= -1; // reset cooldowntime
422 maxslots
= MAXECMRATELIMIT
; //use oscam defined max slots
423 cs_log("Reader: %s ratelimiter returning to setup phase cooling down period of %d seconds is done!", reader
->label
, reader
->cooldown
[1]);
425 } // if cooldownstate == 1
427 if(reader
->cooldownstate
== 2 && gone
> reader
->cooldown
[0] * 1000)
429 // Need to check if the otherslots are not exceeding the ratelimit at the moment that
430 // cooldown[0] time was exceeded!
431 // time_t actualtime = reader->cooldowntime + reader->cooldown[0];
432 maxslots
= 0; // maxslots is used as counter
433 for(h
= 0; h
< MAXECMRATELIMIT
; h
++)
435 if(reader
->rlecmh
[h
].last
.time
== -1) { continue; } // skip empty slots
436 // how many active slots are registered at end of cooldown delay period
438 gone
= comp_timeb(&now
, &reader
->rlecmh
[h
].last
);
439 if(gone
<= (reader
->ratelimittime
+ reader
->srvidholdtime
))
442 if(maxslots
>= reader
->ratelimitecm
) { break; } // Need to go cooling down phase
446 if(maxslots
< reader
->ratelimitecm
)
448 reader
->cooldownstate
= 0; // set cooldown setup phase
449 reader
->cooldowntime
.time
= -1; // reset cooldowntime
450 maxslots
= MAXECMRATELIMIT
; // maxslots is maxslots again
451 cs_log("Reader: %s ratelimiter returning to setup phase after %d seconds cooldowndelay!", reader
->label
, reader
->cooldown
[0]);
454 reader
->cooldownstate
= 1; // Entering ratelimit for cooldown ratelimitseconds
455 cs_ftime(&reader
->cooldowntime
); // set time to enforce ecmratelimit for defined cooldowntime
456 maxslots
= reader
->ratelimitecm
; // maxslots is maxslots again
457 sort_ecmrl(reader
); // keep youngest ecm requests in list + housekeeping
458 cs_log("Reader: %s ratelimiter starting cooling down period of %d seconds!", reader
->label
, reader
->cooldown
[1]);
460 } // if cooldownstate == 2
462 cs_log_dbg(D_CLIENT
, "ratelimiter cooldownphase %d find a slot for srvid %04X on reader %s", reader
->cooldownstate
, er
->srvid
, reader
->label
);
464 foundspace
= ecm_ratelimit_findspace(reader
, er
, rl
, reader_mode
);
472 cs_log_dbg(D_CLIENT
, "ratelimiter cooldownphase %d no free slot for srvid %04X on reader %s -> dropping!", reader
->cooldownstate
, er
->srvid
, reader
->label
);
473 write_ecm_answer(reader
, er
, E_NOTFOUND
, E2_RATELIMIT
, NULL
, "Ratelimiter: cooldown no slots free!", 0, NULL
);
477 return ERROR
; // not even trowing an error... obvious reason ;)
479 else // we are within ecmratelimits
484 //reader->rlecmh[foundspace].srvid=er->srvid; // register srvid
485 reader
->rlecmh
[foundspace
] = rl
; // register this srvid ratelimit params
486 cs_ftime(&reader
->rlecmh
[foundspace
].last
); // register request time
487 memcpy(reader
->rlecmh
[foundspace
].ecmd5
, er
->ecmd5
, CS_ECMSTORESIZE
);// register ecmhash
488 reader
->rlecmh
[foundspace
].kindecm
= er
->ecm
[0]; // register kind of ecm
492 if(reader
->cooldownstate
== 0 && foundspace
>= reader
->ratelimitecm
)
494 if(!reader_mode
) // No actual ecm request, just check
499 cs_log("Reader: %s ratelimiter cooldown detected overrun ecmratelimit of %d during setup phase!",
500 reader
->label
, (foundspace
- reader
->ratelimitecm
+ 1));
501 reader
->cooldownstate
= 2; // Entering cooldowndelay phase
502 cs_ftime(&reader
->cooldowntime
); // Set cooldowntime to calculate delay
503 cs_log_dbg(D_CLIENT
, "ratelimiter cooldowndelaying %d seconds", reader
->cooldown
[0]);
506 // Cooldown state housekeeping is done. There is a slot available.
510 //reader->rlecmh[foundspace].srvid=er->srvid; // register srvid
511 reader
->rlecmh
[foundspace
] = rl
; // register this srvid ratelimit params
512 cs_ftime(&reader
->rlecmh
[foundspace
].last
); // register request time
513 memcpy(reader
->rlecmh
[foundspace
].ecmd5
, er
->ecmd5
, CS_ECMSTORESIZE
);// register ecmhash
514 reader
->rlecmh
[foundspace
].kindecm
= er
->ecm
[0]; // register kind of ecm
520 const struct s_cardsystem
*get_cardsystem_by_caid(uint16_t caid
)
523 for(i
= 0; cardsystems
[i
]; i
++)
525 const struct s_cardsystem
*csystem
= cardsystems
[i
];
526 for(j
= 0; csystem
->caids
[j
]; j
++)
528 uint16_t cs_caid
= csystem
->caids
[j
];
531 if(cs_caid
== caid
|| cs_caid
== caid
>> 8)
538 struct s_reader
*get_reader_by_label(char *lbl
)
540 struct s_reader
*rdr
;
541 LL_ITER itr
= ll_iter_create(configured_readers
);
542 while((rdr
= ll_iter_next(&itr
)))
544 if(streq(lbl
, rdr
->label
))
550 const char *reader_get_type_desc(struct s_reader
*rdr
, int32_t extended
)
552 const char *desc
= "unknown";
553 if(rdr
->crdr
&& rdr
->crdr
->desc
)
554 { return rdr
->crdr
->desc
; }
555 if(is_network_reader(rdr
) || rdr
->typ
== R_SERIAL
)
558 { desc
= rdr
->ph
.desc
; }
560 if(rdr
->typ
== R_NEWCAMD
&& rdr
->ncd_proto
== NCD_524
)
561 { desc
= "newcamd524"; }
562 else if(rdr
->typ
== R_CCCAM
)
565 if(extended
&& cccam_client_extended_mode(rdr
->client
)) desc
= "cccam_ext";
566 if(cccam_client_multics_mode(rdr
->client
)) desc
= "cccam_mcs";
571 bool hexserialset(struct s_reader
*rdr
)
576 for(i
= 0; i
< 8; i
++)
578 if(rdr
->hexserial
[i
])
584 void hexserial_to_newcamd(uint8_t *source
, uint8_t *dest
, uint16_t caid
)
586 if(caid_is_bulcrypt(caid
))
590 memcpy(dest
+ 2, source
, 4);
592 else if(caid_is_irdeto(caid
) || caid_is_betacrypt(caid
))
594 // only 4 Bytes Hexserial for newcamd clients (Hex Base + Hex Serial)
595 // first 2 Byte always 00
596 dest
[0] = 0x00; //serial only 4 bytes
597 dest
[1] = 0x00; //serial only 4 bytes
598 // 1 Byte Hex Base (see reader-irdeto.c how this is stored in "source")
600 // 3 Bytes Hex Serial (see reader-irdeto.c how this is stored in "source")
605 else if(caid_is_viaccess(caid
) || caid_is_cryptoworks(caid
))
608 memcpy(dest
+ 1, source
, 5);
612 memcpy(dest
, source
, 6);
616 void newcamd_to_hexserial(uint8_t *source
, uint8_t *dest
, uint16_t caid
)
618 if(caid_is_bulcrypt(caid
))
620 memcpy(dest
, source
+ 2, 4);
624 else if(caid_is_irdeto(caid
) || caid_is_betacrypt(caid
))
626 memcpy(dest
, source
+ 3, 3);
631 else if(caid_is_viaccess(caid
) || caid_is_cryptoworks(caid
))
633 memcpy(dest
, source
+ 1, 5);
638 memcpy(dest
, source
, 6);
643 * add or find one entitlement item to entitlements of reader
644 * use add = 0 for find only, or add > 0 to find and add if not found
646 S_ENTITLEMENT
*cs_add_entitlement(struct s_reader
*rdr
, uint16_t caid
, uint32_t provid
, uint64_t id
, uint32_t class, time_t start
, time_t end
, uint8_t type
, uint8_t add
)
648 if(!rdr
->ll_entitlements
)
650 rdr
->ll_entitlements
= ll_create("ll_entitlements");
653 S_ENTITLEMENT
*item
= NULL
;
656 it
= ll_iter_create(rdr
->ll_entitlements
);
657 while((item
= ll_iter_next(&it
)) != NULL
)
659 if((caid
&& item
->caid
!= caid
) || (provid
&& item
->provid
!= provid
) ||
660 (id
&& item
->id
!= id
) || (class && item
->class != class) ||
661 (start
&& ((!add
&& item
->start
< start
) || (add
&& item
->start
!=start
))) ||
662 (end
&& ((!add
&& item
->end
< end
) || (add
&& item
->end
!= end
))) ||
663 (type
&& item
->type
!= type
))
665 continue; // no match, try next!
667 break; // match found!
670 if(add
&& item
== NULL
)
672 if(cs_malloc(&item
, sizeof(S_ENTITLEMENT
)))
676 item
->provid
= provid
;
684 ll_append(rdr
->ll_entitlements
, item
);
685 // cs_log_dbg(D_TRACE, "entitlement: Add caid %4X id %4X %s - %s ", item->caid, item->id, item->start, item->end);
689 cs_log("ERROR: Can't allocate entitlement to reader!");
697 * clears entitlements of reader.
699 void cs_clear_entitlement(struct s_reader
*rdr
)
701 if(!rdr
->ll_entitlements
)
704 ll_clear_data(rdr
->ll_entitlements
);
708 void casc_check_dcw(struct s_reader
*reader
, int32_t idx
, int32_t rc
, uint8_t *cw
)
710 int32_t i
, pending
= 0;
711 time_t t
= time(NULL
);
713 struct s_client
*cl
= reader
->client
;
715 if(!check_client(cl
)) { return; }
717 for(i
= 0; i
< cfg
.max_pending
; i
++)
719 ecm
= &cl
->ecmtask
[i
];
720 if((ecm
->rc
>= E_NOCARD
) && ecm
->caid
== cl
->ecmtask
[idx
].caid
&& (!memcmp(ecm
->ecmd5
, cl
->ecmtask
[idx
].ecmd5
, CS_ECMSTORESIZE
)))
722 if(rc
== 2) // E_INVALID from camd35 CMD08
724 write_ecm_answer(reader
, ecm
, E_INVALID
, 0, cw
, NULL
, 0, NULL
);
728 #ifdef CS_CACHEEX_AIO
729 if(rc
== 0x86) // lg-flagged rc
731 ecm
->localgenerated
= 1;
734 write_ecm_answer(reader
, ecm
, E_FOUND
, 0, cw
, NULL
, 0, NULL
);
738 write_ecm_answer(reader
, ecm
, E_NOTFOUND
, 0 , NULL
, NULL
, 0, NULL
);
744 if(ecm
->rc
>= E_NOCARD
&& (t
- (uint32_t)ecm
->tps
.time
> ((cfg
.ctimeout
+ 500) / 1000) + 1)) // drop timeouts
749 if(ecm
->rc
>= E_NOCARD
)
752 cl
->pending
= pending
;
755 int32_t hostResolve(struct s_reader
*rdr
)
757 struct s_client
*cl
= rdr
->client
;
759 if(!cl
) { return 0; }
762 IP_ASSIGN(last_ip
, cl
->ip
);
763 cs_resolve(rdr
->device
, &cl
->ip
, &cl
->udp_sa
, &cl
->udp_sa_len
);
764 IP_ASSIGN(SIN_GET_ADDR(cl
->udp_sa
), cl
->ip
);
766 if(!IP_EQUAL(cl
->ip
, last_ip
))
768 cs_log("%s: resolved ip=%s", rdr
->device
, cs_inet_ntoa(cl
->ip
));
771 return IP_ISSET(cl
->ip
);
774 void clear_block_delay(struct s_reader
*rdr
)
776 rdr
->tcp_block_delay
= 0;
777 cs_ftime(&rdr
->tcp_block_connect_till
);
780 void block_connect(struct s_reader
*rdr
)
782 if(!rdr
->tcp_block_delay
)
783 { rdr
->tcp_block_delay
= 100; } // starting blocking time, 100ms
785 cs_ftime(&rdr
->tcp_block_connect_till
);
786 add_ms_to_timeb(&rdr
->tcp_block_connect_till
, rdr
->tcp_block_delay
);
787 rdr
->tcp_block_delay
*= 4; // increment timeouts
789 if(rdr
->tcp_block_delay
>= rdr
->tcp_reconnect_delay
)
790 { rdr
->tcp_block_delay
= rdr
->tcp_reconnect_delay
; }
792 rdr_log_dbg(rdr
, D_TRACE
, "tcp connect blocking delay set to %d", rdr
->tcp_block_delay
);
795 int32_t is_connect_blocked(struct s_reader
*rdr
)
797 struct timeb cur_time
;
799 int32_t diff
= comp_timeb(&cur_time
, &rdr
->tcp_block_connect_till
);
800 int32_t blocked
= rdr
->tcp_block_delay
&& diff
< 0;
803 rdr_log_dbg(rdr
, D_TRACE
, "connection blocked, retrying in %d ms", -diff
);
808 int32_t network_tcp_connection_open(struct s_reader
*rdr
)
810 if(!rdr
) { return -1; }
811 struct s_client
*client
= rdr
->client
;
812 struct SOCKADDR loc_sa
;
814 memset((char *)&client
->udp_sa
, 0, sizeof(client
->udp_sa
));
817 IP_ASSIGN(last_ip
, client
->ip
);
818 if(!hostResolve(rdr
))
821 if(!IP_EQUAL(last_ip
, client
->ip
)) // clean blocking delay on ip change:
822 { clear_block_delay(rdr
); }
824 if(is_connect_blocked(rdr
)) // inside of blocking delay, do not connect!
829 if(client
->reader
->r_port
<= 0)
831 rdr_log(client
->reader
, "invalid port %d for server %s", client
->reader
->r_port
, client
->reader
->device
);
835 client
->is_udp
= (rdr
->typ
== R_CAMD35
);
837 rdr_log(rdr
, "connecting to %s:%d", rdr
->device
, rdr
->r_port
);
840 { rdr_log(rdr
, "WARNING: client->udp_fd was not 0"); }
842 int s_domain
= PF_INET
;
843 int s_family
= AF_INET
;
845 if(!IN6_IS_ADDR_V4MAPPED(&rdr
->client
->ip
) && !IN6_IS_ADDR_V4COMPAT(&rdr
->client
->ip
))
851 int s_type
= client
->is_udp
? SOCK_DGRAM
: SOCK_STREAM
;
852 int s_proto
= client
->is_udp
? IPPROTO_UDP
: IPPROTO_TCP
;
854 if((client
->udp_fd
= socket(s_domain
, s_type
, s_proto
)) < 0)
856 rdr_log(rdr
, "Socket creation failed (errno=%d %s)", errno
, strerror(errno
));
862 set_socket_priority(client
->udp_fd
, cfg
.netprio
);
864 int32_t keep_alive
= 1;
865 setsockopt(client
->udp_fd
, SOL_SOCKET
, SO_KEEPALIVE
, (void *)&keep_alive
, sizeof(keep_alive
));
868 setsockopt(client
->udp_fd
, IPPROTO_TCP
, TCP_NODELAY
, (void *)&flag
, sizeof(flag
));
870 if(setsockopt(client
->udp_fd
, SOL_SOCKET
, SO_REUSEADDR
, (void *)&flag
, sizeof(flag
)) < 0)
872 rdr_log(rdr
, "setsockopt failed (errno=%d: %s)", errno
, strerror(errno
));
878 set_so_reuseport(client
->udp_fd
);
880 memset((char *)&loc_sa
, 0, sizeof(loc_sa
));
881 SIN_GET_FAMILY(loc_sa
) = s_family
;
883 if(IP_ISSET(cfg
.srvip
))
884 { IP_ASSIGN(SIN_GET_ADDR(loc_sa
), cfg
.srvip
); }
886 { SIN_GET_ADDR(loc_sa
) = ADDR_ANY
; }
888 if(client
->reader
->l_port
)
889 { SIN_GET_PORT(loc_sa
) = htons(client
->reader
->l_port
); }
891 if(client
->is_udp
&& bind(client
->udp_fd
, (struct sockaddr
*)&loc_sa
, sizeof(loc_sa
)) < 0)
893 rdr_log(rdr
, "bind failed (errno=%d %s)", errno
, strerror(errno
));
894 close(client
->udp_fd
);
901 if(IN6_IS_ADDR_V4MAPPED(&rdr
->client
->ip
) || IN6_IS_ADDR_V4COMPAT(&rdr
->client
->ip
))
903 ((struct sockaddr_in
*)(&client
->udp_sa
))->sin_family
= AF_INET
;
904 ((struct sockaddr_in
*)(&client
->udp_sa
))->sin_port
= htons((uint16_t)client
->reader
->r_port
);
908 ((struct sockaddr_in6
*)(&client
->udp_sa
))->sin6_family
= AF_INET6
;
909 ((struct sockaddr_in6
*)(&client
->udp_sa
))->sin6_port
= htons((uint16_t)client
->reader
->r_port
);
912 client
->udp_sa
.sin_family
= AF_INET
;
913 client
->udp_sa
.sin_port
= htons((uint16_t)client
->reader
->r_port
);
916 rdr_log_dbg(rdr
, D_TRACE
, "socket open fd=%d", client
->udp_fd
);
920 rdr
->tcp_connected
= 1;
921 return client
->udp_fd
;
924 set_nonblock(client
->udp_fd
, true);
926 int32_t res
= connect(client
->udp_fd
, (struct sockaddr
*)&client
->udp_sa
, client
->udp_sa_len
);
930 if(errno
== EINPROGRESS
|| errno
== EALREADY
)
933 pfd
.fd
= client
->udp_fd
;
934 pfd
.events
= POLLOUT
;
935 int32_t rc
= poll(&pfd
, 1, 3000);
938 uint32_t l
= sizeof(r
);
939 if(getsockopt(client
->udp_fd
, SOL_SOCKET
, SO_ERROR
, &r
, (socklen_t
*)&l
) != 0)
951 rdr_log(rdr
, "connect failed: %s", strerror(errno
));
952 block_connect(rdr
); // connect has failed. Block connect for a while
953 close(client
->udp_fd
);
959 set_nonblock(client
->udp_fd
, false); // restore blocking mode
961 setTCPTimeouts(client
->udp_fd
);
962 clear_block_delay(rdr
);
963 client
->last
= client
->login
= time((time_t *)0);
964 client
->last_caid
= NO_CAID_VALUE
;
965 client
->last_provid
= NO_PROVID_VALUE
;
966 client
->last_srvid
= NO_SRVID_VALUE
;
967 client
->pfd
= client
->udp_fd
;
968 rdr
->tcp_connected
= 1;
969 rdr_log_dbg(rdr
, D_TRACE
, "connect successful fd=%d", client
->udp_fd
);
970 return client
->udp_fd
;
973 void network_tcp_connection_close(struct s_reader
*reader
, char *reason
)
977 // only proxy reader should call this, client connections are closed on thread cleanup
978 cs_log("WARNING: invalid client");
979 cs_disconnect_client(cur_client());
983 struct s_client
*cl
= reader
->client
;
985 int32_t fd
= cl
->udp_fd
;
991 rdr_log(reader
, "disconnected: reason %s", reason
? reason
: "undef");
998 reader
->tcp_connected
= 0;
999 reader
->card_status
= UNKNOWN
;
1000 cl
->logout
= time((time_t *)0);
1004 for(i
= 0; i
< cfg
.max_pending
; i
++)
1006 cl
->ecmtask
[i
].idx
= 0;
1007 cl
->ecmtask
[i
].rc
= E_FOUND
;
1010 // newcamd message ids are stored as a reference in ecmtask[].idx
1011 // so we need to reset them aswell
1012 if(reader
->typ
== R_NEWCAMD
)
1013 { cl
->ncd_msgid
= 0; }
1016 int32_t casc_process_ecm(struct s_reader
*reader
, ECM_REQUEST
*er
)
1018 int32_t rc
, n
, i
, sflag
, pending
= 0;
1020 struct s_client
*cl
= reader
->client
;
1022 if(!cl
|| !cl
->ecmtask
)
1024 rdr_log(reader
, "WARNING: ecmtask not available");
1028 t
= time((time_t *)0);
1030 for(i
= 0; i
< cfg
.max_pending
; i
++)
1032 ecm
= &cl
->ecmtask
[i
];
1033 if((ecm
->rc
>= E_NOCARD
) && (t
- (uint32_t)ecm
->tps
.time
> ((cfg
.ctimeout
+ 500) / 1000) + 1)) // drop timeouts
1039 for(n
= -1, i
= 0, sflag
= 1; i
< cfg
.max_pending
; i
++)
1041 ecm
= &cl
->ecmtask
[i
];
1042 if(n
< 0 && (ecm
->rc
< E_NOCARD
)) // free slot found
1045 // ecm already pending
1046 // ...this level at least
1047 if((ecm
->rc
>= E_NOCARD
) && er
->caid
== ecm
->caid
&& (!memcmp(er
->ecmd5
, ecm
->ecmd5
, CS_ECMSTORESIZE
)))
1050 if(ecm
->rc
>= E_NOCARD
)
1053 cl
->pending
= pending
;
1057 rdr_log(reader
, "WARNING: reader ecm pending table overflow !!");
1061 memcpy(&cl
->ecmtask
[n
], er
, sizeof(ECM_REQUEST
));
1062 cl
->ecmtask
[n
].matching_rdr
= NULL
; // This avoids double free of matching_rdr!
1064 cl
->ecmtask
[n
].csp_lastnodes
= NULL
; // This avoids double free of csp_lastnodes!
1066 cl
->ecmtask
[n
].parent
= er
;
1068 if(reader
->typ
== R_NEWCAMD
)
1069 { cl
->ecmtask
[n
].idx
= (cl
->ncd_msgid
== 0) ? 2 : cl
->ncd_msgid
+ 1; }
1074 cl
->ecmtask
[n
].idx
= cl
->idx
++;
1077 cl
->ecmtask
[n
].rc
= E_NOCARD
;
1078 cs_log_dbg(D_TRACE
, "---- ecm_task %d, idx %d, sflag=%d", n
, cl
->ecmtask
[n
].idx
, sflag
);
1080 cs_log_dump_dbg(D_ATR
, er
->ecm
, er
->ecmlen
, "casc ecm (%s):", (reader
) ? reader
->label
: "n/a");
1085 rc
= reader
->ph
.c_send_ecm(cl
, &cl
->ecmtask
[n
]);
1088 casc_check_dcw(reader
, n
, 0, cl
->ecmtask
[n
].cw
); // simulate "not found"
1091 { cl
->last_idx
= cl
->ecmtask
[n
].idx
; }
1092 reader
->last_s
= t
; // used for inactive_timeout and reconnect_timeout in TCP reader
1095 if(cl
->idx
> 0x1ffe) { cl
->idx
= 1; }
1100 void reader_get_ecm(struct s_reader
*reader
, ECM_REQUEST
*er
)
1102 if(!reader
) { return; }
1103 struct s_client
*cl
= reader
->client
;
1104 if(!check_client(cl
)) { return; }
1106 if(!chk_bcaid(er
, &reader
->ctab
))
1108 rdr_log_dbg(reader
, D_READER
, "caid %04X filtered", er
->caid
);
1109 write_ecm_answer(reader
, er
, E_NOTFOUND
, E2_CAID
, NULL
, NULL
, 0, NULL
);
1113 // CHECK if ecm already sent to reader
1114 struct s_ecm_answer
*ea_er
= get_ecm_answer(reader
, er
);
1115 if(!ea_er
) { return; }
1117 struct s_ecm_answer
*ea
= NULL
, *ea_prev
= NULL
;
1118 struct ecm_request_t
*ecm
;
1121 cs_readlock(__func__
, &ecmcache_lock
);
1123 for(ecm
= ecmcwcache
; ecm
; ecm
= ecm
->next
)
1125 timeout
= time(NULL
) - ((cfg
.ctimeout
+500)/1000+1);
1126 if(ecm
->tps
.time
<= timeout
)
1129 if(!ecm
->matching_rdr
|| ecm
== er
|| ecm
->rc
== E_99
) { continue; }
1132 if(er
->caid
== ecm
->caid
&& !memcmp(er
->ecmd5
, ecm
->ecmd5
, CS_ECMSTORESIZE
))
1134 //check if ask this reader
1135 ea
= get_ecm_answer(reader
, ecm
);
1136 if(ea
&& !ea
->is_pending
&& (ea
->status
& REQUEST_SENT
) && ea
->rc
!= E_TIMEOUT
&& ea
->rcEx
!= E2_RATELIMIT
) { break; }
1141 cs_readunlock(__func__
, &ecmcache_lock
);
1143 if(ea
) // found ea in cached ecm, asking for this reader
1145 ea_er
->is_pending
= true;
1147 cs_readlock(__func__
, &ea
->ecmanswer_lock
);
1150 cs_readunlock(__func__
, &ea
->ecmanswer_lock
);
1151 cs_log_dbg(D_LB
, "{client %s, caid %04X, prid %06X, srvid %04X} [reader_get_ecm] ecm already sent to reader %s (%s)", (check_client(er
->client
) ? er
->client
->account
->usr
: "-"), er
->caid
, er
->prid
, er
->srvid
, reader
? reader
->label
: "-", ea
->rc
==E_FOUND
?"OK":"NOK");
1153 //e.g. we cannot send timeout, because "ea_temp->er->client" could wait/ask other readers! Simply set not_found if different from E_FOUND!
1154 write_ecm_answer(reader
, er
, (ea
->rc
==E_FOUND
? E_FOUND
: E_NOTFOUND
), ea
->rcEx
, ea
->cw
, NULL
, ea
->tier
, &ea
->cw_ex
);
1159 ea_prev
= ea
->pending
;
1160 ea
->pending
= ea_er
;
1161 ea
->pending
->pending_next
= ea_prev
;
1162 cs_log_dbg(D_LB
, "{client %s, caid %04X, prid %06X, srvid %04X} [reader_get_ecm] ecm already sent to reader %s... set as pending", (check_client(er
->client
) ? er
->client
->account
->usr
: "-"), er
->caid
, er
->prid
, er
->srvid
, reader
? reader
->label
: "-");
1164 cs_readunlock(__func__
, &ea
->ecmanswer_lock
);
1168 lb_update_last(ea_er
, reader
);
1170 if(ecm_ratelimit_check(reader
, er
, 1) != OK
)
1172 rdr_log_dbg(reader
, D_READER
, "ratelimiter has no space left -> skip!");
1176 if(is_cascading_reader(reader
)) // forward request to proxy reader
1178 cl
->last_srvid
= er
->srvid
;
1179 cl
->last_caid
= er
->caid
;
1180 cl
->last_provid
= er
->prid
;
1181 casc_process_ecm(reader
, er
);
1182 cl
->lastecm
= time((time_t *)0);
1186 cardreader_process_ecm(reader
, cl
, er
); // forward request to physical reader
1189 void reader_do_card_info(struct s_reader
*reader
)
1191 cardreader_get_card_info(reader
);
1192 if(reader
->ph
.c_card_info
)
1193 { reader
->ph
.c_card_info(); }
1196 void reader_do_idle(struct s_reader
*reader
)
1198 if(reader
->ph
.c_idle
)
1199 { reader
->ph
.c_idle(); }
1200 else if (reader
->tcp_ito
> 0)
1205 time_diff
= llabs(now
- reader
->last_s
);
1206 if(time_diff
> reader
->tcp_ito
)
1208 struct s_client
*cl
= reader
->client
;
1209 if(check_client(cl
) && reader
->tcp_connected
&& reader
->ph
.type
== MOD_CONN_TCP
)
1211 rdr_log_dbg(reader
, D_READER
, "inactive_timeout, close connection (fd=%d)", cl
->pfd
);
1212 network_tcp_connection_close(reader
, "inactivity");
1215 { reader
->last_s
= now
; }
1220 int32_t reader_init(struct s_reader
*reader
)
1222 struct s_client
*client
= reader
->client
;
1224 if(is_cascading_reader(reader
))
1227 client
->port
= reader
->r_port
;
1228 set_null_ip(&client
->ip
);
1230 if(!(reader
->ph
.c_init
))
1232 rdr_log(reader
, "FATAL: protocol not supporting cascading");
1236 if(reader
->ph
.c_init(client
))
1238 //proxy reader start failed
1244 add_garbage(client
->ecmtask
);
1245 client
->ecmtask
= NULL
;
1248 if(!cs_malloc(&client
->ecmtask
, cfg
.max_pending
* sizeof(ECM_REQUEST
)))
1251 rdr_log(reader
, "proxy initialized, server %s:%d", reader
->device
, reader
->r_port
);
1255 if(!cardreader_init(reader
))
1259 ll_destroy_data(&reader
->emmstat
);
1261 client
->login
= time((time_t *)0);
1262 client
->init_done
= 1;
1267 #if !defined(WITH_CARDREADER) && (defined(WITH_STAPI) || defined(WITH_STAPI5))
1268 /* Dummy function stub for stapi compiles without cardreader as libstapi needs it. */
1269 int32_t ATR_InitFromArray(ATR
*atr
, const uint8_t atr_buffer
[ATR_MAX_SIZE
], uint32_t length
)
1278 void cs_card_info(void)
1280 struct s_client
*cl
;
1281 for(cl
= first_client
->next
; cl
; cl
= cl
->next
)
1283 if(cl
->typ
== 'r' && cl
->reader
)
1284 { add_job(cl
, ACTION_READER_CARDINFO
, NULL
, 0); }
1289 /* Adds a reader to the list of active readers so that it can serve ecms. */
1290 static void add_reader_to_active(struct s_reader
*rdr
)
1292 struct s_reader
*rdr2
, *rdr_prv
= NULL
, *rdr_tmp
= NULL
;
1293 int8_t at_first
= 1;
1296 { remove_reader_from_active(rdr
); }
1298 cs_writelock(__func__
, &readerlist_lock
);
1299 cs_writelock(__func__
, &clientlist_lock
);
1301 // search configured position:
1302 LL_ITER it
= ll_iter_create(configured_readers
);
1303 while((rdr2
= ll_iter_next(&it
)))
1307 if(rdr2
->client
&& rdr2
->enable
)
1314 // insert at configured position:
1315 if(first_active_reader
)
1319 rdr
->next
= first_active_reader
;
1320 first_active_reader
= rdr
;
1322 // resort client list:
1323 struct s_client
*prev
, *cl
;
1325 for(prev
= first_client
, cl
= first_client
->next
;
1326 prev
->next
!= NULL
; prev
= prev
->next
, cl
= cl
->next
)
1328 if(rdr
->client
== cl
)
1332 if(cl
&& rdr
->client
== cl
)
1334 prev
->next
= cl
->next
; // remove client from list
1335 cl
->next
= first_client
->next
;
1336 first_client
->next
= cl
;
1341 for(rdr2
= first_active_reader
; rdr2
->next
&& rdr2
!= rdr_prv
; rdr2
= rdr2
->next
) { ; } // search last element
1344 rdr_tmp
= rdr2
->next
;
1346 rdr
->next
= rdr_tmp
;
1348 // resort client list:
1349 struct s_client
*prev
, *cl
;
1351 for(prev
= first_client
, cl
= first_client
->next
;
1352 prev
->next
!= NULL
; prev
= prev
->next
, cl
= cl
->next
)
1354 if(rdr
->client
== cl
)
1358 if(cl
&& rdr
->client
== cl
)
1360 prev
->next
= cl
->next
; // remove client from list
1361 cl
->next
= rdr_prv
->client
->next
;
1362 rdr_prv
->client
->next
= cl
;
1368 first_active_reader
= rdr
;
1371 cs_writeunlock(__func__
, &clientlist_lock
);
1372 cs_writeunlock(__func__
, &readerlist_lock
);
1375 /* Removes a reader from the list of active readers so that no ecms can be requested anymore. */
1376 void remove_reader_from_active(struct s_reader
*rdr
)
1378 struct s_reader
*rdr2
, *prv
= NULL
;
1379 //rdr_log(rdr, "CHECK: REMOVE READER FROM ACTIVE");
1380 cs_writelock(__func__
, &readerlist_lock
);
1381 for(rdr2
= first_active_reader
; rdr2
; prv
= rdr2
, rdr2
= rdr2
->next
)
1385 if(prv
) { prv
->next
= rdr2
->next
; }
1386 else { first_active_reader
= rdr2
->next
; }
1392 cs_writeunlock(__func__
, &readerlist_lock
);
1395 /* Starts or restarts a cardreader without locking. If restart=1, the existing thread is killed before restarting,
1396 if restart=0 the cardreader is only started. */
1397 static int32_t restart_cardreader_int(struct s_reader
*rdr
, int32_t restart
)
1399 struct s_client
*cl
= rdr
->client
;
1402 uint16_t waitme
= 1500;
1403 remove_reader_from_active(rdr
); // remove from list
1404 kill_thread(cl
); // kill old thread
1406 // wait a bit if socket not closed and is_valid_client, othervise safe for reload?
1409 if (!is_valid_client(cl
))
1411 // 100 mS I think is enought for freeing garbage
1417 // If we quick disable+enable a reader (webif), remove_reader_from_active is called from
1418 // cleanup. this could happen AFTER reader is restarted, so oscam crashes or reader is hidden
1419 // rdr_log(rdr, "CHECK: WAITING FOR CLEANUP");
1420 cs_sleepms(500); // we have to wait a bit so free_client is ended and socket closed too!
1423 } while(waitme
|| cl
->pfd
);
1427 rdr
->tcp_connected
= 0;
1428 rdr
->card_status
= UNKNOWN
;
1429 rdr
->tcp_block_delay
= 100;
1430 cs_ftime(&rdr
->tcp_block_connect_till
);
1432 if(rdr
->device
[0] && is_cascading_reader(rdr
))
1436 rdr_log(rdr
, "Protocol Support missing. (typ=%d)", rdr
->typ
);
1448 rdr_log(rdr
, "Restarting reader");
1450 cl
= create_client(first_client
->ip
);
1454 rdr_log(rdr
, "creating thread for device %s", rdr
->device
);
1456 cl
->sidtabs
.ok
= rdr
->sidtabs
.ok
;
1457 cl
->sidtabs
.no
= rdr
->sidtabs
.no
;
1458 cl
->lb_sidtabs
.ok
= rdr
->lb_sidtabs
.ok
;
1459 cl
->lb_sidtabs
.no
= rdr
->lb_sidtabs
.no
;
1466 add_job(cl
, ACTION_READER_INIT
, NULL
, 0);
1467 add_reader_to_active(rdr
);
1474 /* Starts or restarts a cardreader with locking. If restart=1, the existing thread is killed before restarting,
1475 if restart=0 the cardreader is only started. */
1476 int32_t restart_cardreader(struct s_reader
*rdr
, int32_t restart
)
1478 cs_writelock(__func__
, &system_lock
);
1479 int32_t result
= restart_cardreader_int(rdr
, restart
);
1480 cs_writeunlock(__func__
, &system_lock
);
1484 void init_cardreader(void)
1486 cs_log_dbg(D_TRACE
, "cardreader: Initializing");
1487 cs_writelock(__func__
, &system_lock
);
1488 struct s_reader
*rdr
;
1490 cardreader_init_locks();
1491 LL_ITER itr
= ll_iter_create(configured_readers
);
1492 while((rdr
= ll_iter_next(&itr
)))
1496 restart_cardreader_int(rdr
, 0);
1500 load_stat_from_file();
1501 cs_writeunlock(__func__
, &system_lock
);
1504 void kill_all_readers(void)
1506 struct s_reader
*rdr
;
1507 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1509 struct s_client
*cl
= rdr
->client
;
1512 rdr_log(rdr
, "Killing reader");
1514 #ifdef CS_CACHEEX_AIO
1515 ll_destroy_data(&cl
->ll_cacheex_stats
);
1518 first_active_reader
= NULL
;
1521 int32_t reader_slots_available(struct s_reader
*reader
, ECM_REQUEST
*er
)
1523 if(ecm_ratelimit_check(reader
, er
, 0) != OK
) // check ratelimiter & cooldown -> in check mode: dont register srvid!!!
1525 return 0; // no slot free
1529 return 1; // slots available!