?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- fix linking errors when compiling oscam with static LIBCRYPTO library alone
[oscam.git] / oscam-config-reader.c
blob61a15324fbb9a0e51fd9fe9f2dd4c0bd86f5bced
1 #define MODULE_LOG_PREFIX "config"
2
3 #include "globals.h"
4 #include "module-stat.h"
5 #include "oscam-aes.h"
6 #include "oscam-array.h"
7 #include "oscam-conf.h"
8 #include "oscam-conf-chk.h"
9 #include "oscam-conf-mk.h"
10 #include "oscam-config.h"
11 #include "oscam-garbage.h"
12 #include "oscam-lock.h"
13 #include "oscam-reader.h"
14 #include "oscam-string.h"
15 #ifdef MODULE_GBOX
16 #include "module-gbox.h"
17 #endif
18 #ifdef CS_CACHEEX_AIO
19 #include "module-cacheex.h"
20 #endif
21
22 #define cs_srvr "oscam.server"
23
24 extern const struct s_cardreader *cardreaders[];
25 extern char *RDR_CD_TXT[];
26
27 static void reader_label_fn(const char *token, char *value, void *setting, FILE *f)
28 {
29 struct s_reader *rdr = setting;
30 if(value)
31 {
32 int i, found = 0;
33 if(!cs_strlen(value))
34 { return; }
35 for(i = 0; i < (int)cs_strlen(value); i++)
36 {
37 if(value[i] == ' ')
38 {
39 value[i] = '_';
40 found++;
41 }
42 }
43 if(found)
44 { fprintf(stderr, "Configuration reader: corrected label to %s\n", value); }
45 cs_strncpy(rdr->label, value, sizeof(rdr->label));
46 return;
47 }
48 fprintf_conf(f, token, "%s\n", rdr->label);
49 }
50
51 static void ecmwhitelist_fn(const char *token, char *value, void *setting, FILE *f)
52 {
53 struct s_reader *rdr = setting;
54 if(value)
55 {
56 if(cs_strlen(value))
57 chk_ecm_whitelist(value, &rdr->ecm_whitelist);
58 else
59 ecm_whitelist_clear(&rdr->ecm_whitelist);
60 return;
61 }
62
63 value = mk_t_ecm_whitelist(&rdr->ecm_whitelist);
64 if(cs_strlen(value) > 0 || cfg.http_full_cfg)
65 { fprintf_conf(f, token, "%s\n", value); }
66 free_mk_t(value);
67 }
68
69 static void ecmheaderwhitelist_fn(const char *token, char *value, void *setting, FILE *f)
70 {
71 struct s_reader *rdr = setting;
72 if(value)
73 {
74 if(cs_strlen(value))
75 chk_ecm_hdr_whitelist(value, &rdr->ecm_hdr_whitelist);
76 else
77 ecm_hdr_whitelist_clear(&rdr->ecm_hdr_whitelist);
78 return;
79 }
80
81 value = mk_t_ecm_hdr_whitelist(&rdr->ecm_hdr_whitelist);
82 if(cs_strlen(value) > 0 || cfg.http_full_cfg)
83 { fprintf_conf(f, token, "%s\n", value); }
84 free_mk_t(value);
85 }
86
87 static void protocol_fn(const char *token, char *value, void *setting, FILE *f)
88 {
89 struct s_reader *rdr = setting;
90 if(value)
91 {
92 if(cs_strlen(value) == 0)
93 { return; }
94 struct protocol_map
95 {
96 char *name;
97 int typ;
98 } protocols[] =
99 {
100 { "serial", R_SERIAL },
101 { "camd35", R_CAMD35 },
102 { "cs378x", R_CS378X },
103 { "cs357x", R_CAMD35 },
104 { "camd33", R_CAMD33 },
105 { "gbox", R_GBOX },
106 { "cccam", R_CCCAM },
107 { "cccam_ext", R_CCCAM },
108 { "cccam_mcs", R_CCCAM },
109 { "constcw", R_CONSTCW },
110 { "radegast", R_RADEGAST },
111 { "scam", R_SCAM },
112 { "ghttp", R_GHTTP },
113 { "newcamd", R_NEWCAMD },
114 { "newcamd525", R_NEWCAMD },
115 { "newcamd524", R_NEWCAMD },
116 { "drecas", R_DRECAS },
117 { "emu", R_EMU },
118 { NULL, 0 }
119 }, *p;
120 int i;
121 // Parse card readers
122 for(i = 0; cardreaders[i]; i++)
123 {
124 if(streq(value, cardreaders[i]->desc))
125 {
126 rdr->crdr = cardreaders[i];
127 rdr->typ = cardreaders[i]->typ;
128 return;
129 }
130 }
131 // Parse protocols
132 for(i = 0, p = &protocols[0]; p->name; p = &protocols[++i])
133 {
134 if(streq(p->name, value))
135 {
136 rdr->typ = p->typ;
137 break;
138 }
139 }
140 if(rdr->typ == R_NEWCAMD)
141 { rdr->ncd_proto = streq(value, "newcamd524") ? NCD_524 : NCD_525; }
142 if(!rdr->typ)
143 {
144 fprintf(stderr, "ERROR: '%s' is unsupported reader protocol!\n", value);
145 rdr->enable = 0;
146 }
147 return;
148 }
149 fprintf_conf(f, token, "%s\n", reader_get_type_desc(rdr, 0));
150 }
151
152 static void device_fn(const char *token, char *value, void *setting, FILE *f)
153 {
154 struct s_reader *rdr = setting;
155 int32_t isphysical = !is_network_reader(rdr);
156 if(value)
157 {
158 int32_t i;
159 char *ptr, *saveptr1 = NULL;
160 for(i = 0, ptr = strtok_r(value, ",", &saveptr1); (i < 3) && (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++)
161 {
162 trim(ptr);
163 switch(i)
164 {
165 case 0:
166 cs_strncpy(rdr->device, ptr, sizeof(rdr->device));
167 break;
168 case 1:
169 rdr->r_port = atoi(ptr);
170 break;
171 case 2:
172 rdr->l_port = atoi(ptr);
173 break;
174 }
175 }
176 return;
177 }
178 fprintf_conf(f, token, "%s", rdr->device); // it should not have \n at the end
179 if((rdr->r_port || cfg.http_full_cfg) && !isphysical)
180 { fprintf(f, ",%d", rdr->r_port); }
181 if((rdr->l_port || cfg.http_full_cfg) && !isphysical && strncmp(reader_get_type_desc(rdr, 0), "cccam", 5))
182 { fprintf(f, ",%d", rdr->l_port); }
183 fprintf(f, "\n");
184 }
185
186 static void reader_services_fn(const char *token, char *value, void *setting, FILE *f)
187 {
188 services_fn(token, value, setting, f);
189 if(value)
190 {
191 struct s_reader *rdr = container_of(setting, struct s_reader, sidtabs);
192 if(rdr)
193 { rdr->changes_since_shareupdate = 1; }
194 }
195 }
196
197 static void reader_lb_services_fn(const char *token, char *value, void *setting, FILE *f)
198 {
199 services_fn(token, value, setting, f);
200 if(value)
201 {
202 struct s_reader *rdr = container_of(setting, struct s_reader, lb_sidtabs);
203 if(rdr)
204 { rdr->changes_since_shareupdate = 1; }
205 }
206 }
207
208 static void reader_caid_fn(const char *token, char *value, void *setting, FILE *f)
209 {
210 check_caidtab_fn(token, value, setting, f);
211 if(value)
212 {
213 struct s_reader *rdr = container_of(setting, struct s_reader, ctab);
214 if(rdr)
215 { rdr->changes_since_shareupdate = 1; }
216 }
217 }
218
219 static void boxid_fn(const char *token, char *value, void *setting, FILE *f)
220 {
221 struct s_reader *rdr = setting;
222 if(value)
223 {
224 rdr->boxid = cs_strlen(value) ? a2i(value, 4) : 0;
225 return;
226 }
227 if(rdr->boxid)
228 { fprintf_conf(f, token, "%08X\n", rdr->boxid); }
229 else if(cfg.http_full_cfg)
230 { fprintf_conf(f, token, "\n"); }
231 }
232
233 static void cwpkkey_fn(const char *token, char *value, void *setting, FILE *f)
234 {
235 struct s_reader *rdr = setting;
236 if(value)
237 {
238 int32_t len = strlen(value);
239 // rdr_log(rdr, "CWPK config key length: %16X", len);
240 if(len == 0 || len > 32)
241 {
242 rdr->cwpk_mod_length = 0;
243 memset(rdr->cwpk_mod, 0, sizeof(rdr->cwpk_mod));
244 }
245 else
246 {
247 if(key_atob_l(value, rdr->cwpk_mod, len))
248 {
249 fprintf(stderr, "reader cwpkkey parse error, %s=%s\n", token, value);
250 rdr->cwpk_mod_length = 0;
251 memset(rdr->cwpk_mod, 0, sizeof(rdr->cwpk_mod));
252 }
253 else
254 {
255 rdr->cwpk_mod_length = len/2;
256 }
257 }
258 return;
259 }
260 int32_t len = rdr->cwpk_mod_length;
261 if(len > 0)
262 {
263 char tmp[len * 2 + 1];
264 fprintf_conf(f, "cwpkkey", "%s\n", cs_hexdump(0, rdr->cwpk_mod, len, tmp, sizeof(tmp)));
265 }
266 else if(cfg.http_full_cfg)
267 { fprintf_conf(f, "cwpkkey", "\n"); }
268 }
269
270 static void rsakey_fn(const char *token, char *value, void *setting, FILE *f)
271 {
272 struct s_reader *rdr = setting;
273 if(value)
274 {
275 int32_t len = cs_strlen(value);
276 if(len != 128 && len != 240)
277 {
278 rdr->rsa_mod_length = 0;
279 memset(rdr->rsa_mod, 0, 120);
280 }
281 else
282 {
283 if(key_atob_l(value, rdr->rsa_mod, len))
284 {
285 fprintf(stderr, "reader rsakey parse error, %s=%s\n", token, value);
286 rdr->rsa_mod_length = 0;
287 memset(rdr->rsa_mod, 0, sizeof(rdr->rsa_mod));
288 }
289 else
290 {
291 rdr->rsa_mod_length = len/2;
292 }
293 }
294 return;
295 }
296 int32_t len = rdr->rsa_mod_length;
297 if(len > 0)
298 {
299 char tmp[len * 2 + 1];
300 fprintf_conf(f, "rsakey", "%s\n", cs_hexdump(0, rdr->rsa_mod, len, tmp, sizeof(tmp)));
301 }
302 else if(cfg.http_full_cfg)
303 { fprintf_conf(f, "rsakey", "\n"); }
304 }
305
306 static void deskey_fn(const char *token, char *value, void *setting, FILE *f)
307 {
308 struct s_reader *rdr = setting;
309 if(value)
310 {
311 int32_t len = cs_strlen(value);
312 if(((len % 16) != 0) || len == 0 || len > 128*2)
313 {
314 rdr->des_key_length = 0;
315 memset(rdr->des_key, 0, sizeof(rdr->des_key));
316 }
317 else
318 {
319 if(key_atob_l(value, rdr->des_key, len))
320 {
321 fprintf(stderr, "reader 3DES key parse error, %s=%s\n", token, value);
322 rdr->des_key_length = 0;
323 memset(rdr->des_key, 0, sizeof(rdr->des_key));
324 }
325 else
326 {
327 rdr->des_key_length = len/2;
328 }
329 }
330 return;
331 }
332 int32_t len = rdr->des_key_length;
333 if(len > 0)
334 {
335 char tmp[len * 2 + 1];
336 fprintf_conf(f, "deskey", "%s\n", cs_hexdump(0, rdr->des_key, len, tmp, sizeof(tmp)));
337 }
338 else if(cfg.http_full_cfg)
339 { fprintf_conf(f, "deskey", "\n"); }
340 }
341
342 static void boxkey_fn(const char *token, char *value, void *setting, FILE *f)
343 {
344 struct s_reader *rdr = setting;
345 if(value)
346 {
347 int32_t len = cs_strlen(value);
348 if(((len % 8) != 0) || len == 0 || len > 32)
349 {
350 rdr->boxkey_length = 0;
351 memset(rdr->boxkey, 0, sizeof(rdr->boxkey));
352 }
353 else
354 {
355 if(key_atob_l(value, rdr->boxkey, len))
356 {
357 fprintf(stderr, "reader boxkey parse error, %s=%s\n", token, value);
358 rdr->boxkey_length = 0;
359 memset(rdr->boxkey, 0, sizeof(rdr->boxkey));
360 }
361 else
362 {
363 rdr->boxkey_length = len/2;
364 }
365 }
366 return;
367 }
368 int32_t len = rdr->boxkey_length;
369 if(len > 0)
370 {
371 char tmp[len * 2 + 1];
372 fprintf_conf(f, "boxkey", "%s\n", cs_hexdump(0, rdr->boxkey, len, tmp, sizeof(tmp)));
373 }
374 else if(cfg.http_full_cfg)
375 { fprintf_conf(f, "boxkey", "\n"); }
376 }
377
378 #ifdef READER_NAGRA_MERLIN
379 static void mod1_fn(const char *token, char *value, void *setting, FILE *f)
380 {
381 struct s_reader *rdr = setting;
382 if(value)
383 {
384 int32_t len = cs_strlen(value);
385 if(len != 224)
386 {
387 rdr->mod1_length = 0;
388 memset(rdr->mod1, 0, 112);
389 }
390 else
391 {
392 if(key_atob_l(value, rdr->mod1, len))
393 {
394 fprintf(stderr, "reader mod1 parse error, %s=%s\n", token, value);
395 rdr->mod1_length = 0;
396 memset(rdr->mod1, 0, sizeof(rdr->mod1));
397 }
398 else
399 {
400 rdr->mod1_length = len/2;
401 }
402 }
403 return;
404 }
405 int32_t len = rdr->mod1_length;
406 if(len > 0)
407 {
408 char tmp[len * 2 + 1];
409 fprintf_conf(f, "mod1", "%s\n", cs_hexdump(0, rdr->mod1, len, tmp, sizeof(tmp)));
410 }
411 else if(cfg.http_full_cfg)
412 { fprintf_conf(f, "mod1", "\n"); }
413 }
414
415 static void mod2_fn(const char *token, char *value, void *setting, FILE *f)
416 {
417 struct s_reader *rdr = setting;
418 if(value)
419 {
420 int32_t len = strlen(value);
421 if(len != 224)
422 {
423 rdr->mod2_length = 0;
424 memset(rdr->mod2, 0, 112);
425 }
426 else
427 {
428 if(key_atob_l(value, rdr->mod2, len))
429 {
430 fprintf(stderr, "reader mod2 parse error, %s=%s\n", token, value);
431 rdr->mod2_length = 0;
432 memset(rdr->mod2, 0, sizeof(rdr->mod2));
433 }
434 else
435 {
436 rdr->mod2_length = len/2;
437 }
438 }
439 return;
440 }
441 int32_t len = rdr->mod2_length;
442 if(len > 0)
443 {
444 char tmp[len * 2 + 1];
445 fprintf_conf(f, "mod2", "%s\n", cs_hexdump(0, rdr->mod2, len, tmp, sizeof(tmp)));
446 }
447 else if(cfg.http_full_cfg)
448 { fprintf_conf(f, "mod2", "\n"); }
449 }
450
451 static void idird_fn(const char *token, char *value, void *setting, FILE *f)
452 {
453 struct s_reader *rdr = setting;
454 if(value)
455 {
456 int32_t len = strlen(value);
457 if(len != 8)
458 {
459 rdr->idird_length = 0;
460 memset(rdr->idird, 0, 4);
461 }
462 else
463 {
464 if(key_atob_l(value, rdr->idird, len))
465 {
466 fprintf(stderr, "reader idird parse error, %s=%s\n", token, value);
467 rdr->idird_length = 0;
468 memset(rdr->idird, 0, sizeof(rdr->idird));
469 }
470 else
471 {
472 rdr->idird_length = len/2;
473 }
474 }
475 return;
476 }
477 int32_t len = rdr->idird_length;
478 if(len > 0)
479 {
480 char tmp[len * 2 + 1];
481 fprintf_conf(f, "idird", "%s\n", cs_hexdump(0, rdr->idird, len, tmp, sizeof(tmp)));
482 }
483 else if(cfg.http_full_cfg)
484 { fprintf_conf(f, "idird", "\n"); }
485 }
486
487 static void cmd0eprov_fn(const char *token, char *value, void *setting, FILE *f)
488 {
489 struct s_reader *rdr = setting;
490 if(value)
491 {
492 int32_t len = strlen(value);
493 if(len != 4)
494 {
495 rdr->cmd0eprov_length = 0;
496 memset(rdr->cmd0eprov, 0, 2);
497 }
498 else
499 {
500 if(key_atob_l(value, rdr->cmd0eprov, len))
501 {
502 fprintf(stderr, "reader cmd0eprov parse error, %s=%s\n", token, value);
503 rdr->cmd0eprov_length = 0;
504 memset(rdr->cmd0eprov, 0, sizeof(rdr->cmd0eprov));
505 }
506 else
507 {
508 rdr->cmd0eprov_length = len/2;
509 }
510 }
511 return;
512 }
513 int32_t len = rdr->cmd0eprov_length;
514 if(len > 0)
515 {
516 char tmp[len * 2 + 1];
517 fprintf_conf(f, "cmd0eprov", "%s\n", cs_hexdump(0, rdr->cmd0eprov, len, tmp, sizeof(tmp)));
518 }
519 else if(cfg.http_full_cfg)
520 { fprintf_conf(f, "cmd0eprov", "\n"); }
521 }
522
523 static void key3588_fn(const char *token, char *value, void *setting, FILE *f)
524 {
525 struct s_reader *rdr = setting;
526 if(value)
527 {
528 int32_t len = strlen(value);
529 if(len != 272)
530 {
531 rdr->key3588_length = 0;
532 memset(rdr->key3588, 0, 136);
533 }
534 else
535 {
536 if(key_atob_l(value, rdr->key3588, len))
537 {
538 fprintf(stderr, "reader key3588 parse error, %s=%s\n", token, value);
539 rdr->key3588_length = 0;
540 memset(rdr->key3588, 0, sizeof(rdr->key3588));
541 }
542 else
543 {
544 rdr->key3588_length = len/2;
545 }
546 }
547 return;
548 }
549 int32_t len = rdr->key3588_length;
550 if(len > 0)
551 {
552 char tmp[len * 2 + 1];
553 fprintf_conf(f, "key3588", "%s\n", cs_hexdump(0, rdr->key3588, len, tmp, sizeof(tmp)));
554 }
555 else if(cfg.http_full_cfg)
556 { fprintf_conf(f, "key3588", "\n"); }
557 }
558
559 static void data50_fn(const char *token, char *value, void *setting, FILE *f)
560 {
561 struct s_reader *rdr = setting;
562 if(value)
563 {
564 int32_t len = cs_strlen(value);
565 if(len != 160)
566 {
567 rdr->data50_length = 0;
568 memset(rdr->data50, 0, 80);
569 }
570 else
571 {
572 if(key_atob_l(value, rdr->data50, len))
573 {
574 fprintf(stderr, "reader data50 parse error, %s=%s\n", token, value);
575 rdr->data50_length = 0;
576 memset(rdr->data50, 0, sizeof(rdr->data50));
577 }
578 else
579 {
580 rdr->data50_length = len/2;
581 }
582 }
583 return;
584 }
585 int32_t len = rdr->data50_length;
586 if(len > 0)
587 {
588 char tmp[len * 2 + 1];
589 fprintf_conf(f, "data50", "%s\n", cs_hexdump(0, rdr->data50, len, tmp, sizeof(tmp)));
590 }
591 else if(cfg.http_full_cfg)
592 { fprintf_conf(f, "data50", "\n"); }
593 }
594
595 static void mod50_fn(const char *token, char *value, void *setting, FILE *f)
596 {
597 struct s_reader *rdr = setting;
598 if(value)
599 {
600 int32_t len = cs_strlen(value);
601 if(len != 160)
602 {
603 rdr->mod50_length = 0;
604 memset(rdr->mod50, 0, 80);
605 }
606 else
607 {
608 if(key_atob_l(value, rdr->mod50, len))
609 {
610 fprintf(stderr, "reader mod50 parse error, %s=%s\n", token, value);
611 rdr->mod50_length = 0;
612 memset(rdr->mod50, 0, sizeof(rdr->mod50));
613 }
614 else
615 {
616 rdr->mod50_length = len/2;
617 }
618 }
619 return;
620 }
621 int32_t len = rdr->mod50_length;
622 if(len > 0)
623 {
624 char tmp[len * 2 + 1];
625 fprintf_conf(f, "mod50", "%s\n", cs_hexdump(0, rdr->mod50, len, tmp, sizeof(tmp)));
626 }
627 else if(cfg.http_full_cfg)
628 { fprintf_conf(f, "mod50", "\n"); }
629 }
630
631 static void key3460_fn(const char *token, char *value, void *setting, FILE *f)
632 {
633 struct s_reader *rdr = setting;
634 if(value)
635 {
636 int32_t len = cs_strlen(value);
637 if(len != 192)
638 {
639 rdr->key3460_length = 0;
640 memset(rdr->key3460, 0, 96);
641 }
642 else
643 {
644 if(key_atob_l(value, rdr->key3460, len))
645 {
646 fprintf(stderr, "reader key3460 parse error, %s=%s\n", token, value);
647 rdr->key3460_length = 0;
648 memset(rdr->key3460, 0, sizeof(rdr->key3460));
649 }
650 else
651 {
652 rdr->key3460_length = len/2;
653 }
654 }
655 return;
656 }
657 int32_t len = rdr->key3460_length;
658 if(len > 0)
659 {
660 char tmp[len * 2 + 1];
661 fprintf_conf(f, "key3460", "%s\n", cs_hexdump(0, rdr->key3460, len, tmp, sizeof(tmp)));
662 }
663 else if(cfg.http_full_cfg)
664 { fprintf_conf(f, "key3460", "\n"); }
665 }
666
667 static void key3310_fn(const char *token, char *value, void *setting, FILE *f)
668 {
669 struct s_reader *rdr = setting;
670 if(value)
671 {
672 int32_t len = cs_strlen(value);
673 if(len != 32)
674 {
675 rdr->key3310_length = 0;
676 memset(rdr->key3310, 0, 16);
677 }
678 else
679 {
680 if(key_atob_l(value, rdr->key3310, len))
681 {
682 fprintf(stderr, "reader key3310 parse error, %s=%s\n", token, value);
683 rdr->key3310_length = 0;
684 memset(rdr->key3310, 0, sizeof(rdr->key3310));
685 }
686 else
687 {
688 rdr->key3310_length = len/2;
689 }
690 }
691 return;
692 }
693 int32_t len = rdr->key3310_length;
694 if(len > 0)
695 {
696 char tmp[len * 2 + 1];
697 fprintf_conf(f, "key3310", "%s\n", cs_hexdump(0, rdr->key3310, len, tmp, sizeof(tmp)));
698 }
699 else if(cfg.http_full_cfg)
700 { fprintf_conf(f, "key3310", "\n"); }
701 }
702
703 static void nuid_fn(const char *token, char *value, void *setting, FILE *f)
704 {
705 struct s_reader *rdr = setting;
706 if(value)
707 {
708 int32_t len = cs_strlen(value);
709 if(len != 8)
710 {
711 rdr->nuid_length = 0;
712 memset(rdr->nuid, 0, 4);
713 }
714 else
715 {
716 if(key_atob_l(value, rdr->nuid, len))
717 {
718 fprintf(stderr, "reader nuid parse error, %s=%s\n", token, value);
719 rdr->nuid_length = 0;
720 memset(rdr->nuid, 0, sizeof(rdr->nuid));
721 }
722 else
723 {
724 rdr->nuid_length = len/2;
725 }
726 }
727 return;
728 }
729 int32_t len = rdr->nuid_length;
730 if(len > 0)
731 {
732 char tmp[len * 2 + 1];
733 fprintf_conf(f, "nuid", "%s\n", cs_hexdump(0, rdr->nuid, len, tmp, sizeof(tmp)));
734 }
735 else if(cfg.http_full_cfg)
736 { fprintf_conf(f, "nuid", "\n"); }
737 }
738
739 static void forcepair_fn(const char *token, char *value, void *setting, FILE *f)
740 {
741 struct s_reader *rdr = setting;
742 if(value)
743 {
744 int32_t len = cs_strlen(value);
745 if(len != 2)
746 {
747 rdr->forcepair_length = 0;
748 memset(rdr->forcepair, 0, 1);
749 }
750 else
751 {
752 if(key_atob_l(value, rdr->forcepair, len))
753 {
754 fprintf(stderr, "reader forcepair parse error, %s=%s\n", token, value);
755 rdr->forcepair_length = 0;
756 memset(rdr->forcepair, 0, sizeof(rdr->forcepair));
757 }
758 else
759 {
760 rdr->forcepair_length = len/2;
761 }
762 }
763 return;
764 }
765 int32_t len = rdr->forcepair_length;
766 if(len > 0)
767 {
768 char tmp[len * 2 + 1];
769 fprintf_conf(f, "forcepair", "%s\n", cs_hexdump(0, rdr->forcepair, len, tmp, sizeof(tmp)));
770 }
771 else if(cfg.http_full_cfg)
772 { fprintf_conf(f, "forcepair", "\n"); }
773 }
774
775 static void otpcsc_fn(const char *token, char *value, void *setting, FILE *f)
776 {
777 struct s_reader *rdr = setting;
778 if(value)
779 {
780 int32_t len = strlen(value);
781 if(len != 4)
782 {
783 rdr->otpcsc_length = 0;
784 memset(rdr->otpcsc, 0, 2);
785 }
786 else
787 {
788 if(key_atob_l(value, rdr->otpcsc, len))
789 {
790 fprintf(stderr, "reader otpcsc parse error, %s=%s\n", token, value);
791 rdr->otpcsc_length = 0;
792 memset(rdr->otpcsc, 0, sizeof(rdr->otpcsc));
793 }
794 else
795 {
796 rdr->otpcsc_length = len/2;
797 }
798 }
799 return;
800 }
801 int32_t len = rdr->otpcsc_length;
802 if(len > 0)
803 {
804 char tmp[len * 2 + 1];
805 fprintf_conf(f, "otpcsc", "%s\n", cs_hexdump(0, rdr->otpcsc, len, tmp, sizeof(tmp)));
806 }
807 else if(cfg.http_full_cfg)
808 { fprintf_conf(f, "otpcsc", "\n"); }
809 }
810
811 static void otacsc_fn(const char *token, char *value, void *setting, FILE *f)
812 {
813 struct s_reader *rdr = setting;
814 if(value)
815 {
816 int32_t len = strlen(value);
817 if(len != 4)
818 {
819 rdr->otacsc_length = 0;
820 memset(rdr->otacsc, 0, 2);
821 }
822 else
823 {
824 if(key_atob_l(value, rdr->otacsc, len))
825 {
826 fprintf(stderr, "reader otacsc parse error, %s=%s\n", token, value);
827 rdr->otacsc_length = 0;
828 memset(rdr->otacsc, 0, sizeof(rdr->otacsc));
829 }
830 else
831 {
832 rdr->otacsc_length = len/2;
833 }
834 }
835 return;
836 }
837 int32_t len = rdr->otacsc_length;
838 if(len > 0)
839 {
840 char tmp[len * 2 + 1];
841 fprintf_conf(f, "otacsc", "%s\n", cs_hexdump(0, rdr->otacsc, len, tmp, sizeof(tmp)));
842 }
843 else if(cfg.http_full_cfg)
844 { fprintf_conf(f, "otacsc", "\n"); }
845 }
846
847 static void cwpkcaid_fn(const char *token, char *value, void *setting, FILE *f)
848 {
849 struct s_reader *rdr = setting;
850 if(value)
851 {
852 int32_t len = strlen(value);
853 if(len != 4)
854 {
855 rdr->cwpkcaid_length = 0;
856 memset(rdr->cwpkcaid, 0, 2);
857 }
858 else
859 {
860 if(key_atob_l(value, rdr->cwpkcaid, len))
861 {
862 fprintf(stderr, "reader cwpkcaid parse error, %s=%s\n", token, value);
863 rdr->cwpkcaid_length = 0;
864 memset(rdr->cwpkcaid, 0, sizeof(rdr->cwpkcaid));
865 }
866 else
867 {
868 rdr->cwpkcaid_length = len/2;
869 }
870 }
871 return;
872 }
873 int32_t len = rdr->cwpkcaid_length;
874 if(len > 0)
875 {
876 char tmp[len * 2 + 1];
877 fprintf_conf(f, "cwpkcaid", "%s\n", cs_hexdump(0, rdr->cwpkcaid, len, tmp, sizeof(tmp)));
878 }
879 else if(cfg.http_full_cfg)
880 { fprintf_conf(f, "cwpkcaid", "\n"); }
881 }
882
883 static void cwekey0_fn(const char *token, char *value, void *setting, FILE *f)
884 {
885 struct s_reader *rdr = setting;
886 if(value)
887 {
888 int32_t len = strlen(value);
889 if(len != 32)
890 {
891 rdr->cwekey0_length = 0;
892 memset(rdr->cwekey0, 0, 16);
893 }
894 else
895 {
896 if(key_atob_l(value, rdr->cwekey0, len))
897 {
898 fprintf(stderr, "reader cwekey0 parse error, %s=%s\n", token, value);
899 rdr->cwekey0_length = 0;
900 memset(rdr->cwekey0, 0, sizeof(rdr->cwekey0));
901 }
902 else
903 {
904 rdr->cwekey0_length = len/2;
905 }
906 }
907 return;
908 }
909 int32_t len = rdr->cwekey0_length;
910 if(len > 0)
911 {
912 char tmp[len * 2 + 1];
913 fprintf_conf(f, "cwekey0", "%s\n", cs_hexdump(0, rdr->cwekey0, len, tmp, sizeof(tmp)));
914 }
915 else if(cfg.http_full_cfg)
916 { fprintf_conf(f, "cwekey0", "\n"); }
917 }
918
919 static void cwekey1_fn(const char *token, char *value, void *setting, FILE *f)
920 {
921 struct s_reader *rdr = setting;
922 if(value)
923 {
924 int32_t len = strlen(value);
925 if(len != 32)
926 {
927 rdr->cwekey1_length = 0;
928 memset(rdr->cwekey1, 0, 16);
929 }
930 else
931 {
932 if(key_atob_l(value, rdr->cwekey1, len))
933 {
934 fprintf(stderr, "reader cwekey1 parse error, %s=%s\n", token, value);
935 rdr->cwekey1_length = 0;
936 memset(rdr->cwekey1, 0, sizeof(rdr->cwekey1));
937 }
938 else
939 {
940 rdr->cwekey1_length = len/2;
941 }
942 }
943 return;
944 }
945 int32_t len = rdr->cwekey1_length;
946 if(len > 0)
947 {
948 char tmp[len * 2 + 1];
949 fprintf_conf(f, "cwekey1", "%s\n", cs_hexdump(0, rdr->cwekey1, len, tmp, sizeof(tmp)));
950 }
951 else if(cfg.http_full_cfg)
952 { fprintf_conf(f, "cwekey1", "\n"); }
953 }
954
955 static void cwekey2_fn(const char *token, char *value, void *setting, FILE *f)
956 {
957 struct s_reader *rdr = setting;
958 if(value)
959 {
960 int32_t len = strlen(value);
961 if(len != 32)
962 {
963 rdr->cwekey2_length = 0;
964 memset(rdr->cwekey2, 0, 16);
965 }
966 else
967 {
968 if(key_atob_l(value, rdr->cwekey2, len))
969 {
970 fprintf(stderr, "reader cwekey2 parse error, %s=%s\n", token, value);
971 rdr->cwekey2_length = 0;
972 memset(rdr->cwekey2, 0, sizeof(rdr->cwekey2));
973 }
974 else
975 {
976 rdr->cwekey2_length = len/2;
977 }
978 }
979 return;
980 }
981 int32_t len = rdr->cwekey2_length;
982 if(len > 0)
983 {
984 char tmp[len * 2 + 1];
985 fprintf_conf(f, "cwekey2", "%s\n", cs_hexdump(0, rdr->cwekey2, len, tmp, sizeof(tmp)));
986 }
987 else if(cfg.http_full_cfg)
988 { fprintf_conf(f, "cwekey2", "\n"); }
989 }
990
991 static void cwekey3_fn(const char *token, char *value, void *setting, FILE *f)
992 {
993 struct s_reader *rdr = setting;
994 if(value)
995 {
996 int32_t len = strlen(value);
997 if(len != 32)
998 {
999 rdr->cwekey3_length = 0;
1000 memset(rdr->cwekey3, 0, 16);
1001 }
1002 else
1003 {
1004 if(key_atob_l(value, rdr->cwekey3, len))
1005 {
1006 fprintf(stderr, "reader cwekey3 parse error, %s=%s\n", token, value);
1007 rdr->cwekey3_length = 0;
1008 memset(rdr->cwekey3, 0, sizeof(rdr->cwekey3));
1009 }
1010 else
1011 {
1012 rdr->cwekey3_length = len/2;
1013 }
1014 }
1015 return;
1016 }
1017 int32_t len = rdr->cwekey3_length;
1018 if(len > 0)
1019 {
1020 char tmp[len * 2 + 1];
1021 fprintf_conf(f, "cwekey3", "%s\n", cs_hexdump(0, rdr->cwekey3, len, tmp, sizeof(tmp)));
1022 }
1023 else if(cfg.http_full_cfg)
1024 { fprintf_conf(f, "cwekey3", "\n"); }
1025 }
1026
1027 static void cwekey4_fn(const char *token, char *value, void *setting, FILE *f)
1028 {
1029 struct s_reader *rdr = setting;
1030 if(value)
1031 {
1032 int32_t len = strlen(value);
1033 if(len != 32)
1034 {
1035 rdr->cwekey4_length = 0;
1036 memset(rdr->cwekey4, 0, 16);
1037 }
1038 else
1039 {
1040 if(key_atob_l(value, rdr->cwekey4, len))
1041 {
1042 fprintf(stderr, "reader cwekey4 parse error, %s=%s\n", token, value);
1043 rdr->cwekey4_length = 0;
1044 memset(rdr->cwekey4, 0, sizeof(rdr->cwekey4));
1045 }
1046 else
1047 {
1048 rdr->cwekey4_length = len/2;
1049 }
1050 }
1051 return;
1052 }
1053 int32_t len = rdr->cwekey4_length;
1054 if(len > 0)
1055 {
1056 char tmp[len * 2 + 1];
1057 fprintf_conf(f, "cwekey4", "%s\n", cs_hexdump(0, rdr->cwekey4, len, tmp, sizeof(tmp)));
1058 }
1059 else if(cfg.http_full_cfg)
1060 { fprintf_conf(f, "cwekey4", "\n"); }
1061 }
1062
1063 static void cwekey5_fn(const char *token, char *value, void *setting, FILE *f)
1064 {
1065 struct s_reader *rdr = setting;
1066 if(value)
1067 {
1068 int32_t len = strlen(value);
1069 if(len != 32)
1070 {
1071 rdr->cwekey5_length = 0;
1072 memset(rdr->cwekey5, 0, 16);
1073 }
1074 else
1075 {
1076 if(key_atob_l(value, rdr->cwekey5, len))
1077 {
1078 fprintf(stderr, "reader cwekey5 parse error, %s=%s\n", token, value);
1079 rdr->cwekey5_length = 0;
1080 memset(rdr->cwekey5, 0, sizeof(rdr->cwekey5));
1081 }
1082 else
1083 {
1084 rdr->cwekey5_length = len/2;
1085 }
1086 }
1087 return;
1088 }
1089 int32_t len = rdr->cwekey5_length;
1090 if(len > 0)
1091 {
1092 char tmp[len * 2 + 1];
1093 fprintf_conf(f, "cwekey5", "%s\n", cs_hexdump(0, rdr->cwekey5, len, tmp, sizeof(tmp)));
1094 }
1095 else if(cfg.http_full_cfg)
1096 { fprintf_conf(f, "cwekey5", "\n"); }
1097 }
1098
1099 static void cwekey6_fn(const char *token, char *value, void *setting, FILE *f)
1100 {
1101 struct s_reader *rdr = setting;
1102 if(value)
1103 {
1104 int32_t len = strlen(value);
1105 if(len != 32)
1106 {
1107 rdr->cwekey6_length = 0;
1108 memset(rdr->cwekey6, 0, 16);
1109 }
1110 else
1111 {
1112 if(key_atob_l(value, rdr->cwekey6, len))
1113 {
1114 fprintf(stderr, "reader cwekey6 parse error, %s=%s\n", token, value);
1115 rdr->cwekey6_length = 0;
1116 memset(rdr->cwekey6, 0, sizeof(rdr->cwekey6));
1117 }
1118 else
1119 {
1120 rdr->cwekey6_length = len/2;
1121 }
1122 }
1123 return;
1124 }
1125 int32_t len = rdr->cwekey6_length;
1126 if(len > 0)
1127 {
1128 char tmp[len * 2 + 1];
1129 fprintf_conf(f, "cwekey6", "%s\n", cs_hexdump(0, rdr->cwekey6, len, tmp, sizeof(tmp)));
1130 }
1131 else if(cfg.http_full_cfg)
1132 { fprintf_conf(f, "cwekey6", "\n"); }
1133 }
1134
1135 static void cwekey7_fn(const char *token, char *value, void *setting, FILE *f)
1136 {
1137 struct s_reader *rdr = setting;
1138 if(value)
1139 {
1140 int32_t len = strlen(value);
1141 if(len != 32)
1142 {
1143 rdr->cwekey7_length = 0;
1144 memset(rdr->cwekey7, 0, 16);
1145 }
1146 else
1147 {
1148 if(key_atob_l(value, rdr->cwekey7, len))
1149 {
1150 fprintf(stderr, "reader cwekey7 parse error, %s=%s\n", token, value);
1151 rdr->cwekey7_length = 0;
1152 memset(rdr->cwekey7, 0, sizeof(rdr->cwekey7));
1153 }
1154 else
1155 {
1156 rdr->cwekey7_length = len/2;
1157 }
1158 }
1159 return;
1160 }
1161 int32_t len = rdr->cwekey7_length;
1162 if(len > 0)
1163 {
1164 char tmp[len * 2 + 1];
1165 fprintf_conf(f, "cwekey7", "%s\n", cs_hexdump(0, rdr->cwekey7, len, tmp, sizeof(tmp)));
1166 }
1167 else if(cfg.http_full_cfg)
1168 { fprintf_conf(f, "cwekey7", "\n"); }
1169 }
1170 #endif
1171
1172 #if defined(READER_NAGRA)
1173 static void cak63nuid_fn(const char *token, char *value, void *setting, FILE *f)
1174 {
1175 struct s_reader *rdr = setting;
1176 if(value)
1177 {
1178 int32_t len = cs_strlen(value);
1179 if(len != 8)
1180 {
1181 rdr->cak63nuid_length = 0;
1182 memset(rdr->cak63nuid, 0, 4);
1183 }
1184 else
1185 {
1186 if(key_atob_l(value, rdr->cak63nuid, len))
1187 {
1188 fprintf(stderr, "reader cak63nuid parse error, %s=%s\n", token, value);
1189 rdr->cak63nuid_length = 0;
1190 memset(rdr->cak63nuid, 0, sizeof(rdr->cak63nuid));
1191 }
1192 else
1193 {
1194 rdr->cak63nuid_length = len/2;
1195 }
1196 }
1197 return;
1198 }
1199 int32_t len = rdr->cak63nuid_length;
1200 if(len > 0)
1201 {
1202 char tmp[len * 2 + 1];
1203 fprintf_conf(f, "cak63nuid", "%s\n", cs_hexdump(0, rdr->cak63nuid, len, tmp, sizeof(tmp)));
1204 }
1205 else if(cfg.http_full_cfg)
1206 { fprintf_conf(f, "cak63nuid", "\n"); }
1207 }
1208
1209 static void cak63cwekey_fn(const char *token, char *value, void *setting, FILE *f)
1210 {
1211 struct s_reader *rdr = setting;
1212 if(value)
1213 {
1214 int32_t len = cs_strlen(value);
1215 if(len != 32)
1216 {
1217 rdr->cak63cwekey_length = 0;
1218 memset(rdr->cak63cwekey, 0, 16);
1219 }
1220 else
1221 {
1222 if(key_atob_l(value, rdr->cak63cwekey, len))
1223 {
1224 fprintf(stderr, "reader cak63cwekey parse error, %s=%s\n", token, value);
1225 rdr->cak63cwekey_length = 0;
1226 memset(rdr->cak63cwekey, 0, sizeof(rdr->cak63cwekey));
1227 }
1228 else
1229 {
1230 rdr->cak63cwekey_length = len/2;
1231 }
1232 }
1233 return;
1234 }
1235 int32_t len = rdr->cak63cwekey_length;
1236 if(len > 0)
1237 {
1238 char tmp[len * 2 + 1];
1239 fprintf_conf(f, "cak63cwekey", "%s\n", cs_hexdump(0, rdr->cak63cwekey, len, tmp, sizeof(tmp)));
1240 }
1241 else if(cfg.http_full_cfg)
1242 { fprintf_conf(f, "cak63cwekey", "\n"); }
1243 }
1244 #endif
1245
1246 static void flags_fn(const char *token, char *value, void *setting, long flag, FILE *f)
1247 {
1248 uint32_t *var = setting;
1249 if(value)
1250 {
1251 int i = atoi(value);
1252 if(!i && (*var & flag))
1253 { *var -= flag; }
1254 if(i)
1255 { *var |= flag; }
1256 return;
1257 }
1258 if((*var & flag) || cfg.http_full_cfg)
1259 { fprintf_conf(f, token, "%d\n", (*var & flag) ? 1 : 0); }
1260 }
1261
1262 static void ins7E_fn(const char *token, char *value, void *setting, long var_size, FILE *f)
1263 {
1264 uint8_t *var = setting;
1265 var_size -= 1; // var_size contains sizeof(var) which is [X + 1]
1266 if(value)
1267 {
1268 int32_t len = cs_strlen(value);
1269 if(len != var_size * 2 || key_atob_l(value, var, len))
1270 {
1271 if(len > 0)
1272 { fprintf(stderr, "reader %s parse error, %s=%s\n", token, token, value); }
1273 memset(var, 0, var_size + 1);
1274 }
1275 else
1276 {
1277 var[var_size] = 1; // found and correct
1278 }
1279 return;
1280 }
1281 if(var[var_size])
1282 {
1283 char tmp[var_size * 2 + 1];
1284 fprintf_conf(f, token, "%s\n", cs_hexdump(0, var, var_size, tmp, sizeof(tmp)));
1285 }
1286 else if(cfg.http_full_cfg)
1287 { fprintf_conf(f, token, "\n"); }
1288 }
1289
1290 static void ins42_fn(const char *token, char *value, void *setting, long var_size, FILE *f)
1291 {
1292 uint8_t *var = setting;
1293 var_size -= 1; // var_size contains sizeof(var) which is [X + 1]
1294 if(value)
1295 {
1296 int32_t len = cs_strlen(value);
1297 if(len != var_size * 2 || key_atob_l(value, var, len))
1298 {
1299 if(len > 0)
1300 { fprintf(stderr, "reader %s parse error, %s=%s\n", token, token, value); }
1301 memset(var, 0, var_size + 1);
1302 }
1303 else
1304 {
1305 var[var_size] = 1; // found and correct
1306 }
1307 return;
1308 }
1309 if(var[var_size])
1310 {
1311 char tmp[var_size * 2 + 1];
1312 fprintf_conf(f, token, "%s\n", cs_hexdump(0, var, var_size, tmp, sizeof(tmp)));
1313 }
1314 else if(cfg.http_full_cfg)
1315 { fprintf_conf(f, token, "\n"); }
1316 }
1317
1318 static void des_and_3des_key_fn(const char *token, char *value, void *setting, FILE *f)
1319 {
1320 uint8_t *var = setting;
1321 if(value)
1322 {
1323 int32_t len = cs_strlen(value);
1324 if(((len != 16) && (len != 32)) || (key_atob_l(value, var, len)))
1325 {
1326 if(len > 0)
1327 { fprintf(stderr, "reader %s parse error, %s=%s\n", token, token, value); }
1328 memset(var, 0, 17);
1329 }
1330 else
1331 {
1332 var[16] = len/2;
1333 }
1334 return;
1335 }
1336 if(var[16])
1337 {
1338 char tmp[var[16] * 2 + 1];
1339 fprintf_conf(f, token, "%s\n", cs_hexdump(0, var, var[16], tmp, sizeof(tmp)));
1340 }
1341 else if(cfg.http_full_cfg)
1342 { fprintf_conf(f, token, "\n"); }
1343 }
1344
1345 static void atr_fn(const char *token, char *value, void *setting, FILE *f)
1346 {
1347 struct s_reader *rdr = setting;
1348 if(value)
1349 {
1350 memset(rdr->atr, 0, sizeof(rdr->atr));
1351 rdr->atrlen = cs_strlen(value);
1352 if(rdr->atrlen)
1353 {
1354 if(rdr->atrlen > (int32_t)sizeof(rdr->atr) * 2)
1355 { rdr->atrlen = (int32_t)sizeof(rdr->atr) * 2; }
1356 key_atob_l(value, rdr->atr, rdr->atrlen);
1357 }
1358 return;
1359 }
1360 if(rdr->atr[0] || cfg.http_full_cfg)
1361 {
1362 int j;
1363 fprintf_conf(f, token, "%s", ""); // it should not have \n at the end
1364 if(rdr->atr[0])
1365 {
1366 for(j = 0; j < rdr->atrlen / 2; j++)
1367 {
1368 fprintf(f, "%02X", rdr->atr[j]);
1369 }
1370 }
1371 fprintf(f, "\n");
1372 }
1373 }
1374
1375 static void detect_fn(const char *token, char *value, void *setting, FILE *f)
1376 {
1377 struct s_reader *rdr = setting;
1378 if(value)
1379 {
1380 int i;
1381 for(i = 0; RDR_CD_TXT[i]; i++)
1382 {
1383 if(!strcmp(value, RDR_CD_TXT[i]))
1384 {
1385 rdr->detect = i;
1386 }
1387 else
1388 {
1389 if(value[0] == '!' && streq(value + 1, RDR_CD_TXT[i]))
1390 { rdr->detect = i | 0x80; }
1391 }
1392 }
1393 return;
1394 }
1395 fprintf_conf(f, token, "%s%s\n", rdr->detect & 0x80 ? "!" : "", RDR_CD_TXT[rdr->detect & 0x7f]);
1396 }
1397
1398 void ftab_fn(const char *token, char *value, void *setting, long ftab_type, FILE *f)
1399 {
1400 FTAB *ftab = setting;
1401 if(value)
1402 {
1403 if(cs_strlen(value))
1404 chk_ftab(value, ftab);
1405 else
1406 ftab_clear(ftab);
1407 return;
1408 }
1409 if(ftab_type & FTAB_READER)
1410 {
1411 struct s_reader *rdr = NULL;
1412 if(ftab_type & FTAB_PROVID) { rdr = container_of(setting, struct s_reader, ftab); }
1413 if(ftab_type & FTAB_CHID) { rdr = container_of(setting, struct s_reader, fchid); }
1414 if(ftab_type & FTAB_FBPCAID) { rdr = container_of(setting, struct s_reader, fallback_percaid); }
1415 if(ftab_type & FTAB_LOCALCARDS) { rdr = container_of(setting, struct s_reader, localcards); }
1416 if(ftab_type & FTAB_IGNCHKSMCAID){ rdr = container_of(setting, struct s_reader, disablecrccws_only_for); }
1417 #ifdef WITH_EMU
1418 if(ftab_type & FTAB_EMUAU) { rdr = container_of(setting, struct s_reader, emu_auproviders); }
1419 #endif
1420 #ifdef MODULE_GBOX
1421 if(ftab_type & FTAB_CCCGBXRESHARE){ rdr = container_of(setting, struct s_reader, ccc_gbx_reshare_ident); }
1422 #endif
1423 if(rdr)
1424 { rdr->changes_since_shareupdate = 1; }
1425 }
1426 value = mk_t_ftab(ftab);
1427 if(cs_strlen(value) > 0 || cfg.http_full_cfg)
1428 { fprintf_conf(f, token, "%s\n", value); }
1429 free_mk_t(value);
1430 }
1431
1432 static void aeskeys_fn(const char *token, char *value, void *setting, FILE *f)
1433 {
1434 struct s_reader *rdr = setting;
1435 if(value)
1436 {
1437 parse_aes_keys(rdr, value);
1438 return;
1439 }
1440 value = mk_t_aeskeys(rdr);
1441 if(cs_strlen(value) > 0 || cfg.http_full_cfg)
1442 { fprintf_conf(f, token, "%s\n", value); }
1443 free_mk_t(value);
1444 }
1445
1446 static void emmcache_fn(const char *token, char *value, void *setting, FILE *f)
1447 {
1448 struct s_reader *rdr = setting;
1449 if(value)
1450 {
1451 rdr->cachemm = 0;
1452 rdr->rewritemm = 0;
1453 rdr->logemm = 0;
1454 rdr->deviceemm = 0;
1455 if(cs_strlen(value))
1456 {
1457 int i;
1458 char *ptr, *saveptr1 = NULL;
1459 for(i = 0, ptr = strtok_r(value, ",", &saveptr1); (i < 4) && (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++)
1460 {
1461 switch(i)
1462 {
1463 case 0:
1464 rdr->cachemm = atoi(ptr);
1465 break;
1466 case 1:
1467 rdr->rewritemm = atoi(ptr);
1468 break;
1469 case 2:
1470 rdr->logemm = atoi(ptr);
1471 break;
1472 case 3:
1473 rdr->deviceemm = atoi(ptr);
1474 }
1475 }
1476 if(rdr->rewritemm <= 0)
1477 {
1478 fprintf(stderr, "Setting reader \"emmcache\" to %i,%d,%i,%i instead of %i,%i,%i,%i.",
1479 rdr->cachemm, 1, rdr->logemm, rdr->deviceemm,
1480 rdr->cachemm, rdr->rewritemm, rdr->logemm, rdr->deviceemm);
1481 fprintf(stderr, "Zero or negative number of rewrites is silly\n");
1482 rdr->rewritemm = 1;
1483 }
1484 }
1485 return;
1486 }
1487 if(rdr->cachemm || rdr->logemm || cfg.http_full_cfg)
1488 { fprintf_conf(f, token, "%d,%d,%d,%d\n", rdr->cachemm, rdr->rewritemm, rdr->logemm,rdr->deviceemm); }
1489 }
1490
1491 static void blockemm_bylen_fn(const char *token, char *value, void *setting, FILE *f)
1492 {
1493 struct s_reader *rdr = setting;
1494 if(value)
1495 {
1496 char *ptr, *saveptr1 = NULL, dash;
1497 struct s_emmlen_range *blocklen;
1498 uint32_t num;
1499
1500 if(!cs_strlen(value))
1501 {
1502 ll_destroy_data(&rdr->blockemmbylen);
1503 return;
1504 }
1505
1506 if(!rdr->blockemmbylen)
1507 { rdr->blockemmbylen = ll_create("blockemmbylen"); }
1508 else
1509 { ll_clear_data(rdr->blockemmbylen); }
1510
1511 for(ptr = strtok_r(value, ",", &saveptr1); ptr;
1512 ptr = strtok_r(NULL, ",", &saveptr1))
1513 {
1514 if(!cs_malloc(&blocklen, sizeof(*blocklen)))
1515 { return; }
1516 num = sscanf(ptr, "%hd%c%hd", &blocklen->min, &dash, &blocklen->max);
1517 if(num <= 0)
1518 {
1519 NULLFREE(blocklen);
1520 fprintf(stderr, "blockemm-bylen parse error: %s\n", value);
1521 continue;
1522 }
1523 if(num == 1) // single values: x1, x2, x3, ...
1524 { blocklen->max = blocklen->min; }
1525 else if(num == 2) // range values with open end: x1-
1526 { blocklen->max = 0; }
1527 ll_append(rdr->blockemmbylen, blocklen);
1528 }
1529 return;
1530 }
1531 value = mk_t_emmbylen(rdr);
1532 if(cs_strlen(value) > 0 || cfg.http_full_cfg)
1533 { fprintf_conf(f, token, "%s\n", value); }
1534 free_mk_t(value);
1535 }
1536
1537 static void nano_fn(const char *token, char *value, void *setting, FILE *f)
1538 {
1539 uint16_t *nano = setting;
1540 if(value)
1541 {
1542 *nano = 0;
1543 if(cs_strlen(value) > 0)
1544 {
1545 if(streq(value, "all"))
1546 {
1547 *nano = 0xFFFF;
1548 }
1549 else
1550 {
1551 int32_t i;
1552 char *ptr, *saveptr1 = NULL;
1553 for(ptr = strtok_r(value, ",", &saveptr1); ptr; ptr = strtok_r(NULL, ",", &saveptr1))
1554 {
1555 i = (byte_atob(ptr) % 0x80);
1556 if(i >= 0 && i <= 16)
1557 { *nano |= (1 << i); }
1558 }
1559 }
1560 }
1561 return;
1562 }
1563 value = mk_t_nano(*nano);
1564 if(cs_strlen(value) > 0 || cfg.http_full_cfg)
1565 { fprintf_conf(f, token, "%s\n", value); }
1566 free_mk_t(value);
1567 }
1568
1569 static void auprovid_fn(const char *token, char *value, void *setting, FILE *f)
1570 {
1571 struct s_reader *rdr = setting;
1572 if(value)
1573 {
1574 rdr->auprovid = 0;
1575 if(cs_strlen(value))
1576 { rdr->auprovid = a2i(value, 3); }
1577 return;
1578 }
1579 if(rdr->auprovid)
1580 { fprintf_conf(f, token, "%06X\n", rdr->auprovid); }
1581 else if(cfg.http_full_cfg)
1582 { fprintf_conf(f, token, "\n"); }
1583 }
1584
1585 static void ratelimitecm_fn(const char *token, char *value, void *setting, FILE *f)
1586 {
1587 struct s_reader *rdr = setting;
1588 if(value)
1589 {
1590 rdr->ratelimitecm = 0;
1591 if(cs_strlen(value))
1592 {
1593 int i;
1594 rdr->ratelimitecm = atoi(value);
1595 for(i = 0; i < MAXECMRATELIMIT; i++) // reset all slots
1596 {
1597 rdr->rlecmh[i].srvid = -1;
1598 rdr->rlecmh[i].last.time = -1;
1599 }
1600 }
1601 return;
1602 }
1603 if(rdr->ratelimitecm || cfg.http_full_cfg)
1604 { fprintf_conf(f, token, "%d\n", rdr->ratelimitecm); }
1605 }
1606
1607 static void ecmunique_fn(const char *token, char *value, void *setting, FILE *f)
1608 {
1609 struct s_reader *rdr = setting;
1610 if(value)
1611 {
1612 if(cs_strlen(value) == 0)
1613 {
1614 rdr->ecmunique = 0; // default
1615 }
1616 else
1617 {
1618 rdr->ecmunique = atoi(value);
1619 if(rdr->ecmunique >= 1)
1620 { rdr->ecmunique = 1; }
1621 else
1622 { rdr->ecmunique = 0; }
1623 }
1624 return;
1625 }
1626 if((rdr->ratelimitecm && rdr->ecmunique != 0) || cfg.http_full_cfg)
1627 { fprintf_conf(f, token, "%d\n", rdr->ecmunique); }
1628 }
1629
1630 static void ratelimittime_fn(const char *token, char *value, void *setting, FILE *f)
1631 {
1632 struct s_reader *rdr = setting;
1633 if(value)
1634 {
1635 if(cs_strlen(value) == 0)
1636 {
1637 if(rdr->ratelimitecm > 0)
1638 {
1639 rdr->ratelimittime = 9000; // default 9 seconds
1640 rdr->srvidholdtime = 2000; // default 2 seconds hold
1641 }
1642 else
1643 {
1644 rdr->ratelimitecm = 0; // in case someone set a negative value
1645 rdr->ratelimittime = 0;
1646 rdr->srvidholdtime = 0;
1647 }
1648 }
1649 else
1650 {
1651 rdr->ratelimittime = atoi(value);
1652 if (rdr->ratelimittime < 60) rdr->ratelimittime *= 1000;
1653 }
1654 return;
1655 }
1656 if(rdr->ratelimitecm || cfg.http_full_cfg)
1657 { fprintf_conf(f, token, "%d\n", rdr->ratelimittime); }
1658 }
1659
1660 static void srvidholdtime_fn(const char *token, char *value, void *setting, FILE *f)
1661 {
1662 struct s_reader *rdr = setting;
1663 if(value)
1664 {
1665 if(cs_strlen(value) == 0)
1666 {
1667 if(rdr->ratelimitecm > 0)
1668 {
1669 rdr->srvidholdtime = 2000; // default 2 seconds hold
1670 }
1671 else
1672 {
1673 rdr->ratelimitecm = 0; // in case someone set a negative value
1674 rdr->srvidholdtime = 0;
1675 }
1676 }
1677 else
1678 {
1679 rdr->srvidholdtime = atoi(value);
1680 if (rdr->srvidholdtime < 60) rdr->srvidholdtime *=1000;
1681 }
1682 return;
1683 }
1684 if(rdr->ratelimitecm || cfg.http_full_cfg)
1685 { fprintf_conf(f, token, "%d\n", rdr->srvidholdtime); }
1686 }
1687
1688 static void cooldown_fn(const char *token, char *value, void *setting, FILE *f)
1689 {
1690 struct s_reader *rdr = setting;
1691 if(value)
1692 {
1693 if(cs_strlen(value) == 0)
1694 {
1695 rdr->cooldown[0] = 0;
1696 rdr->cooldown[1] = 0;
1697 }
1698 else
1699 {
1700 int32_t i;
1701 char *ptr, *saveptr1 = NULL;
1702 for(i = 0, ptr = strtok_r(value, ",", &saveptr1); (i < 2) && (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++)
1703 {
1704 rdr->cooldown[i] = atoi(ptr);
1705 }
1706 if(rdr->cooldown[0] <= 0 || rdr->cooldown[1] <= 0)
1707 {
1708 fprintf(stderr, "cooldown must have 2 positive values (x,y) set values %d,%d ! cooldown deactivated\n",
1709 rdr->cooldown[0], rdr->cooldown[1]);
1710 rdr->cooldown[0] = 0;
1711 rdr->cooldown[1] = 0;
1712 }
1713 }
1714 return;
1715 }
1716 if(rdr->cooldown[0] || cfg.http_full_cfg)
1717 {
1718 fprintf_conf(f, token, "%d,%d\n", rdr->cooldown[0], rdr->cooldown[1]);
1719 }
1720 }
1721
1722 static void cooldowndelay_fn(const char *UNUSED(token), char *value, void *setting, FILE *UNUSED(f))
1723 {
1724 struct s_reader *rdr = setting;
1725 if(value)
1726 {
1727 rdr->cooldown[0] = cs_strlen(value) ? atoi(value) : 0;
1728 }
1729 // This option is *not* written in the config file.
1730 // It is only set by WebIf as convenience
1731 }
1732
1733 static void cooldowntime_fn(const char *UNUSED(token), char *value, void *setting, FILE *UNUSED(f))
1734 {
1735 struct s_reader *rdr = setting;
1736 if(value)
1737 {
1738 if(cs_strlen(value) == 0)
1739 {
1740 rdr->cooldown[0] = 0; // no cooling down time means no cooling set
1741 rdr->cooldown[1] = 0;
1742 }
1743 else
1744 {
1745 rdr->cooldown[1] = atoi(value);
1746 }
1747 return;
1748 }
1749 // This option is *not* written in the config file.
1750 // It is only set by WebIf as convenience
1751 }
1752
1753 void reader_fixups_fn(void *var)
1754 {
1755 struct s_reader *rdr = var;
1756 #ifdef WITH_LB
1757 if(rdr->lb_weight > 1000)
1758 { rdr->lb_weight = 1000; }
1759 else if(rdr->lb_weight <= 0)
1760 { rdr->lb_weight = 100; }
1761 #endif
1762
1763 #ifdef CS_CACHEEX_AIO
1764 caidtab2ftab_add(&rdr->cacheex.localgenerated_only_in_caidtab, &rdr->cacheex.lg_only_in_tab);
1765 caidtab_clear(&rdr->cacheex.localgenerated_only_in_caidtab);
1766 caidtab2ftab_add(&rdr->cacheex.localgenerated_only_caidtab, &rdr->cacheex.lg_only_tab);
1767 caidtab_clear(&rdr->cacheex.localgenerated_only_caidtab);
1768 #endif
1769
1770 if(is_cascading_reader(rdr) && (rdr->typ == R_CAMD35 || rdr->typ == R_CS378X))
1771 {
1772 #ifdef CS_CACHEEX
1773 if(rdr && rdr->cacheex.mode>1)
1774 { rdr->keepalive = 1; } // with cacheex, it is required!
1775 else
1776 #endif
1777 if(rdr->typ == R_CAMD35)
1778 { rdr->keepalive = 0; } // with NO-cacheex, and UDP, keepalive is not required!
1779 }
1780 }
1781
1782 #define OFS(X) offsetof(struct s_reader, X)
1783 #define SIZEOF(X) sizeof(((struct s_reader *)0)->X)
1784
1785 static const struct config_list reader_opts[] =
1786 {
1787 DEF_OPT_FIXUP_FUNC(reader_fixups_fn),
1788 DEF_OPT_FUNC("label" , 0, reader_label_fn),
1789 #ifdef WEBIF
1790 DEF_OPT_STR("description" , OFS(description), NULL),
1791 #endif
1792 DEF_OPT_INT8("enable" , OFS(enable), 1),
1793 DEF_OPT_FUNC("protocol" , 0, protocol_fn),
1794 DEF_OPT_FUNC("device" , 0, device_fn),
1795 DEF_OPT_HEX("key" , OFS(ncd_key), SIZEOF(ncd_key)),
1796 DEF_OPT_SSTR("user" , OFS(r_usr), "", SIZEOF(r_usr)),
1797 DEF_OPT_SSTR("password" , OFS(r_pwd), "", SIZEOF(r_pwd)),
1798 DEF_OPT_SSTR("pincode" , OFS(pincode), "none", SIZEOF(pincode)),
1799 #ifdef MODULE_GBOX
1800 DEF_OPT_UINT8("gbox_max_distance" , OFS(gbox_maxdist), DEFAULT_GBOX_MAX_DIST),
1801 DEF_OPT_UINT8("gbox_max_ecm_send" , OFS(gbox_maxecmsend), DEFAULT_GBOX_MAX_ECM_SEND),
1802 DEF_OPT_UINT8("gbox_reshare" , OFS(gbox_reshare), DEFAULT_GBOX_RESHARE),
1803 DEF_OPT_INT8("cccam_reshare" , OFS(gbox_cccam_reshare), -1),
1804 DEF_OPT_UINT8("force_remm" , OFS(gbox_force_remm), 0),
1805 DEF_OPT_FUNC_X("ccc_gbx_reshare_ident" , OFS(ccc_gbx_reshare_ident), ftab_fn, FTAB_READER | FTAB_CCCGBXRESHARE),
1806 DEF_OPT_UINT8("send_offline_cmd" , OFS(send_offline_cmd), 0),
1807 #endif
1808 DEF_OPT_STR("readnano" , OFS(emmfile), NULL),
1809 DEF_OPT_FUNC("services" , OFS(sidtabs), reader_services_fn),
1810 DEF_OPT_FUNC("lb_whitelist_services" , OFS(lb_sidtabs), reader_lb_services_fn),
1811 DEF_OPT_INT32("inactivitytimeout" , OFS(tcp_ito), DEFAULT_INACTIVITYTIMEOUT),
1812 DEF_OPT_INT32("reconnecttimeout" , OFS(tcp_rto), DEFAULT_TCP_RECONNECT_TIMEOUT),
1813 DEF_OPT_INT32("reconnectdelay" , OFS(tcp_reconnect_delay), 60000),
1814 DEF_OPT_INT32("resetcycle" , OFS(resetcycle), 0),
1815 DEF_OPT_INT8("disableserverfilter" , OFS(ncd_disable_server_filt), 0),
1816 DEF_OPT_INT8("connectoninit" , OFS(ncd_connect_on_init), 0),
1817 DEF_OPT_UINT8("keepalive" , OFS(keepalive), 0),
1818 DEF_OPT_INT8("smargopatch" , OFS(smargopatch), 0),
1819 DEF_OPT_INT8("autospeed" , OFS(autospeed), 1),
1820 DEF_OPT_UINT8("sc8in1_dtrrts_patch" , OFS(sc8in1_dtrrts_patch), 0),
1821 DEF_OPT_INT8("fallback" , OFS(fallback), 0),
1822 DEF_OPT_FUNC_X("fallback_percaid" , OFS(fallback_percaid), ftab_fn, FTAB_READER | FTAB_FBPCAID),
1823 DEF_OPT_FUNC_X("localcards" , OFS(localcards), ftab_fn, FTAB_READER | FTAB_LOCALCARDS),
1824 DEF_OPT_FUNC_X("disablecrccws_only_for" , OFS(disablecrccws_only_for), ftab_fn, FTAB_READER | FTAB_IGNCHKSMCAID),
1825 #ifdef CS_CACHEEX
1826 DEF_OPT_INT8("cacheex" , OFS(cacheex.mode), 0),
1827 DEF_OPT_INT8("cacheex_maxhop" , OFS(cacheex.maxhop), 0),
1828 #ifdef CS_CACHEEX_AIO
1829 DEF_OPT_INT8("cacheex_maxhop_lg" , OFS(cacheex.maxhop_lg), 0),
1830 #endif
1831 DEF_OPT_FUNC("cacheex_ecm_filter" , OFS(cacheex.filter_caidtab), cacheex_hitvaluetab_fn),
1832 DEF_OPT_UINT8("cacheex_allow_request" , OFS(cacheex.allow_request), 0),
1833 DEF_OPT_UINT8("cacheex_drop_csp" , OFS(cacheex.drop_csp), 0),
1834 DEF_OPT_UINT8("cacheex_allow_filter" , OFS(cacheex.allow_filter), 1),
1835 #ifdef CS_CACHEEX_AIO
1836 DEF_OPT_UINT8("cacheex_allow_maxhop" , OFS(cacheex.allow_maxhop), 0),
1837 #endif
1838 DEF_OPT_UINT8("cacheex_block_fakecws" , OFS(cacheex.block_fakecws), 0),
1839 #ifdef CS_CACHEEX_AIO
1840 DEF_OPT_UINT8("cacheex_cw_check_for_push" , OFS(cacheex.cw_check_for_push), 0),
1841 DEF_OPT_UINT8("cacheex_lg_only_remote_settings", OFS(cacheex.lg_only_remote_settings), 1),
1842 DEF_OPT_UINT8("cacheex_localgenerated_only" , OFS(cacheex.localgenerated_only), 0),
1843 DEF_OPT_FUNC("cacheex_localgenerated_only_caid", OFS(cacheex.localgenerated_only_caidtab), check_caidtab_fn),
1844 DEF_OPT_FUNC_X("cacheex_lg_only_tab" , OFS(cacheex.lg_only_tab), ftab_fn, FTAB_ACCOUNT),
1845 DEF_OPT_UINT8("cacheex_lg_only_in_aio_only" , OFS(cacheex.lg_only_in_aio_only), 0),
1846 DEF_OPT_UINT8("cacheex_localgenerated_only_in", OFS(cacheex.localgenerated_only_in), 0),
1847 DEF_OPT_FUNC("cacheex_localgenerated_only_in_caid", OFS(cacheex.localgenerated_only_in_caidtab), check_caidtab_fn),
1848 DEF_OPT_FUNC_X("cacheex_lg_only_in_tab" , OFS(cacheex.lg_only_in_tab), ftab_fn, FTAB_ACCOUNT),
1849 DEF_OPT_FUNC("cacheex_nopushafter" , OFS(cacheex.cacheex_nopushafter_tab), caidvaluetab_fn),
1850 #endif
1851 #endif
1852 DEF_OPT_FUNC("caid" , OFS(ctab), reader_caid_fn),
1853 DEF_OPT_FUNC("atr" , 0, atr_fn),
1854 DEF_OPT_FUNC("boxid" , 0, boxid_fn),
1855 DEF_OPT_FUNC("boxkey" , 0, boxkey_fn),
1856 DEF_OPT_FUNC("rsakey" , 0, rsakey_fn),
1857 DEF_OPT_FUNC("cwpkkey" , 0, cwpkkey_fn),
1858 DEF_OPT_FUNC("deskey" , 0, deskey_fn),
1859 #ifdef READER_NAGRA_MERLIN
1860 DEF_OPT_FUNC("mod1" , 0, mod1_fn),
1861 DEF_OPT_FUNC("idird" , 0, idird_fn),
1862 DEF_OPT_FUNC("cmd0eprov" , 0, cmd0eprov_fn),
1863 DEF_OPT_FUNC("mod2" , 0, mod2_fn),
1864 DEF_OPT_FUNC("key3588" , 0, key3588_fn),
1865 DEF_OPT_FUNC("key3460" , 0, key3460_fn),
1866 DEF_OPT_FUNC("key3310" , 0, key3310_fn),
1867 DEF_OPT_FUNC("data50" , 0, data50_fn),
1868 DEF_OPT_FUNC("mod50" , 0, mod50_fn),
1869 DEF_OPT_FUNC("nuid" , 0, nuid_fn),
1870 DEF_OPT_FUNC("forcepair" , 0, forcepair_fn),
1871 DEF_OPT_FUNC("otpcsc" , 0, otpcsc_fn),
1872 DEF_OPT_FUNC("otacsc" , 0, otacsc_fn),
1873 DEF_OPT_FUNC("cwpkcaid" , 0, cwpkcaid_fn),
1874 DEF_OPT_FUNC("cwekey0" , 0, cwekey0_fn),
1875 DEF_OPT_FUNC("cwekey1" , 0, cwekey1_fn),
1876 DEF_OPT_FUNC("cwekey2" , 0, cwekey2_fn),
1877 DEF_OPT_FUNC("cwekey3" , 0, cwekey3_fn),
1878 DEF_OPT_FUNC("cwekey4" , 0, cwekey4_fn),
1879 DEF_OPT_FUNC("cwekey5" , 0, cwekey5_fn),
1880 DEF_OPT_FUNC("cwekey6" , 0, cwekey6_fn),
1881 DEF_OPT_FUNC("cwekey7" , 0, cwekey7_fn),
1882 DEF_OPT_INT8("forcecwswap" , OFS(forcecwswap), 0),
1883 DEF_OPT_INT8("evensa" , OFS(evensa), 0),
1884 DEF_OPT_INT8("forceemmg" , OFS(forceemmg), 0),
1885 DEF_OPT_INT8("cwpkota" , OFS(cwpkota), 0),
1886 #endif
1887 #if defined(READER_NAGRA)
1888 DEF_OPT_FUNC("cak63nuid" , 0, cak63nuid_fn),
1889 DEF_OPT_FUNC("cak63cwekey" , 0, cak63cwekey_fn),
1890 #endif
1891
1892 DEF_OPT_INT8("cak7_mode" , OFS(cak7_mode), 0),
1893 DEF_OPT_FUNC_X("ins7e" , OFS(ins7E), ins7E_fn, SIZEOF(ins7E)),
1894 DEF_OPT_FUNC_X("ins42" , OFS(ins42), ins42_fn, SIZEOF(ins42)),
1895 DEF_OPT_FUNC_X("ins7e11" , OFS(ins7E11), ins7E_fn, SIZEOF(ins7E11)),
1896 DEF_OPT_FUNC_X("ins2e06" , OFS(ins2e06), ins7E_fn, SIZEOF(ins2e06)),
1897 DEF_OPT_FUNC("k1_generic" , OFS(k1_generic), des_and_3des_key_fn),
1898 DEF_OPT_FUNC("k1_unique" , OFS(k1_unique), des_and_3des_key_fn),
1899 DEF_OPT_INT8("fix07" , OFS(fix_07), 1),
1900 DEF_OPT_INT8("fix9993" , OFS(fix_9993), 0),
1901 DEF_OPT_INT8("readtiers" , OFS(readtiers), 1),
1902 DEF_OPT_INT8("force_irdeto" , OFS(force_irdeto), 0),
1903 DEF_OPT_INT8("needsemmfirst" , OFS(needsemmfirst), 0),
1904 #ifdef READER_CRYPTOWORKS
1905 DEF_OPT_INT8("needsglobalfirst" , OFS(needsglobalfirst), 0),
1906 #endif
1907 DEF_OPT_UINT32("ecmnotfoundlimit" , OFS(ecmnotfoundlimit), 0),
1908 DEF_OPT_FUNC("ecmwhitelist" , 0, ecmwhitelist_fn),
1909 DEF_OPT_FUNC("ecmheaderwhitelist" , 0, ecmheaderwhitelist_fn),
1910 DEF_OPT_FUNC("detect" , 0, detect_fn),
1911 DEF_OPT_INT8("nagra_read" , OFS(nagra_read), 0),
1912 DEF_OPT_INT8("detect_seca_nagra_tunneled_card", OFS(detect_seca_nagra_tunneled_card), 1),
1913 DEF_OPT_INT32("mhz" , OFS(mhz), 357),
1914 DEF_OPT_INT32("cardmhz" , OFS(cardmhz), 357),
1915 #ifdef WITH_AZBOX
1916 DEF_OPT_INT32("mode" , OFS(azbox_mode), -1),
1917 #endif
1918 DEF_OPT_FUNC_X("ident" , OFS(ftab), ftab_fn, FTAB_READER | FTAB_PROVID),
1919 DEF_OPT_FUNC_X("chid" , OFS(fchid), ftab_fn, FTAB_READER | FTAB_CHID),
1920 DEF_OPT_FUNC("class" , OFS(cltab), class_fn),
1921 DEF_OPT_FUNC("aeskeys" , 0, aeskeys_fn),
1922 DEF_OPT_FUNC("group" , OFS(grp), group_fn),
1923 DEF_OPT_FUNC("emmcache" , 0, emmcache_fn),
1924 DEF_OPT_FUNC_X("blockemm-unknown" , OFS(blockemm), flags_fn, EMM_UNKNOWN),
1925 DEF_OPT_FUNC_X("blockemm-u" , OFS(blockemm), flags_fn, EMM_UNIQUE),
1926 DEF_OPT_FUNC_X("blockemm-s" , OFS(blockemm), flags_fn, EMM_SHARED),
1927 DEF_OPT_FUNC_X("blockemm-g" , OFS(blockemm), flags_fn, EMM_GLOBAL),
1928 DEF_OPT_FUNC_X("saveemm-unknown" , OFS(saveemm), flags_fn, EMM_UNKNOWN),
1929 DEF_OPT_FUNC_X("saveemm-u" , OFS(saveemm), flags_fn, EMM_UNIQUE),
1930 DEF_OPT_FUNC_X("saveemm-s" , OFS(saveemm), flags_fn, EMM_SHARED),
1931 DEF_OPT_FUNC_X("saveemm-g" , OFS(saveemm), flags_fn, EMM_GLOBAL),
1932 DEF_OPT_FUNC("blockemm-bylen" , 0, blockemm_bylen_fn),
1933 #ifdef WITH_LB
1934 DEF_OPT_INT32("lb_weight" , OFS(lb_weight), 100),
1935 DEF_OPT_INT8("lb_force_fallback" , OFS(lb_force_fallback), 0),
1936 #endif
1937 DEF_OPT_FUNC("savenano" , OFS(s_nano), nano_fn),
1938 DEF_OPT_FUNC("blocknano" , OFS(b_nano), nano_fn),
1939 DEF_OPT_INT8("dropbadcws" , OFS(dropbadcws), 0),
1940 DEF_OPT_INT8("disablecrccws" , OFS(disablecrccws), 0),
1941 DEF_OPT_INT32("use_gpio" , OFS(use_gpio), 0),
1942 #ifdef MODULE_PANDORA
1943 DEF_OPT_UINT8("pand_send_ecm" , OFS(pand_send_ecm), 0),
1944 #endif
1945 #ifdef MODULE_CCCAM
1946 DEF_OPT_SSTR("cccversion" , OFS(cc_version), "", SIZEOF(cc_version)),
1947 DEF_OPT_INT8("cccmaxhops" , OFS(cc_maxhops), DEFAULT_CC_MAXHOPS),
1948 DEF_OPT_INT8("cccmindown" , OFS(cc_mindown), 0),
1949 DEF_OPT_INT8("cccwantemu" , OFS(cc_want_emu), 0),
1950 DEF_OPT_INT8("ccckeepalive" , OFS(cc_keepalive), DEFAULT_CC_KEEPALIVE),
1951 DEF_OPT_INT8("cccreshare" , OFS(cc_reshare), DEFAULT_CC_RESHARE),
1952 DEF_OPT_INT32("cccreconnect" , OFS(cc_reconnect), DEFAULT_CC_RECONNECT),
1953 DEF_OPT_INT8("ccchop" , OFS(cc_hop), 0),
1954 #endif
1955 #ifdef MODULE_GHTTP
1956 DEF_OPT_UINT8("use_ssl" , OFS(ghttp_use_ssl), 0),
1957 #endif
1958 #if defined(READER_DRE) || defined(READER_DRECAS)
1959 DEF_OPT_HEX("force_ua" , OFS(force_ua), 4),
1960 DEF_OPT_STR("exec_cmd_file" , OFS(userscript), NULL),
1961 #endif
1962 #ifdef READER_DRECAS
1963 DEF_OPT_STR("stmkeys" , OFS(stmkeys), NULL),
1964 #endif
1965 #ifdef WITH_EMU
1966 DEF_OPT_FUNC_X("emu_auproviders" , OFS(emu_auproviders), ftab_fn, FTAB_READER | FTAB_EMUAU),
1967 DEF_OPT_INT8("emu_datecodedenabled" , OFS(emu_datecodedenabled), 0),
1968 #endif
1969 DEF_OPT_INT8("deprecated" , OFS(deprecated), 0),
1970 DEF_OPT_INT8("audisabled" , OFS(audisabled), 0),
1971 DEF_OPT_INT8("autype" , OFS(autype), 0),
1972 DEF_OPT_FUNC("auprovid" , 0, auprovid_fn),
1973 DEF_OPT_INT8("ndsversion" , OFS(ndsversion), 0),
1974 DEF_OPT_FUNC("ratelimitecm" , 0, ratelimitecm_fn),
1975 DEF_OPT_FUNC("ecmunique" , 0, ecmunique_fn),
1976 DEF_OPT_FUNC("ratelimittime" , 0, ratelimittime_fn),
1977 DEF_OPT_FUNC("srvidholdtime" , 0, srvidholdtime_fn),
1978 DEF_OPT_FUNC("cooldown" , 0, cooldown_fn),
1979 DEF_OPT_FUNC("cooldowndelay" , 0, cooldowndelay_fn),
1980 DEF_OPT_FUNC("cooldowntime" , 0, cooldowntime_fn),
1981 DEF_OPT_UINT8("read_old_classes" , OFS(read_old_classes), 1),
1982 DEF_LAST_OPT
1983 };
1984
1985 static inline bool in_list(const char *token, const char *list[])
1986 {
1987 int i;
1988 for(i = 0; list[i]; i++)
1989 {
1990 if(streq(token, list[i]))
1991 { return true; }
1992 }
1993 return false;
1994 }
1995
1996 static bool reader_check_setting(const struct config_list *UNUSED(clist), void *config_data, const char *setting)
1997 {
1998 struct s_reader *reader = config_data;
1999 // These are written only when the reader is physical reader
2000 static const char *hw_only_settings[] =
2001 {
2002 "readnano", "resetcycle", "smargopatch", "autospeed", "sc8in1_dtrrts_patch", "boxid","fix07",
2003 "fix9993", "rsakey", "deskey", "ins7e", "ins42", "ins7e11", "ins2e06", "k1_generic", "k1_unique", "force_irdeto", "needsemmfirst", "boxkey",
2004 "atr", "detect", "nagra_read", "mhz", "cardmhz", "readtiers", "read_old_classes", "use_gpio", "needsglobalfirst",
2005 #ifdef READER_NAGRA_MERLIN
2006 "mod1", "idird", "cmd0eprov", "mod2", "key3588", "key3460", "key3310", "data50", "mod50", "nuid", "forcepair", "otpcsc", "otacsc", "cwpkcaid", "cwekey0", "cwekey1", "cwekey2", "cwekey3", "cwekey4", "cwekey5", "cwekey6", "cwekey7",
2007 #endif
2008 #if defined(READER_NAGRA)
2009 "cak63nuid", "cak63cwekey",
2010 #endif
2011 #if defined(READER_DRE) || defined(READER_DRECAS)
2012 "exec_cmd_file",
2013 #endif
2014 #ifdef READER_CONAX
2015 "cwpkkey",
2016 #endif
2017 #ifdef WITH_AZBOX
2018 "mode",
2019 #endif
2020 "deprecated", "ndsversion",
2021 0
2022 };
2023 // These are written only when the reader is network reader
2024 static const char *network_only_settings[] =
2025 {
2026 "user", "inactivitytimeout", "reconnecttimeout", "autype",
2027 0
2028 };
2029 if(is_network_reader(reader))
2030 {
2031 if(in_list(setting, hw_only_settings))
2032 { return false; }
2033 }
2034 else
2035 {
2036 if(in_list(setting, network_only_settings))
2037 { return false; }
2038 }
2039
2040 // These are not written in the config file
2041 static const char *deprecated_settings[] =
2042 {
2043 "cooldowndelay", "cooldowntime",
2044 0
2045 };
2046 if(in_list(setting, deprecated_settings))
2047 { return false; }
2048
2049 // Special settings for NEWCAMD
2050 static const char *newcamd_settings[] =
2051 {
2052 "disableserverfilter", "connectoninit",
2053 0
2054 };
2055 if(reader->typ != R_NEWCAMD && in_list(setting, newcamd_settings))
2056 { return false; }
2057 #ifdef MODULE_CCCAM
2058 // These are written only when the reader is CCCAM
2059 static const char *cccam_settings[] =
2060 {
2061 "cccversion", "cccmaxhops", "cccmindown", "cccwantemu", "ccckeepalive",
2062 "cccreconnect",
2063 0
2064 };
2065 // Special settings for CCCAM
2066 if(reader->typ != R_CCCAM)
2067 {
2068 if(in_list(setting, cccam_settings))
2069 { return false; }
2070 }
2071 else if(streq(setting, "ccchop"))
2072 {
2073 return false;
2074 }
2075 #endif
2076
2077 #ifdef MODULE_PANDORA
2078 // Special settings for PANDORA
2079 if(reader->typ != R_PANDORA && streq(setting, "pand_send_ecm"))
2080 { return false; }
2081 #endif
2082
2083 #ifdef MODULE_GBOX
2084 // These are written only when the reader is GBOX
2085 static const char *gbox_settings[] =
2086 {
2087 "gbox_max_distance", "gbox_max_ecm_send", "gbox_reshare", "cccam_reshare", "force_remm","ccc_gbx_reshare_ident","send_offline_cmd",
2088 0
2089 };
2090 if(reader->typ != R_GBOX)
2091 {
2092 if(in_list(setting, gbox_settings))
2093 { return false; }
2094 }
2095 #endif
2096
2097 return true; // Write the setting
2098 }
2099
2100 void chk_reader(char *token, char *value, struct s_reader *rdr)
2101 {
2102 if(config_list_parse(reader_opts, token, value, rdr))
2103 { return; }
2104 else if(token[0] != '#')
2105 { fprintf(stderr, "Warning: keyword '%s' in reader section not recognized\n", token); }
2106 }
2107
2108 void reader_set_defaults(struct s_reader *rdr)
2109 {
2110 config_list_set_defaults(reader_opts, rdr);
2111 }
2112
2113 int32_t init_readerdb(void)
2114 {
2115 configured_readers = ll_create("configured_readers");
2116
2117 FILE *fp = open_config_file(cs_srvr);
2118 if(!fp)
2119 { return 1; }
2120
2121 int32_t tag = 0;
2122 char *value, *token;
2123
2124 if(!cs_malloc(&token, MAXLINESIZE))
2125 { return 1; }
2126
2127 struct s_reader *rdr;
2128 if(!cs_malloc(&rdr, sizeof(struct s_reader)))
2129 {
2130 NULLFREE(token);
2131 return 1;
2132 }
2133
2134 ll_append(configured_readers, rdr);
2135 while(fgets(token, MAXLINESIZE, fp))
2136 {
2137 int32_t l;
2138 if((l = cs_strlen(trim(token))) < 3)
2139 { continue; }
2140 if((token[0] == '[') && (token[l - 1] == ']'))
2141 {
2142 token[l - 1] = 0;
2143 tag = (!strcmp("reader", strtolower(token + 1)));
2144 if(rdr->label[0] && rdr->typ)
2145 {
2146 struct s_reader *newreader;
2147 if(cs_malloc(&newreader, sizeof(struct s_reader)))
2148 {
2149 ll_append(configured_readers, newreader);
2150 rdr = newreader;
2151 }
2152 }
2153 reader_set_defaults(rdr);
2154 continue;
2155 }
2156
2157 if(!tag)
2158 { continue; }
2159 if(!(value = strchr(token, '=')))
2160 { continue; }
2161 *value++ = '\0';
2162 chk_reader(trim(strtolower(token)), trim(value), rdr);
2163 }
2164 NULLFREE(token);
2165 LL_ITER itr = ll_iter_create(configured_readers);
2166 while((rdr = ll_iter_next(&itr))) // build active readers list
2167 {
2168 reader_fixups_fn(rdr);
2169 module_reader_set(rdr);
2170 }
2171 fclose(fp);
2172 return (0);
2173 }
2174
2175 void free_reader(struct s_reader *rdr)
2176 {
2177 NULLFREE(rdr->emmfile);
2178
2179 ecm_whitelist_clear(&rdr->ecm_whitelist);
2180 ecm_hdr_whitelist_clear(&rdr->ecm_hdr_whitelist);
2181
2182 ftab_clear(&rdr->fallback_percaid);
2183 ftab_clear(&rdr->localcards);
2184 ftab_clear(&rdr->fchid);
2185 ftab_clear(&rdr->ftab);
2186 ftab_clear(&rdr->disablecrccws_only_for);
2187 #ifdef MODULE_GBOX
2188 ftab_clear(&rdr->ccc_gbx_reshare_ident);
2189 #endif
2190
2191 NULLFREE(rdr->cltab.aclass);
2192 NULLFREE(rdr->cltab.bclass);
2193
2194 caidtab_clear(&rdr->ctab);
2195 #ifdef CS_CACHEEX
2196 cecspvaluetab_clear(&rdr->cacheex.filter_caidtab);
2197 #ifdef CS_CACHEEX_AIO
2198 caidtab_clear(&rdr->cacheex.localgenerated_only_caidtab);
2199 caidtab_clear(&rdr->cacheex.localgenerated_only_in_caidtab);
2200 ftab_clear(&rdr->cacheex.lg_only_tab);
2201 ftab_clear(&rdr->cacheex.lg_only_in_tab);
2202 caidvaluetab_clear(&rdr->cacheex.cacheex_nopushafter_tab);
2203 #endif
2204 #endif
2205 lb_destroy_stats(rdr);
2206
2207 cs_clear_entitlement(rdr);
2208 ll_destroy(&rdr->ll_entitlements);
2209
2210 if(rdr->csystem && rdr->csystem->card_done)
2211 rdr->csystem->card_done(rdr);
2212 NULLFREE(rdr->csystem_data);
2213
2214 ll_destroy_data(&rdr->blockemmbylen);
2215
2216 ll_destroy_data(&rdr->emmstat);
2217
2218 aes_clear_entries(&rdr->aes_list);
2219
2220 config_list_gc_values(reader_opts, rdr);
2221 add_garbage(rdr);
2222 }
2223
2224 int32_t free_readerdb(void)
2225 {
2226 int count = 0;
2227 struct s_reader *rdr;
2228 LL_ITER itr = ll_iter_create(configured_readers);
2229 while((rdr = ll_iter_next(&itr)))
2230 {
2231 free_reader(rdr);
2232 count++;
2233 }
2234 cs_log("readerdb %d readers freed", count);
2235 ll_destroy(&configured_readers);
2236 return count;
2237 }
2238
2239 int32_t write_server(void)
2240 {
2241 FILE *f = create_config_file(cs_srvr);
2242 if(!f)
2243 { return 1; }
2244 struct s_reader *rdr;
2245 LL_ITER itr = ll_iter_create(configured_readers);
2246 while((rdr = ll_iter_next(&itr)))
2247 {
2248 if(rdr->label[0])
2249 {
2250 fprintf(f, "[reader]\n");
2251 config_list_apply_fixups(reader_opts, rdr);
2252 config_list_save_ex(f, reader_opts, rdr, cfg.http_full_cfg, reader_check_setting);
2253 fprintf(f, "\n");
2254 }
2255 }
2256 return flush_config_file(f, cs_srvr);
2257 }
2258
2259 void reload_readerdb(void)
2260 {
2261 struct s_reader *rdr;
2262 LL_ITER itr = ll_iter_create(configured_readers);
2263 while((rdr = ll_iter_next(&itr)))
2264 {
2265 // disable the current reader
2266 rdr->enable = 0;
2267 restart_cardreader(rdr,1);
2268 }
2269 free_readerdb(); // release the old readerdb
2270 init_readerdb(); // reload the new readerdb
2271 init_cardreader(); // start the readers
2272 }
Open Source Conditional Access Modul