?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert breaks some stupid old compilers
[oscam.git] / oscam-ecm.c
blob020e4e42f6ab2d59a6370850318e308674a7ecbb
1 #define MODULE_LOG_PREFIX "ecm"
2
3 #include "globals.h"
4 #include "cscrypt/md5.h"
5 #include "module-anticasc.h"
6 #include "module-cacheex.h"
7 #include "module-led.h"
8 #include "module-stat.h"
9 #include "module-webif.h"
10 #include "module-ird-guess.h"
11 #include "module-cw-cycle-check.h"
12 #include "module-gbox.h"
13 #include "oscam-cache.h"
14 #include "oscam-chk.h"
15 #include "oscam-client.h"
16 #include "oscam-config.h"
17 #include "oscam-ecm.h"
18 #include "oscam-garbage.h"
19 #include "oscam-failban.h"
20 #include "oscam-net.h"
21 #include "oscam-time.h"
22 #include "oscam-lock.h"
23 #include "oscam-string.h"
24 #include "oscam-work.h"
25 #include "reader-common.h"
26
27 extern CS_MUTEX_LOCK ecmcache_lock;
28 extern struct ecm_request_t *ecmcwcache;
29 extern uint16_t len4caid[256];
30 extern uint32_t ecmcwcache_size;
31 extern int32_t exit_oscam;
32
33 extern CS_MUTEX_LOCK ecm_pushed_deleted_lock;
34 extern struct ecm_request_t *ecm_pushed_deleted;
35
36 static pthread_mutex_t cw_process_sleep_cond_mutex;
37 static pthread_cond_t cw_process_sleep_cond;
38 static int cw_process_wakeups;
39
40 void fallback_timeout(ECM_REQUEST *er)
41 {
42 if(er->rc >= E_UNHANDLED && er->stage < 4)
43 {
44 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} fallback timeout! (stage: %d)", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, er->stage);
45 debug_ecm(D_TRACE, "fallback for %s %s", username(er->client), buf);
46 while(er->stage < 4) //if preferlocalcards=1 and no answer from locals, initial stage will be 2! We need to reach stage=4 to call fallback's.
47 {
48 request_cw_from_readers(er, 0);
49 }
50 }
51 }
52
53 void ecm_timeout(ECM_REQUEST *er)
54 {
55 if(!er->readers_timeout_check)
56 {
57 er->readers_timeout_check = 1;
58
59 if(check_client(er->client) && er->rc >= E_UNHANDLED)
60 {
61 debug_ecm(D_TRACE, "timeout for %s %s", username(er->client), buf);
62
63
64 //set timeout for readers not answering
65 struct s_ecm_answer *ea_list;
66 for(ea_list = er->matching_rdr; ea_list; ea_list = ea_list->next)
67 {
68 if((ea_list->status & (REQUEST_SENT | REQUEST_ANSWERED)) == REQUEST_SENT) //Request sent, but no answer!
69 {
70 write_ecm_answer(ea_list->reader, er, E_TIMEOUT, 0, NULL, NULL, 0, NULL); //set timeout for readers not answered!
71 }
72 }
73
74 //send timeout to client!
75 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} client timeout! ", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid);
76 er->rc = E_TIMEOUT;
77 er->rcEx = 0;
78 send_dcw(er->client, er);
79 }
80 }
81 }
82
83 void increment_n_request(struct s_client *cl){
84 if(check_client(cl)){
85 cl->n_request[1]++;
86 first_client->n_request[1]++;
87 }
88 }
89
90 void update_n_request(void){
91 struct s_client *cl;
92
93 cs_readlock(__func__, &clientlist_lock);
94 for(cl = first_client->next; cl; cl = cl->next)
95 {
96 #ifdef CS_CACHEEX
97 if(check_client(cl) && get_module(cl)->num != R_CSP && cl->typ == 'c' && !cl->dup && cl->account && cl->account->cacheex.mode<=1) //no cacheex 2/3 client
98 #else
99 if(check_client(cl) && get_module(cl)->num != R_CSP && cl->typ == 'c' && !cl->dup)
100 #endif
101 {
102 cl->n_request[0]=cl->n_request[1];
103 cl->n_request[1]=0;
104 }else{
105 cl->n_request[0]=0;
106 cl->n_request[1]=0;
107 }
108 }
109
110 first_client->n_request[0]=first_client->n_request[1];
111 first_client->n_request[1]=0;
112
113 cs_readunlock(__func__, &clientlist_lock);
114 }
115
116 static void *cw_process(void)
117 {
118 set_thread_name(__func__);
119 int64_t time_to_check_fbtimeout, time_to_check_ctimeout, next_check, ecmc_next, cache_next, n_request_next, msec_wait = 3000;
120 struct timeb t_now, tbc, ecmc_time, cache_time, n_request_time;
121 ECM_REQUEST *er = NULL;
122 time_t ecm_maxcachetime;
123
124 #ifdef CS_CACHEEX
125 int64_t time_to_check_cacheex_wait_time;
126 int64_t time_to_check_cacheex_mode1_delay;
127 #endif
128
129 cs_pthread_cond_init(__func__, &cw_process_sleep_cond_mutex, &cw_process_sleep_cond);
130
131 #ifdef CS_ANTICASC
132 int32_t ac_next;
133 struct timeb ac_time;
134 cs_ftime(&ac_time);
135 add_ms_to_timeb(&ac_time, cfg.ac_stime * 60 * 1000);
136 #endif
137
138 cs_ftime(&ecmc_time);
139 add_ms_to_timeb(&ecmc_time, 1000);
140 cs_ftime(&cache_time);
141 add_ms_to_timeb(&cache_time, 3000);
142 cs_ftime(&n_request_time);
143 add_ms_to_timeb(&n_request_time, 60 * 1000);
144
145 while(!exit_oscam)
146 {
147 if(cw_process_wakeups == 0) // No waiting wakeups, proceed to sleep
148 {
149 sleepms_on_cond(__func__, &cw_process_sleep_cond_mutex, &cw_process_sleep_cond, msec_wait);
150 }
151 cw_process_wakeups = 0; // We've been woken up, reset the counter
152 if(exit_oscam)
153 { break; }
154
155 next_check = 0;
156 #ifdef CS_ANTICASC
157 ac_next = 0;
158 #endif
159 ecmc_next = 0;
160 cache_next = 0;
161 msec_wait = 0;
162
163 cs_ftime(&t_now);
164 cs_readlock(__func__, &ecmcache_lock);
165 for(er = ecmcwcache; er; er = er->next)
166 {
167
168 if(
169 (er->from_cacheex || er->from_csp) //ignore ecms from cacheex/csp
170 ||
171 er->readers_timeout_check //ignore already checked
172 ||
173 !check_client(er->client) //ignore ecm of killed clients
174 )
175 { continue; }
176
177 if(er->rc >= E_UNHANDLED)
178 {
179
180 #ifdef CS_CACHEEX
181 //cacheex_wait_time
182 if(er->cacheex_wait_time && !er->cacheex_wait_time_expired)
183 {
184 tbc = er->tps;
185 time_to_check_cacheex_mode1_delay = 0;
186 time_to_check_cacheex_wait_time = add_ms_to_timeb_diff(&tbc, lb_auto_timeout(er, er->cacheex_wait_time));
187 if(comp_timeb(&t_now, &tbc) >= 0)
188 {
189 add_job(er->client, ACTION_CACHEEX_TIMEOUT, (void *)er, 0);
190 time_to_check_cacheex_wait_time = 0;
191
192 }else if(er->cacheex_mode1_delay && !er->stage && er->cacheex_reader_count>0){
193 //check for cacheex_mode1_delay
194 tbc = er->tps;
195 time_to_check_cacheex_mode1_delay = add_ms_to_timeb_diff(&tbc, lb_auto_timeout(er, er->cacheex_mode1_delay));
196 if(comp_timeb(&t_now, &tbc) >= 0)
197 {
198 add_job(er->client, ACTION_CACHEEX1_DELAY, (void *)er, 0);
199 time_to_check_cacheex_mode1_delay = 0;
200 }
201 }
202 if(!next_check || (time_to_check_cacheex_wait_time > 0 && time_to_check_cacheex_wait_time < next_check))
203 { next_check = time_to_check_cacheex_wait_time; }
204 if(!next_check || (time_to_check_cacheex_mode1_delay > 0 && time_to_check_cacheex_mode1_delay < next_check))
205 { next_check = time_to_check_cacheex_mode1_delay; }
206 }
207 #endif
208 if(er->stage < 4)
209 {
210 //fbtimeout
211 tbc = er->tps;
212 time_to_check_fbtimeout = add_ms_to_timeb_diff(&tbc, lb_auto_timeout(er, get_fallbacktimeout(er->caid)));
213 if(comp_timeb(&t_now, &tbc) >= 0)
214 {
215 add_job(er->client, ACTION_FALLBACK_TIMEOUT, (void *)er, 0);
216 time_to_check_fbtimeout = 0;
217 }
218 if(!next_check || (time_to_check_fbtimeout > 0 && time_to_check_fbtimeout < next_check))
219 { next_check = time_to_check_fbtimeout; }
220 }
221 }
222
223
224 //clienttimeout
225 if(!er->readers_timeout_check) //ecm stays in cache at least ctimeout+2seconds!
226 {
227 tbc = er->tps;
228 time_to_check_ctimeout = add_ms_to_timeb_diff(&tbc, lb_auto_timeout(er, cfg.ctimeout));
229 if(comp_timeb(&t_now, &tbc) >= 0)
230 {
231 add_job(er->client, ACTION_CLIENT_TIMEOUT, (void *)er, 0);
232 time_to_check_ctimeout = 0;
233 }
234 if(!next_check || (time_to_check_ctimeout > 0 && time_to_check_ctimeout < next_check))
235 { next_check = time_to_check_ctimeout; }
236 }
237 }
238 cs_readunlock(__func__, &ecmcache_lock);
239 #ifdef CS_ANTICASC
240 if(cfg.ac_enabled && (ac_next = comp_timeb(&ac_time, &t_now)) <= 10)
241 {
242 ac_do_stat();
243 cs_ftime(&ac_time);
244 ac_next = add_ms_to_timeb_diff(&ac_time, cfg.ac_stime * 60 * 1000);
245 }
246 #endif
247 if((ecmc_next = comp_timeb(&ecmc_time, &t_now)) <= 10)
248 {
249 uint32_t count = 0;
250 struct ecm_request_t *ecm, *ecmt = NULL, *prv;
251
252 cs_readlock(__func__, &ecmcache_lock);
253 for(ecm = ecmcwcache, prv = NULL; ecm; prv = ecm, ecm = ecm->next, count++)
254 {
255 ecm_maxcachetime = t_now.time - ((cfg.ctimeout+500)/1000+3); //to be sure no more access er!
256
257 if(ecm->tps.time < ecm_maxcachetime)
258 {
259 cs_readunlock(__func__, &ecmcache_lock);
260 cs_writelock(__func__, &ecmcache_lock);
261 ecmt = ecm;
262 if(prv)
263 { prv->next = NULL; }
264 else
265 { ecmcwcache = NULL; }
266 cs_writeunlock(__func__, &ecmcache_lock);
267 break;
268 }
269 }
270 if(!ecmt)
271 { cs_readunlock(__func__, &ecmcache_lock); }
272 ecmcwcache_size = count;
273
274 while(ecmt)
275 {
276 ecm = ecmt->next;
277 free_ecm(ecmt);
278 ecmt = ecm;
279 }
280
281 #ifdef CS_CACHEEX
282 ecmt=NULL;
283 cs_readlock(__func__, &ecm_pushed_deleted_lock);
284 for(ecm = ecm_pushed_deleted, prv = NULL; ecm; prv = ecm, ecm = ecm->next)
285 {
286 ecm_maxcachetime = t_now.time - ((cfg.ctimeout+500)/1000+3);
287 if(ecm->tps.time < ecm_maxcachetime)
288 {
289 cs_readunlock(__func__, &ecm_pushed_deleted_lock);
290 cs_writelock(__func__, &ecm_pushed_deleted_lock);
291 ecmt = ecm;
292 if(prv)
293 { prv->next = NULL; }
294 else
295 { ecm_pushed_deleted = NULL; }
296 cs_writeunlock(__func__, &ecm_pushed_deleted_lock);
297 break;
298 }
299 }
300 if(!ecmt)
301 { cs_readunlock(__func__, &ecm_pushed_deleted_lock); }
302
303 while(ecmt)
304 {
305 ecm = ecmt->next;
306 free_push_in_ecm(ecmt);
307 ecmt = ecm;
308 }
309 #endif
310
311 cs_ftime(&ecmc_time);
312 ecmc_next = add_ms_to_timeb_diff(&ecmc_time, 1000);
313 }
314
315
316 if((cache_next = comp_timeb(&cache_time, &t_now)) <= 10)
317 {
318
319
320 cleanup_cache(false);
321 cacheex_cleanup_hitcache(false);
322
323 cs_ftime(&cache_time);
324 cache_next = add_ms_to_timeb_diff(&cache_time, 3000);
325 }
326
327 if((n_request_next = comp_timeb(&n_request_time, &t_now)) <= 10)
328 {
329 update_n_request();
330 cs_ftime(&n_request_time);
331 n_request_next = add_ms_to_timeb_diff(&n_request_time, 60 * 1000);
332 }
333
334
335 msec_wait = next_check;
336 #ifdef CS_ANTICASC
337 if(!msec_wait || (ac_next > 0 && ac_next < msec_wait))
338 { msec_wait = ac_next; }
339 #endif
340 if(!msec_wait || (ecmc_next > 0 && ecmc_next < msec_wait))
341 { msec_wait = ecmc_next; }
342
343 if(!msec_wait || (cache_next > 0 && cache_next < msec_wait))
344 { msec_wait = cache_next; }
345
346 if(!msec_wait || (n_request_next > 0 && n_request_next < msec_wait))
347 { msec_wait = n_request_next; }
348
349 if(!msec_wait)
350 { msec_wait = 3000; }
351
352 cleanupcwcycle();
353 }
354
355 return NULL;
356 }
357
358 void cw_process_thread_start(void)
359 {
360 start_thread("cw_process", (void *) &cw_process, NULL, NULL, 1, 1);
361 }
362
363 void cw_process_thread_wakeup(void)
364 {
365 cw_process_wakeups++; // Do not sleep...
366 SAFE_COND_SIGNAL(&cw_process_sleep_cond);
367 }
368
369 void convert_to_beta(struct s_client *cl, ECM_REQUEST *er, uint16_t caidto)
370 {
371 static uint8_t headerN3[10] = {0xc7, 0x00, 0x00, 0x00, 0x01, 0x10, 0x10, 0x00, 0x87, 0x12};
372 static uint8_t headerN2[10] = {0xc9, 0x00, 0x00, 0x00, 0x01, 0x10, 0x10, 0x00, 0x48, 0x12};
373
374 er->ocaid = er->caid;
375 er->caid = caidto;
376 er->prid = 0;
377 er->ecmlen = er->ecm[2] + 3;
378
379 memmove(er->ecm + 13, er->ecm + 3, er->ecmlen - 3);
380
381 if(er->ecmlen > 0x88)
382 {
383 memcpy(er->ecm + 3, headerN3, 10);
384 if(er->ecm[0] == 0x81)
385 { er->ecm[12] += 1; }
386 er->ecm[1] = 0x70;
387 }
388 else
389 {
390 memcpy(er->ecm + 3, headerN2, 10);
391 }
392
393 er->ecmlen += 10;
394 er->ecm[2] = er->ecmlen - 3;
395 er->btun = 1;
396
397 cl->cwtun++;
398 cl->account->cwtun++;
399 first_client->cwtun++;
400
401 cs_log_dbg(D_TRACE, "ECM converted ocaid from 0x%04X to BetaCrypt caid 0x%04X for service id 0x%04X",
402 er->ocaid, caidto, er->srvid);
403 }
404
405 void convert_to_nagra(struct s_client *cl, ECM_REQUEST *er, uint16_t caidto)
406 {
407 cs_log_dbg(D_TRACE, "convert_to_nagra");
408 er->ocaid = er->caid;
409 er->caid = caidto;
410 er->prid = 0;
411 er->ecmlen = er->ecm[2] + 3;
412
413 //not sure
414 if(er->ecmlen < 0x52)
415 { er->ecm[1] = 0x30; }
416
417 memmove(er->ecm + 3, er->ecm + 13, er->ecmlen - 3);
418
419 er->ecmlen -= 10;
420 er->ecm[2] = er->ecmlen - 3;
421 er->btun = 1;
422
423 cl->cwtun++;
424 cl->account->cwtun++;
425 first_client->cwtun++;
426
427 cs_log_dbg(D_TRACE, "ECM converted ocaid from: 0x%04X to Nagra: 0x04%X for service id:0x04%X",
428 er->ocaid, caidto, er->srvid);
429 }
430
431 void cs_betatunnel(ECM_REQUEST *er)
432 {
433 int32_t i;
434 struct s_client *cl = cur_client();
435 uint32_t mask_all = 0xFFFF;
436 TUNTAB *ttab = &cl->ttab;
437
438 for(i = 0; i < ttab->ttnum; i++)
439 {
440 if((er->caid == ttab->ttdata[i].bt_caidfrom) && ((er->srvid == ttab->ttdata[i].bt_srvid) || (ttab->ttdata[i].bt_srvid) == mask_all))
441 {
442 if(chk_is_betatunnel_caid(er->caid) == 1 && er->ocaid == 0x0000)
443 {
444 convert_to_nagra(cl, er, ttab->ttdata[i].bt_caidto);
445 }
446 else if(er->ocaid == 0x0000)
447 {
448 convert_to_beta(cl, er, ttab->ttdata[i].bt_caidto);
449 }
450 return;
451 }
452 }
453 }
454
455 static void remove_ecm_from_reader(ECM_REQUEST *ecm)
456 {
457 int32_t i;
458 struct s_ecm_answer *ea = ecm->matching_rdr;
459 while(ea)
460 {
461 if((ea->status & REQUEST_SENT) && !(ea->status & REQUEST_ANSWERED))
462 {
463 //we found a outstanding reader, clean it:
464 struct s_reader *rdr = ea->reader;
465 if(rdr)
466 {
467 struct s_client *cl = rdr->client;
468 if(check_client(cl))
469 {
470 ECM_REQUEST *ecmtask = cl->ecmtask;
471 if(ecmtask)
472 {
473 for(i = 0; i < cfg.max_pending; ++i)
474 {
475 if(ecmtask[i].parent == ecm)
476 {
477 ecmtask[i].client = NULL;
478 cacheex_set_csp_lastnode(&ecmtask[i]);
479 }
480 }
481 }
482 }
483 }
484 }
485 ea = ea->next;
486 }
487 }
488
489 void free_ecm(ECM_REQUEST *ecm)
490 {
491 struct s_ecm_answer *ea, *nxt;
492 cacheex_free_csp_lastnodes(ecm);
493 gbox_free_cards_pending(ecm);
494 //remove this ecm from reader queue to avoid segfault on very late answers (when ecm is already disposed)
495 //first check for outstanding answers:
496 remove_ecm_from_reader(ecm);
497 //free matching_rdr list:
498 ea = ecm->matching_rdr;
499 ecm->matching_rdr = NULL;
500 while(ea)
501 {
502 nxt = ea->next;
503 cs_lock_destroy(__func__, &ea->ecmanswer_lock);
504 add_garbage(ea);
505 ea = nxt;
506 }
507 if(ecm->src_data)
508 { add_garbage(ecm->src_data); }
509 add_garbage(ecm);
510 }
511
512
513 void free_push_in_ecm(ECM_REQUEST *ecm)
514 {
515 cacheex_free_csp_lastnodes(ecm);
516 gbox_free_cards_pending(ecm);
517 if(ecm->src_data)
518 { NULLFREE(ecm->src_data); }
519 NULLFREE(ecm);
520 }
521
522
523 ECM_REQUEST *get_ecmtask(void)
524 {
525 ECM_REQUEST *er = NULL;
526 struct s_client *cl = cur_client();
527 if(!cl)
528 { return NULL; }
529 if(!cs_malloc(&er, sizeof(ECM_REQUEST)))
530 { return NULL; }
531 cs_ftime(&er->tps);
532 er->rc = E_UNHANDLED;
533 er->client = cl;
534 er->grp = 0; //no readers/cacheex-clients answers yet
535 //cs_log("client %s ECMTASK %d module %s", username(cl), n, get_module(cl)->desc);
536 return er;
537 }
538
539 void cleanup_ecmtasks(struct s_client *cl)
540 {
541 if(!cl) { return; }
542
543 ECM_REQUEST *ecm;
544
545 //remove this clients ecm from queue. because of cache, just null the client:
546 cs_readlock(__func__, &ecmcache_lock);
547 for(ecm = ecmcwcache; ecm && cl; ecm = ecm->next)
548 {
549 if(ecm->client == cl)
550 {
551 ecm->client = NULL;
552 }
553 }
554 cs_readunlock(__func__, &ecmcache_lock);
555
556 //remove client from rdr ecm-queue:
557 cs_readlock(__func__, &readerlist_lock);
558 struct s_reader *rdr = first_active_reader;
559 while(rdr)
560 {
561 if(check_client(rdr->client) && rdr->client->ecmtask)
562 {
563 int i;
564 for(i = 0; (i < cfg.max_pending) && cl; i++)
565 {
566 ecm = &rdr->client->ecmtask[i];
567 if(ecm->client == cl)
568 {
569 ecm->client = NULL;
570 }
571 }
572 }
573 rdr = rdr->next;
574 }
575 cs_readunlock(__func__, &readerlist_lock);
576
577 }
578
579
580 static void add_cascade_data(struct s_client *client, ECM_REQUEST *er)
581 {
582 if(!client->cascadeusers)
583 { client->cascadeusers = ll_create("cascade_data"); }
584 LLIST *l = client->cascadeusers;
585 LL_ITER it = ll_iter_create(l);
586 time_t now = time(NULL);
587 struct s_cascadeuser *cu;
588 int8_t found = 0;
589 while((cu = ll_iter_next(&it)))
590 {
591 if(er->caid == cu->caid && er->prid == cu->prid && er->srvid == cu->srvid) //found it
592 {
593 if(cu->time < now)
594 { cu->cwrate = now - cu->time; }
595 cu->time = now;
596 found = 1;
597 }
598 else if(cu->time + 60 < now) // old
599 { ll_iter_remove_data(&it); }
600 }
601 if(!found) //add it if not found
602 {
603 if(!cs_malloc(&cu, sizeof(struct s_cascadeuser)))
604 { return; }
605 cu->caid = er->caid;
606 cu->prid = er->prid;
607 cu->srvid = er->srvid;
608 cu->time = now;
609 ll_append(l, cu);
610 }
611 }
612
613 static int32_t is_double_check_caid(ECM_REQUEST *er)
614 {
615 if(!cfg.double_check_caid.ctnum) //no caids defined: Check all
616 { return 1; }
617 int32_t i;
618 for(i = 0; i < cfg.double_check_caid.ctnum; i++)
619 {
620 CAIDTAB_DATA *d = &cfg.double_check_caid.ctdata[i];
621 uint16_t tcaid = d->caid;
622 if(!tcaid)
623 { break; }
624 if(tcaid == er->caid || (tcaid < 0x0100 && (er->caid >> 8) == tcaid))
625 {
626 return 1;
627 }
628 }
629 return 0;
630 }
631
632 struct s_ecm_answer *get_ecm_answer(struct s_reader *reader, ECM_REQUEST *er)
633 {
634 if(!er || !reader) { return NULL; }
635
636 struct s_ecm_answer *ea;
637
638 for(ea = er->matching_rdr; ea; ea = ea->next)
639 {
640 if(ea->reader == reader)
641 {
642 return ea;
643 }
644 }
645 return NULL;
646 }
647
648
649 void distribute_ea(struct s_ecm_answer *ea)
650 {
651
652 struct s_ecm_answer *ea_temp;
653
654 for(ea_temp = ea->pending; ea_temp; ea_temp = ea_temp->pending_next)
655 {
656 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [distribute_ea] send ea (%s) by reader %s answering for client %s", (check_client(ea_temp->er->client) ? ea_temp->er->client->account->usr : "-"), ea_temp->er->caid, ea_temp->er->prid, ea_temp->er->srvid, ea->rc==E_FOUND?"OK":"NOK", ea_temp->reader->label, (check_client(ea->er->client) ? ea->er->client->account->usr : "-"));
657
658 //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!
659 write_ecm_answer(ea_temp->reader, ea_temp->er, (ea->rc==E_FOUND? E_FOUND : E_NOTFOUND), ea->rcEx, ea->cw, NULL, ea->tier, &ea->cw_ex);
660 }
661 }
662
663 int32_t send_dcw(struct s_client *client, ECM_REQUEST *er)
664 {
665 if(!check_client(client) || client->typ != 'c')
666 { return 0; }
667
668 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [send_dcw] rc %d from reader %s", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, er->rc, er->selected_reader ? er->selected_reader->label : "-");
669
670 static const char stageTxt[] = {'0', 'C', 'L', 'P', 'F', 'X'};
671 static const char *stxt[] = {"found", "cache1", "cache2", "cache3",
672 "not found", "timeout", "sleeping",
673 "fake", "invalid", "corrupt", "no card", "expdate", "disabled", "stopped"
674 };
675 static const char *stxtEx[16] = {"", "group", "caid", "ident", "class", "chid", "queue", "peer", "sid", "", "", "", "", "", "", ""};
676 static const char *stxtWh[16] = {"", "user ", "reader ", "server ", "lserver ", "", "", "", "", "", "", "", "" , "" , "", ""};
677 char sby[100] = "", sreason[32] = "", scwcinfo[32] = "", schaninfo[CS_SERVICENAME_SIZE] = "", srealecmtime[50]="";
678 char erEx[32] = "";
679 char usrname[38] = "";
680 char channame[CS_SERVICENAME_SIZE];
681 struct timeb tpe;
682
683 snprintf(usrname, sizeof(usrname) - 1, "%s", username(client));
684
685 #ifdef WITH_DEBUG
686 if(cs_dblevel & D_CLIENTECM)
687 {
688 char buf[ECM_FMT_LEN];
689 char ecmd5[17 * 3];
690 char cwstr[17 * 3];
691 format_ecm(er, buf, ECM_FMT_LEN);
692 cs_hexdump(0, er->ecmd5, 16, ecmd5, sizeof(ecmd5));
693 cs_hexdump(0, er->cw, 16, cwstr, sizeof(cwstr));
694 #ifdef CS_CACHEEX
695 char csphash[5 * 3];
696 cs_hexdump(0, (void *)&er->csp_hash, 4, csphash, sizeof(csphash));
697 cs_log_dbg(D_CLIENTECM, "Client %s csphash %s cw %s rc %d %s", username(client), csphash, cwstr, er->rc, buf);
698 #else
699 cs_log_dbg(D_CLIENTECM, "Client %s cw %s rc %d %s", username(client), cwstr, er->rc, buf);
700 #endif
701 }
702 #endif
703
704 struct s_reader *er_reader = er->selected_reader; //responding reader
705 struct s_ecm_answer *ea_orig = get_ecm_answer(er_reader, er);
706
707
708 //check if ecm_answer from pending's
709 if(ea_orig && ea_orig->is_pending && er->rc == E_FOUND)
710 { er->rc = E_CACHE2; }
711
712
713 //check if answer from cacheex-1 reader
714 if(er->rc == E_FOUND && er_reader && cacheex_reader(er_reader)) //so add hit to cacheex mode 1 readers
715 {
716 er->rc = E_CACHEEX;
717 }
718
719 //real ecm time
720 if(ea_orig && !ea_orig->is_pending && er->rc == E_FOUND
721 &&
722 (
723 #ifdef CS_CACHEEX
724 er->cacheex_wait_time ||
725 #endif
726 (ea_orig->status & READER_FALLBACK))
727 )
728 {
729 snprintf(srealecmtime, sizeof(srealecmtime) - 1, " (real %d ms)", ea_orig->ecm_time);
730 }
731
732
733 if(er->rc == E_TIMEOUT)
734 {
735 #ifdef CS_CACHEEX
736 if(!er->from_cacheex1_client){ //cosmetic: show "by" readers only for "normal" clients
737 #endif
738 struct s_ecm_answer *ea_list;
739 int32_t ofs = 0;
740 for(ea_list = er->matching_rdr; ea_list; ea_list = ea_list->next)
741 {
742 if(ea_list->reader && ofs < (int32_t)sizeof(sby) && ((ea_list->status & REQUEST_SENT) && (ea_list->rc == E_TIMEOUT || ea_list->rc >= E_99))) //Request send, but no cw answered!
743 {
744 ofs += snprintf(sby + ofs, sizeof(sby) - ofs - 1, "%s%s", ofs ? "," : " by ", ea_list->reader->label);
745 }
746 }
747 if(er->ocaid && ofs < (int32_t)sizeof(sby))
748 { snprintf(sby + ofs, sizeof(sby) - ofs - 1, "(btun %04X)", er->ocaid); }
749
750 #ifdef CS_CACHEEX
751 }
752 #endif
753 }
754 else if(er_reader)
755 {
756 // add marker to reader if ECM_REQUEST was betatunneled
757 if(er->ocaid)
758 { snprintf(sby, sizeof(sby) - 1, " by %s(btun %04X)", er_reader->label, er->ocaid); }
759 else
760 { snprintf(sby, sizeof(sby) - 1, " by %s", er_reader->label); }
761 }
762 #ifdef CS_CACHEEX
763 else if(er->cacheex_src) //only for cacheex mode-3 clients (no mode-1 or mode-2 because reader is set!) and csp
764 {
765 char *cex_name = "-";
766 if(check_client(er->cacheex_src) && er->cacheex_src->account){
767 if(er->cacheex_src->account->usr[0] != '\0')
768 cex_name = er->cacheex_src->account->usr;
769 else
770 cex_name = "csp";
771 }
772
773 if(er->ocaid){
774 snprintf(sby, sizeof(sby) - 1, " by %s(btun %04X)", cex_name, er->ocaid);
775 }else{
776 snprintf(sby, sizeof(sby) - 1, " by %s", cex_name);
777 }
778 }
779 #endif
780
781
782 if(er->rc < E_NOTFOUND)
783 {
784 er->rcEx = 0;
785 memset(er->msglog, 0, MSGLOGSIZE); // remove reader msglog from previous requests that failed, founds never give back msglog!
786 }
787
788 if(er->rcEx)
789 { snprintf(erEx, sizeof(erEx) - 1, "rejected %s%s", stxtWh[er->rcEx >> 4], stxtEx[er->rcEx & 0xf]); }
790
791 get_servicename_or_null(client, er->srvid, er->prid, er->caid, channame, sizeof(channame));
792 if(!channame[0])
793 { schaninfo[0] = '\0'; }
794 else
795 { snprintf(schaninfo, sizeof(schaninfo) - 1, " - %s", channame); }
796
797 if(er->msglog[0])
798 { snprintf(sreason, sizeof(sreason) - 1, " (%s)", er->msglog); }
799 #ifdef CW_CYCLE_CHECK
800 if(er->cwc_msg_log[0])
801 { snprintf(scwcinfo, sizeof(scwcinfo) - 1, " (%s)", er->cwc_msg_log); }
802 #endif
803
804 cs_ftime(&tpe);
805
806 #ifdef CS_CACHEEX
807 int cx = 0;
808 if(er->rc >= E_CACHEEX && er->cacheex_wait_time && er->cacheex_wait_time_expired){
809 cx = snprintf ( sreason, sizeof sreason, " (wait_time over)");
810 }
811 if(er->cw_count>1){
812 snprintf ( sreason+cx, (sizeof sreason)-cx, " (cw count %d)", er->cw_count);
813 }
814 #endif
815
816 client->cwlastresptime = comp_timeb(&tpe, &er->tps);
817
818 time_t now = time(NULL);
819 webif_client_add_lastresponsetime(client, client->cwlastresptime, now, er->rc); // add to ringbuffer
820
821 if(er_reader)
822 {
823 struct s_client *er_cl = er_reader->client;
824 if(check_client(er_cl))
825 {
826 er_cl->cwlastresptime = client->cwlastresptime;
827 webif_client_add_lastresponsetime(er_cl, client->cwlastresptime, now, er->rc);
828 er_cl->last_providptr = client->last_providptr;
829 er_cl->last_srvidptr = client->last_srvidptr;
830 }
831 }
832
833 webif_client_init_lastreader(client, er, er_reader, stxt);
834
835 client->last = now;
836
837 //cs_log_dbg(D_TRACE, "CHECK rc=%d er->cacheex_src=%s", er->rc, username(er->cacheex_src));
838 switch(er->rc)
839 {
840 case E_FOUND:
841 {
842 client->cwfound++;
843 client->account->cwfound++;
844 first_client->cwfound++;
845 break;
846 }
847 case E_CACHE1:
848 case E_CACHE2:
849 case E_CACHEEX:
850 {
851 client->cwcache++;
852 client->account->cwcache++;
853 first_client->cwcache++;
854 #ifdef CS_CACHEEX
855 if(check_client(er->cacheex_src))
856 {
857 first_client->cwcacheexhit++;
858 er->cacheex_src->cwcacheexhit++;
859 if(er->cacheex_src->account)
860 { er->cacheex_src->account->cwcacheexhit++; }
861 }
862 #endif
863 break;
864 }
865 case E_NOTFOUND:
866 case E_CORRUPT:
867 case E_NOCARD:
868 {
869 if(er->rcEx)
870 {
871 client->cwignored++;
872 client->account->cwignored++;
873 first_client->cwignored++;
874 }
875 else
876 {
877 client->cwnot++;
878 client->account->cwnot++;
879 first_client->cwnot++;
880 }
881 break;
882 }
883 case E_TIMEOUT:
884 {
885 client->cwtout++;
886 client->account->cwtout++;
887 first_client->cwtout++;
888 break;
889 }
890 default:
891 {
892 client->cwignored++;
893 client->account->cwignored++;
894 first_client->cwignored++;
895 }
896 }
897
898 #ifdef CS_ANTICASC
899 // [zaplist] ACoSC anticascading
900 if(cfg.acosc_enabled)
901 {
902 int8_t max_active_sids = 0;
903 int8_t zap_limit = 0;
904 int8_t penalty = 0;
905 int32_t penalty_duration = 0;
906 int32_t delay = 0;
907 char *info1 = NULL;
908 char *info2 = NULL;
909 char *info3 = NULL;
910 char *info4 = NULL;
911 char *info5 = NULL;
912
913
914 //**global or user value?
915 cs_writelock(__func__, &clientlist_lock);
916
917 max_active_sids = client->account->acosc_max_active_sids == -1 ? cfg.acosc_max_active_sids : client->account->acosc_max_active_sids;
918 info1 = client->account->acosc_max_active_sids == -1 ? "Globalvalue" : "Uservalue";
919
920 zap_limit = client->account->acosc_zap_limit == -1 ? cfg.acosc_zap_limit : client->account->acosc_zap_limit;
921 info5 = client->account->acosc_zap_limit == -1 ? "Globalvalue" : "Uservalue";
922
923 penalty = client->account->acosc_penalty == -1 ? cfg.acosc_penalty : client->account->acosc_penalty;
924 info2 = client->account->acosc_penalty == -1 ? "Globalvalue" : "Uservalue";
925
926 penalty_duration = client->account->acosc_penalty_duration == -1 ? cfg.acosc_penalty_duration : client->account->acosc_penalty_duration;
927 info3 = client->account->acosc_penalty_duration == -1 ? "Globalvalue" : "Uservalue";
928
929 delay = client->account->acosc_delay == -1 ? cfg.acosc_delay : client->account->acosc_delay;
930 info4 = client->account->acosc_delay == -1 ? "Globalvalue" : "Uservalue";
931
932 //**
933
934 if((er->rc < E_NOTFOUND && max_active_sids > 0) || zap_limit > 0)
935 {
936 int8_t k = 0;
937 int8_t active_sid_count = 0;
938 time_t zaptime = time(NULL);
939
940 if(client->account->acosc_penalty_active == 3 && client->account->acosc_penalty_until <= zaptime) // reset penalty_active
941 {
942 client->account->acosc_penalty_active = 0;
943 client->account->acosc_penalty_until = 0;
944 }
945
946 if(client->account->acosc_penalty_active == 0 && max_active_sids > 0)
947 {
948 for(k=0; k<15 ; k++)
949 {
950 if(zaptime-30 < client->client_zap_list[k].lasttime && client->client_zap_list[k].request_stage == 10)
951 {
952 cs_log_dbg(D_TRACE, "[zaplist] ACoSC for Client: %s more then 10 ECM's for %04X@%06X/%04X/%04X", username(client), client->client_zap_list[k].caid, client->client_zap_list[k].provid, client->client_zap_list[k].chid, client->client_zap_list[k].sid);
953 active_sid_count ++;
954 }
955 }
956 cs_log_dbg(D_TRACE, "[zaplist] ACoSC for Client: %s active_sid_count= %i with more than 10 followed ECM's (mas:%i (%s))", username(client), active_sid_count, max_active_sids, info1);
957 }
958 if(client->account->acosc_penalty_active == 0 && max_active_sids > 0 && active_sid_count > max_active_sids) //max_active_sids reached
959 {
960 client->account->acosc_penalty_active = 1;
961 client->account->acosc_penalty_until = zaptime + penalty_duration;
962 }
963
964 if(client->account->acosc_penalty_active == 0 && zap_limit > 0 && client->account->acosc_user_zap_count > zap_limit) // zap_limit reached
965 {
966 client->account->acosc_penalty_active = 2;
967 client->account->acosc_penalty_until = zaptime + penalty_duration;
968 }
969
970 if(client->account->acosc_penalty_active > 0)
971 {
972 if(client->account->acosc_penalty_active == 3)
973 { cs_log("[zaplist] ACoSC for Client: %s penalty_duration: %ld seconds left(%s)", username(client), client->account->acosc_penalty_until - zaptime, info3); }
974
975 int16_t lt = get_module(client)->listenertype;
976 switch(penalty)
977 {
978 case 1: // NULL CW
979 er->rc = E_FAKE; //E_FAKE give only a status fake not a NULL cw
980 er->rcEx = E2_WRONG_CHKSUM;
981 if(client->account->acosc_penalty_active == 1)
982 { cs_log("[zaplist] ACoSC for Client: %s max_activ_sids reached: %i:%i(%s) penalty: 1(%s) send null CW", username(client), active_sid_count, max_active_sids, info1, info2); }
983 if(client->account->acosc_penalty_active == 2)
984 { cs_log("[zaplist] ACoSC for Client: %s zap_limit reached: %i:%i(%s) penalty: 1(%s) send null CW", username(client), client->account->acosc_user_zap_count, zap_limit, info5, info2); }
985
986 break;
987 case 2: // ban
988 if(lt != LIS_DVBAPI)
989 {
990 if(client->account->acosc_penalty_active == 1)
991 { cs_log("[zaplist] ACoSC for Client: %s max_activ_sids reached: %i:%i(%s) penalty: 2(%s) BAN Client - Kill and set Client to failban list for %i sec.", username(client), active_sid_count, max_active_sids, info1, info2, penalty_duration); }
992 if(client->account->acosc_penalty_active == 2)
993 { cs_log("[zaplist] ACoSC for Client: %s zap_limit reached: %i:%i(%s) penalty: 2(%s) BAN Client - Kill and set Client to failban list for %i sec.", username(client), client->account->acosc_user_zap_count, zap_limit, info5, info2, penalty_duration); }
994
995 cs_add_violation_acosc(client, client->account->usr, penalty_duration);
996 add_job(client, ACTION_CLIENT_KILL, NULL, 0);
997 }
998 else
999 {
1000 cs_log("[zaplist] ACoSC for Client: %s %i:%i(%s) penalty: 2(%s) BAN Client - don't Ban dvbapi user only stop decoding", username(client), active_sid_count, max_active_sids, info1, info2);
1001 }
1002 er->rc = E_DISABLED;
1003 break;
1004 case 3: // delay
1005 if(client->account->acosc_penalty_active == 1)
1006 { cs_log("[zaplist] ACoSC for Client: %s max_activ_sids reached: %i:%i(%s) penalty: 3(%s) delay CW: %ims(%s)", username(client), active_sid_count, max_active_sids, info1, info2, delay, info4); }
1007 if(client->account->acosc_penalty_active == 2)
1008 { cs_log("[zaplist] ACoSC for Client: %s zap_limit reached: %i:%i(%s) penalty: 3(%s) delay CW: %ims(%s)", username(client), client->account->acosc_user_zap_count, zap_limit, info5, info2, delay, info4); }
1009 cs_writeunlock(__func__, &clientlist_lock);
1010 cs_sleepms(delay);
1011 cs_writelock(__func__, &clientlist_lock);
1012 client->cwlastresptime += delay;
1013 snprintf(sreason, sizeof(sreason)-1, " (%d ms penalty delay)", delay);
1014 break;
1015 default: // logging
1016 if(client->account->acosc_penalty_active == 1)
1017 { cs_log("[zaplist] ACoSC for Client: %s max_activ_sids reached: %i:%i(%s) penalty: 0(%s) only logging", username(client), active_sid_count, max_active_sids, info1, info2); }
1018 if(client->account->acosc_penalty_active == 2)
1019 { cs_log("[zaplist] ACoSC for Client: %s zap_limit reached: %i:%i(%s) penalty: 0(%s) only logging", username(client), client->account->acosc_user_zap_count, zap_limit, info5, info2); }
1020
1021 break;
1022 }
1023 client->account->acosc_user_zap_count = 0; // we got already a penalty
1024 client->account->acosc_penalty_active = 3;
1025 }
1026 }
1027 cs_writeunlock(__func__, &clientlist_lock);
1028 }
1029 #endif
1030
1031 if(cfg.double_check && er->rc < E_NOTFOUND && er->selected_reader && is_double_check_caid(er))
1032 {
1033 if(er->checked == 0) //First CW, save it and wait for next one
1034 {
1035 er->checked = 1;
1036 er->origin_reader = er->selected_reader;
1037 memcpy(er->cw_checked, er->cw, sizeof(er->cw));
1038 cs_log("DOUBLE CHECK FIRST CW by %s idx %d cpti %d", er->origin_reader->label, er->idx, er->msgid);
1039 }
1040 else if(er->origin_reader != er->selected_reader) //Second (or third and so on) cw. We have to compare
1041 {
1042 if(memcmp(er->cw_checked, er->cw, sizeof(er->cw)) == 0)
1043 {
1044 er->checked++;
1045 cs_log("CW matched by %s total matches %d idx %d cpti %d", er->selected_reader->label, er->checked, er->idx, er->msgid);
1046 }
1047 else
1048 {
1049 er->checked--;
1050 cs_log("CW mismatch by %s total matches %d idx %d cpti %d", er->selected_reader->label, er->checked, er->idx, er->msgid);
1051 }
1052 }
1053 if(er->checked < 2) //less as two same cw? mark as pending!
1054 {
1055 er->rc = E_UNHANDLED;
1056 goto ESC;
1057 }
1058 }
1059
1060 ac_chk(client, er, 1);
1061 int32_t is_fake = 0;
1062 if(er->rc == E_FAKE)
1063 {
1064 is_fake = 1;
1065 er->rc = E_FOUND;
1066 }
1067
1068 get_module(client)->send_dcw(client, er);
1069
1070 add_cascade_data(client, er);
1071
1072 if(is_fake)
1073 { er->rc = E_FAKE; }
1074
1075 if(!(er->rc == E_SLEEPING && client->cwlastresptime == 0))
1076 {
1077 char buf[ECM_FMT_LEN];
1078 format_ecm(er, buf, ECM_FMT_LEN);
1079 if(er->reader_avail == 1 || er->stage == 0)
1080 {
1081 cs_log("%s (%s): %s (%d ms)%s%s%s%s",
1082 usrname, buf,
1083 er->rcEx ? erEx : stxt[er->rc], client->cwlastresptime, sby, schaninfo, sreason, scwcinfo);
1084 }
1085 else
1086 {
1087 cs_log("%s (%s): %s (%d ms)%s (%c/%d/%d/%d)%s%s%s%s",
1088 usrname, buf,
1089 er->rcEx ? erEx : stxt[er->rc],
1090 client->cwlastresptime, sby,
1091 stageTxt[er->stage], er->reader_requested, (er->reader_count + er->fallback_reader_count), er->reader_avail,
1092 schaninfo, srealecmtime, sreason, scwcinfo);
1093 }
1094 }
1095
1096 cs_log_dump_dbg(D_ATR, er->cw, 16, "cw:");
1097 led_status_cw_not_found(er);
1098
1099 ESC:
1100
1101 return 0;
1102 }
1103
1104 /*
1105 * write_ecm_request():
1106 */
1107 static int32_t write_ecm_request(struct s_reader *rdr, ECM_REQUEST *er)
1108 {
1109 add_job(rdr->client, ACTION_READER_ECM_REQUEST, (void *)er, 0);
1110 return 1;
1111 }
1112
1113
1114 /**
1115 * sends the ecm request to the readers
1116 * ECM_REQUEST er : the ecm
1117 * er->stage: 0 = no reader asked yet
1118 * 2 = ask only local reader (skipped without preferlocalcards)
1119 * 3 = ask any non fallback reader
1120 * 4 = ask fallback reader
1121 **/
1122 void request_cw_from_readers(ECM_REQUEST *er, uint8_t stop_stage)
1123 {
1124 struct s_ecm_answer *ea;
1125 int8_t sent = 0;
1126
1127 if(er->stage >= 4) { return; }
1128
1129 while(1)
1130 {
1131 if(stop_stage && er->stage >= stop_stage) { return; }
1132
1133 er->stage++;
1134
1135 #ifdef CS_CACHEEX
1136 if(er->stage == 1 && er->preferlocalcards==2)
1137 { er->stage++; }
1138 #else
1139 if(er->stage == 1)
1140 { er->stage++; }
1141 #endif
1142
1143 if(er->stage == 2 && !er->preferlocalcards)
1144 { er->stage++; }
1145
1146 for(ea = er->matching_rdr; ea; ea = ea->next)
1147 {
1148 switch(er->stage)
1149 {
1150 #ifdef CS_CACHEEX
1151 case 1:
1152 {
1153 // Cache-Exchange
1154 if((ea->status & REQUEST_SENT) ||
1155 (ea->status & (READER_CACHEEX | READER_ACTIVE)) != (READER_CACHEEX | READER_ACTIVE))
1156 { continue; }
1157 break;
1158 }
1159 #endif
1160 case 2:
1161 {
1162 // only local reader
1163 if((ea->status & REQUEST_SENT) ||
1164 (ea->status & (READER_ACTIVE | READER_FALLBACK | READER_LOCAL)) != (READER_ACTIVE | READER_LOCAL))
1165 { continue; }
1166 break;
1167 }
1168 case 3:
1169 {
1170 // any non fallback reader not asked yet
1171 if((ea->status & REQUEST_SENT) ||
1172 (ea->status & (READER_ACTIVE | READER_FALLBACK)) != READER_ACTIVE)
1173 { continue; }
1174 break;
1175 }
1176 default:
1177 {
1178 // only fallbacks
1179 if((ea->status & REQUEST_SENT) ||
1180 (ea->status & (READER_ACTIVE | READER_FALLBACK)) != (READER_ACTIVE | READER_FALLBACK))
1181 { continue; }
1182 break;
1183 }
1184 }
1185
1186 struct s_reader *rdr = ea->reader;
1187 char ecmd5[17 * 3];
1188 cs_hexdump(0, er->ecmd5, 16, ecmd5, sizeof(ecmd5));
1189 cs_log_dbg(D_TRACE | D_CSP, "request_cw stage=%d to reader %s ecm hash=%s", er->stage, rdr ? rdr->label : "", ecmd5);
1190
1191 ea->status |= REQUEST_SENT;
1192 cs_ftime(&ea->time_request_sent);
1193
1194 er->reader_requested++;
1195
1196 write_ecm_request(ea->reader, er);
1197
1198 //set sent=1 only if reader is active/connected. If not, switch to next stage!
1199 if(!sent && rdr)
1200 {
1201 struct s_client *rcl = rdr->client;
1202 if(check_client(rcl))
1203 {
1204 if(rcl->typ == 'r' && rdr->card_status == CARD_INSERTED)
1205 { sent = 1; }
1206 else if(rcl->typ == 'p' && (rdr->card_status == CARD_INSERTED || rdr->tcp_connected))
1207 { sent = 1; }
1208 }
1209 }
1210
1211 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [write_ecm_request] reader %s --> SENT %d", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, rdr ? ea->reader->label : "-", sent);
1212 }
1213 if(sent || er->stage >= 4)
1214 { break; }
1215 }
1216 }
1217
1218
1219 void add_cache_from_reader(ECM_REQUEST *er, struct s_reader *rdr, uint32_t csp_hash, uchar *ecmd5, uchar *cw, int16_t caid, int32_t prid, int16_t srvid ){
1220 ECM_REQUEST *ecm;
1221 if (cs_malloc(&ecm, sizeof(ECM_REQUEST))){
1222 cs_ftime(&ecm->tps);
1223
1224 ecm->cwc_cycletime = er->cwc_cycletime;
1225 ecm->cwc_next_cw_cycle = er->cwc_next_cw_cycle;
1226 memcpy(ecm->ecm, er->ecm, sizeof(ecm->ecm)); // ecm[0] is pushed to cacheexclients so we need a copy from it
1227 ecm->caid = caid;
1228 ecm->prid = prid;
1229 ecm->srvid = srvid;
1230 memcpy(ecm->ecmd5, ecmd5, CS_ECMSTORESIZE);
1231 ecm->csp_hash = csp_hash;
1232 ecm->rc = E_FOUND;
1233 memcpy(ecm->cw, cw, sizeof(ecm->cw));
1234 ecm->grp = rdr->grp;
1235 ecm->selected_reader = rdr;
1236 #ifdef CS_CACHEEX
1237 if(rdr && cacheex_reader(rdr))
1238 { ecm->cacheex_src = rdr->client; } //so adds hits to reader
1239 #endif
1240
1241 add_cache(ecm); //add cw to cache
1242
1243 #ifdef CS_CACHEEX
1244 cs_writelock(__func__, &ecm_pushed_deleted_lock);
1245 ecm->next = ecm_pushed_deleted;
1246 ecm_pushed_deleted = ecm;
1247 cs_writeunlock(__func__, &ecm_pushed_deleted_lock);
1248 #else
1249 NULLFREE(ecm);
1250 #endif
1251 }
1252 }
1253
1254
1255 void chk_dcw(struct s_ecm_answer *ea)
1256 {
1257 if(!ea || !ea->er)
1258 { return; }
1259
1260 ECM_REQUEST *ert = ea->er;
1261 struct s_ecm_answer *ea_list;
1262 struct s_reader *eardr = ea->reader;
1263 if(!ert)
1264 { return; }
1265
1266 //ecm request already answered!
1267 if(ert->rc < E_99)
1268 {
1269 #ifdef CS_CACHEEX
1270 if(ea && ert->rc < E_NOTFOUND && ea->rc < E_NOTFOUND && memcmp(ea->cw, ert->cw, sizeof(ert->cw)) != 0)
1271 {
1272 char cw1[16 * 3 + 2], cw2[16 * 3 + 2];
1273 cs_hexdump(0, ea->cw, 16, cw1, sizeof(cw1));
1274 cs_hexdump(0, ert->cw, 16, cw2, sizeof(cw2));
1275
1276 char ip1[20] = "", ip2[20] = "";
1277 if(ea->reader && check_client(ea->reader->client)) { cs_strncpy(ip1, cs_inet_ntoa(ea->reader->client->ip), sizeof(ip1)); }
1278 if(ert->cacheex_src) { cs_strncpy(ip2, cs_inet_ntoa(ert->cacheex_src->ip), sizeof(ip2)); }
1279 else if(ert->selected_reader && check_client(ert->selected_reader->client)) { cs_strncpy(ip2, cs_inet_ntoa(ert->selected_reader->client->ip), sizeof(ip2)); }
1280
1281 ECM_REQUEST *er = ert;
1282 debug_ecm(D_TRACE, "WARNING2: Different CWs %s from %s(%s)<>%s(%s): %s<>%s", buf,
1283 username(ea->reader ? ea->reader->client : ert->client), ip1,
1284 er->cacheex_src ? username(er->cacheex_src) : (ert->selected_reader ? ert->selected_reader->label : "unknown/csp"), ip2,
1285 cw1, cw2);
1286 }
1287 #endif
1288
1289 return;
1290 }
1291
1292
1293 #ifdef CS_CACHEEX
1294 /* if answer from cacheex-1 reader, not send answer to client! thread check_cache will check counter and send answer to client!
1295 * Anyway, we should check if we have to go to oher stage (>1)
1296 */
1297
1298 if(eardr && cacheex_reader(eardr)){
1299
1300 // if wait_time, and not wait_time expired and wait_time due to hitcache(or awtime>0), we have to wait cacheex timeout before call other readers (stage>1)
1301 if(cacheex_reader(eardr) && !ert->cacheex_wait_time_expired && ert->cacheex_hitcache)
1302 { return; }
1303
1304 int8_t cacheex_left = 0;
1305 uint8_t has_cacheex = 0;
1306 if(ert->stage==1){
1307 for(ea_list = ert->matching_rdr; ea_list; ea_list = ea_list->next)
1308 {
1309 cs_readlock(__func__, &ea_list->ecmanswer_lock);
1310 if(((ea_list->status & (READER_CACHEEX | READER_FALLBACK | READER_ACTIVE))) == (READER_CACHEEX | READER_ACTIVE))
1311 { has_cacheex = 1; }
1312 if((!(ea_list->status & READER_FALLBACK) && ((ea_list->status & (REQUEST_SENT | REQUEST_ANSWERED | READER_CACHEEX | READER_ACTIVE)) == (REQUEST_SENT | READER_CACHEEX | READER_ACTIVE))) || ea_list->rc < E_NOTFOUND)
1313 { cacheex_left++; }
1314 cs_readunlock(__func__, &ea_list->ecmanswer_lock);
1315 }
1316
1317 if(has_cacheex && !cacheex_left) { request_cw_from_readers(ert, 0); }
1318 }
1319
1320 return;
1321 }
1322 #endif
1323
1324
1325 int32_t reader_left = 0, local_left = 0, reader_not_flb_left = 0, has_not_fallback = 0, has_local = 0;
1326 ert->selected_reader = eardr;
1327
1328 switch(ea->rc)
1329 {
1330 case E_FOUND:
1331 memcpy(ert->cw, ea->cw, 16);
1332 ert->cw_ex = ea->cw_ex;
1333 ert->rcEx = 0;
1334 ert->rc = ea->rc;
1335 ert->grp |= eardr->grp;
1336 #ifdef HAVE_DVBAPI
1337 ert->adapter_index = ea->er->adapter_index;
1338 #endif
1339
1340 break;
1341 case E_INVALID:
1342 case E_NOTFOUND:
1343 {
1344
1345 //check if there are other readers to ask, and if not send NOT_FOUND to client
1346 ert->rcEx = ea->rcEx;
1347 cs_strncpy(ert->msglog, ea->msglog, sizeof(ert->msglog));
1348
1349 for(ea_list = ert->matching_rdr; ea_list; ea_list = ea_list->next)
1350 {
1351 cs_readlock(__func__, &ea_list->ecmanswer_lock);
1352
1353 if((!(ea_list->status & READER_FALLBACK) && ((ea_list->status & (REQUEST_SENT | REQUEST_ANSWERED | READER_LOCAL | READER_ACTIVE)) == (REQUEST_SENT | READER_LOCAL | READER_ACTIVE))) || ea_list->rc < E_NOTFOUND)
1354 { local_left++; }
1355
1356 if((!(ea_list->status & READER_FALLBACK) && ((ea_list->status & (REQUEST_SENT | REQUEST_ANSWERED | READER_ACTIVE)) == (REQUEST_SENT | READER_ACTIVE))) || ea_list->rc < E_NOTFOUND)
1357 { reader_not_flb_left++; }
1358
1359 if(((ea_list->status & (REQUEST_ANSWERED | READER_ACTIVE)) == (READER_ACTIVE)) || ea_list->rc < E_NOTFOUND)
1360 { reader_left++; }
1361
1362 if(((ea_list->status & (READER_FALLBACK | READER_ACTIVE))) == (READER_ACTIVE))
1363 { has_not_fallback = 1; }
1364 if(((ea_list->status & (READER_LOCAL | READER_FALLBACK | READER_ACTIVE))) == (READER_LOCAL | READER_ACTIVE))
1365 { has_local = 1; }
1366
1367 cs_readunlock(__func__, &ea_list->ecmanswer_lock);
1368 }
1369
1370 switch(ert->stage)
1371 {
1372 case 2: // only local reader (used only if preferlocalcards=1)
1373 {
1374 if(has_local && !local_left) { request_cw_from_readers(ert, 0); }
1375 break;
1376 }
1377 case 3:
1378 {
1379 // any fallback reader not asked yet
1380 if(has_not_fallback && !reader_not_flb_left) { request_cw_from_readers(ert, 0); }
1381 break;
1382 }
1383 }
1384
1385 if(!reader_left // no more matching reader
1386 #ifdef CS_CACHEEX
1387 && !cfg.wait_until_ctimeout
1388 #endif
1389 )
1390 { ert->rc = E_NOTFOUND; } //so we set the return code
1391
1392 break;
1393 }
1394 case E_TIMEOUT: // if timeout, we have to send timeout to client: this is done by ecm_timeout callback
1395 return;
1396 break;
1397 case E_UNHANDLED:
1398 return;
1399 break;
1400 default:
1401 cs_log("unexpected ecm answer rc=%d.", ea->rc);
1402 return;
1403 break;
1404 }
1405
1406 if(ert->rc < E_99)
1407 send_dcw(ert->client, ert);
1408 }
1409
1410 uint32_t chk_provid(uint8_t *ecm, uint16_t caid)
1411 {
1412 int32_t i, len, descriptor_length = 0;
1413 uint32_t provid = 0;
1414
1415 switch(caid >> 8)
1416 {
1417 case 0x01:
1418 // seca
1419 provid = b2i(2, ecm + 3);
1420 break;
1421 case 0x05:
1422 // viaccess
1423 i = (ecm[4] == 0xD2) ? ecm[5] + 2 : 0; // skip d2 nano
1424 if((ecm[5 + i] == 3) && ((ecm[4 + i] == 0x90) || (ecm[4 + i] == 0x40)))
1425 { provid = (b2i(3, ecm + 6 + i) & 0xFFFFF0); }
1426
1427 i = (ecm[6] == 0xD2) ? ecm[7] + 2 : 0; // skip d2 nano long ecm
1428 if((ecm[7 + i] == 7) && ((ecm[6 + i] == 0x90) || (ecm[6 + i] == 0x40)))
1429 { provid = (b2i(3, ecm + 8 + i) & 0xFFFFF0); }
1430
1431 break;
1432 case 0x0D:
1433 // cryptoworks
1434 len = (((ecm[1] & 0xf) << 8) | ecm[2]) + 3;
1435 for(i = 8; i < len; i += descriptor_length + 2)
1436 {
1437 descriptor_length = ecm[i + 1];
1438 if(ecm[i] == 0x83)
1439 {
1440 provid = (uint32_t)ecm[i + 2] & 0xFE;
1441 break;
1442 }
1443 }
1444 break;
1445
1446 case 0x18:
1447 // nagra2
1448 if (caid == 0x1801) // more safety
1449 provid = b2i(2, ecm + 5);
1450 break;
1451 }
1452
1453 return provid;
1454 }
1455
1456 void update_chid(ECM_REQUEST *er)
1457 {
1458 er->chid = get_subid(er);
1459 }
1460
1461 /*
1462 * This function writes the current CW from ECM struct to a cwl file.
1463 * The filename is re-calculated and file re-opened every time.
1464 * This will consume a bit cpu time, but nothing has to be stored between
1465 * each call. If not file exists, a header is prepended
1466 */
1467 static void logCWtoFile(ECM_REQUEST *er, uchar *cw)
1468 {
1469 FILE *pfCWL;
1470 char srvname[CS_SERVICENAME_SIZE];
1471 /* %s / %s _I %04X _ %s .cwl */
1472 char buf[256 + sizeof(srvname)];
1473 char date[9];
1474 unsigned char i, parity, writeheader = 0;
1475 struct tm timeinfo;
1476
1477 /*
1478 * search service name for that id and change characters
1479 * causing problems in file name
1480 */
1481
1482 get_servicename(cur_client(), er->srvid, er->prid, er->caid, srvname, sizeof(srvname));
1483
1484 for(i = 0; srvname[i]; i++)
1485 if(srvname[i] == ' ') { srvname[i] = '_'; }
1486
1487 /* calc log file name */
1488 time_t walltime = cs_time();
1489 localtime_r(&walltime, &timeinfo);
1490 strftime(date, sizeof(date), "%Y%m%d", &timeinfo);
1491 snprintf(buf, sizeof(buf), "%s/%s_I%04X_%s.cwl", cfg.cwlogdir, date, er->srvid, srvname);
1492
1493 /* open failed, assuming file does not exist, yet */
1494 if((pfCWL = fopen(buf, "r")) == NULL)
1495 {
1496 writeheader = 1;
1497 }
1498 else
1499 {
1500 /* we need to close the file if it was opened correctly */
1501 fclose(pfCWL);
1502 }
1503
1504 if((pfCWL = fopen(buf, "a+")) == NULL)
1505 {
1506 /* maybe this fails because the subdir does not exist. Is there a common function to create it?
1507 for the moment do not print32_t to log on every ecm
1508 cs_log(""error opening cw logfile for writing: %s (errno=%d %s)", buf, errno, strerror(errno)); */
1509 return;
1510 }
1511 if(writeheader)
1512 {
1513 /* no global macro for cardserver name :( */
1514 fprintf(pfCWL, "# OSCam cardserver v%s - http://www.streamboard.tv/oscam/\n", CS_VERSION);
1515 fprintf(pfCWL, "# control word log file for use with tsdec offline decrypter\n");
1516 strftime(buf, sizeof(buf), "DATE %Y-%m-%d, TIME %H:%M:%S, TZ %Z\n", &timeinfo);
1517 fprintf(pfCWL, "# %s", buf);
1518 fprintf(pfCWL, "# CAID 0x%04X, SID 0x%04X, SERVICE \"%s\"\n", er->caid, er->srvid, srvname);
1519 }
1520
1521 parity = er->ecm[0] & 1;
1522 fprintf(pfCWL, "%d ", parity);
1523 for(i = parity * 8; i < 8 + parity * 8; i++)
1524 { fprintf(pfCWL, "%02X ", cw[i]); }
1525 /* better use incoming time er->tps rather than current time? */
1526 strftime(buf, sizeof(buf), "%H:%M:%S\n", &timeinfo);
1527 fprintf(pfCWL, "# %s", buf);
1528 fflush(pfCWL);
1529 fclose(pfCWL);
1530 }
1531
1532 int32_t write_ecm_answer(struct s_reader *reader, ECM_REQUEST *er, int8_t rc, uint8_t rcEx, uint8_t *cw, char *msglog, uint16_t used_cardtier, EXTENDED_CW* cw_ex)
1533 {
1534 if(!reader || !er || !er->tps.time) { return 0; }
1535
1536 // drop too late answers, to avoid seg fault --> only answer until tps.time+((cfg.ctimeout+500)/1000+1) is accepted
1537 time_t timeout = time(NULL) - ((cfg.ctimeout+500)/1000+1);
1538 if(er->tps.time < timeout) //< and NOT <=
1539 { return 0; }
1540
1541 int32_t i;
1542 uint8_t c;
1543 struct timeb now;
1544 cs_ftime(&now);
1545
1546 if(er && er->parent)
1547 {
1548 // parent is only set on reader->client->ecmtask[], but we want original er
1549 ECM_REQUEST *er_reader_cp = er;
1550 er = er->parent; //Now er is "original" ecm, before it was the reader-copy
1551 er_reader_cp->rc = rc;
1552 er_reader_cp->idx = 0;
1553
1554 timeout = time(NULL) - ((cfg.ctimeout+500)/1000+1);
1555 if(er->tps.time < timeout)
1556 { return 0; }
1557 }
1558
1559 struct s_ecm_answer *ea = get_ecm_answer(reader, er);
1560 if(!ea) { return 0; }
1561
1562 cs_writelock(__func__, &ea->ecmanswer_lock);
1563
1564 if((ea->status & REQUEST_ANSWERED))
1565 {
1566 cs_log_dbg(D_READER, "Reader %s already answer, skip this ecm answer!", reader ? reader->label : "-");
1567 cs_writeunlock(__func__, &ea->ecmanswer_lock);
1568 return 0;
1569 }
1570
1571 //SPECIAL CHECKs for rc
1572 if(rc < E_NOTFOUND && cw && chk_is_null_CW(cw) && er->caid !=0x2600) // 0x2600 used by biss and constant cw could be zero but still catch cw=0 by anticascading
1573 {
1574 rc = E_NOTFOUND;
1575 cs_log_dbg(D_TRACE | D_LB, "WARNING: reader %s send fake cw, set rc=E_NOTFOUND!", reader ? reader->label : "-");
1576 }
1577
1578
1579
1580 if(rc < E_NOTFOUND && cw && !chk_halfCW(er,cw)){
1581 rc = E_NOTFOUND;
1582 cs_log_dbg(D_TRACE | D_LB, "WARNING: reader %s send wrong swapped NDS cw, set rc=E_NOTFOUND!", reader ? reader->label : "-");
1583 }
1584
1585
1586 if(reader && cw && rc < E_NOTFOUND)
1587 {
1588 if(cfg.disablecrccws == 0 && reader->disablecrccws == 0)
1589 {
1590 uint8_t selectedForIgnChecksum = chk_if_ignore_checksum(er, cfg.disablecrccws, &cfg.disablecrccws_only_for)
1591 + chk_if_ignore_checksum(er, reader->disablecrccws, &reader->disablecrccws_only_for);
1592
1593 for(i = 0; i < 16; i += 4)
1594 {
1595 c = ((cw[i] + cw[i + 1] + cw[i + 2]) & 0xff);
1596
1597 if((i!=12) && selectedForIgnChecksum && (cw[i + 3] != c)){
1598 cs_log_dbg(D_TRACE, "notice: CW checksum check disabled for %04X:%06X", er->caid, er->prid);
1599 break;
1600 }
1601
1602 if(cw[i + 3] != c)
1603 {
1604 unsigned char nano = 0x00;
1605 if(er->caid == 0x100 && er->ecm[5] > 0x00)
1606 {
1607 nano = er->ecm[5]; // seca nano protection
1608 }
1609
1610 if(reader->dropbadcws && !nano) // only drop controlword if no cw encryption is applied
1611 {
1612 rc = E_NOTFOUND;
1613 rcEx = E2_WRONG_CHKSUM;
1614 break;
1615 }
1616 else
1617 {
1618 if(!nano) // only fix checksum if no cw encryption is applied (nano = 0)
1619 {
1620 cs_log_dbg(D_TRACE, "notice: changed dcw checksum byte cw[%i] from %02x to %02x", i + 3, cw[i + 3], c);
1621 cw[i + 3] = c;
1622 }
1623 else
1624 {
1625 if(i==12) // there are servers delivering correct controlwords but with failing last cw checksum (on purpose?!)
1626 {
1627 cs_log_dbg(D_TRACE,"NANO%02d: BAD PEER DETECTED, oscam has fixed the last cw crc that wasn't matching!", nano);
1628 cw[i + 3] = c; // fix the last controlword
1629 }
1630 else
1631 {
1632 cs_log_dbg(D_TRACE,"NANO%02d: not fixing the crc of this cw since its still encrypted!", nano);
1633 break; // crc failed so stop!
1634 }
1635 }
1636 }
1637 }
1638 }
1639 }
1640 else
1641 {
1642 cs_log_dbg(D_TRACE, "notice: CW checksum check disabled");
1643 }
1644 }
1645
1646 #ifdef CW_CYCLE_CHECK
1647 uint8_t cwc_ct = er->cwc_cycletime > 0 ? er->cwc_cycletime : 0;
1648 uint8_t cwc_ncwc = er->cwc_next_cw_cycle < 2 ? er->cwc_next_cw_cycle : 2;
1649 if(!checkcwcycle(er->client, er, reader, cw, rc, cwc_ct, cwc_ncwc))
1650 {
1651 rc = E_NOTFOUND;
1652 rcEx = E2_WRONG_CHKSUM;
1653 cs_log_dbg(D_CACHEEX | D_CWC | D_LB, "{client %s, caid %04X, srvid %04X} [write_ecm_answer] cyclecheck failed! Reader: %s set rc: %i", (er->client ? er->client->account->usr : "-"), er->caid, er->srvid, reader ? reader->label : "-", rc);
1654 }
1655 else { cs_log_dbg(D_CACHEEX | D_CWC | D_LB, "{client %s, caid %04X, srvid %04X} [write_ecm_answer] cyclecheck passed! Reader: %s rc: %i", (er->client ? er->client->account->usr : "-"), er->caid, er->srvid, reader ? reader->label : "-", rc); }
1656 #endif
1657 //END -- SPECIAL CHECKs for rc
1658
1659
1660 ea->status |= REQUEST_ANSWERED;
1661 ea->rc = rc;
1662 ea->ecm_time = comp_timeb(&now, &ea->time_request_sent);
1663 if(ea->ecm_time < 1) { ea->ecm_time = 1; } //set ecm_time 1 if answer immediately
1664 ea->rcEx = rcEx;
1665 if(cw) { memcpy(ea->cw, cw, 16); }
1666 if(msglog) { memcpy(ea->msglog, msglog, MSGLOGSIZE); }
1667 ea->tier = used_cardtier;
1668 if(cw_ex)
1669 {
1670 ea->cw_ex = *cw_ex;
1671 }
1672
1673 cs_writeunlock(__func__, &ea->ecmanswer_lock);
1674
1675 struct timeb tpe;
1676 cs_ftime(&tpe);
1677 int32_t ntime = comp_timeb(&tpe, &er->tps);
1678 if(ntime < 1) { ntime = 1; }
1679 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [write_ecm_answer] reader %s rc %d, ecm time %d ms (%d ms)", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, reader ? reader->label : "-", rc, ea->ecm_time, ntime);
1680
1681 //send ea for ecm request
1682 int32_t res = 0;
1683 struct s_client *cl = er->client;
1684 if(check_client(cl))
1685 {
1686 res = 1;
1687 add_job(er->client, ACTION_ECM_ANSWER_READER, ea, 0); //chk_dcw
1688 }
1689
1690 //distribute ea for pendings
1691 if(ea->pending) //has pending ea
1692 { distribute_ea(ea); }
1693
1694
1695 if(!ea->is_pending) //not for pending ea - only once for ea
1696 {
1697 //cache update
1698 if(ea && (ea->rc < E_NOTFOUND) && (!chk_is_null_CW(ea->cw) && er->caid !=0x2600)) // 0x2600 used by biss and constant cw could be indeed zero
1699 add_cache_from_reader(er, reader, er->csp_hash, er->ecmd5, ea->cw, er->caid, er->prid, er->srvid );
1700
1701 //readers stats for LB
1702 send_reader_stat(reader, er, ea, ea->rc);
1703
1704 //reader checks
1705 char ecmd5[17 * 3];
1706 cs_hexdump(0, er->ecmd5, 16, ecmd5, sizeof(ecmd5));
1707 rdr_log_dbg(reader, D_TRACE, "ecm answer for ecm hash %s rc=%d", ecmd5, ea->rc);
1708
1709 //Update reader stats:
1710 if(ea->rc == E_FOUND)
1711 {
1712 if(cfg.cwlogdir != NULL)
1713 { logCWtoFile(er, ea->cw); } /* CWL logging only if cwlogdir is set in config */
1714
1715 reader->ecmsok++;
1716 reader->webif_ecmsok++;
1717 #ifdef CS_CACHEEX
1718 struct s_client *eacl = reader->client;
1719 if(cacheex_reader(reader) && check_client(eacl))
1720 {
1721 eacl->cwcacheexgot++;
1722 cacheex_add_stats(eacl, ea->er->caid, ea->er->srvid, ea->er->prid, 1);
1723 first_client->cwcacheexgot++;
1724 }
1725 #endif
1726 }
1727 else if(ea->rc == E_NOTFOUND)
1728 {
1729 reader->ecmsnok++;
1730 reader->webif_ecmsnok++;
1731 if(reader->ecmnotfoundlimit && reader->ecmsnok >= reader->ecmnotfoundlimit)
1732 {
1733 rdr_log(reader, "ECM not found limit reached %u. Restarting the reader.",
1734 reader->ecmsnok);
1735 reader->ecmsnok = 0; // Reset the variable
1736 reader->ecmshealthnok = 0; // Reset the variable
1737 add_job(reader->client, ACTION_READER_RESTART, NULL, 0);
1738 }
1739 }
1740
1741 // this fixes big oscam mistake - wrong reader status on web info aka not counted timeouts which dispalyed reader info 100 percent OK but reader had a ton of unhandled timeouts!
1742 else if(ea->rc == E_TIMEOUT)
1743 {
1744 #ifdef WITH_LB
1745 STAT_QUERY q;
1746 readerinfofix_get_stat_query(er, &q);
1747 READER_STAT *s;
1748 s = readerinfofix_get_add_stat(reader, &q);
1749 if (s)
1750 {
1751 cs_log_dbg(D_LB, "inc fail {client %s, caid %04X, prid %06X, srvid %04X} [write_ecm_answer] reader %s rc %d, ecm time %d ms (%d ms)", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, reader ? reader->label : "-", rc, ea->ecm_time, ntime);
1752 readerinfofix_inc_fail(s); //now increase fail factor for unhandled timeouts
1753 }
1754 #endif
1755 reader->ecmstout++; //now append timeouts to the readerinfo timeout count
1756 reader->webif_ecmstout++;
1757 }
1758
1759 //Reader ECMs Health Try (by Pickser)
1760 if(reader->ecmsok != 0 || reader->ecmsnok != 0 || reader->ecmstout != 0)
1761 {
1762 reader->ecmshealthok = ((double) reader->ecmsok / (reader->ecmsok + reader->ecmsnok + reader->ecmstout)) * 100;
1763 reader->ecmshealthnok = ((double) reader->ecmsnok / (reader->ecmsok + reader->ecmsnok + reader->ecmstout)) * 100;
1764 reader->ecmshealthtout = ((double) reader->ecmstout / (reader->ecmsok + reader->ecmsnok + reader->ecmstout)) * 100;
1765 }
1766
1767 if(rc == E_FOUND && reader->resetcycle > 0)
1768 {
1769 reader->resetcounter++;
1770 if(reader->resetcounter > reader->resetcycle)
1771 {
1772 reader->resetcounter = 0;
1773 rdr_log(reader, "Resetting reader, resetcyle of %d ecms reached", reader->resetcycle);
1774 reader->card_status = CARD_NEED_INIT;
1775 cardreader_reset(cl);
1776 }
1777 }
1778 }
1779
1780 return res;
1781 }
1782
1783 static void guess_cardsystem(ECM_REQUEST *er)
1784 {
1785 uint16_t last_hope = 0;
1786
1787 // viaccess - check by provid-search
1788 if((er->prid = chk_provid(er->ecm, 0x500)))
1789 { er->caid = 0x500; }
1790
1791 // nagra
1792 // is ecm[1] always 0x30 ?
1793 // is ecm[3] always 0x07 ?
1794 if((er->ecm[6] == 1) && (er->ecm[4] == er->ecm[2] - 2))
1795 { er->caid = 0x1801; }
1796
1797 // seca2 - very poor
1798 if((er->ecm[8] == 0x10) && ((er->ecm[9] & 0xF1) == 1))
1799 { last_hope = 0x100; }
1800
1801 // is cryptoworks, but which caid ?
1802 if((er->ecm[3] == 0x81) && (er->ecm[4] == 0xFF) &&
1803 (!er->ecm[5]) && (!er->ecm[6]) && (er->ecm[7] == er->ecm[2] - 5))
1804 {
1805 last_hope = 0xd00;
1806 }
1807
1808 if(!er->caid && er->ecm[2] == 0x31 && er->ecm[0x0b] == 0x28)
1809 { guess_irdeto(er); }
1810
1811 if(!er->caid) // guess by len ..
1812 { er->caid = len4caid[er->ecm[2] + 3]; }
1813
1814 if(!er->caid)
1815 { er->caid = last_hope; }
1816 }
1817
1818 //chid calculation from module stat to here
1819 //to improve the quickfix concerning ecm chid info and extend it to all client requests wereby the chid is known in module stat
1820
1821 uint32_t get_subid(ECM_REQUEST *er)
1822 {
1823 if(!er->ecmlen)
1824 { return 0; }
1825
1826 uint32_t id = 0;
1827 switch(er->caid >> 8)
1828 {
1829 case 0x01:
1830 id = b2i(2, er->ecm + 7);
1831 break; // seca
1832 case 0x05:
1833 id = b2i(2, er->ecm + 8);
1834 break; // viaccess
1835 case 0x06:
1836 id = b2i(2, er->ecm + 6);
1837 break; // irdeto
1838 case 0x09:
1839 id = b2i(2, er->ecm + 11);
1840 break; // videoguard
1841 case 0x4A: // DRE-Crypt, Bulcrypt, Tongfang and others?
1842 if(!caid_is_bulcrypt(er->caid) && !caid_is_dre(er->caid))
1843 { id = b2i(2, er->ecm + 6); }
1844 break;
1845 }
1846 return id;
1847 }
1848
1849
1850 static void set_readers_counter(ECM_REQUEST *er)
1851 {
1852 struct s_ecm_answer *ea;
1853
1854 er->reader_count = 0;
1855 er->fallback_reader_count = 0;
1856 er->localreader_count = 0;
1857 er->cacheex_reader_count = 0;
1858
1859 for(ea = er->matching_rdr; ea; ea = ea->next)
1860 {
1861 if(ea->status & READER_ACTIVE)
1862 {
1863 if(!(ea->status & READER_FALLBACK))
1864 { er->reader_count++; }
1865 else
1866 { er->fallback_reader_count++; }
1867
1868 if(cacheex_reader(ea->reader))
1869 { er->cacheex_reader_count++; }
1870 else if(is_localreader(ea->reader, er))
1871 { er->localreader_count++; }
1872 }
1873 }
1874 }
1875
1876
1877 void write_ecm_answer_fromcache(struct s_write_from_cache *wfc)
1878 {
1879 ECM_REQUEST *er = NULL;
1880 ECM_REQUEST *ecm = NULL;
1881
1882 er = wfc->er_new;
1883 ecm = wfc->er_cache;
1884
1885 int8_t rc_orig = er->rc;
1886
1887 er->grp |= ecm->grp; //update group
1888 #ifdef CS_CACHEEX
1889 if(ecm->from_csp) { er->csp_answered = 1; } //update er as answered by csp (csp have no group)
1890 #endif
1891
1892 if(er->rc >= E_NOTFOUND)
1893 {
1894 #ifdef CS_CACHEEX
1895 if(ecm->cacheex_src) //from cacheex or csp
1896 {
1897 er->rc = E_CACHEEX;
1898 }
1899 else
1900 #endif
1901 { er->rc=E_CACHE1; } //from normal readers
1902
1903 memcpy(er->cw, ecm->cw, 16);
1904 er->selected_reader = ecm->selected_reader;
1905 er->cw_count = ecm->cw_count;
1906
1907 #ifdef CS_CACHEEX
1908 if(ecm->cacheex_src && is_valid_client(ecm->cacheex_src) && !ecm->cacheex_src->kill){ //here we should be sure cex client has not been freed!
1909 er->cacheex_src = ecm->cacheex_src;
1910 er->cwc_cycletime = ecm->cwc_cycletime;
1911 er->cwc_next_cw_cycle = ecm->cwc_next_cw_cycle;
1912 }else{
1913 er->cacheex_src = NULL;
1914 }
1915
1916 int8_t cacheex = check_client(er->client) && er->client->account ? er->client->account->cacheex.mode : 0;
1917 if(cacheex == 1 && check_client(er->client))
1918 {
1919 cacheex_add_stats(er->client, er->caid, er->srvid, er->prid, 0);
1920 er->client->cwcacheexpush++;
1921 if(er->client->account)
1922 { er->client->account->cwcacheexpush++; }
1923 first_client->cwcacheexpush++;
1924 }
1925 #endif
1926
1927 #ifdef CS_CACHEEX
1928 if(cfg.delay && cacheex!=1) //No delay on cacheexchange mode 1 client!
1929 { cs_sleepms(cfg.delay); }
1930 #else
1931 if(cfg.delay)
1932 { cs_sleepms(cfg.delay); }
1933 #endif
1934
1935 if(rc_orig == E_UNHANDLED)
1936 {
1937 cs_log_dbg(D_LB,"{client %s, caid %04X, prid %06X, srvid %04X} [write_ecm_answer_fromcache] found cw in CACHE (count %d)!", (check_client(er->client)?er->client->account->usr:"-"),er->caid, er->prid, er->srvid, er->cw_count);
1938 send_dcw(er->client, er);
1939 }
1940 }
1941 }
1942
1943 void get_cw(struct s_client *client, ECM_REQUEST *er)
1944 {
1945 cs_log_dump_dbg(D_ATR, er->ecm, er->ecmlen, "get cw for ecm:");
1946 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [get_cw] NEW REQUEST!", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid);
1947 increment_n_request(client);
1948
1949 int32_t i, j, m;
1950 time_t now = time((time_t *)0);
1951 uint32_t line = 0;
1952 uint16_t sct_len;
1953
1954 er->client = client;
1955 er->rc = E_UNHANDLED; // set default rc status to unhandled
1956 er->cwc_next_cw_cycle = 2; //set it to: we dont know
1957 if(now - client->lastecm > cfg.hideclient_to) { client->lastswitch = 0; } // user was on freetv or didn't request for some time so we reset lastswitch to get correct stats/webif display
1958 client->lastecm = now;
1959
1960 if(client == first_client || !client ->account || client->account == first_client->account)
1961 {
1962 //DVBApi+serial is allowed to request anonymous accounts:
1963 int16_t listenertype = get_module(client)->listenertype;
1964 if(listenertype != LIS_DVBAPI && listenertype != LIS_SERIAL)
1965 {
1966 er->rc = E_INVALID;
1967 er->rcEx = E2_GLOBAL;
1968 snprintf(er->msglog, sizeof(er->msglog), "invalid user account %s", username(client));
1969 }
1970 }
1971
1972 // ecmlen must be 0 (no ecm) or >2 (because SCT_LEN() needs at least 3 bytes)
1973 if(er->ecmlen < 0 || er->ecmlen == 1 || er->ecmlen == 2)
1974 {
1975 er->rc = E_INVALID;
1976 er->rcEx = E2_GLOBAL;
1977 snprintf(er->msglog, sizeof(er->msglog), "ECM size %d invalid, ignored! client %s", er->ecmlen, username(client));
1978 }
1979
1980 if(er->ecmlen > MAX_ECM_SIZE)
1981 {
1982 er->rc = E_INVALID;
1983 er->rcEx = E2_GLOBAL;
1984 snprintf(er->msglog, sizeof(er->msglog), "ECM size %d > Max ECM size %d, ignored! client %s", er->ecmlen, MAX_ECM_SIZE, username(client));
1985 }
1986
1987 if(er->ecmlen > 2)
1988 {
1989 sct_len = SCT_LEN(er->ecm);
1990 if(sct_len > er->ecmlen)
1991 {
1992 er->rc = E_INVALID;
1993 er->rcEx = E2_GLOBAL;
1994 snprintf(er->msglog, sizeof(er->msglog), "Real ECM size %d > ECM size %d, ignored! client %s", sct_len, er->ecmlen, username(client));
1995 }
1996 er->ecmlen = sct_len;
1997 }
1998
1999 if(!client->grp)
2000 {
2001 er->rc = E_INVALID;
2002 er->rcEx = E2_GROUP;
2003 snprintf(er->msglog, sizeof(er->msglog), "invalid user group %s", username(client));
2004 }
2005
2006
2007 if(!er->caid)
2008 { guess_cardsystem(er); }
2009
2010 /* Quickfix Area */
2011
2012 // add chid for all client requests as in module stat
2013 update_chid(er);
2014
2015 // quickfix for 0100:000065
2016 if(er->caid == 0x100 && er->prid == 0x65 && er->srvid == 0)
2017 { er->srvid = 0x0642; }
2018
2019 // Quickfixes for Opticum/Globo HD9500
2020 // Quickfix for 0500:030300
2021 if(er->caid == 0x500 && er->prid == 0x030300)
2022 { er->prid = 0x030600; }
2023
2024 // Quickfix for 0500:D20200
2025 if(er->caid == 0x500 && er->prid == 0xD20200)
2026 { er->prid = 0x030600; }
2027
2028 //betacrypt ecm with nagra header
2029 if(chk_is_betatunnel_caid(er->caid) == 1 && (er->ecmlen == 0x89 || er->ecmlen == 0x4A) && er->ecm[3] == 0x07 && (er->ecm[4] == 0x84 || er->ecm[4] == 0x45))
2030 {
2031 if(er->caid == 0x1702)
2032 {
2033 er->caid = 0x1833;
2034 }
2035 else
2036 {
2037 check_lb_auto_betatunnel_mode(er);
2038 }
2039 cs_log_dbg(D_TRACE, "Quickfix remap beta->nagra: 0x%X, 0x%X, 0x%X, 0x%X", er->caid, er->ecmlen, er->ecm[3], er->ecm[4]);
2040 }
2041
2042 //nagra ecm with betacrypt header 1801, 1833, 1834, 1835
2043 if(chk_is_betatunnel_caid(er->caid) == 2 && (er->ecmlen == 0x93 || er->ecmlen == 0x54) && er->ecm[13] == 0x07 && (er->ecm[14] == 0x84 || er->ecm[14] == 0x45))
2044 {
2045 if(er->caid == 0x1833)
2046 {
2047 er->caid = 0x1702;
2048 }
2049 else
2050 {
2051 er->caid = 0x1722;
2052 }
2053 cs_log_dbg(D_TRACE, "Quickfix remap nagra->beta: 0x%X, 0x%X, 0x%X, 0x%X", er->caid, er->ecmlen, er->ecm[13], er->ecm[44]);
2054 }
2055
2056 //Ariva quickfix (invalid nagra provider)
2057 if(((er->caid & 0xFF00) == 0x1800) && er->prid > 0x00FFFF)
2058 { er->prid = 0; }
2059
2060 //Check for invalid provider, extract provider out of ecm:
2061 uint32_t prid = chk_provid(er->ecm, er->caid);
2062 if(!er->prid)
2063 {
2064 er->prid = prid;
2065 }
2066 else
2067 {
2068 if(prid && prid != er->prid)
2069 {
2070 cs_log_dbg(D_TRACE, "provider fixed: %04X@%06X to %04X@%06X", er->caid, er->prid, er->caid, prid);
2071 er->prid = prid;
2072 }
2073 }
2074
2075 #ifdef MODULE_NEWCAMD
2076 // Set providerid for newcamd clients if none is given
2077 if(!er->prid && client->ncd_server)
2078 {
2079 int32_t pi = client->port_idx;
2080 if(pi >= 0 && cfg.ncd_ptab.nports && cfg.ncd_ptab.nports >= pi && cfg.ncd_ptab.ports[pi].ncd)
2081 { er->prid = cfg.ncd_ptab.ports[pi].ncd->ncd_ftab.filts[0].prids[0]; }
2082 }
2083 #endif
2084
2085 // CAID not supported or found
2086 if(!er->caid)
2087 {
2088 er->rc = E_INVALID;
2089 er->rcEx = E2_CAID;
2090 snprintf(er->msglog, MSGLOGSIZE, "CAID not supported or found");
2091 }
2092
2093 // user expired
2094 if(client->expirationdate && client->expirationdate < client->lastecm)
2095 { er->rc = E_EXPDATE; }
2096
2097 // out of timeframe
2098 if(client->allowedtimeframe_set)
2099 {
2100 struct tm acttm;
2101 localtime_r(&now, &acttm);
2102 int32_t curday = acttm.tm_wday;
2103 char *dest = strstr(weekdstr,"ALL");
2104 int32_t all_idx = (dest - weekdstr)/3;
2105 uint8_t allowed=0;
2106
2107 // checkout if current time is allowed in the current day
2108 allowed = CHECK_BIT(client->allowedtimeframe[curday][acttm.tm_hour][acttm.tm_min/30], (acttm.tm_min % 30));
2109
2110 // or checkout if current time is allowed for all days
2111 allowed |= CHECK_BIT(client->allowedtimeframe[all_idx][acttm.tm_hour][acttm.tm_min/30], (acttm.tm_min % 30));
2112
2113 if(!(allowed))
2114 {
2115 er->rc = E_EXPDATE;
2116 }
2117 cs_log_dbg(D_TRACE, "Check Timeframe - result: %d, day:%s time: %02dH%02d, allowed: %s\n", er->rc, shortDay[curday], acttm.tm_hour, acttm.tm_min, allowed ? "true" : "false");
2118 }
2119
2120 // user disabled
2121 if(client->disabled != 0)
2122 {
2123 if(client->failban & BAN_DISABLED)
2124 {
2125 cs_add_violation(client, client->account->usr);
2126 cs_disconnect_client(client);
2127 }
2128 er->rc = E_DISABLED;
2129 }
2130
2131 if(!chk_global_whitelist(er, &line))
2132 {
2133 debug_ecm(D_TRACE, "whitelist filtered: %s (%s) line %d", username(client), buf, line);
2134 er->rc = E_INVALID;
2135 }
2136
2137 #ifdef CS_CACHEEX
2138 if(client->account && client->account->cacheex.mode==2 && !client->account->cacheex.allow_request)
2139 {
2140 er->rc = E_INVALID;
2141 snprintf(er->msglog, MSGLOGSIZE, "invalid request form cacheex-2 client");
2142 }
2143 #endif
2144
2145
2146 // rc<100 -> ecm error
2147 if(er->rc >= E_UNHANDLED)
2148 {
2149 m = er->caid;
2150 i = er->srvid;
2151
2152 if(i != client->last_srvid || !client->lastswitch)
2153 {
2154 if(cfg.usrfileflag)
2155 { cs_statistics(client); }
2156 client->lastswitch = now;
2157 }
2158
2159 // user sleeping
2160 if(client->tosleep && (now - client->lastswitch > client->tosleep))
2161 {
2162 if(client->failban & BAN_SLEEPING)
2163 {
2164 cs_add_violation(client, client->account->usr);
2165 cs_disconnect_client(client);
2166 }
2167 if(client->c35_sleepsend != 0)
2168 {
2169 er->rc = E_STOPPED; // send sleep command CMD08 {00 255}
2170 }
2171 else
2172 {
2173 er->rc = E_SLEEPING;
2174 }
2175 }
2176
2177 client->last_srvid = i;
2178 client->last_caid = m;
2179 client->last_provid = er->prid;
2180
2181 int32_t ecm_len = (((er->ecm[1] & 0x0F) << 8) | er->ecm[2]) + 3;
2182
2183 for(j = 0; (j < 6) && (er->rc >= E_UNHANDLED); j++)
2184 {
2185 switch(j)
2186 {
2187 case 0:
2188 // fake (uniq)
2189 if(client->dup)
2190 { er->rc = E_FAKE; }
2191 break;
2192 case 1:
2193 // invalid (caid)
2194 if(!chk_bcaid(er, &client->ctab))
2195 {
2196 er->rc = E_INVALID;
2197 er->rcEx = E2_CAID;
2198 snprintf(er->msglog, MSGLOGSIZE, "invalid caid 0x%04X", er->caid);
2199 }
2200 break;
2201 case 2:
2202 // invalid (srvid)
2203 // matching srvids (or 0000) specified in betatunnel will bypass this filter
2204 if(!chk_srvid(client, er))
2205 {
2206 if(!chk_on_btun(SRVID_ZERO, client, er))
2207 {
2208 er->rc = E_INVALID;
2209 snprintf(er->msglog, MSGLOGSIZE, "invalid SID");
2210 }
2211 }
2212 break;
2213 case 3:
2214 // invalid (ufilters)
2215 if(!chk_ufilters(er))
2216 { er->rc = E_INVALID; }
2217 break;
2218 case 4:
2219 // invalid (sfilter)
2220 if(!chk_sfilter(er, &get_module(client)->ptab))
2221 { er->rc = E_INVALID; }
2222 break;
2223 case 5:
2224 // corrupt
2225 if((i = er->ecmlen - ecm_len))
2226 {
2227 if(i > 0)
2228 {
2229 cs_log_dbg(D_TRACE, "warning: ecm size adjusted from %d to %d", er->ecmlen, ecm_len);
2230 er->ecmlen = ecm_len;
2231 }
2232 else
2233 { er->rc = E_CORRUPT; }
2234 }
2235 break;
2236 }
2237 }
2238 }
2239
2240 //checks for odd/even byte
2241 if(!caid_is_biss(er->caid) && !caid_is_fake(er->caid) && get_odd_even(er)==0){
2242 cs_log_dbg(D_TRACE, "warning: ecm with null odd/even byte from %s", (check_client(er->client)?er->client->account->usr:"-"));
2243 er->rc = E_INVALID;
2244 }
2245
2246 //not continue, send rc to client
2247 if(er->rc < E_UNHANDLED)
2248 {
2249 send_dcw(client, er);
2250 free_ecm(er);
2251 return;
2252 }
2253
2254
2255 #ifdef CS_CACHEEX
2256 int8_t cacheex = client->account ? client->account->cacheex.mode : 0;
2257 er->from_cacheex1_client = 0;
2258 if(cacheex == 1) {er->from_cacheex1_client = 1;}
2259 #endif
2260
2261
2262 //set preferlocalcards for this ecm request (actually, paramter is per user based, maybe in fiture it will be caid based too)
2263 er->preferlocalcards = cfg.preferlocalcards;
2264 if(client->account && client->account->preferlocalcards > -1){
2265 er->preferlocalcards = client->account->preferlocalcards;
2266 }
2267 if(er->preferlocalcards <0 || er->preferlocalcards >2) {er->preferlocalcards=0;}
2268
2269
2270 if(chk_is_betatunnel_caid(er->caid) && client->ttab.ttnum)
2271 {
2272 cs_log_dump_dbg(D_TRACE, er->ecm, 13, "betatunnel? ecmlen=%d", er->ecmlen);
2273 cs_betatunnel(er);
2274 }
2275
2276
2277 // ignore ecm ...
2278 int32_t offset = 3;
2279 // ... and betacrypt header for cache md5 calculation
2280 if(caid_is_betacrypt(er->caid))
2281 { offset = 13; }
2282 unsigned char md5tmp[MD5_DIGEST_LENGTH];
2283 // store ECM in cache
2284 memcpy(er->ecmd5, MD5(er->ecm + offset, er->ecmlen - offset, md5tmp), CS_ECMSTORESIZE);
2285 cacheex_update_hash(er);
2286 ac_chk(client, er, 0);
2287
2288
2289 //******** CHECK IF FOUND ECM IN CACHE
2290 struct ecm_request_t *ecm = NULL;
2291 ecm = check_cache(er, client);
2292 if(ecm) //found in cache
2293 {
2294 cs_log_dbg(D_LB,"{client %s, caid %04X, prid %06X, srvid %04X} [get_cw] cw found immediately in cache! ", (check_client(er->client)?er->client->account->usr:"-"),er->caid, er->prid, er->srvid);
2295
2296 struct s_write_from_cache *wfc = NULL;
2297 if(!cs_malloc(&wfc, sizeof(struct s_write_from_cache)))
2298 {
2299 NULLFREE(ecm);
2300 free_ecm(er);
2301 return;
2302 }
2303
2304 wfc->er_new = er;
2305 wfc->er_cache = ecm;
2306 write_ecm_answer_fromcache(wfc);
2307 NULLFREE(wfc);
2308 NULLFREE(ecm);
2309 free_ecm(er);
2310
2311 return;
2312 }
2313
2314
2315 // zaplist ACoSC
2316 #ifdef CS_ANTICASC
2317 if(cfg.acosc_enabled)
2318 {
2319 cs_writelock(__func__, &clientlist_lock);
2320 insert_zaplist(er, client);
2321 cs_writeunlock(__func__, &clientlist_lock);
2322 }
2323 #endif
2324
2325
2326 er->reader_avail = 0;
2327 er->readers = 0;
2328
2329 struct s_ecm_answer *ea, *prv = NULL;
2330 struct s_reader *rdr;
2331
2332 cs_readlock(__func__, &readerlist_lock);
2333 cs_readlock(__func__, &clientlist_lock);
2334
2335 for(rdr = first_active_reader; rdr; rdr = rdr->next)
2336 {
2337 uint8_t is_fallback = chk_is_fixed_fallback(rdr, er);
2338 int8_t match = matching_reader(er, rdr);
2339
2340 if(!match) // if this reader does not match, check betatunnel for it
2341 match = lb_check_auto_betatunnel(er, rdr);
2342
2343 if(match)
2344 {
2345 er->reader_avail++;
2346
2347 #ifdef CS_CACHEEX
2348 if(cacheex == 1 && !cacheex_reader(rdr)) //ex1-cl only ask ex1-rdr
2349 { continue; }
2350 #endif
2351
2352 if(!cs_malloc(&ea, sizeof(struct s_ecm_answer)))
2353 { goto OUT; }
2354
2355 er->readers++;
2356
2357 ea->reader = rdr;
2358 ea->er = er;
2359 ea->rc = E_UNHANDLED;
2360 if(prv)
2361 { prv->next = ea; }
2362 else
2363 { er->matching_rdr = ea; }
2364 prv = ea;
2365
2366 ea->status = READER_ACTIVE;
2367 if(cacheex_reader(rdr))
2368 { ea->status |= READER_CACHEEX; }
2369 else if(is_localreader(rdr, er))
2370 { ea->status |= READER_LOCAL; }
2371
2372 if(is_fallback && (!is_localreader(rdr, er) || (is_localreader(rdr, er) && !er->preferlocalcards)))
2373 { ea->status |= READER_FALLBACK; }
2374
2375 ea->pending = NULL;
2376 ea->is_pending = false;
2377 cs_lock_create(__func__, &ea->ecmanswer_lock, "ecmanswer_lock", 5000);
2378 }
2379 }
2380
2381 OUT:
2382 cs_readunlock(__func__, &clientlist_lock);
2383 cs_readunlock(__func__, &readerlist_lock);
2384
2385 lb_set_best_reader(er);
2386
2387 //set reader_count and fallback_reader_count
2388 set_readers_counter(er);
2389
2390 //if preferlocalcards>0, check if we have local readers selected: if not, switch to preferlocalcards=0 for this ecm
2391 if(er->preferlocalcards>0){
2392 if(er->localreader_count == 0){
2393 er->preferlocalcards=0;
2394 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} NO local readers, set preferlocalcards = %d", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, er->preferlocalcards);
2395 }
2396 }
2397
2398
2399 #ifdef CS_CACHEEX
2400 //WAIT_TIME
2401 uint32_t cacheex_wait_time = 0;
2402 uint32_t wait_time_no_hitcache = 0;
2403 uint32_t wait_time_hitcache = 0;
2404
2405 if(client->account && !client->account->no_wait_time && er->preferlocalcards<2)
2406 {
2407 wait_time_no_hitcache = get_cacheex_wait_time(er,NULL); //NO check hitcache. Wait_time is dwtime, or, if 0, awtime.
2408 wait_time_hitcache = get_cacheex_wait_time(er,client); //check hitcache for calculating wait_time! If hitcache wait_time is biggest value between dwtime and awtime, else it's awtime.
2409
2410 if(
2411 //If "normal" client and ex1-rdr>0, we cannot use hitcache for calculating wait_time because we cannot know if cw is available or not on ex1 server!
2412 (cacheex != 1 && er->cacheex_reader_count)
2413 ||
2414 /* Cw for ex1-cl comes from: INT. cache by "normal" readers (normal clients that ask normal readers), ex1-rdr and ex2-rdr and ex3-rdr.
2415 * If readers, we have to wait cws generating by normal clients asking normal readers and answers by ex1-rdr (cannot use hitcache).
2416 * If no readers, use hitcache for calculating wait_time.
2417 */
2418 (cacheex == 1 && er->reader_avail)
2419 )
2420 { cacheex_wait_time = wait_time_no_hitcache; }
2421 else
2422 { cacheex_wait_time = wait_time_hitcache; }
2423 }
2424
2425 cs_log_dbg(D_TRACE | D_CACHEEX, "[GET_CW] wait_time %d caid %04X prov %06X srvid %04X rc %d cacheex cl mode %d ex1rdr %d", cacheex_wait_time, er->caid, er->prid, er->srvid, er->rc, cacheex, er->cacheex_reader_count);
2426 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [get_cw] wait_time %d - client cacheex mode %d, reader avail for ecm %d, hitcache %d, preferlocalcards %d", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid, cacheex_wait_time, cacheex == 1 ? 1 : 0, er->reader_avail, wait_time_hitcache ? 1 : 0, er->preferlocalcards);
2427 //END WAIT_TIME calculation
2428
2429 if(!cacheex_wait_time && (er->reader_count + er->fallback_reader_count) == 0)
2430 #else
2431 if((er->reader_count + er->fallback_reader_count) == 0)
2432 #endif
2433 {
2434 er->rc = E_NOTFOUND;
2435 if(!er->rcEx)
2436 { er->rcEx = E2_GROUP; }
2437 snprintf(er->msglog, MSGLOGSIZE, "no matching reader");
2438 cs_log_dbg(D_LB, "{client %s, caid %04X, prid %06X, srvid %04X} [get_cw] NO Readers and NO wait_time... not_found! ", (check_client(er->client) ? er->client->account->usr : "-"), er->caid, er->prid, er->srvid);
2439 send_dcw(client, er);
2440 free_ecm(er);
2441 return;
2442 }
2443
2444
2445 //insert it in ecmcwcache!
2446 cs_writelock(__func__, &ecmcache_lock);
2447 er->next = ecmcwcache;
2448 ecmcwcache = er;
2449 ecmcwcache_size++;
2450 cs_writeunlock(__func__, &ecmcache_lock);
2451
2452
2453 er->rcEx = 0;
2454 #ifdef CS_CACHEEX
2455 er->cacheex_wait_time = 0;
2456 er->cacheex_wait_time_expired = 1;
2457 er->cacheex_hitcache = 0;
2458 er->cacheex_mode1_delay = 0;
2459
2460 if(cacheex_wait_time) //wait time for cacheex
2461 {
2462 er->cacheex_wait_time = cacheex_wait_time;
2463 er->cacheex_wait_time_expired = 0;
2464 er->cacheex_hitcache = wait_time_hitcache ? 1 : 0; //usefull only when cacheex mode 1 readers answers before wait_time and we have to decide if we have to wait until wait_time expires.
2465 er->cacheex_mode1_delay = get_cacheex_mode1_delay(er);
2466
2467 if(!er->cacheex_mode1_delay && er->cacheex_reader_count > 0)
2468 {
2469 request_cw_from_readers(er, 1); // setting stop_stage=1, we request only cacheex mode 1 readers. Others are requested at cacheex timeout!
2470 }
2471 }
2472 else
2473 #endif
2474 request_cw_from_readers(er, 0);
2475
2476
2477 #ifdef WITH_DEBUG
2478 if(D_CLIENTECM & cs_dblevel)
2479 {
2480 char buf[ECM_FMT_LEN];
2481 format_ecm(er, buf, ECM_FMT_LEN);
2482 cs_log_dump_dbg(D_CLIENTECM, er->ecm, er->ecmlen, "Client %s ECM dump %s", username(client), buf);
2483 }
2484 #endif
2485
2486 cw_process_thread_wakeup();
2487 }
2488
2489
2490 int32_t ecmfmt(char *result, size_t size, uint16_t caid, uint16_t onid, uint32_t prid, uint16_t chid, uint16_t pid,
2491 uint16_t srvid, uint16_t l, char *ecmd5hex, char *csphash, char *cw, uint16_t origin_peer, uint8_t distance, char *payload, char *tier)
2492 {
2493 if(!cfg.ecmfmt)
2494 {
2495 if(tier && payload)
2496 {
2497 return snprintf(result, size, "%04X@%06X/%04X/%04X/%02X:%s:0F06%s:%s", caid, prid, chid, srvid, l, ecmd5hex, payload, tier);
2498 }
2499 else if(tier)
2500 {
2501 return snprintf(result, size, "%04X@%06X/%04X/%04X/%02X:%s:%s", caid, prid, chid, srvid, l, ecmd5hex, tier);
2502 }
2503 else if(payload)
2504 {
2505 return snprintf(result, size, "%04X@%06X/%04X/%04X/%02X:%s:0F06%s", caid, prid, chid, srvid, l, ecmd5hex, payload);
2506 }
2507 else
2508 {
2509 return snprintf(result, size, "%04X@%06X/%04X/%04X/%02X:%s", caid, prid, chid, srvid, l, ecmd5hex);
2510 }
2511 }
2512
2513 #define ECMFMT_NUMBER 0
2514 #define ECMFMT_STRING 1
2515 #define ECMFMT_CHAR 2
2516
2517 uint8_t type = 0;
2518 uint32_t ivalue = 0;
2519 char *ifmt = NULL, *sfmt = NULL;
2520 char *svalue = NULL, cvalue = '\0';
2521 uint8_t hide_if_zero = 0;
2522 char *c;
2523 uint32_t s = 0;
2524
2525 for(c = cfg.ecmfmt; *c; c++)
2526 {
2527 if(*c == '0')
2528 {
2529 hide_if_zero = 1;
2530 continue;
2531 }
2532
2533 sfmt = NULL;
2534
2535 switch(*c)
2536 {
2537 case 't':
2538 type = ECMFMT_STRING;
2539 svalue = tier;
2540 if(tier == NULL && !hide_if_zero)
2541 {
2542 type = ECMFMT_NUMBER;
2543 ifmt = "%04X";
2544 ivalue = 0;
2545 }
2546 break;
2547 case 'c':
2548 type = ECMFMT_NUMBER;
2549 ifmt = "%04X";
2550 ivalue = caid;
2551 break;
2552 case 'o':
2553 type = ECMFMT_NUMBER;
2554 ifmt = "%04X";
2555 ivalue = onid;
2556 break;
2557 case 'p':
2558 type = ECMFMT_NUMBER;
2559 ifmt = "%06X";
2560 ivalue = prid;
2561 break;
2562 case 'i':
2563 type = ECMFMT_NUMBER;
2564 ifmt = "%04X";
2565 ivalue = chid;
2566 break;
2567 case 'd':
2568 type = ECMFMT_NUMBER;
2569 ifmt = "%04X";
2570 ivalue = pid;
2571 break;
2572 case 's':
2573 type = ECMFMT_NUMBER;
2574 ifmt = "%04X";
2575 ivalue = srvid;
2576 break;
2577 case 'l':
2578 type = ECMFMT_NUMBER;
2579 ifmt = "%02X";
2580 ivalue = l;
2581 break;
2582 case 'h':
2583 type = ECMFMT_STRING;
2584 svalue = ecmd5hex;
2585 break;
2586 case 'e':
2587 type = ECMFMT_STRING;
2588 svalue = csphash;
2589 break;
2590 case 'w':
2591 type = ECMFMT_STRING;
2592 svalue = cw;
2593 break;
2594 case 'j':
2595 type = ECMFMT_NUMBER;
2596 ifmt = "%02X";
2597 ivalue = distance;
2598 break;
2599 case 'g':
2600 type = ECMFMT_NUMBER;
2601 ifmt = "%04X";
2602 ivalue = origin_peer;
2603 break;
2604 case '\\':
2605 c++;
2606 type = ECMFMT_CHAR;
2607 cvalue = *c;
2608
2609 if(cvalue == '\0')
2610 { return s; }
2611 break;
2612 case 'y':
2613 type = ECMFMT_STRING;
2614 svalue = payload;
2615 sfmt = "0F06%.06s";
2616 if(payload == NULL && !hide_if_zero)
2617 {
2618 type = ECMFMT_NUMBER;
2619 ifmt = "0F06%06X";
2620 ivalue = 0;
2621 }
2622 break;
2623 case 'Y':
2624 type = ECMFMT_STRING;
2625 svalue = payload;
2626 sfmt = "0F06%s";
2627 if(payload == NULL && !hide_if_zero)
2628 {
2629 type = ECMFMT_NUMBER;
2630 ifmt = "0F06%12X";
2631 ivalue = 0;
2632 }
2633 break;
2634 default:
2635 type = ECMFMT_CHAR;
2636 cvalue = *c;
2637 break;
2638 }
2639
2640 if(hide_if_zero)
2641 {
2642 if(type == ECMFMT_NUMBER && ivalue == 0)
2643 {
2644 hide_if_zero = 0;
2645 continue;
2646 }
2647 else if(type == ECMFMT_STRING && svalue == NULL)
2648 {
2649 hide_if_zero = 0;
2650 continue;
2651 }
2652 }
2653
2654 switch(type)
2655 {
2656 case ECMFMT_NUMBER:
2657 s += snprintf(result + s, size - s, ifmt, ivalue);
2658 break;
2659
2660 case ECMFMT_STRING:
2661 s += snprintf(result + s, size - s , sfmt != NULL ? sfmt : "%s", svalue);
2662 break;
2663
2664 case ECMFMT_CHAR:
2665 if(size - s > 1)
2666 {
2667 result[s] = cvalue;
2668 result[s+1] = '\0';
2669 s++;
2670 }
2671 break;
2672
2673 default:
2674 break;
2675 }
2676 }
2677
2678 return s;
2679 }
2680
2681 uint8_t checkCWpart(uchar *cw, int8_t part)
2682 {
2683 uint8_t eo = part ? 8 : 0;
2684 int8_t i;
2685 for(i = 0; i < 8; i++)
2686 if(cw[i + eo]) { return 1; }
2687 return 0;
2688 }
2689
2690 int32_t format_ecm(ECM_REQUEST *ecm, char *result, size_t size)
2691 {
2692 char ecmd5hex[(16*2)+1];
2693 char csphash[(4*2)+1] = { 0 };
2694 char cwhex[(16*2)+1];
2695 char *payload = NULL;
2696 char *tier = NULL;
2697 #ifdef READER_VIDEOGUARD
2698 char payload_string[(6*2)+1];
2699 char tier_string[83];
2700 struct s_ecm_answer *ea;
2701
2702 if(ecm->selected_reader && caid_is_videoguard(ecm->selected_reader->caid) && !is_network_reader(ecm->selected_reader))
2703 {
2704 for(ea = ecm->matching_rdr; ea; ea = ea->next)
2705 {
2706 if(ea->tier && (ea->status & REQUEST_ANSWERED) && !is_network_reader(ea->reader))
2707 {
2708 get_tiername_defaultid(ea->tier, ecm->selected_reader->caid, tier_string);
2709 tier = tier_string;
2710 break;
2711 }
2712 }
2713
2714 cs_hexdump(0, ecm->selected_reader->VgLastPayload, 6, payload_string, sizeof(payload_string));
2715 payload = payload_string;
2716 }
2717 #endif
2718 cs_hexdump(0, ecm->ecmd5, 16, ecmd5hex, sizeof(ecmd5hex));
2719 #ifdef CS_CACHEEX
2720 cs_hexdump(0, (void *)&ecm->csp_hash, 4, csphash, sizeof(csphash));
2721 #endif
2722 cs_hexdump(0, ecm->cw, 16, cwhex, sizeof(cwhex));
2723 #ifdef MODULE_GBOX
2724 struct gbox_ecm_request_ext *ere = ecm->src_data;
2725 if(ere && check_client(ecm->client) && get_module(ecm->client)->num == R_GBOX && ere->gbox_hops)
2726 { return ecmfmt(result, size, ecm->caid, ecm->onid, ecm->prid, ecm->chid, ecm->pid, ecm->srvid, ecm->ecmlen, ecmd5hex, csphash, cwhex, ere->gbox_peer, ere->gbox_hops, payload, tier); }
2727 else if (ecm->selected_reader && ecm->selected_reader->typ == R_GBOX && ecm->gbox_ecm_id)
2728 { return ecmfmt(result, size, ecm->caid, ecm->onid, ecm->prid, ecm->chid, ecm->pid, ecm->srvid, ecm->ecmlen, ecmd5hex, csphash, cwhex, ecm->gbox_ecm_id, 0, payload, tier); }
2729 else
2730 #endif
2731 return ecmfmt(result, size, ecm->caid, ecm->onid, ecm->prid, ecm->chid, ecm->pid, ecm->srvid, ecm->ecmlen, ecmd5hex, csphash, cwhex, 0,
2732 ((ecm->selected_reader && ecm->selected_reader->currenthops) ? ecm->selected_reader->currenthops : 0), payload, tier);
2733 }
2734
Open Source Conditional Access Modul