?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[gbx] - more generalized routing info in cw msg
[oscam.git] / oscam-config-global.c
blob37a95b93b233af970f9b85e96d9b772214004a03
1 #define MODULE_LOG_PREFIX "config"
2
3 #include "globals.h"
4 #include "module-dvbapi.h"
5 #include "module-gbox.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-net.h"
12 #include "oscam-string.h"
13
14 #define cs_conf "oscam.conf"
15
16 #define DEFAULT_HTTP_PORT 8888
17 #define DEFAULT_HTTP_ALLOW "127.0.0.1,192.168.0.0-192.168.255.255,10.0.0.0-10.255.255.255,::1"
18
19 static void disablelog_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
20 {
21 if(value)
22 {
23 cs_disable_log(strToIntVal(value, 0));
24 return;
25 }
26 if(cfg.disablelog || cfg.http_full_cfg)
27 { fprintf_conf(f, token, "%d\n", cfg.disablelog); }
28 }
29
30 #if defined(WEBIF) || defined(MODULE_MONITOR)
31 static void loghistorylines_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
32 {
33 if(value)
34 {
35 uint32_t newsize = strToUIntVal(value, 256);
36 if(newsize < 64 && newsize != 0)
37 {
38 fprintf(stderr, "WARNING: loghistorylines is too small, adjusted to 64\n");
39 newsize = 64;
40 }
41 cs_reinit_loghist(newsize);
42 return;
43 }
44 if(cfg.loghistorylines != 256 || cfg.http_full_cfg)
45 { fprintf_conf(f, token, "%u\n", cfg.loghistorylines); }
46 }
47 #endif
48
49 static void serverip_fn(const char *token, char *value, void *setting, FILE *f)
50 {
51 IN_ADDR_T srvip = *(IN_ADDR_T *)setting;
52 if(value)
53 {
54 if(strlen(value) == 0)
55 {
56 set_null_ip((IN_ADDR_T *)setting);
57 }
58 else
59 {
60 cs_inet_addr(value, (IN_ADDR_T *)setting);
61 }
62 return;
63 }
64 if(IP_ISSET(srvip) || cfg.http_full_cfg)
65 { fprintf_conf(f, token, "%s\n", cs_inet_ntoa(srvip)); }
66 }
67
68 void iprange_fn(const char *token, char *value, void *setting, FILE *f)
69 {
70 struct s_ip **ip = setting;
71 if(value)
72 {
73 if(strlen(value) == 0)
74 {
75 clear_sip(ip);
76 }
77 else
78 {
79 chk_iprange(value, ip);
80 }
81 return;
82 }
83 value = mk_t_iprange(*ip);
84 if(strlen(value) > 0 || cfg.http_full_cfg)
85 { fprintf_conf(f, token, "%s\n", value); }
86 free_mk_t(value);
87 }
88
89 void iprange_free_fn(void *setting)
90 {
91 clear_sip(setting);
92 }
93
94 static void logfile_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
95 {
96 if(value)
97 {
98 char *saveptr1 = NULL;
99 cfg.logtostdout = 0;
100 cfg.logtosyslog = 0;
101 NULLFREE(cfg.logfile);
102 if(strlen(value) > 0)
103 {
104 char *pch;
105 for(pch = strtok_r(value, ";", &saveptr1); pch != NULL; pch = strtok_r(NULL, ";", &saveptr1))
106 {
107 pch = trim(pch);
108 if(!strcmp(pch, "stdout")) { cfg.logtostdout = 1; }
109 else if(!strcmp(pch, "syslog")) { cfg.logtosyslog = 1; }
110 else
111 {
112 NULLFREE(cfg.logfile);
113 if(!(cfg.logfile = cs_strdup(pch)))
114 { continue; }
115 }
116 }
117 }
118 else
119 {
120 if(!(cfg.logfile = cs_strdup(CS_LOGFILE)))
121 { cfg.logtostdout = 1; }
122 }
123 return;
124 }
125 if(cfg.logfile || cfg.logtostdout == 1 || cfg.logtosyslog == 1 || cfg.http_full_cfg)
126 {
127 value = mk_t_logfile();
128 fprintf_conf(f, token, "%s\n", value);
129 free_mk_t(value);
130 }
131 }
132
133 void check_caidtab_fn(const char *token, char *value, void *setting, FILE *f)
134 {
135 CAIDTAB *caid_table = setting;
136 if(value)
137 {
138 if(strlen(value)) {
139 chk_caidtab(value, caid_table);
140 } else {
141 caidtab_clear(caid_table);
142 }
143 return;
144 }
145 if(caid_table->ctnum || cfg.http_full_cfg)
146 {
147 value = mk_t_caidtab(caid_table);
148 fprintf_conf(f, token, "%s\n", value);
149 free_mk_t(value);
150 }
151 }
152
153 void chk_ftab_fn(const char *token, char *value, void *setting, FILE *f)
154 {
155 FTAB *ftab = setting;
156 if(value)
157 {
158 if(strlen(value))
159 chk_ftab(value, ftab);
160 else
161 ftab_clear(ftab);
162 return;
163 }
164 value = mk_t_ftab(ftab);
165 if(strlen(value) > 0 || cfg.http_full_cfg)
166 { fprintf_conf(f, token, "%s\n", value); }
167 free_mk_t(value);
168 }
169
170
171 void caidvaluetab_fn(const char *token, char *value, void *setting, FILE *f)
172 {
173 CAIDVALUETAB *caid_value_table = setting;
174 if(value)
175 {
176 if (strlen(value)) {
177 chk_caidvaluetab(value, caid_value_table);
178 if (streq(token, "lb_retrylimits"))
179 {
180 int32_t i;
181 for (i = 0; i < caid_value_table->cvnum; i++)
182 {
183 if (caid_value_table->cvdata[i].value < 50)
184 caid_value_table->cvdata[i].value = 50;
185 }
186 }
187 } else {
188 caidvaluetab_clear(caid_value_table);
189 }
190 return;
191 }
192 if(caid_value_table->cvnum || cfg.http_full_cfg)
193 {
194 value = mk_t_caidvaluetab(caid_value_table);
195 fprintf_conf(f, token, "%s\n", value);
196 free_mk_t(value);
197 }
198 }
199
200 #ifdef CS_CACHEEX
201 void cacheex_valuetab_fn(const char *token, char *value, void *setting, FILE *f)
202 {
203 CECSPVALUETAB *cacheex_value_table = setting;
204 if(value)
205 {
206 if(strlen(value) == 0)
207 { clear_cacheextab(cacheex_value_table); }
208 else
209 { chk_cacheex_valuetab(value, cacheex_value_table); }
210 return;
211 }
212 if(cacheex_value_table->cevnum || cfg.http_full_cfg)
213 {
214 value = mk_t_cacheex_valuetab(cacheex_value_table);
215 fprintf_conf(f, token, "%s\n", value);
216 free_mk_t(value);
217 }
218 }
219
220 void cacheex_cwcheck_tab_fn(const char *token, char *value, void *setting, FILE *f)
221 {
222 CWCHECKTAB *cacheex_value_table = setting;
223 if(value)
224 {
225 if(strlen(value) == 0)
226 {
227 cacheex_value_table->cwchecknum = 0;
228 NULLFREE(cacheex_value_table->cwcheckdata);
229 }
230 else
231 {
232 chk_cacheex_cwcheck_valuetab(value, cacheex_value_table);
233 }
234 return;
235 }
236
237 if(cacheex_value_table->cwchecknum || cfg.http_full_cfg)
238 {
239 value = mk_t_cacheex_cwcheck_valuetab(cacheex_value_table);
240 fprintf_conf(f, token, "%s\n", value);
241 free_mk_t(value);
242 }
243 }
244
245 void cacheex_hitvaluetab_fn(const char *token, char *value, void *setting, FILE *f)
246 {
247 CECSPVALUETAB *cacheex_value_table = setting;
248 if(value)
249 {
250 if(strlen(value) == 0)
251 { clear_cacheextab(cacheex_value_table); }
252 else
253 { chk_cacheex_hitvaluetab(value, cacheex_value_table); }
254 return;
255 }
256 if(cacheex_value_table->cevnum || cfg.http_full_cfg)
257 {
258 value = mk_t_cacheex_hitvaluetab(cacheex_value_table);
259 fprintf_conf(f, token, "%s\n", value);
260 free_mk_t(value);
261 }
262 }
263 #endif
264
265 #ifdef __CYGWIN__
266 #include <windows.h>
267 #else
268 #include <sys/resource.h> // for setpriority
269 #endif
270
271 void global_fixups_fn(void *UNUSED(var))
272 {
273 if(!cfg.usrfile) { cfg.disableuserfile = 1; }
274 if(!cfg.mailfile) { cfg.disablemail = 1; }
275 if(cfg.ctimeout < 10) { cfg.ctimeout = cfg.ctimeout * 1000; } // save always in ms
276
277 if(cfg.nice < -20 || cfg.nice > 20) { cfg.nice = 99; }
278 if(cfg.nice != 99)
279 {
280 #ifndef __CYGWIN__
281 setpriority(PRIO_PROCESS, 0, cfg.nice);
282 #else
283 HANDLE WinId;
284 uint32_t wprio;
285 switch((cfg.nice + 20) / 10)
286 {
287 case 0:
288 wprio = REALTIME_PRIORITY_CLASS;
289 break;
290 case 1:
291 wprio = HIGH_PRIORITY_CLASS;
292 break;
293 case 2:
294 wprio = NORMAL_PRIORITY_CLASS;
295 break;
296 default:
297 wprio = IDLE_PRIORITY_CLASS;
298 break;
299 }
300 WinId = GetCurrentProcess();
301 SetPriorityClass(WinId, wprio);
302 #endif
303 }
304 if(cfg.netprio <= 0 || cfg.netprio > 20) { cfg.netprio = 0; }
305 if(cfg.max_log_size != 0 && cfg.max_log_size <= 10) { cfg.max_log_size = 10; }
306 #ifdef WITH_LB
307 if(cfg.lb_save > 0 && cfg.lb_save < 100) { cfg.lb_save = 100; }
308 if(cfg.lb_nbest_readers < 2) { cfg.lb_nbest_readers = DEFAULT_NBEST; }
309 #endif
310 }
311
312 #define OFS(X) offsetof(struct s_config, X)
313 #define SIZEOF(X) sizeof(((struct s_config *)0)->X)
314
315 static const struct config_list global_opts[] =
316 {
317 DEF_OPT_FIXUP_FUNC(global_fixups_fn),
318 #ifdef LEDSUPPORT
319 DEF_OPT_INT8("enableled" , OFS(enableled) , 0),
320 #endif
321 DEF_OPT_FUNC("disablelog" , OFS(disablelog) , disablelog_fn),
322 #if defined(WEBIF) || defined(MODULE_MONITOR)
323 DEF_OPT_FUNC("loghistorylines" , OFS(loghistorylines) , loghistorylines_fn),
324 #endif
325 DEF_OPT_FUNC("serverip" , OFS(srvip) , serverip_fn),
326 DEF_OPT_FUNC("logfile" , OFS(logfile) , logfile_fn),
327 DEF_OPT_INT32("initial_debuglevel" , OFS(initial_debuglevel) , 0),
328 DEF_OPT_STR("sysloghost" , OFS(sysloghost) , NULL),
329 DEF_OPT_INT32("syslogport" , OFS(syslogport) , 514),
330 DEF_OPT_INT8("logduplicatelines" , OFS(logduplicatelines) , 0),
331 DEF_OPT_STR("pidfile" , OFS(pidfile) , NULL),
332 DEF_OPT_INT8("disableuserfile" , OFS(disableuserfile) , 1),
333 DEF_OPT_INT8("disablemail" , OFS(disablemail) , 1),
334 DEF_OPT_INT8("usrfileflag" , OFS(usrfileflag) , 0),
335 DEF_OPT_UINT32("clienttimeout" , OFS(ctimeout) , CS_CLIENT_TIMEOUT),
336 DEF_OPT_UINT32("fallbacktimeout" , OFS(ftimeout) , CS_CLIENT_TIMEOUT / 2),
337 DEF_OPT_FUNC("fallbacktimeout_percaid" , OFS(ftimeouttab) , caidvaluetab_fn),
338 DEF_OPT_UINT32("clientmaxidle" , OFS(cmaxidle) , CS_CLIENT_MAXIDLE),
339 DEF_OPT_INT32("bindwait" , OFS(bindwait) , CS_BIND_TIMEOUT),
340 DEF_OPT_UINT32("netprio" , OFS(netprio) , 0),
341 DEF_OPT_INT32("sleep" , OFS(tosleep) , 0),
342 DEF_OPT_INT32("unlockparental" , OFS(ulparent) , 0),
343 DEF_OPT_INT32("nice" , OFS(nice) , 99),
344 DEF_OPT_INT32("maxlogsize" , OFS(max_log_size) , 10),
345 DEF_OPT_INT8("waitforcards" , OFS(waitforcards) , 1),
346 DEF_OPT_INT32("waitforcards_extra_delay" , OFS(waitforcards_extra_delay) , 500),
347 DEF_OPT_INT8("preferlocalcards" , OFS(preferlocalcards) , 0),
348 DEF_OPT_INT32("readerrestartseconds" , OFS(reader_restart_seconds) , 5),
349 DEF_OPT_INT8("dropdups" , OFS(dropdups) , 0),
350 DEF_OPT_INT8("reload_useraccounts" , OFS(reload_useraccounts) , 0),
351 DEF_OPT_INT8("reload_readers" , OFS(reload_readers) , 0),
352 DEF_OPT_INT8("reload_provid" , OFS(reload_provid) , 0),
353 DEF_OPT_INT8("reload_services_ids" , OFS(reload_services_ids) , 0),
354 DEF_OPT_INT8("reload_tier_ids" , OFS(reload_tier_ids) , 0),
355 DEF_OPT_INT8("reload_fakecws" , OFS(reload_fakecws) , 0),
356 DEF_OPT_INT8("reload_ac_stat" , OFS(reload_ac_stat) , 0),
357 DEF_OPT_INT8("reload_log" , OFS(reload_log) , 0),
358 DEF_OPT_INT8("block_same_ip" , OFS(block_same_ip) , 1),
359 DEF_OPT_INT8("block_same_name" , OFS(block_same_name) , 1),
360 DEF_OPT_STR("usrfile" , OFS(usrfile) , NULL),
361 DEF_OPT_STR("mailfile" , OFS(mailfile) , NULL),
362 DEF_OPT_STR("cwlogdir" , OFS(cwlogdir) , NULL),
363 DEF_OPT_STR("emmlogdir" , OFS(emmlogdir) , NULL),
364 #ifdef WITH_LB
365 DEF_OPT_INT32("lb_mode" , OFS(lb_mode) , DEFAULT_LB_MODE),
366 DEF_OPT_INT32("lb_save" , OFS(lb_save) , 0),
367 DEF_OPT_INT32("lb_nbest_readers" , OFS(lb_nbest_readers) , DEFAULT_NBEST),
368 DEF_OPT_INT32("lb_nfb_readers" , OFS(lb_nfb_readers) , DEFAULT_NFB),
369 DEF_OPT_INT32("lb_min_ecmcount" , OFS(lb_min_ecmcount) , DEFAULT_MIN_ECM_COUNT),
370 DEF_OPT_INT32("lb_max_ecmcount" , OFS(lb_max_ecmcount) , DEFAULT_MAX_ECM_COUNT),
371 DEF_OPT_INT32("lb_reopen_seconds" , OFS(lb_reopen_seconds) , DEFAULT_REOPEN_SECONDS),
372 DEF_OPT_INT8("lb_reopen_invalid" , OFS(lb_reopen_invalid) , 1),
373 DEF_OPT_INT8("lb_force_reopen_always" , OFS(lb_force_reopen_always) , 0),
374 DEF_OPT_INT32("lb_retrylimit" , OFS(lb_retrylimit) , DEFAULT_RETRYLIMIT),
375 DEF_OPT_INT32("lb_stat_cleanup" , OFS(lb_stat_cleanup) , DEFAULT_LB_STAT_CLEANUP),
376 DEF_OPT_INT32("lb_max_readers" , OFS(lb_max_readers) , 0),
377 DEF_OPT_INT32("lb_auto_betatunnel" , OFS(lb_auto_betatunnel) , DEFAULT_LB_AUTO_BETATUNNEL),
378 DEF_OPT_INT32("lb_auto_betatunnel_mode" , OFS(lb_auto_betatunnel_mode) , DEFAULT_LB_AUTO_BETATUNNEL_MODE),
379 DEF_OPT_INT32("lb_auto_betatunnel_prefer_beta" , OFS(lb_auto_betatunnel_prefer_beta), DEFAULT_LB_AUTO_BETATUNNEL_PREFER_BETA),
380 DEF_OPT_STR("lb_savepath" , OFS(lb_savepath) , NULL),
381 DEF_OPT_FUNC("lb_retrylimits" , OFS(lb_retrylimittab) , caidvaluetab_fn),
382 DEF_OPT_FUNC("lb_nbest_percaid" , OFS(lb_nbest_readers_tab) , caidvaluetab_fn),
383 DEF_OPT_FUNC("lb_noproviderforcaid" , OFS(lb_noproviderforcaid) , check_caidtab_fn),
384 DEF_OPT_INT32("lb_auto_timeout" , OFS(lb_auto_timeout) , DEFAULT_LB_AUTO_TIMEOUT),
385 DEF_OPT_INT32("lb_auto_timeout_p" , OFS(lb_auto_timeout_p) , DEFAULT_LB_AUTO_TIMEOUT_P),
386 DEF_OPT_INT32("lb_auto_timeout_t" , OFS(lb_auto_timeout_t) , DEFAULT_LB_AUTO_TIMEOUT_T),
387 #endif
388 DEF_OPT_FUNC("double_check_caid" , OFS(double_check_caid) , check_caidtab_fn),
389 DEF_OPT_STR("ecmfmt" , OFS(ecmfmt) , NULL),
390 DEF_OPT_INT32("resolvegethostbyname" , OFS(resolve_gethostbyname) , 0),
391 DEF_OPT_INT32("failbantime" , OFS(failbantime) , 0),
392 DEF_OPT_INT32("failbancount" , OFS(failbancount) , 0),
393 DEF_OPT_INT8("suppresscmd08" , OFS(c35_suppresscmd08) , 0),
394 DEF_OPT_INT8("getblockemmauprovid" , OFS(getblockemmauprovid) , 0),
395 DEF_OPT_INT8("double_check" , OFS(double_check) , 0),
396 DEF_OPT_INT8("disablecrccws" , OFS(disablecrccws) , 0),
397 DEF_OPT_FUNC("disablecrccws_only_for" , OFS(disablecrccws_only_for) , chk_ftab_fn),
398 DEF_LAST_OPT
399 };
400
401 #ifdef CS_ANTICASC
402 static void anticasc_fixups_fn(void *UNUSED(var))
403 {
404 if(cfg.ac_users < 0) { cfg.ac_users = 0; }
405 if(cfg.ac_stime < 0) { cfg.ac_stime = 2; }
406 if(cfg.ac_samples < 2 || cfg.ac_samples > 10) { cfg.ac_samples = 10; }
407 if(cfg.ac_penalty < 0 || cfg.ac_penalty > 3) { cfg.ac_penalty = 0; }
408 if(cfg.ac_fakedelay < 100 || cfg.ac_fakedelay > 3000) { cfg.ac_fakedelay = 1000; }
409 if(cfg.ac_denysamples < 2 || cfg.ac_denysamples > cfg.ac_samples - 1) { cfg.ac_denysamples = cfg.ac_samples - 1; }
410 if(cfg.ac_denysamples + 1 > cfg.ac_samples) { cfg.ac_denysamples = cfg.ac_samples - 1; }
411 if(cfg.acosc_max_ecms_per_minute < 0) { cfg.acosc_max_ecms_per_minute = 0; }
412 if(cfg.acosc_penalty == 4)
413 {
414 cfg.acosc_max_active_sids = 0; // set default
415 cfg.acosc_zap_limit = 0; // set default
416 //cfg.acosc_penalty_duration = 0; // set default
417
418 if(cfg.acosc_max_ecms_per_minute != 0)
419 {
420 if(cfg.acosc_max_ecms_per_minute < 6) { cfg.acosc_max_ecms_per_minute = 6; }
421 if(cfg.acosc_max_ecms_per_minute > 20) { cfg.acosc_max_ecms_per_minute = 20; }
422 cfg.acosc_penalty_duration = (60 / cfg.acosc_max_ecms_per_minute);
423 }
424 }
425 if(cfg.acosc_max_active_sids < 0) { cfg.acosc_max_active_sids = 0; }
426 if(cfg.acosc_zap_limit < 0) { cfg.acosc_zap_limit = 0; }
427 if(cfg.acosc_penalty < 0 || cfg.acosc_penalty > 4) { cfg.acosc_penalty = 0; }
428 if(cfg.acosc_penalty_duration < 0) { cfg.acosc_penalty_duration = 0; }
429 if(cfg.acosc_delay < 0 || cfg.acosc_delay > 4000) { cfg.acosc_delay = 0; }
430 }
431
432 static bool anticasc_should_save_fn(void *UNUSED(var))
433 {
434 return cfg.ac_enabled || cfg.acosc_enabled;
435 }
436
437 static const struct config_list anticasc_opts[] =
438 {
439 DEF_OPT_SAVE_FUNC(anticasc_should_save_fn),
440 DEF_OPT_FIXUP_FUNC(anticasc_fixups_fn),
441 DEF_OPT_INT8("enabled" , OFS(ac_enabled) , 0),
442 DEF_OPT_INT32("numusers" , OFS(ac_users) , 0),
443 DEF_OPT_INT32("sampletime" , OFS(ac_stime) , 2),
444 DEF_OPT_INT32("samples" , OFS(ac_samples) , 10),
445 DEF_OPT_INT8("penalty" , OFS(ac_penalty) , 0),
446 DEF_OPT_STR("aclogfile" , OFS(ac_logfile) , NULL),
447 DEF_OPT_INT32("fakedelay" , OFS(ac_fakedelay) , 3000),
448 DEF_OPT_INT32("denysamples" , OFS(ac_denysamples) , 8),
449 DEF_OPT_INT8("acosc_enabled" , OFS(acosc_enabled) , 0 ),
450 DEF_OPT_INT8("acosc_max_ecms_per_minute" , OFS(acosc_max_ecms_per_minute), 0 ),
451 DEF_OPT_INT8("acosc_max_active_sids" , OFS(acosc_max_active_sids) , 0 ),
452 DEF_OPT_INT8("acosc_zap_limit" , OFS(acosc_zap_limit) , 0 ),
453 DEF_OPT_INT8("acosc_penalty" , OFS(acosc_penalty) , 0 ),
454 DEF_OPT_INT32("acosc_penalty_duration" , OFS(acosc_penalty_duration), 0 ),
455 DEF_OPT_INT32("acosc_delay" , OFS(acosc_delay) , 0 ),
456 DEF_LAST_OPT
457 };
458 #else
459 static const struct config_list anticasc_opts[] = { DEF_LAST_OPT };
460 #endif
461
462 #ifdef MODULE_MONITOR
463 static bool monitor_should_save_fn(void *UNUSED(var))
464 {
465 return cfg.mon_port;
466 }
467
468 static const struct config_list monitor_opts[] =
469 {
470 DEF_OPT_SAVE_FUNC(monitor_should_save_fn),
471 DEF_OPT_INT32("port" , OFS(mon_port) , 0),
472 DEF_OPT_FUNC("serverip" , OFS(mon_srvip) , serverip_fn),
473 DEF_OPT_FUNC("nocrypt" , OFS(mon_allowed) , iprange_fn, .free_value = iprange_free_fn),
474 DEF_OPT_INT32("aulow" , OFS(aulow) , 30),
475 DEF_OPT_UINT8("monlevel" , OFS(mon_level) , 2),
476 DEF_OPT_INT32("hideclient_to" , OFS(hideclient_to), 25),
477 DEF_LAST_OPT
478 };
479 #else
480 static const struct config_list monitor_opts[] = { DEF_LAST_OPT };
481 #endif
482
483 #ifdef WEBIF
484 static void http_port_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
485 {
486 if(value)
487 {
488 cfg.http_port = 0;
489 if(value[0])
490 {
491 if(value[0] == '+')
492 {
493 if(config_enabled(WITH_SSL))
494 {
495 cfg.http_use_ssl = 1;
496 }
497 else
498 {
499 fprintf(stderr, "Warning: OSCam compiled without SSL support.\n");
500 }
501 cfg.http_port = strtoul(value + 1, NULL, 10);
502 }
503 else
504 {
505 cfg.http_port = strtoul(value, NULL, 10);
506 }
507 }
508 return;
509 }
510 fprintf_conf(f, token, "%s%d\n", cfg.http_use_ssl ? "+" : "", cfg.http_port);
511 }
512
513 static void http_dyndns_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
514 {
515 int i;
516 if(value)
517 {
518 char *ptr, *saveptr1 = NULL;
519 memset(cfg.http_dyndns, 0, sizeof(cfg.http_dyndns));
520 for(i = 0, ptr = strtok_r(value, ",", &saveptr1); (i < MAX_HTTP_DYNDNS) && (ptr); ptr = strtok_r(NULL, ",", &saveptr1), i++)
521 {
522 trim(ptr);
523 cs_strncpy((char *)cfg.http_dyndns[i], ptr, sizeof(cfg.http_dyndns[i]));
524 }
525 return;
526 }
527 if(strlen((const char *)(cfg.http_dyndns[0])) > 0 || cfg.http_full_cfg)
528 {
529 fprintf_conf(f, token, "%s", ""); // it should not have \n at the end
530 for(i = 0; i < MAX_HTTP_DYNDNS; i++)
531 {
532 if(cfg.http_dyndns[i][0])
533 {
534 fprintf(f, "%s%s", i > 0 ? "," : "", cfg.http_dyndns[i]);
535 }
536 }
537 fprintf(f, "\n");
538 }
539 }
540
541 static bool webif_should_save_fn(void *UNUSED(var))
542 {
543 return cfg.http_port;
544 }
545
546 static const struct config_list webif_opts[] =
547 {
548 DEF_OPT_SAVE_FUNC(webif_should_save_fn),
549 DEF_OPT_FUNC("httpport" , OFS(http_port) , http_port_fn),
550 DEF_OPT_FUNC("serverip" , OFS(http_srvip) , serverip_fn),
551 DEF_OPT_STR("httpuser" , OFS(http_user) , NULL),
552 DEF_OPT_STR("httppwd" , OFS(http_pwd) , NULL),
553 DEF_OPT_STR("httpcss" , OFS(http_css) , NULL),
554 DEF_OPT_STR("httpjscript" , OFS(http_jscript) , NULL),
555 DEF_OPT_STR("httpscript" , OFS(http_script) , NULL),
556 DEF_OPT_STR("httptpl" , OFS(http_tpl) , NULL),
557 DEF_OPT_STR("httppiconpath" , OFS(http_piconpath) , NULL),
558 DEF_OPT_STR("httphelplang" , OFS(http_help_lang) , "en"),
559 DEF_OPT_STR("httplocale" , OFS(http_locale) , NULL),
560 DEF_OPT_INT8("http_prepend_embedded_css", OFS(http_prepend_embedded_css), 0),
561 DEF_OPT_INT32("httprefresh" , OFS(http_refresh) , 0),
562 DEF_OPT_INT32("httppollrefresh" , OFS(poll_refresh) , 60),
563 DEF_OPT_INT8("httphideidleclients" , OFS(http_hide_idle_clients) , 1),
564 DEF_OPT_STR("httphidetype" , OFS(http_hide_type) , NULL),
565 DEF_OPT_INT8("httpshowpicons" , OFS(http_showpicons) , 0),
566 DEF_OPT_INT8("httppiconsize" , OFS(http_picon_size) , 0),
567 DEF_OPT_INT8("httpshowmeminfo" , OFS(http_showmeminfo) , 0),
568 DEF_OPT_INT8("httpshowuserinfo" , OFS(http_showuserinfo) , 0),
569 DEF_OPT_INT8("httpshowreaderinfo" , OFS(http_showreaderinfo) , 0),
570 DEF_OPT_INT8("httpshowcacheexinfo" , OFS(http_showcacheexinfo) , 0),
571 DEF_OPT_INT8("httpshowecminfo" , OFS(http_showecminfo) , 0),
572 DEF_OPT_INT8("httpshowloadinfo" , OFS(http_showloadinfo) , 0),
573 DEF_OPT_FUNC("httpallowed" , OFS(http_allowed) , iprange_fn, .free_value = iprange_free_fn),
574 DEF_OPT_INT8("httpreadonly" , OFS(http_readonly) , 0),
575 DEF_OPT_INT8("httpsavefullcfg" , OFS(http_full_cfg) , 0),
576 DEF_OPT_INT8("httpoverwritebakfile" , OFS(http_overwrite_bak_file) , 0),
577 DEF_OPT_STR("httpcert" , OFS(http_cert) , NULL),
578 DEF_OPT_INT8("https_force_secure_mode" , OFS(https_force_secure_mode) , 1),
579 DEF_OPT_FUNC("httpdyndns" , OFS(http_dyndns) , http_dyndns_fn),
580 DEF_OPT_INT32("aulow" , OFS(aulow) , 30),
581 DEF_OPT_INT32("hideclient_to" , OFS(hideclient_to) , 25),
582 DEF_OPT_STR("httposcamlabel" , OFS(http_oscam_label) , "OSCam"),
583 DEF_OPT_INT32("httpemmuclean" , OFS(http_emmu_clean) , 256),
584 DEF_OPT_INT32("httpemmsclean" , OFS(http_emms_clean) , -1),
585 DEF_OPT_INT32("httpemmgclean" , OFS(http_emmg_clean) , -1),
586 #ifdef WEBIF_LIVELOG
587 DEF_OPT_INT8("http_status_log" , OFS(http_status_log) , 0),
588 #else
589 DEF_OPT_INT8("http_status_log" , OFS(http_status_log) , 1),
590 #endif
591 #ifndef WEBIF_JQUERY
592 DEF_OPT_STR("http_extern_jquery" , OFS(http_extern_jquery) , "//code.jquery.com/jquery-1.12.4.min.js"),
593 #endif
594 DEF_LAST_OPT
595 };
596 #else
597 static const struct config_list webif_opts[] = { DEF_LAST_OPT };
598 #endif
599
600 #ifdef MODULE_CAMD33
601 static bool camd33_should_save_fn(void *UNUSED(var))
602 {
603 return cfg.c33_port;
604 }
605
606 static const struct config_list camd33_opts[] =
607 {
608 DEF_OPT_SAVE_FUNC(camd33_should_save_fn),
609 DEF_OPT_INT32("port" , OFS(c33_port) , 0),
610 DEF_OPT_FUNC("serverip", OFS(c33_srvip) , serverip_fn),
611 DEF_OPT_FUNC("nocrypt" , OFS(c33_plain) , iprange_fn, .free_value = iprange_free_fn),
612 DEF_OPT_INT32("passive", OFS(c33_passive), 0),
613 DEF_OPT_HEX("key" , OFS(c33_key) , SIZEOF(c33_key)),
614 DEF_LAST_OPT
615 };
616 #else
617 static const struct config_list camd33_opts[] = { DEF_LAST_OPT };
618 #endif
619
620
621 void cache_fixups_fn(void *UNUSED(var))
622 {
623 if(cfg.max_cache_time < ((int32_t)(cfg.ctimeout + 500) / 1000 + 3)) { cfg.max_cache_time = ((cfg.ctimeout + 500) / 1000 + 3); }
624 #ifdef CW_CYCLE_CHECK
625 if(cfg.maxcyclelist > 4000) { cfg.maxcyclelist = 4000; }
626 if(cfg.keepcycletime > 240) { cfg.keepcycletime = 240; }
627 if(cfg.cwcycle_sensitive > 4) { cfg.cwcycle_sensitive = 4; }
628 if(cfg.cwcycle_sensitive == 1) { cfg.cwcycle_sensitive = 2; }
629 #endif
630 }
631
632 static bool cache_should_save_fn(void *UNUSED(var))
633 {
634 return cfg.delay > 0 || cfg.max_cache_time != 15
635 #ifdef CS_CACHEEX
636 || cfg.cacheex_wait_timetab.cevnum || cfg.cacheex_enable_stats > 0 || cfg.csp_port || cfg.csp.filter_caidtab.cevnum || cfg.csp.allow_request == 0 || cfg.csp.allow_reforward > 0
637 #endif
638 #ifdef CW_CYCLE_CHECK
639 || cfg.cwcycle_check_enable || cfg.cwcycle_check_caidtab.ctnum || cfg.maxcyclelist != 500 || cfg.keepcycletime || cfg.onbadcycle || cfg.cwcycle_dropold || cfg.cwcycle_sensitive || cfg.cwcycle_allowbadfromffb || cfg.cwcycle_usecwcfromce
640 #endif
641 ;
642 }
643
644 static const struct config_list cache_opts[] =
645 {
646 DEF_OPT_SAVE_FUNC(cache_should_save_fn),
647 DEF_OPT_FIXUP_FUNC(cache_fixups_fn),
648 DEF_OPT_UINT32("delay" , OFS(delay) , CS_DELAY),
649 DEF_OPT_INT32("max_time" , OFS(max_cache_time) , DEFAULT_MAX_CACHE_TIME),
650 #ifdef CS_CACHEEX
651 DEF_OPT_INT32("max_hit_time" , OFS(max_hitcache_time) , DEFAULT_MAX_HITCACHE_TIME),
652 DEF_OPT_FUNC("wait_time" , OFS(cacheex_wait_timetab) , cacheex_valuetab_fn),
653 DEF_OPT_FUNC("cacheex_mode1_delay" , OFS(cacheex_mode1_delay_tab), caidvaluetab_fn),
654 DEF_OPT_UINT8("cacheexenablestats" , OFS(cacheex_enable_stats) , 0),
655 DEF_OPT_INT32("csp_port" , OFS(csp_port) , 0),
656 DEF_OPT_FUNC("csp_serverip" , OFS(csp_srvip) , serverip_fn),
657 DEF_OPT_FUNC("csp_ecm_filter" , OFS(csp.filter_caidtab) , cacheex_hitvaluetab_fn),
658 DEF_OPT_UINT8("csp_allow_request" , OFS(csp.allow_request) , 1),
659 DEF_OPT_UINT8("csp_allow_reforward" , OFS(csp.allow_reforward) , 0),
660 DEF_OPT_FUNC("cacheex_cw_check" , OFS(cacheex_cwcheck_tab) , cacheex_cwcheck_tab_fn),
661 DEF_OPT_UINT8("wait_until_ctimeout" , OFS(wait_until_ctimeout) , 0),
662 DEF_OPT_UINT8("csp_block_fakecws" , OFS(csp.block_fakecws) , 0),
663 #endif
664 #ifdef CW_CYCLE_CHECK
665 DEF_OPT_INT8("cwcycle_check_enable" , OFS(cwcycle_check_enable) , 0),
666 DEF_OPT_FUNC("cwcycle_check_caid" , OFS(cwcycle_check_caidtab) , check_caidtab_fn),
667 DEF_OPT_INT32("cwcycle_maxlist" , OFS(maxcyclelist) , 500),
668 DEF_OPT_INT32("cwcycle_keeptime" , OFS(keepcycletime) , 15),
669 DEF_OPT_INT8("cwcycle_onbad" , OFS(onbadcycle) , 1),
670 DEF_OPT_INT8("cwcycle_dropold" , OFS(cwcycle_dropold) , 1),
671 DEF_OPT_INT8("cwcycle_sensitive" , OFS(cwcycle_sensitive) , 4),
672 DEF_OPT_INT8("cwcycle_allowbadfromffb", OFS(cwcycle_allowbadfromffb), 0),
673 DEF_OPT_INT8("cwcycle_usecwcfromce" , OFS(cwcycle_usecwcfromce) , 0),
674 #endif
675 DEF_LAST_OPT
676 };
677
678 #ifdef MODULE_CAMD35
679 static bool camd35_should_save_fn(void *UNUSED(var))
680 {
681 return cfg.c35_port;
682 }
683
684 static const struct config_list camd35_opts[] =
685 {
686 DEF_OPT_SAVE_FUNC(camd35_should_save_fn),
687 DEF_OPT_INT32("port" , OFS(c35_port) , 0),
688 DEF_OPT_FUNC("serverip" , OFS(c35_srvip) , serverip_fn),
689 DEF_OPT_INT8("suppresscmd08", OFS(c35_udp_suppresscmd08), 0),
690 DEF_LAST_OPT
691 };
692 #else
693 static const struct config_list camd35_opts[] = { DEF_LAST_OPT };
694 #endif
695
696 #ifdef MODULE_NEWCAMD
697 static void porttab_fn(const char *token, char *value, void *setting, FILE *f)
698 {
699 PTAB *ptab = setting;
700 if(value)
701 {
702 if(strlen(value) == 0)
703 {
704 clear_ptab(ptab);
705 }
706 else
707 {
708 chk_port_tab(value, ptab);
709 }
710 return;
711 }
712 value = mk_t_newcamd_port();
713 fprintf_conf(f, token, "%s\n", value);
714 free_mk_t(value);
715 }
716 #endif
717
718 #ifdef MODULE_CAMD35_TCP
719 static void porttab_camd35_fn(const char *token, char *value, void *setting, FILE *f)
720 {
721 PTAB *ptab = setting;
722 if(value)
723 {
724 if(strlen(value) == 0)
725 {
726 clear_ptab(ptab);
727 }
728 else
729 {
730 chk_port_camd35_tab(value, ptab);
731 }
732 return;
733 }
734 value = mk_t_camd35tcp_port();
735 fprintf_conf(f, token, "%s\n", value);
736 free_mk_t(value);
737 }
738 #endif
739
740 #if defined(MODULE_NEWCAMD) || defined(MODULE_CAMD35_TCP)
741 static void porttab_free_fn(void *setting)
742 {
743 clear_ptab(setting);
744 }
745 #endif
746
747 #ifdef MODULE_CAMD35_TCP
748 static bool cs378x_should_save_fn(void *UNUSED(var))
749 {
750 return cfg.c35_tcp_ptab.nports && cfg.c35_tcp_ptab.ports[0].s_port;
751 }
752
753 static const struct config_list cs378x_opts[] =
754 {
755 DEF_OPT_SAVE_FUNC(cs378x_should_save_fn),
756 DEF_OPT_FUNC("port" , OFS(c35_tcp_ptab) , porttab_camd35_fn, .free_value = porttab_free_fn),
757 DEF_OPT_FUNC("serverip" , OFS(c35_tcp_srvip) , serverip_fn),
758 DEF_OPT_INT8("suppresscmd08", OFS(c35_tcp_suppresscmd08), 0),
759 DEF_LAST_OPT
760 };
761 #else
762 static const struct config_list cs378x_opts[] = { DEF_LAST_OPT };
763 #endif
764
765 #ifdef MODULE_NEWCAMD
766 static bool newcamd_should_save_fn(void *UNUSED(var))
767 {
768 return cfg.ncd_ptab.nports && cfg.ncd_ptab.ports[0].s_port;
769 }
770
771 static const struct config_list newcamd_opts[] =
772 {
773 DEF_OPT_SAVE_FUNC(newcamd_should_save_fn),
774 DEF_OPT_FUNC("port" , OFS(ncd_ptab) , porttab_fn, .free_value = porttab_free_fn),
775 DEF_OPT_FUNC("serverip" , OFS(ncd_srvip) , serverip_fn),
776 DEF_OPT_FUNC("allowed" , OFS(ncd_allowed) , iprange_fn, .free_value = iprange_free_fn),
777 DEF_OPT_HEX("key" , OFS(ncd_key) , SIZEOF(ncd_key)),
778 DEF_OPT_INT8("keepalive" , OFS(ncd_keepalive), DEFAULT_NCD_KEEPALIVE),
779 DEF_OPT_INT8("mgclient" , OFS(ncd_mgclient) , 0),
780 DEF_LAST_OPT
781 };
782 #else
783 static const struct config_list newcamd_opts[] = { DEF_LAST_OPT };
784 #endif
785
786 #ifdef MODULE_CCCAM
787 static void cccam_port_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
788 {
789 if(value)
790 {
791 int i;
792 char *ptr, *saveptr1 = NULL;
793 memset(cfg.cc_port, 0, sizeof(cfg.cc_port));
794 for(i = 0, ptr = strtok_r(value, ",", &saveptr1); ptr && i < CS_MAXPORTS; ptr = strtok_r(NULL, ",", &saveptr1))
795 {
796 cfg.cc_port[i] = strtoul(ptr, NULL, 10);
797 if(cfg.cc_port[i])
798 { i++; }
799 }
800 return;
801 }
802 value = mk_t_cccam_port();
803 fprintf_conf(f, token, "%s\n", value);
804 free_mk_t(value);
805 }
806
807 static bool cccam_should_save_fn(void *UNUSED(var))
808 {
809 return cfg.cc_port[0];
810 }
811
812 static const struct config_list cccam_opts[] =
813 {
814 DEF_OPT_SAVE_FUNC(cccam_should_save_fn),
815 DEF_OPT_FUNC("port" , OFS(cc_port) , cccam_port_fn),
816 DEF_OPT_FUNC("serverip" , OFS(cc_srvip) , serverip_fn),
817 DEF_OPT_HEX("nodeid" , OFS(cc_fixed_nodeid) , SIZEOF(cc_fixed_nodeid)),
818 DEF_OPT_SSTR("version" , OFS(cc_version) , "", SIZEOF(cc_version)),
819 DEF_OPT_INT8("reshare" , OFS(cc_reshare) , 10),
820 DEF_OPT_INT8("reshare_mode" , OFS(cc_reshare_services) , 4),
821 DEF_OPT_INT8("ignorereshare" , OFS(cc_ignore_reshare) , 0),
822 DEF_OPT_INT8("forward_origin_card", OFS(cc_forward_origin_card), 0),
823 DEF_OPT_INT8("stealth" , OFS(cc_stealth) , 0),
824 DEF_OPT_INT32("updateinterval" , OFS(cc_update_interval) , DEFAULT_UPDATEINTERVAL),
825 DEF_OPT_INT8("minimizecards" , OFS(cc_minimize_cards) , 0),
826 DEF_OPT_INT8("keepconnected" , OFS(cc_keep_connected) , 1),
827 DEF_OPT_UINT32("recv_timeout" , OFS(cc_recv_timeout) , DEFAULT_CC_RECV_TIMEOUT),
828 DEF_LAST_OPT
829 };
830 #else
831 static const struct config_list cccam_opts[] = { DEF_LAST_OPT };
832 #endif
833
834 #ifdef MODULE_PANDORA
835 static bool pandora_should_save_fn(void *UNUSED(var))
836 {
837 return cfg.pand_port;
838 }
839
840 static const struct config_list pandora_opts[] =
841 {
842 DEF_OPT_SAVE_FUNC(pandora_should_save_fn),
843 DEF_OPT_INT32("pand_port" , OFS(pand_port) , 0),
844 DEF_OPT_FUNC("pand_srvid" , OFS(pand_srvip) , serverip_fn),
845 DEF_OPT_STR("pand_usr" , OFS(pand_usr) , NULL),
846 DEF_OPT_STR("pand_pass" , OFS(pand_pass) , NULL),
847 DEF_OPT_INT8("pand_ecm" , OFS(pand_ecm) , 0),
848 DEF_OPT_INT8("pand_skip_send_dw", OFS(pand_skip_send_dw), 0),
849 DEF_OPT_FUNC("pand_allowed" , OFS(pand_allowed) , iprange_fn, .free_value = iprange_free_fn),
850 DEF_LAST_OPT
851 };
852 #else
853 static const struct config_list pandora_opts[] = { DEF_LAST_OPT };
854 #endif
855
856 #ifdef MODULE_SCAM
857 static bool scam_should_save_fn(void *UNUSED(var))
858 {
859 return cfg.scam_port;
860 }
861 static const struct config_list scam_opts[] =
862 {
863 DEF_OPT_SAVE_FUNC(scam_should_save_fn),
864 DEF_OPT_INT32("port" , OFS(scam_port) , 0),
865 DEF_OPT_FUNC("serverip" , OFS(scam_srvip) , serverip_fn),
866 DEF_OPT_FUNC("allowed" , OFS(scam_allowed), iprange_fn, .free_value = iprange_free_fn),
867 DEF_LAST_OPT
868 };
869 #else
870 static const struct config_list scam_opts[] = { DEF_LAST_OPT };
871 #endif
872
873 #ifdef WITH_EMU
874 static bool streamrelay_should_save_fn(void *UNUSED(var))
875 {
876 return 1;
877 }
878 static const struct config_list streamrelay_opts[] =
879 {
880 DEF_OPT_SAVE_FUNC(streamrelay_should_save_fn),
881 DEF_OPT_STR("stream_source_host" , OFS(emu_stream_source_host), "127.0.0.1"),
882 DEF_OPT_INT32("stream_source_port" , OFS(emu_stream_source_port), 8001),
883 DEF_OPT_STR("stream_source_auth_user" , OFS(emu_stream_source_auth_user), NULL),
884 DEF_OPT_STR("stream_source_auth_password" , OFS(emu_stream_source_auth_password), NULL),
885 DEF_OPT_INT32("stream_relay_port" , OFS(emu_stream_relay_port), 17999),
886 DEF_OPT_UINT32("stream_ecm_delay" , OFS(emu_stream_ecm_delay), 600),
887 DEF_OPT_INT8("stream_relay_enabled" , OFS(emu_stream_relay_enabled), 1),
888 DEF_OPT_INT8("stream_emm_enabled" , OFS(emu_stream_emm_enabled), 1),
889 DEF_OPT_FUNC("stream_relay_ctab" , OFS(emu_stream_relay_ctab), check_caidtab_fn),
890 DEF_LAST_OPT
891 };
892 #else
893 static const struct config_list streamrelay_opts[] = { DEF_LAST_OPT };
894 #endif
895
896
897 #ifdef MODULE_RADEGAST
898 static bool radegast_should_save_fn(void *UNUSED(var))
899 {
900 return cfg.rad_port;
901 }
902
903 static const struct config_list radegast_opts[] =
904 {
905 DEF_OPT_SAVE_FUNC(radegast_should_save_fn),
906 DEF_OPT_INT32("port" , OFS(rad_port) , 0),
907 DEF_OPT_FUNC("serverip", OFS(rad_srvip) , serverip_fn),
908 DEF_OPT_FUNC("allowed" , OFS(rad_allowed), iprange_fn, .free_value = iprange_free_fn),
909 DEF_OPT_STR("user" , OFS(rad_usr) , NULL),
910 DEF_LAST_OPT
911 };
912 #else
913 static const struct config_list radegast_opts[] = { DEF_LAST_OPT };
914 #endif
915
916 #ifdef MODULE_SERIAL
917 static bool serial_should_save_fn(void *UNUSED(var))
918 {
919 return cfg.ser_device != NULL;
920 }
921
922 static const struct config_list serial_opts[] =
923 {
924 DEF_OPT_SAVE_FUNC(serial_should_save_fn),
925 DEF_OPT_STR("device", OFS(ser_device), NULL),
926 DEF_LAST_OPT
927 };
928 #else
929 static const struct config_list serial_opts[] = { DEF_LAST_OPT };
930 #endif
931
932 #ifdef MODULE_GBOX
933
934 static void gbox_password_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
935 {
936 if (value)
937 {
938 const char *s;
939 s = value;
940 if (s[strspn(s, "0123456789abcdefABCDEF")] == 0)
941 {
942 /* valid Hexa symbol */
943 cfg.gbox_password = a2i(value, 8);
944 return;
945 }
946 else
947 {
948 cfg.gbox_password = 0;
949 }
950 }
951 if (cfg.gbox_password != 0)
952 {
953 fprintf_conf(f, token, "%08X\n", cfg.gbox_password);
954 }
955 }
956
957 static void gbox_block_ecm_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
958 {
959 if (value)
960 {
961 char *ptr1, *saveptr1 = NULL;
962 const char *s;
963 memset(cfg.gbox_block_ecm, 0, sizeof(cfg.gbox_block_ecm));
964 int n = 0, i;
965 for (i = 0, ptr1 = strtok_r(value, ",", &saveptr1); (i < 4) && (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
966 {
967 s=ptr1;
968 if ((n < GBOX_MAX_BLOCKED_ECM) && (s[strspn(s, "0123456789abcdefABCDEF")] == 0))
969 { cfg.gbox_block_ecm[n++] = a2i(ptr1, 4); }
970 }
971 cfg.gbox_block_ecm_num = n;
972 return;
973 }
974 if (cfg.gbox_block_ecm_num > 0)
975 {
976 value = mk_t_gbox_block_ecm();
977 fprintf_conf(f, token, "%s\n", value);
978 free_mk_t(value);
979 }
980 }
981
982 static void accept_remm_peer_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
983 {
984 if (value)
985 {
986 char *ptr1, *saveptr1 = NULL;
987 const char *s;
988 memset(cfg.accept_remm_peer, 0, sizeof(cfg.accept_remm_peer));
989 int n = 0, i;
990 for (i = 0, ptr1 = strtok_r(value, ",", &saveptr1); (i < 4) && (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
991 {
992 s=ptr1;
993 if ((n < GBOX_MAX_REMM_PEERS) && (s[strspn(s, "0123456789abcdefABCDEF")] == 0))
994 { cfg.accept_remm_peer[n++] = a2i(ptr1, 4); }
995 }
996 cfg.accept_remm_peer_num = n;
997 return;
998 }
999
1000 if (cfg.accept_remm_peer_num > 0)
1001 {
1002 value = mk_t_accept_remm_peer();
1003 fprintf_conf(f, token, "%s\n", value);
1004 free_mk_t(value);
1005 }
1006 }
1007
1008 static void gbox_ignored_peer_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1009 {
1010 if (value)
1011 {
1012 char *ptr1, *saveptr1 = NULL;
1013 const char *s;
1014 memset(cfg.gbox_ignored_peer, 0, sizeof(cfg.gbox_ignored_peer));
1015 int n = 0, i;
1016
1017 for (i = 0, ptr1 = strtok_r(value, ",", &saveptr1); (i < 4) && (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
1018 {
1019 s = ptr1;
1020 if ((n < GBOX_MAX_IGNORED_PEERS) && (s[strspn(s, "0123456789abcdefABCDEF")] == 0))
1021 { cfg.gbox_ignored_peer[n++] = a2i(ptr1, 4); }
1022 }
1023 cfg.gbox_ignored_peer_num = n;
1024 return;
1025 }
1026
1027 if (cfg.gbox_ignored_peer_num > 0)
1028 {
1029 value = mk_t_gbox_ignored_peer();
1030 fprintf_conf(f, token, "%s\n", value);
1031 free_mk_t(value);
1032 }
1033 }
1034
1035 static void gbox_proxy_card_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1036 {
1037 if (value)
1038 {
1039 char *ptr1, *saveptr1 = NULL;
1040 const char *s;
1041 memset(cfg.gbox_proxy_card, 0, sizeof(cfg.gbox_proxy_card));
1042 int n = 0, i;
1043 for (i = 0, ptr1 = strtok_r(value, ",", &saveptr1); (i < 8) && (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
1044 {
1045 s = ptr1;
1046 if ((n < GBOX_MAX_PROXY_CARDS) && (s[strspn(s, "0123456789abcdefABCDEF")] == 0))
1047 { cfg.gbox_proxy_card[n++] = a2i(ptr1, 8); }
1048 }
1049 cfg.gbox_proxy_cards_num = n;
1050 return;
1051 }
1052
1053 if (cfg.gbox_proxy_cards_num > 0)
1054 {
1055 value = mk_t_gbox_proxy_card();
1056 fprintf_conf(f, token, "%s\n", value);
1057 free_mk_t(value);
1058 }
1059 }
1060
1061 static void gbox_port_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1062 {
1063 if(value)
1064 {
1065 int i;
1066 char *ptr, *saveptr1 = NULL;
1067 memset(cfg.gbox_port, 0, sizeof(cfg.gbox_port));
1068 for(i = 0, ptr = strtok_r(value, ",", &saveptr1); ptr && i < CS_MAXPORTS; ptr = strtok_r(NULL, ",", &saveptr1))
1069 {
1070 cfg.gbox_port[i] = strtoul(ptr, NULL, 10);
1071 if(cfg.gbox_port[i])
1072 { i++; }
1073 }
1074 return;
1075 }
1076 value = mk_t_gbox_port();
1077 fprintf_conf(f, token, "%s\n", value);
1078 free_mk_t(value);
1079 }
1080
1081 static void gbox_my_vers_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1082 {
1083 if(value)
1084 {
1085 const char *s;
1086 s = value;
1087 int32_t len = strlen(value);
1088
1089 if ((s[strspn(s, "0123456789abcdefABCDEF")] != 0) || (len == 0) || (len > 2))
1090 {
1091 cfg.gbox_my_vers = GBOX_MY_VERS_DEF;
1092 }
1093 else
1094 {
1095 cfg.gbox_my_vers = a2i(value, 1);
1096 return;
1097 }
1098 }
1099
1100 if(cfg.gbox_my_vers != GBOX_MY_VERS_DEF)
1101 {
1102 fprintf_conf(f, token, "%02X\n", cfg.gbox_my_vers);
1103 }
1104 else if(cfg.http_full_cfg)
1105 {
1106 fprintf_conf(f, token, "%02X\n", GBOX_MY_VERS_DEF);
1107 }
1108 }
1109
1110 static void gbox_my_cpu_api_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1111 {
1112 if(value)
1113 {
1114 const char *s;
1115 s = value;
1116 int32_t len = strlen(value);
1117
1118 if ((s[strspn(s, "0123456789abcdefABCDEF")] != 0) || (len == 0) || (len > 2))
1119 {
1120 cfg.gbox_my_cpu_api = GBOX_MY_CPU_API_DEF;
1121 }
1122 else
1123 {
1124 cfg.gbox_my_cpu_api = a2i(value,1);
1125 return;
1126 }
1127 }
1128
1129 if(cfg.gbox_my_cpu_api != GBOX_MY_CPU_API_DEF)
1130 {
1131 fprintf_conf(f, token, "%02X\n", cfg.gbox_my_cpu_api);
1132 }
1133 else if(cfg.http_full_cfg)
1134 { fprintf_conf(f, token, "%02X\n", GBOX_MY_CPU_API_DEF); }
1135 }
1136
1137 static void gbox_dest_peers_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1138 {
1139 if (value)
1140 {
1141 char *ptr1, *saveptr1 = NULL;
1142 const char *s;
1143 memset(cfg.gbox_dest_peers, 0, sizeof(cfg.gbox_dest_peers));
1144 int n = 0;
1145
1146 for (ptr1 = strtok_r(value, ",", &saveptr1); (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
1147 {
1148 s = trim(ptr1);
1149 if ((n < GBOX_MAX_DEST_PEERS) && (s[strspn(s, "0123456789abcdefABCDEF")] == 0))
1150 { cfg.gbox_dest_peers[n++] = a2i(trim(ptr1), strlen(trim(ptr1))); }
1151 }
1152 cfg.gbox_dest_peers_num = n;
1153 return;
1154 }
1155
1156 if ((cfg.gbox_dest_peers_num > 0) && cfg.gbox_save_gsms)
1157 {
1158 value = mk_t_gbox_dest_peers();
1159 fprintf_conf(f, token, "%s\n", value);
1160 free_mk_t(value);
1161 }
1162 }
1163
1164 static void gbox_msg_txt_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1165 {
1166 if (value)
1167 {
1168 cs_strncpy(cfg.gbox_msg_txt, value, sizeof(cfg.gbox_msg_txt));
1169 return;
1170 }
1171
1172 if ((cfg.gbox_msg_txt[0] != '\0') && cfg.gbox_save_gsms)
1173 {
1174 fprintf_conf(f, token, "%s\n", cfg.gbox_msg_txt);
1175 }
1176 }
1177
1178 static bool gbox_should_save_fn(void *UNUSED(var))
1179 {
1180 return cfg.gbox_port[0];
1181 }
1182
1183 static const struct config_list gbox_opts[] =
1184 {
1185 DEF_OPT_SAVE_FUNC(gbox_should_save_fn),
1186 DEF_OPT_FUNC("port" , OFS(gbox_port) , gbox_port_fn),
1187 DEF_OPT_STR("hostname" , OFS(gbox_hostname) , NULL),
1188 DEF_OPT_FUNC("my_password" , OFS(gbox_password) , gbox_password_fn ),
1189 DEF_OPT_UINT32("gbox_reconnect", OFS(gbox_reconnect) , DEFAULT_GBOX_RECONNECT),
1190 DEF_OPT_FUNC("my_vers" , OFS(gbox_my_vers) , gbox_my_vers_fn),
1191 DEF_OPT_FUNC("my_cpu_api" , OFS(gbox_my_cpu_api) , gbox_my_cpu_api_fn),
1192 DEF_OPT_UINT8("gsms_disable" , OFS(gsms_dis) , 1),
1193 DEF_OPT_UINT8("dis_attack_txt" , OFS(dis_attack_txt) , 0),
1194 DEF_OPT_UINT8("log_hello" , OFS(log_hello) , 1),
1195 DEF_OPT_STR("tmp_dir" , OFS(gbox_tmp_dir) , NULL ),
1196 DEF_OPT_FUNC("ignore_peer" , OFS(gbox_ignored_peer), gbox_ignored_peer_fn ),
1197 DEF_OPT_FUNC("accept_remm_peer", OFS(accept_remm_peer) , accept_remm_peer_fn ),
1198 DEF_OPT_FUNC("block_ecm" , OFS(gbox_block_ecm) , gbox_block_ecm_fn ),
1199 DEF_OPT_FUNC("proxy_card" , OFS(gbox_proxy_card) , gbox_proxy_card_fn ),
1200 DEF_OPT_UINT8("gbox_save_gsms" , OFS(gbox_save_gsms) , 0),
1201 DEF_OPT_UINT8("gbox_msg_type" , OFS(gbox_msg_type) , 0),
1202 DEF_OPT_FUNC("gbox_dest_peers" , OFS(gbox_dest_peers) , gbox_dest_peers_fn ),
1203 DEF_OPT_FUNC("gbox_msg_txt" , OFS(gbox_msg_txt) , gbox_msg_txt_fn ),
1204 DEF_OPT_UINT8("ccc_reshare" , OFS(cc_gbx_reshare_en), 0),
1205 DEF_OPT_FUNC("ccc_gbx_caid" , OFS(ccc_gbx_check_caidtab), check_caidtab_fn),
1206 DEF_LAST_OPT
1207 };
1208 #else
1209 static const struct config_list gbox_opts[] = { DEF_LAST_OPT };
1210 #endif
1211
1212 #ifdef HAVE_DVBAPI
1213 extern const char *boxdesc[];
1214
1215 static void dvbapi_boxtype_fn(const char *token, char *value, void *UNUSED(setting), FILE *f)
1216 {
1217 if(value)
1218 {
1219 int i;
1220 cfg.dvbapi_boxtype = 0;
1221 for(i = 1; i <= BOXTYPES; i++)
1222 {
1223 if(streq(value, boxdesc[i]))
1224 {
1225 cfg.dvbapi_boxtype = i;
1226 break;
1227 }
1228 }
1229 return;
1230 }
1231
1232 if(cfg.dvbapi_boxtype)
1233 { fprintf_conf(f, token, "%s\n", boxdesc[cfg.dvbapi_boxtype]); }
1234 }
1235
1236 static void dvbapi_services_fn(const char *UNUSED(token), char *value, void *UNUSED(setting), FILE *UNUSED(f))
1237 {
1238 if(value)
1239 { chk_services(value, &cfg.dvbapi_sidtabs); }
1240 // THIS OPTION IS NOT SAVED
1241 }
1242
1243 extern struct s_dvbapi_priority *dvbapi_priority;
1244
1245 static void dvbapi_caidtab_fn(const char *UNUSED(token), char *caidasc, void *UNUSED(setting), long cmd, FILE *UNUSED(f))
1246 {
1247 char *ptr1, *ptr3, *saveptr1 = NULL;
1248 if(!caidasc)
1249 { return; }
1250 char type = (char)cmd;
1251
1252 for(ptr1 = strtok_r(caidasc, ",", &saveptr1); (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
1253 {
1254 uint32_t caid, prov;
1255 if((ptr3 = strchr(trim(ptr1), ':')))
1256 { * ptr3++ = '\0'; }
1257 else
1258 { ptr3 = ""; }
1259
1260 if(((caid = a2i(ptr1, 2)) | (prov = a2i(ptr3, 3))))
1261 {
1262 struct s_dvbapi_priority *entry;
1263
1264 if(!cs_malloc(&entry, sizeof(struct s_dvbapi_priority)))
1265 { return; }
1266 entry->caid = caid;
1267
1268 if(type == 'd')
1269 {
1270 char tmp1[5];
1271 snprintf(tmp1, sizeof(tmp1), "%04X", (uint)prov);
1272 int32_t cw_delay = strtol(tmp1, NULL, 10);
1273 entry->delay = cw_delay;
1274 }
1275 else
1276 {
1277 entry->provid = prov;
1278 }
1279
1280 entry->type = type;
1281 entry->next = NULL;
1282
1283 if(!dvbapi_priority)
1284 {
1285 dvbapi_priority = entry;
1286 }
1287 else
1288 {
1289 struct s_dvbapi_priority *p;
1290 for(p = dvbapi_priority; p->next != NULL; p = p->next)
1291 { ; }
1292 p->next = entry;
1293 }
1294 }
1295 }
1296 // THIS OPTION IS NOT SAVED
1297 }
1298
1299 static bool dvbapi_should_save_fn(void *UNUSED(var))
1300 {
1301 return cfg.dvbapi_enabled;
1302 }
1303
1304 static const struct config_list dvbapi_opts[] =
1305 {
1306 DEF_OPT_SAVE_FUNC(dvbapi_should_save_fn),
1307 DEF_OPT_INT8("enabled" , OFS(dvbapi_enabled) , 0),
1308 DEF_OPT_INT8("au" , OFS(dvbapi_au) , 0),
1309 DEF_OPT_INT8("pmt_mode" , OFS(dvbapi_pmtmode) , 0),
1310 DEF_OPT_INT8("request_mode" , OFS(dvbapi_requestmode) , 0),
1311 DEF_OPT_INT32("listen_port" , OFS(dvbapi_listenport) , 0),
1312 DEF_OPT_INT32("delayer" , OFS(dvbapi_delayer) , 0),
1313 DEF_OPT_INT8("ecminfo_file" , OFS(dvbapi_ecminfo_file) , 1),
1314 DEF_OPT_INT8("ecminfo_type" , OFS(dvbapi_ecminfo_type) , 0),
1315 DEF_OPT_STR("user" , OFS(dvbapi_usr) , NULL),
1316 DEF_OPT_INT8("read_sdt" , OFS(dvbapi_read_sdt) , 0),
1317 DEF_OPT_INT8("write_sdt_prov" , OFS(dvbapi_write_sdt_prov) , 0),
1318 DEF_OPT_INT8("extended_cw_api", OFS(dvbapi_extended_cw_api), 0),
1319 DEF_OPT_FUNC("boxtype" , OFS(dvbapi_boxtype) , dvbapi_boxtype_fn),
1320 DEF_OPT_FUNC("services" , OFS(dvbapi_sidtabs.ok) , dvbapi_services_fn),
1321 // OBSOLETE OPTIONS
1322 DEF_OPT_FUNC_X("priority" , 0, dvbapi_caidtab_fn , 'p'),
1323 DEF_OPT_FUNC_X("ignore" , 0, dvbapi_caidtab_fn , 'i'),
1324 DEF_OPT_FUNC_X("cw_delay" , 0, dvbapi_caidtab_fn , 'd'),
1325 DEF_LAST_OPT
1326 };
1327 #else
1328 static const struct config_list dvbapi_opts[] = { DEF_LAST_OPT };
1329 #endif
1330
1331 #ifdef LCDSUPPORT
1332 static void lcd_fixups_fn(void *UNUSED(var))
1333 {
1334 if(cfg.lcd_write_intervall < 5) { cfg.lcd_write_intervall = 5; }
1335 }
1336
1337 static bool lcd_should_save_fn(void *UNUSED(var))
1338 {
1339 return cfg.enablelcd;
1340 }
1341
1342 static const struct config_list lcd_opts[] =
1343 {
1344 DEF_OPT_SAVE_FUNC(lcd_should_save_fn),
1345 DEF_OPT_FIXUP_FUNC(lcd_fixups_fn),
1346 DEF_OPT_INT8("enablelcd" , OFS(enablelcd) , 0),
1347 DEF_OPT_STR("lcd_outputpath" , OFS(lcd_output_path) , NULL),
1348 DEF_OPT_INT32("lcd_hideidle" , OFS(lcd_hide_idle) , 0),
1349 DEF_OPT_INT32("lcd_writeintervall", OFS(lcd_write_intervall), 10),
1350 DEF_LAST_OPT
1351 };
1352 #else
1353 static const struct config_list lcd_opts[] = { DEF_LAST_OPT };
1354 #endif
1355
1356 static const struct config_sections oscam_conf[] =
1357 {
1358 { "global", global_opts }, // *** MUST BE FIRST ***
1359 { "anticasc", anticasc_opts },
1360 { "cache", cache_opts },
1361 { "lcd", lcd_opts },
1362 { "camd33", camd33_opts },
1363 { "cs357x", camd35_opts },
1364 { "cs378x", cs378x_opts },
1365 { "newcamd", newcamd_opts },
1366 { "radegast", radegast_opts },
1367 { "serial", serial_opts },
1368 { "gbox", gbox_opts },
1369 { "cccam", cccam_opts },
1370 { "pandora", pandora_opts },
1371 { "scam", scam_opts },
1372 { "streamrelay", streamrelay_opts },
1373 { "dvbapi", dvbapi_opts },
1374 { "monitor", monitor_opts },
1375 { "webif", webif_opts },
1376 { NULL, NULL }
1377 };
1378
1379 void config_set(char *section, const char *token, char *value)
1380 {
1381 config_set_value(oscam_conf, section, token, value, &cfg);
1382 }
1383
1384 void config_free(void)
1385 {
1386 config_sections_free(oscam_conf, &cfg);
1387 caidvaluetab_clear(&cfg.ftimeouttab);
1388 caidtab_clear(&cfg.double_check_caid);
1389 ftab_clear(&cfg.disablecrccws_only_for);
1390 #ifdef WITH_LB
1391 caidvaluetab_clear(&cfg.lb_retrylimittab);
1392 caidvaluetab_clear(&cfg.lb_nbest_readers_tab);
1393 caidtab_clear(&cfg.lb_noproviderforcaid);
1394 #endif
1395 #ifdef CS_CACHEEX
1396 caidvaluetab_clear(&cfg.cacheex_mode1_delay_tab);
1397 cecspvaluetab_clear(&cfg.cacheex_wait_timetab);
1398 #endif
1399 #ifdef CW_CYCLE_CHECK
1400 caidtab_clear(&cfg.cwcycle_check_caidtab);
1401 #endif
1402 }
1403
1404 int32_t init_config(void)
1405 {
1406 FILE *fp;
1407
1408 if(config_enabled(WEBIF))
1409 {
1410 fp = open_config_file(cs_conf);
1411 }
1412 else
1413 {
1414 fp = open_config_file_or_die(cs_conf);
1415 }
1416
1417 const struct config_sections *cur_section = oscam_conf; // Global
1418 char *token;
1419
1420 config_sections_set_defaults(oscam_conf, &cfg);
1421
1422 if(!fp)
1423 {
1424 // no oscam.conf but webif is included in build, set it up for lan access and tweak defaults
1425 #ifdef WEBIF
1426 cfg.http_port = DEFAULT_HTTP_PORT;
1427 char *default_allowed;
1428 if ((default_allowed = cs_strdup(DEFAULT_HTTP_ALLOW)))
1429 {
1430 chk_iprange(default_allowed, &cfg.http_allowed);
1431 free(default_allowed);
1432 }
1433 #endif
1434 NULLFREE(cfg.logfile);
1435 cfg.logtostdout = 1;
1436 #ifdef HAVE_DVBAPI
1437 cfg.dvbapi_enabled = 1;
1438 #endif
1439 return 0;
1440 }
1441
1442 if(!cs_malloc(&token, MAXLINESIZE))
1443 { return 1; }
1444
1445 int line = 0;
1446 int valid_section = 1;
1447 while(fgets(token, MAXLINESIZE, fp))
1448 {
1449 ++line;
1450 int len = strlen(trim(token));
1451 if(len < 3) // a=b or [a] are at least 3 chars
1452 { continue; }
1453 if(token[0] == '#') // Skip comments
1454 { continue; }
1455 if(token[0] == '[' && token[len - 1] == ']')
1456 {
1457 token[len - 1] = '\0';
1458 valid_section = 0;
1459 const struct config_sections *newconf = config_find_section(oscam_conf, token + 1);
1460 if(config_section_is_active(newconf) && cur_section)
1461 {
1462 config_list_apply_fixups(cur_section->config, &cfg);
1463 cur_section = newconf;
1464 valid_section = 1;
1465 }
1466 if(!newconf)
1467 {
1468 fprintf(stderr, "WARNING: %s line %d unknown section [%s].\n",
1469 cs_conf, line, token + 1);
1470 continue;
1471 }
1472 if(!config_section_is_active(newconf))
1473 {
1474 fprintf(stderr, "WARNING: %s line %d section [%s] is ignored (support not compiled in).\n",
1475 cs_conf, line, newconf->section);
1476 }
1477 continue;
1478 }
1479
1480 if(!valid_section)
1481 { continue; }
1482 char *value = strchr(token, '=');
1483 if(!value) // No = found, well go on
1484 { continue; }
1485 *value++ = '\0';
1486 char *tvalue = trim(value);
1487 char *ttoken = trim(strtolower(token));
1488 if(cur_section && !config_list_parse(cur_section->config, ttoken, tvalue, &cfg))
1489 {
1490 fprintf(stderr, "WARNING: %s line %d section [%s] contains unknown setting '%s=%s'\n",
1491 cs_conf, line, cur_section->section, ttoken, tvalue);
1492 }
1493 }
1494 NULLFREE(token);
1495 fclose(fp);
1496 if(cur_section) { config_list_apply_fixups(cur_section->config, &cfg); }
1497 return 0;
1498 }
1499
1500 int32_t write_config(void)
1501 {
1502 FILE *f = create_config_file(cs_conf);
1503 if(!f)
1504 { return 1; }
1505 config_sections_save(oscam_conf, f, &cfg);
1506 return flush_config_file(f, cs_conf);
1507 }
Open Source Conditional Access Modul