1 #define MODULE_LOG_PREFIX "config"
4 #include "module-stat.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"
16 #include "module-gbox.h"
19 #include "module-cacheex.h"
22 #define cs_srvr "oscam.server"
24 extern const struct s_cardreader
*cardreaders
[];
25 extern char *RDR_CD_TXT
[];
27 static void reader_label_fn(const char *token
, char *value
, void *setting
, FILE *f
)
29 struct s_reader
*rdr
= setting
;
35 for(i
= 0; i
< (int)cs_strlen(value
); i
++)
44 { fprintf(stderr
, "Configuration reader: corrected label to %s\n", value
); }
45 cs_strncpy(rdr
->label
, value
, sizeof(rdr
->label
));
48 fprintf_conf(f
, token
, "%s\n", rdr
->label
);
51 static void ecmwhitelist_fn(const char *token
, char *value
, void *setting
, FILE *f
)
53 struct s_reader
*rdr
= setting
;
57 chk_ecm_whitelist(value
, &rdr
->ecm_whitelist
);
59 ecm_whitelist_clear(&rdr
->ecm_whitelist
);
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
); }
69 static void ecmheaderwhitelist_fn(const char *token
, char *value
, void *setting
, FILE *f
)
71 struct s_reader
*rdr
= setting
;
75 chk_ecm_hdr_whitelist(value
, &rdr
->ecm_hdr_whitelist
);
77 ecm_hdr_whitelist_clear(&rdr
->ecm_hdr_whitelist
);
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
); }
87 static void protocol_fn(const char *token
, char *value
, void *setting
, FILE *f
)
89 struct s_reader
*rdr
= setting
;
92 if(cs_strlen(value
) == 0)
100 { "serial", R_SERIAL
},
101 { "camd35", R_CAMD35
},
102 { "cs378x", R_CS378X
},
103 { "cs357x", R_CAMD35
},
104 { "camd33", R_CAMD33
},
106 { "cccam", R_CCCAM
},
107 { "cccam_ext", R_CCCAM
},
108 { "cccam_mcs", R_CCCAM
},
109 { "constcw", R_CONSTCW
},
110 { "radegast", R_RADEGAST
},
112 { "ghttp", R_GHTTP
},
113 { "newcamd", R_NEWCAMD
},
114 { "newcamd525", R_NEWCAMD
},
115 { "newcamd524", R_NEWCAMD
},
116 { "drecas", R_DRECAS
},
121 // Parse card readers
122 for(i
= 0; cardreaders
[i
]; i
++)
124 if(streq(value
, cardreaders
[i
]->desc
))
126 rdr
->crdr
= cardreaders
[i
];
127 rdr
->typ
= cardreaders
[i
]->typ
;
132 for(i
= 0, p
= &protocols
[0]; p
->name
; p
= &protocols
[++i
])
134 if(streq(p
->name
, value
))
140 if(rdr
->typ
== R_NEWCAMD
)
141 { rdr
->ncd_proto
= streq(value
, "newcamd524") ? NCD_524
: NCD_525
; }
144 fprintf(stderr
, "ERROR: '%s' is unsupported reader protocol!\n", value
);
149 fprintf_conf(f
, token
, "%s\n", reader_get_type_desc(rdr
, 0));
152 static void device_fn(const char *token
, char *value
, void *setting
, FILE *f
)
154 struct s_reader
*rdr
= setting
;
155 int32_t isphysical
= !is_network_reader(rdr
);
159 char *ptr
, *saveptr1
= NULL
;
160 for(i
= 0, ptr
= strtok_r(value
, ",", &saveptr1
); (i
< 3) && (ptr
); ptr
= strtok_r(NULL
, ",", &saveptr1
), i
++)
166 cs_strncpy(rdr
->device
, ptr
, sizeof(rdr
->device
));
169 rdr
->r_port
= atoi(ptr
);
172 rdr
->l_port
= atoi(ptr
);
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
); }
186 static void reader_services_fn(const char *token
, char *value
, void *setting
, FILE *f
)
188 services_fn(token
, value
, setting
, f
);
191 struct s_reader
*rdr
= container_of(setting
, struct s_reader
, sidtabs
);
193 { rdr
->changes_since_shareupdate
= 1; }
197 static void reader_lb_services_fn(const char *token
, char *value
, void *setting
, FILE *f
)
199 services_fn(token
, value
, setting
, f
);
202 struct s_reader
*rdr
= container_of(setting
, struct s_reader
, lb_sidtabs
);
204 { rdr
->changes_since_shareupdate
= 1; }
208 static void reader_caid_fn(const char *token
, char *value
, void *setting
, FILE *f
)
210 check_caidtab_fn(token
, value
, setting
, f
);
213 struct s_reader
*rdr
= container_of(setting
, struct s_reader
, ctab
);
215 { rdr
->changes_since_shareupdate
= 1; }
219 static void boxid_fn(const char *token
, char *value
, void *setting
, FILE *f
)
221 struct s_reader
*rdr
= setting
;
224 rdr
->boxid
= cs_strlen(value
) ? a2i(value
, 4) : 0;
228 { fprintf_conf(f
, token
, "%08X\n", rdr
->boxid
); }
229 else if(cfg
.http_full_cfg
)
230 { fprintf_conf(f
, token
, "\n"); }
233 static void cwpkkey_fn(const char *token
, char *value
, void *setting
, FILE *f
)
235 struct s_reader
*rdr
= setting
;
238 int32_t len
= strlen(value
);
239 // rdr_log(rdr, "CWPK config key length: %16X", len);
240 if(len
== 0 || len
> 32)
242 rdr
->cwpk_mod_length
= 0;
243 memset(rdr
->cwpk_mod
, 0, sizeof(rdr
->cwpk_mod
));
247 if(key_atob_l(value
, rdr
->cwpk_mod
, len
))
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
));
255 rdr
->cwpk_mod_length
= len
/2;
260 int32_t len
= rdr
->cwpk_mod_length
;
263 char tmp
[len
* 2 + 1];
264 fprintf_conf(f
, "cwpkkey", "%s\n", cs_hexdump(0, rdr
->cwpk_mod
, len
, tmp
, sizeof(tmp
)));
266 else if(cfg
.http_full_cfg
)
267 { fprintf_conf(f
, "cwpkkey", "\n"); }
270 static void rsakey_fn(const char *token
, char *value
, void *setting
, FILE *f
)
272 struct s_reader
*rdr
= setting
;
275 int32_t len
= cs_strlen(value
);
276 if(len
!= 128 && len
!= 240)
278 rdr
->rsa_mod_length
= 0;
279 memset(rdr
->rsa_mod
, 0, 120);
283 if(key_atob_l(value
, rdr
->rsa_mod
, len
))
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
));
291 rdr
->rsa_mod_length
= len
/2;
296 int32_t len
= rdr
->rsa_mod_length
;
299 char tmp
[len
* 2 + 1];
300 fprintf_conf(f
, "rsakey", "%s\n", cs_hexdump(0, rdr
->rsa_mod
, len
, tmp
, sizeof(tmp
)));
302 else if(cfg
.http_full_cfg
)
303 { fprintf_conf(f
, "rsakey", "\n"); }
306 static void deskey_fn(const char *token
, char *value
, void *setting
, FILE *f
)
308 struct s_reader
*rdr
= setting
;
311 int32_t len
= cs_strlen(value
);
312 if(((len
% 16) != 0) || len
== 0 || len
> 128*2)
314 rdr
->des_key_length
= 0;
315 memset(rdr
->des_key
, 0, sizeof(rdr
->des_key
));
319 if(key_atob_l(value
, rdr
->des_key
, len
))
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
));
327 rdr
->des_key_length
= len
/2;
332 int32_t len
= rdr
->des_key_length
;
335 char tmp
[len
* 2 + 1];
336 fprintf_conf(f
, "deskey", "%s\n", cs_hexdump(0, rdr
->des_key
, len
, tmp
, sizeof(tmp
)));
338 else if(cfg
.http_full_cfg
)
339 { fprintf_conf(f
, "deskey", "\n"); }
342 static void boxkey_fn(const char *token
, char *value
, void *setting
, FILE *f
)
344 struct s_reader
*rdr
= setting
;
347 int32_t len
= cs_strlen(value
);
348 if(((len
% 8) != 0) || len
== 0 || len
> 32)
350 rdr
->boxkey_length
= 0;
351 memset(rdr
->boxkey
, 0, sizeof(rdr
->boxkey
));
355 if(key_atob_l(value
, rdr
->boxkey
, len
))
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
));
363 rdr
->boxkey_length
= len
/2;
368 int32_t len
= rdr
->boxkey_length
;
371 char tmp
[len
* 2 + 1];
372 fprintf_conf(f
, "boxkey", "%s\n", cs_hexdump(0, rdr
->boxkey
, len
, tmp
, sizeof(tmp
)));
374 else if(cfg
.http_full_cfg
)
375 { fprintf_conf(f
, "boxkey", "\n"); }
378 #ifdef READER_NAGRA_MERLIN
379 static void mod1_fn(const char *token
, char *value
, void *setting
, FILE *f
)
381 struct s_reader
*rdr
= setting
;
384 int32_t len
= cs_strlen(value
);
387 rdr
->mod1_length
= 0;
388 memset(rdr
->mod1
, 0, 112);
392 if(key_atob_l(value
, rdr
->mod1
, len
))
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
));
400 rdr
->mod1_length
= len
/2;
405 int32_t len
= rdr
->mod1_length
;
408 char tmp
[len
* 2 + 1];
409 fprintf_conf(f
, "mod1", "%s\n", cs_hexdump(0, rdr
->mod1
, len
, tmp
, sizeof(tmp
)));
411 else if(cfg
.http_full_cfg
)
412 { fprintf_conf(f
, "mod1", "\n"); }
415 static void mod2_fn(const char *token
, char *value
, void *setting
, FILE *f
)
417 struct s_reader
*rdr
= setting
;
420 int32_t len
= strlen(value
);
423 rdr
->mod2_length
= 0;
424 memset(rdr
->mod2
, 0, 112);
428 if(key_atob_l(value
, rdr
->mod2
, len
))
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
));
436 rdr
->mod2_length
= len
/2;
441 int32_t len
= rdr
->mod2_length
;
444 char tmp
[len
* 2 + 1];
445 fprintf_conf(f
, "mod2", "%s\n", cs_hexdump(0, rdr
->mod2
, len
, tmp
, sizeof(tmp
)));
447 else if(cfg
.http_full_cfg
)
448 { fprintf_conf(f
, "mod2", "\n"); }
451 static void idird_fn(const char *token
, char *value
, void *setting
, FILE *f
)
453 struct s_reader
*rdr
= setting
;
456 int32_t len
= strlen(value
);
459 rdr
->idird_length
= 0;
460 memset(rdr
->idird
, 0, 4);
464 if(key_atob_l(value
, rdr
->idird
, len
))
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
));
472 rdr
->idird_length
= len
/2;
477 int32_t len
= rdr
->idird_length
;
480 char tmp
[len
* 2 + 1];
481 fprintf_conf(f
, "idird", "%s\n", cs_hexdump(0, rdr
->idird
, len
, tmp
, sizeof(tmp
)));
483 else if(cfg
.http_full_cfg
)
484 { fprintf_conf(f
, "idird", "\n"); }
487 static void cmd0eprov_fn(const char *token
, char *value
, void *setting
, FILE *f
)
489 struct s_reader
*rdr
= setting
;
492 int32_t len
= strlen(value
);
495 rdr
->cmd0eprov_length
= 0;
496 memset(rdr
->cmd0eprov
, 0, 2);
500 if(key_atob_l(value
, rdr
->cmd0eprov
, len
))
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
));
508 rdr
->cmd0eprov_length
= len
/2;
513 int32_t len
= rdr
->cmd0eprov_length
;
516 char tmp
[len
* 2 + 1];
517 fprintf_conf(f
, "cmd0eprov", "%s\n", cs_hexdump(0, rdr
->cmd0eprov
, len
, tmp
, sizeof(tmp
)));
519 else if(cfg
.http_full_cfg
)
520 { fprintf_conf(f
, "cmd0eprov", "\n"); }
523 static void key3588_fn(const char *token
, char *value
, void *setting
, FILE *f
)
525 struct s_reader
*rdr
= setting
;
528 int32_t len
= strlen(value
);
531 rdr
->key3588_length
= 0;
532 memset(rdr
->key3588
, 0, 136);
536 if(key_atob_l(value
, rdr
->key3588
, len
))
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
));
544 rdr
->key3588_length
= len
/2;
549 int32_t len
= rdr
->key3588_length
;
552 char tmp
[len
* 2 + 1];
553 fprintf_conf(f
, "key3588", "%s\n", cs_hexdump(0, rdr
->key3588
, len
, tmp
, sizeof(tmp
)));
555 else if(cfg
.http_full_cfg
)
556 { fprintf_conf(f
, "key3588", "\n"); }
559 static void data50_fn(const char *token
, char *value
, void *setting
, FILE *f
)
561 struct s_reader
*rdr
= setting
;
564 int32_t len
= cs_strlen(value
);
567 rdr
->data50_length
= 0;
568 memset(rdr
->data50
, 0, 80);
572 if(key_atob_l(value
, rdr
->data50
, len
))
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
));
580 rdr
->data50_length
= len
/2;
585 int32_t len
= rdr
->data50_length
;
588 char tmp
[len
* 2 + 1];
589 fprintf_conf(f
, "data50", "%s\n", cs_hexdump(0, rdr
->data50
, len
, tmp
, sizeof(tmp
)));
591 else if(cfg
.http_full_cfg
)
592 { fprintf_conf(f
, "data50", "\n"); }
595 static void mod50_fn(const char *token
, char *value
, void *setting
, FILE *f
)
597 struct s_reader
*rdr
= setting
;
600 int32_t len
= cs_strlen(value
);
603 rdr
->mod50_length
= 0;
604 memset(rdr
->mod50
, 0, 80);
608 if(key_atob_l(value
, rdr
->mod50
, len
))
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
));
616 rdr
->mod50_length
= len
/2;
621 int32_t len
= rdr
->mod50_length
;
624 char tmp
[len
* 2 + 1];
625 fprintf_conf(f
, "mod50", "%s\n", cs_hexdump(0, rdr
->mod50
, len
, tmp
, sizeof(tmp
)));
627 else if(cfg
.http_full_cfg
)
628 { fprintf_conf(f
, "mod50", "\n"); }
631 static void key3460_fn(const char *token
, char *value
, void *setting
, FILE *f
)
633 struct s_reader
*rdr
= setting
;
636 int32_t len
= cs_strlen(value
);
639 rdr
->key3460_length
= 0;
640 memset(rdr
->key3460
, 0, 96);
644 if(key_atob_l(value
, rdr
->key3460
, len
))
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
));
652 rdr
->key3460_length
= len
/2;
657 int32_t len
= rdr
->key3460_length
;
660 char tmp
[len
* 2 + 1];
661 fprintf_conf(f
, "key3460", "%s\n", cs_hexdump(0, rdr
->key3460
, len
, tmp
, sizeof(tmp
)));
663 else if(cfg
.http_full_cfg
)
664 { fprintf_conf(f
, "key3460", "\n"); }
667 static void key3310_fn(const char *token
, char *value
, void *setting
, FILE *f
)
669 struct s_reader
*rdr
= setting
;
672 int32_t len
= cs_strlen(value
);
675 rdr
->key3310_length
= 0;
676 memset(rdr
->key3310
, 0, 16);
680 if(key_atob_l(value
, rdr
->key3310
, len
))
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
));
688 rdr
->key3310_length
= len
/2;
693 int32_t len
= rdr
->key3310_length
;
696 char tmp
[len
* 2 + 1];
697 fprintf_conf(f
, "key3310", "%s\n", cs_hexdump(0, rdr
->key3310
, len
, tmp
, sizeof(tmp
)));
699 else if(cfg
.http_full_cfg
)
700 { fprintf_conf(f
, "key3310", "\n"); }
703 static void nuid_fn(const char *token
, char *value
, void *setting
, FILE *f
)
705 struct s_reader
*rdr
= setting
;
708 int32_t len
= cs_strlen(value
);
711 rdr
->nuid_length
= 0;
712 memset(rdr
->nuid
, 0, 4);
716 if(key_atob_l(value
, rdr
->nuid
, len
))
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
));
724 rdr
->nuid_length
= len
/2;
729 int32_t len
= rdr
->nuid_length
;
732 char tmp
[len
* 2 + 1];
733 fprintf_conf(f
, "nuid", "%s\n", cs_hexdump(0, rdr
->nuid
, len
, tmp
, sizeof(tmp
)));
735 else if(cfg
.http_full_cfg
)
736 { fprintf_conf(f
, "nuid", "\n"); }
739 static void forcepair_fn(const char *token
, char *value
, void *setting
, FILE *f
)
741 struct s_reader
*rdr
= setting
;
744 int32_t len
= cs_strlen(value
);
747 rdr
->forcepair_length
= 0;
748 memset(rdr
->forcepair
, 0, 1);
752 if(key_atob_l(value
, rdr
->forcepair
, len
))
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
));
760 rdr
->forcepair_length
= len
/2;
765 int32_t len
= rdr
->forcepair_length
;
768 char tmp
[len
* 2 + 1];
769 fprintf_conf(f
, "forcepair", "%s\n", cs_hexdump(0, rdr
->forcepair
, len
, tmp
, sizeof(tmp
)));
771 else if(cfg
.http_full_cfg
)
772 { fprintf_conf(f
, "forcepair", "\n"); }
775 static void otpcsc_fn(const char *token
, char *value
, void *setting
, FILE *f
)
777 struct s_reader
*rdr
= setting
;
780 int32_t len
= strlen(value
);
783 rdr
->otpcsc_length
= 0;
784 memset(rdr
->otpcsc
, 0, 2);
788 if(key_atob_l(value
, rdr
->otpcsc
, len
))
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
));
796 rdr
->otpcsc_length
= len
/2;
801 int32_t len
= rdr
->otpcsc_length
;
804 char tmp
[len
* 2 + 1];
805 fprintf_conf(f
, "otpcsc", "%s\n", cs_hexdump(0, rdr
->otpcsc
, len
, tmp
, sizeof(tmp
)));
807 else if(cfg
.http_full_cfg
)
808 { fprintf_conf(f
, "otpcsc", "\n"); }
811 static void otacsc_fn(const char *token
, char *value
, void *setting
, FILE *f
)
813 struct s_reader
*rdr
= setting
;
816 int32_t len
= strlen(value
);
819 rdr
->otacsc_length
= 0;
820 memset(rdr
->otacsc
, 0, 2);
824 if(key_atob_l(value
, rdr
->otacsc
, len
))
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
));
832 rdr
->otacsc_length
= len
/2;
837 int32_t len
= rdr
->otacsc_length
;
840 char tmp
[len
* 2 + 1];
841 fprintf_conf(f
, "otacsc", "%s\n", cs_hexdump(0, rdr
->otacsc
, len
, tmp
, sizeof(tmp
)));
843 else if(cfg
.http_full_cfg
)
844 { fprintf_conf(f
, "otacsc", "\n"); }
847 static void cwpkcaid_fn(const char *token
, char *value
, void *setting
, FILE *f
)
849 struct s_reader
*rdr
= setting
;
852 int32_t len
= strlen(value
);
855 rdr
->cwpkcaid_length
= 0;
856 memset(rdr
->cwpkcaid
, 0, 2);
860 if(key_atob_l(value
, rdr
->cwpkcaid
, len
))
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
));
868 rdr
->cwpkcaid_length
= len
/2;
873 int32_t len
= rdr
->cwpkcaid_length
;
876 char tmp
[len
* 2 + 1];
877 fprintf_conf(f
, "cwpkcaid", "%s\n", cs_hexdump(0, rdr
->cwpkcaid
, len
, tmp
, sizeof(tmp
)));
879 else if(cfg
.http_full_cfg
)
880 { fprintf_conf(f
, "cwpkcaid", "\n"); }
883 static void cwekey0_fn(const char *token
, char *value
, void *setting
, FILE *f
)
885 struct s_reader
*rdr
= setting
;
888 int32_t len
= strlen(value
);
891 rdr
->cwekey0_length
= 0;
892 memset(rdr
->cwekey0
, 0, 16);
896 if(key_atob_l(value
, rdr
->cwekey0
, len
))
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
));
904 rdr
->cwekey0_length
= len
/2;
909 int32_t len
= rdr
->cwekey0_length
;
912 char tmp
[len
* 2 + 1];
913 fprintf_conf(f
, "cwekey0", "%s\n", cs_hexdump(0, rdr
->cwekey0
, len
, tmp
, sizeof(tmp
)));
915 else if(cfg
.http_full_cfg
)
916 { fprintf_conf(f
, "cwekey0", "\n"); }
919 static void cwekey1_fn(const char *token
, char *value
, void *setting
, FILE *f
)
921 struct s_reader
*rdr
= setting
;
924 int32_t len
= strlen(value
);
927 rdr
->cwekey1_length
= 0;
928 memset(rdr
->cwekey1
, 0, 16);
932 if(key_atob_l(value
, rdr
->cwekey1
, len
))
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
));
940 rdr
->cwekey1_length
= len
/2;
945 int32_t len
= rdr
->cwekey1_length
;
948 char tmp
[len
* 2 + 1];
949 fprintf_conf(f
, "cwekey1", "%s\n", cs_hexdump(0, rdr
->cwekey1
, len
, tmp
, sizeof(tmp
)));
951 else if(cfg
.http_full_cfg
)
952 { fprintf_conf(f
, "cwekey1", "\n"); }
955 static void cwekey2_fn(const char *token
, char *value
, void *setting
, FILE *f
)
957 struct s_reader
*rdr
= setting
;
960 int32_t len
= strlen(value
);
963 rdr
->cwekey2_length
= 0;
964 memset(rdr
->cwekey2
, 0, 16);
968 if(key_atob_l(value
, rdr
->cwekey2
, len
))
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
));
976 rdr
->cwekey2_length
= len
/2;
981 int32_t len
= rdr
->cwekey2_length
;
984 char tmp
[len
* 2 + 1];
985 fprintf_conf(f
, "cwekey2", "%s\n", cs_hexdump(0, rdr
->cwekey2
, len
, tmp
, sizeof(tmp
)));
987 else if(cfg
.http_full_cfg
)
988 { fprintf_conf(f
, "cwekey2", "\n"); }
991 static void cwekey3_fn(const char *token
, char *value
, void *setting
, FILE *f
)
993 struct s_reader
*rdr
= setting
;
996 int32_t len
= strlen(value
);
999 rdr
->cwekey3_length
= 0;
1000 memset(rdr
->cwekey3
, 0, 16);
1004 if(key_atob_l(value
, rdr
->cwekey3
, len
))
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
));
1012 rdr
->cwekey3_length
= len
/2;
1017 int32_t len
= rdr
->cwekey3_length
;
1020 char tmp
[len
* 2 + 1];
1021 fprintf_conf(f
, "cwekey3", "%s\n", cs_hexdump(0, rdr
->cwekey3
, len
, tmp
, sizeof(tmp
)));
1023 else if(cfg
.http_full_cfg
)
1024 { fprintf_conf(f
, "cwekey3", "\n"); }
1027 static void cwekey4_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1029 struct s_reader
*rdr
= setting
;
1032 int32_t len
= strlen(value
);
1035 rdr
->cwekey4_length
= 0;
1036 memset(rdr
->cwekey4
, 0, 16);
1040 if(key_atob_l(value
, rdr
->cwekey4
, len
))
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
));
1048 rdr
->cwekey4_length
= len
/2;
1053 int32_t len
= rdr
->cwekey4_length
;
1056 char tmp
[len
* 2 + 1];
1057 fprintf_conf(f
, "cwekey4", "%s\n", cs_hexdump(0, rdr
->cwekey4
, len
, tmp
, sizeof(tmp
)));
1059 else if(cfg
.http_full_cfg
)
1060 { fprintf_conf(f
, "cwekey4", "\n"); }
1063 static void cwekey5_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1065 struct s_reader
*rdr
= setting
;
1068 int32_t len
= strlen(value
);
1071 rdr
->cwekey5_length
= 0;
1072 memset(rdr
->cwekey5
, 0, 16);
1076 if(key_atob_l(value
, rdr
->cwekey5
, len
))
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
));
1084 rdr
->cwekey5_length
= len
/2;
1089 int32_t len
= rdr
->cwekey5_length
;
1092 char tmp
[len
* 2 + 1];
1093 fprintf_conf(f
, "cwekey5", "%s\n", cs_hexdump(0, rdr
->cwekey5
, len
, tmp
, sizeof(tmp
)));
1095 else if(cfg
.http_full_cfg
)
1096 { fprintf_conf(f
, "cwekey5", "\n"); }
1099 static void cwekey6_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1101 struct s_reader
*rdr
= setting
;
1104 int32_t len
= strlen(value
);
1107 rdr
->cwekey6_length
= 0;
1108 memset(rdr
->cwekey6
, 0, 16);
1112 if(key_atob_l(value
, rdr
->cwekey6
, len
))
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
));
1120 rdr
->cwekey6_length
= len
/2;
1125 int32_t len
= rdr
->cwekey6_length
;
1128 char tmp
[len
* 2 + 1];
1129 fprintf_conf(f
, "cwekey6", "%s\n", cs_hexdump(0, rdr
->cwekey6
, len
, tmp
, sizeof(tmp
)));
1131 else if(cfg
.http_full_cfg
)
1132 { fprintf_conf(f
, "cwekey6", "\n"); }
1135 static void cwekey7_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1137 struct s_reader
*rdr
= setting
;
1140 int32_t len
= strlen(value
);
1143 rdr
->cwekey7_length
= 0;
1144 memset(rdr
->cwekey7
, 0, 16);
1148 if(key_atob_l(value
, rdr
->cwekey7
, len
))
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
));
1156 rdr
->cwekey7_length
= len
/2;
1161 int32_t len
= rdr
->cwekey7_length
;
1164 char tmp
[len
* 2 + 1];
1165 fprintf_conf(f
, "cwekey7", "%s\n", cs_hexdump(0, rdr
->cwekey7
, len
, tmp
, sizeof(tmp
)));
1167 else if(cfg
.http_full_cfg
)
1168 { fprintf_conf(f
, "cwekey7", "\n"); }
1172 #if defined(READER_NAGRA)
1173 static void cak63nuid_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1175 struct s_reader
*rdr
= setting
;
1178 int32_t len
= cs_strlen(value
);
1181 rdr
->cak63nuid_length
= 0;
1182 memset(rdr
->cak63nuid
, 0, 4);
1186 if(key_atob_l(value
, rdr
->cak63nuid
, len
))
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
));
1194 rdr
->cak63nuid_length
= len
/2;
1199 int32_t len
= rdr
->cak63nuid_length
;
1202 char tmp
[len
* 2 + 1];
1203 fprintf_conf(f
, "cak63nuid", "%s\n", cs_hexdump(0, rdr
->cak63nuid
, len
, tmp
, sizeof(tmp
)));
1205 else if(cfg
.http_full_cfg
)
1206 { fprintf_conf(f
, "cak63nuid", "\n"); }
1209 static void cak63cwekey_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1211 struct s_reader
*rdr
= setting
;
1214 int32_t len
= cs_strlen(value
);
1217 rdr
->cak63cwekey_length
= 0;
1218 memset(rdr
->cak63cwekey
, 0, 16);
1222 if(key_atob_l(value
, rdr
->cak63cwekey
, len
))
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
));
1230 rdr
->cak63cwekey_length
= len
/2;
1235 int32_t len
= rdr
->cak63cwekey_length
;
1238 char tmp
[len
* 2 + 1];
1239 fprintf_conf(f
, "cak63cwekey", "%s\n", cs_hexdump(0, rdr
->cak63cwekey
, len
, tmp
, sizeof(tmp
)));
1241 else if(cfg
.http_full_cfg
)
1242 { fprintf_conf(f
, "cak63cwekey", "\n"); }
1246 static void flags_fn(const char *token
, char *value
, void *setting
, long flag
, FILE *f
)
1248 uint32_t *var
= setting
;
1251 int i
= atoi(value
);
1252 if(!i
&& (*var
& flag
))
1258 if((*var
& flag
) || cfg
.http_full_cfg
)
1259 { fprintf_conf(f
, token
, "%d\n", (*var
& flag
) ? 1 : 0); }
1262 static void ins7E_fn(const char *token
, char *value
, void *setting
, long var_size
, FILE *f
)
1264 uint8_t *var
= setting
;
1265 var_size
-= 1; // var_size contains sizeof(var) which is [X + 1]
1268 int32_t len
= cs_strlen(value
);
1269 if(len
!= var_size
* 2 || key_atob_l(value
, var
, len
))
1272 { fprintf(stderr
, "reader %s parse error, %s=%s\n", token
, token
, value
); }
1273 memset(var
, 0, var_size
+ 1);
1277 var
[var_size
] = 1; // found and correct
1283 char tmp
[var_size
* 2 + 1];
1284 fprintf_conf(f
, token
, "%s\n", cs_hexdump(0, var
, var_size
, tmp
, sizeof(tmp
)));
1286 else if(cfg
.http_full_cfg
)
1287 { fprintf_conf(f
, token
, "\n"); }
1290 static void ins42_fn(const char *token
, char *value
, void *setting
, long var_size
, FILE *f
)
1292 uint8_t *var
= setting
;
1293 var_size
-= 1; // var_size contains sizeof(var) which is [X + 1]
1296 int32_t len
= cs_strlen(value
);
1297 if(len
!= var_size
* 2 || key_atob_l(value
, var
, len
))
1300 { fprintf(stderr
, "reader %s parse error, %s=%s\n", token
, token
, value
); }
1301 memset(var
, 0, var_size
+ 1);
1305 var
[var_size
] = 1; // found and correct
1311 char tmp
[var_size
* 2 + 1];
1312 fprintf_conf(f
, token
, "%s\n", cs_hexdump(0, var
, var_size
, tmp
, sizeof(tmp
)));
1314 else if(cfg
.http_full_cfg
)
1315 { fprintf_conf(f
, token
, "\n"); }
1318 static void des_and_3des_key_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1320 uint8_t *var
= setting
;
1323 int32_t len
= cs_strlen(value
);
1324 if(((len
!= 16) && (len
!= 32)) || (key_atob_l(value
, var
, len
)))
1327 { fprintf(stderr
, "reader %s parse error, %s=%s\n", token
, token
, value
); }
1338 char tmp
[var
[16] * 2 + 1];
1339 fprintf_conf(f
, token
, "%s\n", cs_hexdump(0, var
, var
[16], tmp
, sizeof(tmp
)));
1341 else if(cfg
.http_full_cfg
)
1342 { fprintf_conf(f
, token
, "\n"); }
1345 static void atr_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1347 struct s_reader
*rdr
= setting
;
1350 memset(rdr
->atr
, 0, sizeof(rdr
->atr
));
1351 rdr
->atrlen
= cs_strlen(value
);
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
);
1360 if(rdr
->atr
[0] || cfg
.http_full_cfg
)
1363 fprintf_conf(f
, token
, "%s", ""); // it should not have \n at the end
1366 for(j
= 0; j
< rdr
->atrlen
/ 2; j
++)
1368 fprintf(f
, "%02X", rdr
->atr
[j
]);
1375 static void detect_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1377 struct s_reader
*rdr
= setting
;
1381 for(i
= 0; RDR_CD_TXT
[i
]; i
++)
1383 if(!strcmp(value
, RDR_CD_TXT
[i
]))
1389 if(value
[0] == '!' && streq(value
+ 1, RDR_CD_TXT
[i
]))
1390 { rdr
->detect
= i
| 0x80; }
1395 fprintf_conf(f
, token
, "%s%s\n", rdr
->detect
& 0x80 ? "!" : "", RDR_CD_TXT
[rdr
->detect
& 0x7f]);
1398 void ftab_fn(const char *token
, char *value
, void *setting
, long ftab_type
, FILE *f
)
1400 FTAB
*ftab
= setting
;
1403 if(cs_strlen(value
))
1404 chk_ftab(value
, ftab
);
1409 if(ftab_type
& FTAB_READER
)
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
); }
1418 if(ftab_type
& FTAB_EMUAU
) { rdr
= container_of(setting
, struct s_reader
, emu_auproviders
); }
1421 if(ftab_type
& FTAB_CCCGBXRESHARE
){ rdr
= container_of(setting
, struct s_reader
, ccc_gbx_reshare_ident
); }
1424 { rdr
->changes_since_shareupdate
= 1; }
1426 value
= mk_t_ftab(ftab
);
1427 if(cs_strlen(value
) > 0 || cfg
.http_full_cfg
)
1428 { fprintf_conf(f
, token
, "%s\n", value
); }
1432 static void aeskeys_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1434 struct s_reader
*rdr
= setting
;
1437 parse_aes_keys(rdr
, value
);
1440 value
= mk_t_aeskeys(rdr
);
1441 if(cs_strlen(value
) > 0 || cfg
.http_full_cfg
)
1442 { fprintf_conf(f
, token
, "%s\n", value
); }
1446 static void emmcache_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1448 struct s_reader
*rdr
= setting
;
1455 if(cs_strlen(value
))
1458 char *ptr
, *saveptr1
= NULL
;
1459 for(i
= 0, ptr
= strtok_r(value
, ",", &saveptr1
); (i
< 4) && (ptr
); ptr
= strtok_r(NULL
, ",", &saveptr1
), i
++)
1464 rdr
->cachemm
= atoi(ptr
);
1467 rdr
->rewritemm
= atoi(ptr
);
1470 rdr
->logemm
= atoi(ptr
);
1473 rdr
->deviceemm
= atoi(ptr
);
1476 if(rdr
->rewritemm
<= 0)
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");
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
); }
1491 static void blockemm_bylen_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1493 struct s_reader
*rdr
= setting
;
1496 char *ptr
, *saveptr1
= NULL
, dash
;
1497 struct s_emmlen_range
*blocklen
;
1500 if(!cs_strlen(value
))
1502 ll_destroy_data(&rdr
->blockemmbylen
);
1506 if(!rdr
->blockemmbylen
)
1507 { rdr
->blockemmbylen
= ll_create("blockemmbylen"); }
1509 { ll_clear_data(rdr
->blockemmbylen
); }
1511 for(ptr
= strtok_r(value
, ",", &saveptr1
); ptr
;
1512 ptr
= strtok_r(NULL
, ",", &saveptr1
))
1514 if(!cs_malloc(&blocklen
, sizeof(*blocklen
)))
1516 num
= sscanf(ptr
, "%hd%c%hd", &blocklen
->min
, &dash
, &blocklen
->max
);
1520 fprintf(stderr
, "blockemm-bylen parse error: %s\n", value
);
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
);
1531 value
= mk_t_emmbylen(rdr
);
1532 if(cs_strlen(value
) > 0 || cfg
.http_full_cfg
)
1533 { fprintf_conf(f
, token
, "%s\n", value
); }
1537 static void nano_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1539 uint16_t *nano
= setting
;
1543 if(cs_strlen(value
) > 0)
1545 if(streq(value
, "all"))
1552 char *ptr
, *saveptr1
= NULL
;
1553 for(ptr
= strtok_r(value
, ",", &saveptr1
); ptr
; ptr
= strtok_r(NULL
, ",", &saveptr1
))
1555 i
= (byte_atob(ptr
) % 0x80);
1556 if(i
>= 0 && i
<= 16)
1557 { *nano
|= (1 << i
); }
1563 value
= mk_t_nano(*nano
);
1564 if(cs_strlen(value
) > 0 || cfg
.http_full_cfg
)
1565 { fprintf_conf(f
, token
, "%s\n", value
); }
1569 static void auprovid_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1571 struct s_reader
*rdr
= setting
;
1575 if(cs_strlen(value
))
1576 { rdr
->auprovid
= a2i(value
, 3); }
1580 { fprintf_conf(f
, token
, "%06X\n", rdr
->auprovid
); }
1581 else if(cfg
.http_full_cfg
)
1582 { fprintf_conf(f
, token
, "\n"); }
1585 static void ratelimitecm_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1587 struct s_reader
*rdr
= setting
;
1590 rdr
->ratelimitecm
= 0;
1591 if(cs_strlen(value
))
1594 rdr
->ratelimitecm
= atoi(value
);
1595 for(i
= 0; i
< MAXECMRATELIMIT
; i
++) // reset all slots
1597 rdr
->rlecmh
[i
].srvid
= -1;
1598 rdr
->rlecmh
[i
].last
.time
= -1;
1603 if(rdr
->ratelimitecm
|| cfg
.http_full_cfg
)
1604 { fprintf_conf(f
, token
, "%d\n", rdr
->ratelimitecm
); }
1607 static void ecmunique_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1609 struct s_reader
*rdr
= setting
;
1612 if(cs_strlen(value
) == 0)
1614 rdr
->ecmunique
= 0; // default
1618 rdr
->ecmunique
= atoi(value
);
1619 if(rdr
->ecmunique
>= 1)
1620 { rdr
->ecmunique
= 1; }
1622 { rdr
->ecmunique
= 0; }
1626 if((rdr
->ratelimitecm
&& rdr
->ecmunique
!= 0) || cfg
.http_full_cfg
)
1627 { fprintf_conf(f
, token
, "%d\n", rdr
->ecmunique
); }
1630 static void ratelimittime_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1632 struct s_reader
*rdr
= setting
;
1635 if(cs_strlen(value
) == 0)
1637 if(rdr
->ratelimitecm
> 0)
1639 rdr
->ratelimittime
= 9000; // default 9 seconds
1640 rdr
->srvidholdtime
= 2000; // default 2 seconds hold
1644 rdr
->ratelimitecm
= 0; // in case someone set a negative value
1645 rdr
->ratelimittime
= 0;
1646 rdr
->srvidholdtime
= 0;
1651 rdr
->ratelimittime
= atoi(value
);
1652 if (rdr
->ratelimittime
< 60) rdr
->ratelimittime
*= 1000;
1656 if(rdr
->ratelimitecm
|| cfg
.http_full_cfg
)
1657 { fprintf_conf(f
, token
, "%d\n", rdr
->ratelimittime
); }
1660 static void srvidholdtime_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1662 struct s_reader
*rdr
= setting
;
1665 if(cs_strlen(value
) == 0)
1667 if(rdr
->ratelimitecm
> 0)
1669 rdr
->srvidholdtime
= 2000; // default 2 seconds hold
1673 rdr
->ratelimitecm
= 0; // in case someone set a negative value
1674 rdr
->srvidholdtime
= 0;
1679 rdr
->srvidholdtime
= atoi(value
);
1680 if (rdr
->srvidholdtime
< 60) rdr
->srvidholdtime
*=1000;
1684 if(rdr
->ratelimitecm
|| cfg
.http_full_cfg
)
1685 { fprintf_conf(f
, token
, "%d\n", rdr
->srvidholdtime
); }
1688 static void cooldown_fn(const char *token
, char *value
, void *setting
, FILE *f
)
1690 struct s_reader
*rdr
= setting
;
1693 if(cs_strlen(value
) == 0)
1695 rdr
->cooldown
[0] = 0;
1696 rdr
->cooldown
[1] = 0;
1701 char *ptr
, *saveptr1
= NULL
;
1702 for(i
= 0, ptr
= strtok_r(value
, ",", &saveptr1
); (i
< 2) && (ptr
); ptr
= strtok_r(NULL
, ",", &saveptr1
), i
++)
1704 rdr
->cooldown
[i
] = atoi(ptr
);
1706 if(rdr
->cooldown
[0] <= 0 || rdr
->cooldown
[1] <= 0)
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;
1716 if(rdr
->cooldown
[0] || cfg
.http_full_cfg
)
1718 fprintf_conf(f
, token
, "%d,%d\n", rdr
->cooldown
[0], rdr
->cooldown
[1]);
1722 static void cooldowndelay_fn(const char *UNUSED(token
), char *value
, void *setting
, FILE *UNUSED(f
))
1724 struct s_reader
*rdr
= setting
;
1727 rdr
->cooldown
[0] = cs_strlen(value
) ? atoi(value
) : 0;
1729 // This option is *not* written in the config file.
1730 // It is only set by WebIf as convenience
1733 static void cooldowntime_fn(const char *UNUSED(token
), char *value
, void *setting
, FILE *UNUSED(f
))
1735 struct s_reader
*rdr
= setting
;
1738 if(cs_strlen(value
) == 0)
1740 rdr
->cooldown
[0] = 0; // no cooling down time means no cooling set
1741 rdr
->cooldown
[1] = 0;
1745 rdr
->cooldown
[1] = atoi(value
);
1749 // This option is *not* written in the config file.
1750 // It is only set by WebIf as convenience
1753 void reader_fixups_fn(void *var
)
1755 struct s_reader
*rdr
= var
;
1757 if(rdr
->lb_weight
> 1000)
1758 { rdr
->lb_weight
= 1000; }
1759 else if(rdr
->lb_weight
<= 0)
1760 { rdr
->lb_weight
= 100; }
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
);
1770 if(is_cascading_reader(rdr
) && (rdr
->typ
== R_CAMD35
|| rdr
->typ
== R_CS378X
))
1773 if(rdr
&& rdr
->cacheex
.mode
>1)
1774 { rdr
->keepalive
= 1; } // with cacheex, it is required!
1777 if(rdr
->typ
== R_CAMD35
)
1778 { rdr
->keepalive
= 0; } // with NO-cacheex, and UDP, keepalive is not required!
1782 #define OFS(X) offsetof(struct s_reader, X)
1783 #define SIZEOF(X) sizeof(((struct s_reader *)0)->X)
1785 static const struct config_list reader_opts
[] =
1787 DEF_OPT_FIXUP_FUNC(reader_fixups_fn
),
1788 DEF_OPT_FUNC("label" , 0, reader_label_fn
),
1790 DEF_OPT_STR("description" , OFS(description
), NULL
),
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
)),
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),
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
),
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),
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),
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
),
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),
1887 #if defined(READER_NAGRA)
1888 DEF_OPT_FUNC("cak63nuid" , 0, cak63nuid_fn
),
1889 DEF_OPT_FUNC("cak63cwekey" , 0, cak63cwekey_fn
),
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),
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),
1916 DEF_OPT_INT32("mode" , OFS(azbox_mode
), -1),
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
),
1934 DEF_OPT_INT32("lb_weight" , OFS(lb_weight
), 100),
1935 DEF_OPT_INT8("lb_force_fallback" , OFS(lb_force_fallback
), 0),
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),
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),
1956 DEF_OPT_UINT8("use_ssl" , OFS(ghttp_use_ssl
), 0),
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
),
1962 #ifdef READER_DRECAS
1963 DEF_OPT_STR("stmkeys" , OFS(stmkeys
), NULL
),
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),
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),
1985 static inline bool in_list(const char *token
, const char *list
[])
1988 for(i
= 0; list
[i
]; i
++)
1990 if(streq(token
, list
[i
]))
1996 static bool reader_check_setting(const struct config_list
*UNUSED(clist
), void *config_data
, const char *setting
)
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
[] =
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",
2008 #if defined(READER_NAGRA)
2009 "cak63nuid", "cak63cwekey",
2011 #if defined(READER_DRE) || defined(READER_DRECAS)
2020 "deprecated", "ndsversion",
2023 // These are written only when the reader is network reader
2024 static const char *network_only_settings
[] =
2026 "user", "inactivitytimeout", "reconnecttimeout", "autype",
2029 if(is_network_reader(reader
))
2031 if(in_list(setting
, hw_only_settings
))
2036 if(in_list(setting
, network_only_settings
))
2040 // These are not written in the config file
2041 static const char *deprecated_settings
[] =
2043 "cooldowndelay", "cooldowntime",
2046 if(in_list(setting
, deprecated_settings
))
2049 // Special settings for NEWCAMD
2050 static const char *newcamd_settings
[] =
2052 "disableserverfilter", "connectoninit",
2055 if(reader
->typ
!= R_NEWCAMD
&& in_list(setting
, newcamd_settings
))
2058 // These are written only when the reader is CCCAM
2059 static const char *cccam_settings
[] =
2061 "cccversion", "cccmaxhops", "cccmindown", "cccwantemu", "ccckeepalive",
2065 // Special settings for CCCAM
2066 if(reader
->typ
!= R_CCCAM
)
2068 if(in_list(setting
, cccam_settings
))
2071 else if(streq(setting
, "ccchop"))
2077 #ifdef MODULE_PANDORA
2078 // Special settings for PANDORA
2079 if(reader
->typ
!= R_PANDORA
&& streq(setting
, "pand_send_ecm"))
2084 // These are written only when the reader is GBOX
2085 static const char *gbox_settings
[] =
2087 "gbox_max_distance", "gbox_max_ecm_send", "gbox_reshare", "cccam_reshare", "force_remm","ccc_gbx_reshare_ident","send_offline_cmd",
2090 if(reader
->typ
!= R_GBOX
)
2092 if(in_list(setting
, gbox_settings
))
2097 return true; // Write the setting
2100 void chk_reader(char *token
, char *value
, struct s_reader
*rdr
)
2102 if(config_list_parse(reader_opts
, token
, value
, rdr
))
2104 else if(token
[0] != '#')
2105 { fprintf(stderr
, "Warning: keyword '%s' in reader section not recognized\n", token
); }
2108 void reader_set_defaults(struct s_reader
*rdr
)
2110 config_list_set_defaults(reader_opts
, rdr
);
2113 int32_t init_readerdb(void)
2115 configured_readers
= ll_create("configured_readers");
2117 FILE *fp
= open_config_file(cs_srvr
);
2122 char *value
, *token
;
2124 if(!cs_malloc(&token
, MAXLINESIZE
))
2127 struct s_reader
*rdr
;
2128 if(!cs_malloc(&rdr
, sizeof(struct s_reader
)))
2134 ll_append(configured_readers
, rdr
);
2135 while(fgets(token
, MAXLINESIZE
, fp
))
2138 if((l
= cs_strlen(trim(token
))) < 3)
2140 if((token
[0] == '[') && (token
[l
- 1] == ']'))
2143 tag
= (!strcmp("reader", strtolower(token
+ 1)));
2144 if(rdr
->label
[0] && rdr
->typ
)
2146 struct s_reader
*newreader
;
2147 if(cs_malloc(&newreader
, sizeof(struct s_reader
)))
2149 ll_append(configured_readers
, newreader
);
2153 reader_set_defaults(rdr
);
2159 if(!(value
= strchr(token
, '=')))
2162 chk_reader(trim(strtolower(token
)), trim(value
), rdr
);
2165 LL_ITER itr
= ll_iter_create(configured_readers
);
2166 while((rdr
= ll_iter_next(&itr
))) // build active readers list
2168 reader_fixups_fn(rdr
);
2169 module_reader_set(rdr
);
2175 void free_reader(struct s_reader
*rdr
)
2177 NULLFREE(rdr
->emmfile
);
2179 ecm_whitelist_clear(&rdr
->ecm_whitelist
);
2180 ecm_hdr_whitelist_clear(&rdr
->ecm_hdr_whitelist
);
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
);
2188 ftab_clear(&rdr
->ccc_gbx_reshare_ident
);
2191 NULLFREE(rdr
->cltab
.aclass
);
2192 NULLFREE(rdr
->cltab
.bclass
);
2194 caidtab_clear(&rdr
->ctab
);
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
);
2205 lb_destroy_stats(rdr
);
2207 cs_clear_entitlement(rdr
);
2208 ll_destroy(&rdr
->ll_entitlements
);
2210 if(rdr
->csystem
&& rdr
->csystem
->card_done
)
2211 rdr
->csystem
->card_done(rdr
);
2212 NULLFREE(rdr
->csystem_data
);
2214 ll_destroy_data(&rdr
->blockemmbylen
);
2216 ll_destroy_data(&rdr
->emmstat
);
2218 aes_clear_entries(&rdr
->aes_list
);
2220 config_list_gc_values(reader_opts
, rdr
);
2224 int32_t free_readerdb(void)
2227 struct s_reader
*rdr
;
2228 LL_ITER itr
= ll_iter_create(configured_readers
);
2229 while((rdr
= ll_iter_next(&itr
)))
2234 cs_log("readerdb %d readers freed", count
);
2235 ll_destroy(&configured_readers
);
2239 int32_t write_server(void)
2241 FILE *f
= create_config_file(cs_srvr
);
2244 struct s_reader
*rdr
;
2245 LL_ITER itr
= ll_iter_create(configured_readers
);
2246 while((rdr
= ll_iter_next(&itr
)))
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
);
2256 return flush_config_file(f
, cs_srvr
);
2259 void reload_readerdb(void)
2261 struct s_reader
*rdr
;
2262 LL_ITER itr
= ll_iter_create(configured_readers
);
2263 while((rdr
= ll_iter_next(&itr
)))
2265 // disable the current reader
2267 restart_cardreader(rdr
,1);
2269 free_readerdb(); // release the old readerdb
2270 init_readerdb(); // reload the new readerdb
2271 init_cardreader(); // start the readers