1 | #include "globals.h"
|
---|
2 | #include "config.h"
|
---|
3 |
|
---|
4 | #include "simples.h"
|
---|
5 | #include "ac.h"
|
---|
6 | #include "log.h"
|
---|
7 | #include "oscam.h"
|
---|
8 | #include "network.h"
|
---|
9 |
|
---|
10 | #ifdef CS_WITH_BOXKEYS
|
---|
11 | # include "boxkeys.np"
|
---|
12 | #endif
|
---|
13 |
|
---|
14 | #include <stdio.h>
|
---|
15 | #include <stdlib.h>
|
---|
16 |
|
---|
17 | static char *cs_conf = "oscam.conf";
|
---|
18 | static char *cs_user = "oscam.user";
|
---|
19 | static char *cs_srvr = "oscam.server";
|
---|
20 | static char *cs_srid = "oscam.srvid";
|
---|
21 | static char *cs_l4ca = "oscam.guess";
|
---|
22 | static char *cs_cert = "oscam.cert";
|
---|
23 | static char *cs_sidt = "oscam.services";
|
---|
24 |
|
---|
25 | //static char *cs_ird="oscam.ird";
|
---|
26 | #ifdef CS_ANTICASC
|
---|
27 | static char *cs_ac = "oscam.ac";
|
---|
28 | #endif
|
---|
29 |
|
---|
30 | static char token[4096];
|
---|
31 |
|
---|
32 | //--- WARNING: cs_proto_type_t and cctag must use the same order ---//
|
---|
33 | typedef enum cs_proto_type {
|
---|
34 | TAG_GLOBAL, // must be first !
|
---|
35 | TAG_CAMD33, // camd 3.3x
|
---|
36 | TAG_CAMD35, // camd 3.5x UDP
|
---|
37 | TAG_NEWCAMD, // newcamd
|
---|
38 | TAG_RADEGAST, // radegast
|
---|
39 | TAG_SERIAL, // serial (static)
|
---|
40 | TAG_CS357X, // camd 3.5x UDP
|
---|
41 | TAG_CS378X, // camd 3.5x TCP
|
---|
42 | #ifdef CS_WITH_GBOX
|
---|
43 | TAG_GBOX, // gbox
|
---|
44 | #endif
|
---|
45 | #ifdef CS_ANTICASC
|
---|
46 | TAG_ANTICASC, // anti-cascading
|
---|
47 | #endif
|
---|
48 | TAG_MONITOR // monitor
|
---|
49 | } cs_proto_type_t;
|
---|
50 |
|
---|
51 | //--- WARNING: cs_proto_type_t and cctag must use the same order ---//
|
---|
52 | static char *cctag[] = { "global", "camd33", "camd35",
|
---|
53 | "newcamd", "radegast", "serial", "cs357x", "cs378x",
|
---|
54 | #ifdef CS_WITH_GBOX
|
---|
55 | "gbox",
|
---|
56 | #endif
|
---|
57 | #ifdef CS_ANTICASC
|
---|
58 | "anticasc",
|
---|
59 | #endif
|
---|
60 | "monitor",
|
---|
61 | NULL
|
---|
62 | };
|
---|
63 |
|
---|
64 | #ifdef DEBUG_SIDTAB
|
---|
65 | static void config_show_sidtab(struct s_sidtab *sidtab)
|
---|
66 | {
|
---|
67 | for (; sidtab; sidtab = sidtab->next) {
|
---|
68 | int i;
|
---|
69 | char buf[1024];
|
---|
70 |
|
---|
71 | log_normal("label=%s", sidtab->label);
|
---|
72 | sprintf(buf, "caid(%d)=", sidtab->num_caid);
|
---|
73 | for (i = 0; i < sidtab->num_caid; i++)
|
---|
74 | sprintf(buf + strlen(buf), "%04X ", sidtab->caid[i]);
|
---|
75 | log_normal("%s", buf);
|
---|
76 | sprintf(buf, "provider(%d)=", sidtab->num_provid);
|
---|
77 | for (i = 0; i < sidtab->num_provid; i++)
|
---|
78 | sprintf(buf + strlen(buf), "%08X ", sidtab->provid[i]);
|
---|
79 | log_normal("%s", buf);
|
---|
80 | sprintf(buf, "services(%d)=", sidtab->num_srvid);
|
---|
81 | for (i = 0; i < sidtab->num_srvid; i++)
|
---|
82 | sprintf(buf + strlen(buf), "%04X ", sidtab->srvid[i]);
|
---|
83 | log_normal("%s", buf);
|
---|
84 | }
|
---|
85 | }
|
---|
86 | #endif
|
---|
87 |
|
---|
88 | static void config_check_iprange(char *value, struct s_ip **base)
|
---|
89 | {
|
---|
90 | char *ptr1, *ptr2;
|
---|
91 | struct s_ip *lip, *cip;
|
---|
92 |
|
---|
93 | for (cip = lip = *base; cip; cip = cip->next)
|
---|
94 | lip = cip;
|
---|
95 | if (!(cip = malloc(sizeof (struct s_ip)))) {
|
---|
96 | fprintf(stderr, "Error allocating memory (errno=%d)\n", errno);
|
---|
97 | exit(1);
|
---|
98 | }
|
---|
99 | if (*base)
|
---|
100 | lip->next = cip;
|
---|
101 | else
|
---|
102 | *base = cip;
|
---|
103 |
|
---|
104 | memset(cip, 0, sizeof (struct s_ip));
|
---|
105 | for (ptr1 = strtok(value, ","); ptr1; ptr1 = strtok(NULL, ",")) {
|
---|
106 | if ((ptr2 = strchr(trim(ptr1), '-'))) {
|
---|
107 | *ptr2++ = '\0';
|
---|
108 | cip->ip[0] = network_inet_addr(trim(ptr1));
|
---|
109 | cip->ip[1] = network_inet_addr(trim(ptr2));
|
---|
110 | } else
|
---|
111 | cip->ip[0] = cip->ip[1] = network_inet_addr(ptr1);
|
---|
112 | }
|
---|
113 | }
|
---|
114 |
|
---|
115 | static void config_check_caidtab(char *caidasc, CAIDTAB * ctab)
|
---|
116 | {
|
---|
117 | int i;
|
---|
118 | char *ptr1, *ptr2, *ptr3;
|
---|
119 |
|
---|
120 | for (i = 0, ptr1 = strtok(caidasc, ","); (i < CS_MAXCAIDTAB) && (ptr1); ptr1 = strtok(NULL, ",")) {
|
---|
121 | ulong caid, mask, cmap;
|
---|
122 |
|
---|
123 | if ((ptr3 = strchr(trim(ptr1), ':')))
|
---|
124 | *ptr3++ = '\0';
|
---|
125 | else
|
---|
126 | ptr3 = "";
|
---|
127 | if ((ptr2 = strchr(trim(ptr1), '&')))
|
---|
128 | *ptr2++ = '\0';
|
---|
129 | else
|
---|
130 | ptr2 = "";
|
---|
131 | if (((caid = a2i(ptr1, 2)) | (mask = a2i(ptr2, -2)) | (cmap = a2i(ptr3, 2))) < 0x10000) {
|
---|
132 | ctab->caid[i] = caid;
|
---|
133 | ctab->mask[i] = mask;
|
---|
134 | ctab->cmap[i++] = cmap;
|
---|
135 | }
|
---|
136 | // else
|
---|
137 | // log_normal("WARNING: wrong CAID in %s -> ignored", cs_user);
|
---|
138 | }
|
---|
139 | }
|
---|
140 |
|
---|
141 | static void config_check_tuntab(char *tunasc, TUNTAB * ttab)
|
---|
142 | {
|
---|
143 | int i;
|
---|
144 | char *ptr1, *ptr2, *ptr3;
|
---|
145 |
|
---|
146 | for (i = 0, ptr1 = strtok(tunasc, ","); (i < CS_MAXTUNTAB) && (ptr1); ptr1 = strtok(NULL, ",")) {
|
---|
147 | ulong bt_caidfrom, bt_caidto, bt_srvid;
|
---|
148 |
|
---|
149 | if ((ptr3 = strchr(trim(ptr1), ':')))
|
---|
150 | *ptr3++ = '\0';
|
---|
151 | else
|
---|
152 | ptr3 = "";
|
---|
153 | if ((ptr2 = strchr(trim(ptr1), '.')))
|
---|
154 | *ptr2++ = '\0';
|
---|
155 | else
|
---|
156 | ptr2 = "";
|
---|
157 | if ((bt_caidfrom = a2i(ptr1, 2)) | (bt_srvid = a2i(ptr2, -2)) | (bt_caidto = a2i(ptr3, 2))) {
|
---|
158 | ttab->bt_caidfrom[i] = bt_caidfrom;
|
---|
159 | ttab->bt_caidto[i] = bt_caidto;
|
---|
160 | ttab->bt_srvid[i++] = bt_srvid;
|
---|
161 | }
|
---|
162 | // else
|
---|
163 | // log_normal("WARNING: wrong Betatunnel in %s -> ignored", cs_user);
|
---|
164 | }
|
---|
165 | }
|
---|
166 |
|
---|
167 | static void config_check_services(char *labels, ulong * sidok, ulong * sidno)
|
---|
168 | {
|
---|
169 | int i;
|
---|
170 | char *ptr;
|
---|
171 | SIDTAB *sidtab;
|
---|
172 |
|
---|
173 | *sidok = *sidno = 0;
|
---|
174 | for (ptr = strtok(labels, ","); ptr; ptr = strtok(NULL, ","))
|
---|
175 | for (trim(ptr), i = 0, sidtab = cfg->sidtab; sidtab; sidtab = sidtab->next, i++) {
|
---|
176 | if (!strcmp(sidtab->label, ptr))
|
---|
177 | *sidok |= (1 << i);
|
---|
178 | if ((ptr[0] == '!') && (!strcmp(sidtab->label, ptr + 1)))
|
---|
179 | *sidno |= (1 << i);
|
---|
180 | }
|
---|
181 | }
|
---|
182 |
|
---|
183 | static void config_check_ftab(char *zFilterAsc, FTAB * ftab, const char *zType, const char *zName, const char *zFiltName)
|
---|
184 | {
|
---|
185 | int i, j;
|
---|
186 | char *ptr1, *ptr2, *ptr3;
|
---|
187 | char *ptr[CS_MAXFILTERS] = { 0 };
|
---|
188 |
|
---|
189 | memset(ftab, 0, sizeof (FTAB));
|
---|
190 | for (i = 0, ptr1 = strtok(zFilterAsc, ";"); (i < CS_MAXFILTERS) && (ptr1); ptr1 = strtok(NULL, ";"), i++) {
|
---|
191 | ptr[i] = ptr1;
|
---|
192 | if ((ptr2 = strchr(trim(ptr1), ':'))) {
|
---|
193 | *ptr2++ = '\0';
|
---|
194 | ftab->filts[i].caid = (ushort) a2i(ptr1, 4);
|
---|
195 | ptr[i] = ptr2;
|
---|
196 | } else if (zFiltName && zFiltName[0] == 'c') {
|
---|
197 | log_normal("PANIC: CAID field not found in CHID parameter!");
|
---|
198 | oscam_exit(1);
|
---|
199 | }
|
---|
200 | ftab->nfilts++;
|
---|
201 | }
|
---|
202 |
|
---|
203 | if (ftab->nfilts)
|
---|
204 | log_debug("%s '%s' %s filter(s):", zType, zName, zFiltName);
|
---|
205 | for (i = 0; i < ftab->nfilts; i++) {
|
---|
206 | log_debug("CAID #%d: %04X", i, ftab->filts[i].caid);
|
---|
207 | for (j = 0, ptr3 = strtok(ptr[i], ","); (j < CS_MAXPROV) && (ptr3); ptr3 = strtok(NULL, ","), j++) {
|
---|
208 | ftab->filts[i].prids[j] = a2i(ptr3, 6);
|
---|
209 | ftab->filts[i].nprids++;
|
---|
210 | log_debug("%s #%d: %06X", zFiltName, j, ftab->filts[i].prids[j]);
|
---|
211 | }
|
---|
212 | }
|
---|
213 | }
|
---|
214 |
|
---|
215 | static void config_check_cltab(char *classasc, CLASSTAB * clstab)
|
---|
216 | {
|
---|
217 | int i;
|
---|
218 | char *ptr1;
|
---|
219 |
|
---|
220 | for (i = 0, ptr1 = strtok(classasc, ","); (i < CS_MAXCAIDTAB) && (ptr1); ptr1 = strtok(NULL, ",")) {
|
---|
221 | ptr1 = trim(ptr1);
|
---|
222 | if (ptr1[0] == '!')
|
---|
223 | clstab->bclass[clstab->bn++] = (uchar) a2i(ptr1 + 1, 2);
|
---|
224 | else
|
---|
225 | clstab->aclass[clstab->an++] = (uchar) a2i(ptr1, 2);
|
---|
226 | }
|
---|
227 | }
|
---|
228 |
|
---|
229 | static void config_check_port_tab(char *portasc, PTAB * ptab)
|
---|
230 | {
|
---|
231 | int i, j, nfilts, ifilt, iport;
|
---|
232 | char *ptr1, *ptr2, *ptr3;
|
---|
233 | char *ptr[CS_MAXPORTS] = { 0 };
|
---|
234 | int port[CS_MAXPORTS] = { 0 };
|
---|
235 | int previous_nports = ptab->nports;
|
---|
236 |
|
---|
237 | for (nfilts = i = previous_nports, ptr1 = strtok(portasc, ";"); (i < CS_MAXCAIDTAB) && (ptr1); ptr1 = strtok(NULL, ";"), i++) {
|
---|
238 | ptr[i] = ptr1;
|
---|
239 | if ((ptr2 = strchr(trim(ptr1), '@'))) {
|
---|
240 | *ptr2++ = '\0';
|
---|
241 | ptab->ports[i].s_port = atoi(ptr1);
|
---|
242 | ptr[i] = ptr2;
|
---|
243 | port[i] = ptab->ports[i].s_port;
|
---|
244 | ptab->nports++;
|
---|
245 | }
|
---|
246 | nfilts++;
|
---|
247 | }
|
---|
248 |
|
---|
249 | if (nfilts == 1 && strlen(portasc) < 6 && ptab->ports[0].s_port == 0) {
|
---|
250 | ptab->ports[0].s_port = atoi(portasc);
|
---|
251 | ptab->nports = 1;
|
---|
252 | }
|
---|
253 |
|
---|
254 | iport = ifilt = previous_nports;
|
---|
255 | for (i = previous_nports; i < nfilts; i++) {
|
---|
256 | if (port[i] != 0)
|
---|
257 | iport = i;
|
---|
258 | for (j = 0, ptr3 = strtok(ptr[i], ","); (j < CS_MAXPROV) && (ptr3); ptr3 = strtok(NULL, ","), j++) {
|
---|
259 | if ((ptr2 = strchr(trim(ptr3), ':'))) {
|
---|
260 | *ptr2++ = '\0';
|
---|
261 | ptab->ports[iport].ftab.nfilts++;
|
---|
262 | ifilt = ptab->ports[iport].ftab.nfilts - 1;
|
---|
263 | ptab->ports[iport].ftab.filts[ifilt].caid = (ushort) a2i(ptr3, 4);
|
---|
264 | ptab->ports[iport].ftab.filts[ifilt].prids[j] = a2i(ptr2, 6);
|
---|
265 | } else {
|
---|
266 | ptab->ports[iport].ftab.filts[ifilt].prids[j] = a2i(ptr3, 6);
|
---|
267 | }
|
---|
268 | ptab->ports[iport].ftab.filts[ifilt].nprids++;
|
---|
269 | }
|
---|
270 | }
|
---|
271 | }
|
---|
272 |
|
---|
273 | static void config_check_t_global(char *token, char *value)
|
---|
274 | {
|
---|
275 | if (!strcmp(token, "serverip"))
|
---|
276 | cfg->srvip = inet_addr(value);
|
---|
277 | if (!strcmp(token, "logfile"))
|
---|
278 | strncpy(logfile, value, sizeof (logfile) - 1);
|
---|
279 | if (!strcmp(token, "pidfile"))
|
---|
280 | strncpy(cfg->pidfile, value, sizeof (cfg->pidfile) - 1);
|
---|
281 | if (!strcmp(token, "usrfile"))
|
---|
282 | strncpy(cfg->usrfile, value, sizeof (cfg->usrfile) - 1);
|
---|
283 | if (!strcmp(token, "cwlogdir"))
|
---|
284 | strncpy(cfg->cwlogdir, value, sizeof (cfg->cwlogdir) - 1);
|
---|
285 | if (!strcmp(token, "clienttimeout")) {
|
---|
286 | cfg->ctimeout = atoi(value);
|
---|
287 | if (cfg->ctimeout < 100)
|
---|
288 | cfg->ctimeout *= 1000;
|
---|
289 | }
|
---|
290 | if (!strcmp(token, "fallbacktimeout")) {
|
---|
291 | cfg->ftimeout = atoi(value);
|
---|
292 | if (cfg->ftimeout < 100)
|
---|
293 | cfg->ftimeout *= 1000;
|
---|
294 | }
|
---|
295 |
|
---|
296 | if (!strcmp(token, "clientmaxidle"))
|
---|
297 | cfg->cmaxidle = atoi(value);
|
---|
298 | if (!strcmp(token, "cachedelay"))
|
---|
299 | cfg->delay = atoi(value);
|
---|
300 | if (!strcmp(token, "bindwait"))
|
---|
301 | cfg->bindwait = atoi(value);
|
---|
302 | if (!strcmp(token, "netprio"))
|
---|
303 | cfg->netprio = atoi(value);
|
---|
304 | if (!strcmp(token, "resolvedelay"))
|
---|
305 | cfg->resolvedelay = atoi(value);
|
---|
306 | if (!strcmp(token, "sleep"))
|
---|
307 | cfg->tosleep = atoi(value);
|
---|
308 | if (!strcmp(token, "unlockparental"))
|
---|
309 | cfg->ulparent = atoi(value);
|
---|
310 | if (!strcmp(token, "nice")) {
|
---|
311 | cfg->nice = atoi(value);
|
---|
312 | if ((cfg->nice < -20) || (cfg->nice > 20))
|
---|
313 | cfg->nice = 99;
|
---|
314 | if (cfg->nice != 99)
|
---|
315 | oscam_set_priority(cfg->nice); // ignore errors
|
---|
316 | }
|
---|
317 | if (!strcmp(token, "serialreadertimeout")) {
|
---|
318 | if (cfg->srtimeout < 100)
|
---|
319 | cfg->srtimeout = atoi(value) * 1000;
|
---|
320 | else
|
---|
321 | cfg->srtimeout = atoi(value);
|
---|
322 | if (cfg->srtimeout <= 0)
|
---|
323 | cfg->srtimeout = 1500;
|
---|
324 | }
|
---|
325 | if (!strcmp(token, "maxlogsize")) {
|
---|
326 | cfg->max_log_size = atoi(value);
|
---|
327 | if (cfg->max_log_size <= 10)
|
---|
328 | cfg->max_log_size = 10;
|
---|
329 | }
|
---|
330 | if (!strcmp(token, "showecmdw"))
|
---|
331 | cfg->show_ecm_dw = atoi(value);
|
---|
332 |
|
---|
333 | if (!strcmp(token, "waitforcards"))
|
---|
334 | cfg->waitforcards = atoi(value);
|
---|
335 | if (!strcmp(token, "preferlocalcards"))
|
---|
336 | cfg->preferlocalcards = atoi(value);
|
---|
337 | }
|
---|
338 |
|
---|
339 | #ifdef CS_ANTICASC
|
---|
340 | static void config_check_t_ac(char *token, char *value)
|
---|
341 | {
|
---|
342 | if (!strcmp(token, "enabled")) {
|
---|
343 | cfg->ac_enabled = atoi(value);
|
---|
344 | if (cfg->ac_enabled <= 0)
|
---|
345 | cfg->ac_enabled = 0;
|
---|
346 | else
|
---|
347 | cfg->ac_enabled = 1;
|
---|
348 | }
|
---|
349 |
|
---|
350 | if (!strcmp(token, "numusers")) {
|
---|
351 | cfg->ac_users = atoi(value);
|
---|
352 | if (cfg->ac_users < 0)
|
---|
353 | cfg->ac_users = 0;
|
---|
354 | }
|
---|
355 | if (!strcmp(token, "sampletime")) {
|
---|
356 | cfg->ac_stime = atoi(value);
|
---|
357 | if (cfg->ac_stime < 0)
|
---|
358 | cfg->ac_stime = 2;
|
---|
359 | }
|
---|
360 | if (!strcmp(token, "samples")) {
|
---|
361 | cfg->ac_samples = atoi(value);
|
---|
362 | if (cfg->ac_samples < 2 || cfg->ac_samples > 10)
|
---|
363 | cfg->ac_samples = 10;
|
---|
364 | }
|
---|
365 | if (!strcmp(token, "penalty")) {
|
---|
366 | cfg->ac_penalty = atoi(value);
|
---|
367 | if (cfg->ac_penalty < 0)
|
---|
368 | cfg->ac_penalty = 0;
|
---|
369 |
|
---|
370 | }
|
---|
371 | if (!strcmp(token, "aclogfile"))
|
---|
372 | strncpy(cfg->ac_logfile, value, sizeof (cfg->ac_logfile) - 1);
|
---|
373 | if (!strcmp(token, "fakedelay")) {
|
---|
374 | cfg->ac_fakedelay = atoi(value);
|
---|
375 | if (cfg->ac_fakedelay < 100 || cfg->ac_fakedelay > 1000)
|
---|
376 | cfg->ac_fakedelay = 1000;
|
---|
377 | }
|
---|
378 | if (!strcmp(token, "denysamples")) {
|
---|
379 | cfg->ac_denysamples = atoi(value);
|
---|
380 | if (cfg->ac_denysamples < 2 || cfg->ac_denysamples > cfg->ac_samples - 1)
|
---|
381 | cfg->ac_denysamples = cfg->ac_samples - 1;
|
---|
382 | }
|
---|
383 | #endif
|
---|
384 | }
|
---|
385 |
|
---|
386 | static void config_check_t_monitor(char *token, char *value)
|
---|
387 | {
|
---|
388 | if (!strcmp(token, "port"))
|
---|
389 | cfg->mon_port = atoi(value);
|
---|
390 | if (!strcmp(token, "serverip"))
|
---|
391 | cfg->mon_srvip = inet_addr(value);
|
---|
392 | if (!strcmp(token, "nocrypt"))
|
---|
393 | config_check_iprange(value, &cfg->mon_allowed);
|
---|
394 | if (!strcmp(token, "aulow"))
|
---|
395 | cfg->mon_aulow = atoi(value);
|
---|
396 | if (!strcmp(token, "monlevel"))
|
---|
397 | cfg->mon_level = atoi(value);
|
---|
398 | if (!strcmp(token, "hideclient_to"))
|
---|
399 | cfg->mon_hideclient_to = atoi(value);
|
---|
400 | }
|
---|
401 |
|
---|
402 | static void config_check_t_camd33(char *token, char *value)
|
---|
403 | {
|
---|
404 | if (!strcmp(token, "port"))
|
---|
405 | cfg->c33_port = atoi(value);
|
---|
406 | if (!strcmp(token, "serverip"))
|
---|
407 | cfg->c33_srvip = inet_addr(value);
|
---|
408 | if (!strcmp(token, "nocrypt"))
|
---|
409 | config_check_iprange(value, &cfg->c33_plain);
|
---|
410 | if (!strcmp(token, "passive"))
|
---|
411 | cfg->c33_passive = (value[0] != '0');
|
---|
412 | if (!strcmp(token, "key")) {
|
---|
413 | if (key_atob(value, cfg->c33_key)) {
|
---|
414 | fprintf(stderr, "Configuration camd3.3x: Error in Key\n");
|
---|
415 | exit(1);
|
---|
416 | }
|
---|
417 | cfg->c33_crypted = 1;
|
---|
418 | }
|
---|
419 | }
|
---|
420 |
|
---|
421 | static void config_check_t_camd35(char *token, char *value)
|
---|
422 | {
|
---|
423 | if (!strcmp(token, "port"))
|
---|
424 | cfg->c35_port = atoi(value);
|
---|
425 | if (!strcmp(token, "serverip"))
|
---|
426 | cfg->c35_tcp_srvip = inet_addr(value);
|
---|
427 | }
|
---|
428 |
|
---|
429 | static void config_check_t_camd35_tcp(char *token, char *value)
|
---|
430 | {
|
---|
431 | if (!strcmp(token, "port"))
|
---|
432 | config_check_port_tab(value, &cfg->c35_tcp_ptab);
|
---|
433 | if (!strcmp(token, "serverip"))
|
---|
434 | cfg->c35_tcp_srvip = inet_addr(value);
|
---|
435 | }
|
---|
436 |
|
---|
437 | static void config_check_t_newcamd(char *token, char *value)
|
---|
438 | {
|
---|
439 | if (!strcmp(token, "port"))
|
---|
440 | config_check_port_tab(value, &cfg->ncd_ptab);
|
---|
441 | if (!strcmp(token, "serverip"))
|
---|
442 | cfg->ncd_srvip = inet_addr(value);
|
---|
443 | if (!strcmp(token, "key")) {
|
---|
444 | if (key_atob14(value, cfg->ncd_key)) {
|
---|
445 | fprintf(stderr, "Configuration newcamd: Error in Key\n");
|
---|
446 | exit(1);
|
---|
447 | }
|
---|
448 | }
|
---|
449 |
|
---|
450 | }
|
---|
451 |
|
---|
452 | static void config_check_t_radegast(char *token, char *value)
|
---|
453 | {
|
---|
454 | if (!strcmp(token, "port"))
|
---|
455 | cfg->rad_port = atoi(value);
|
---|
456 | if (!strcmp(token, "serverip"))
|
---|
457 | cfg->rad_srvip = inet_addr(value);
|
---|
458 | if (!strcmp(token, "allowed"))
|
---|
459 | config_check_iprange(value, &cfg->rad_allowed);
|
---|
460 | if (!strcmp(token, "user"))
|
---|
461 | strncpy(cfg->rad_usr, value, sizeof (cfg->rad_usr) - 1);
|
---|
462 | }
|
---|
463 |
|
---|
464 | static void config_check_t_serial(char *token, char *value)
|
---|
465 | {
|
---|
466 | if (!strcmp(token, "device")) {
|
---|
467 | int l;
|
---|
468 |
|
---|
469 | l = strlen(cfg->ser_device);
|
---|
470 | if (l)
|
---|
471 | cfg->ser_device[l++] = 1; // use ctrl-a as delimiter
|
---|
472 | strncpy(cfg->ser_device + l, value, sizeof (cfg->ser_device) - 1 - l);
|
---|
473 | }
|
---|
474 | }
|
---|
475 |
|
---|
476 | #ifdef CS_WITH_GBOX
|
---|
477 | static void config_check_t_gbox(char *token, char *value)
|
---|
478 | {
|
---|
479 | if (!strcmp(token, "password"))
|
---|
480 | cs_atob(cfg->gbox_pwd, value, 4);
|
---|
481 | if (!strcmp(token, "maxdist"))
|
---|
482 | cfg->maxdist = atoi(value);
|
---|
483 | if (!strcmp(token, "ignorelist"))
|
---|
484 | strncpy((char *) cfg->ignorefile, value, sizeof (cfg->ignorefile) - 1);
|
---|
485 | if (!strcmp(token, "onlineinfos"))
|
---|
486 | strncpy((char *) cfg->gbxShareOnl, value, sizeof (cfg->gbxShareOnl) - 1);
|
---|
487 | if (!strcmp(token, "cardinfos"))
|
---|
488 | strncpy((char *) cfg->cardfile, value, sizeof (cfg->cardfile) - 1);
|
---|
489 | if (!strcmp(token, "locals")) {
|
---|
490 | char *ptr1;
|
---|
491 | int n = 0, i;
|
---|
492 |
|
---|
493 | for (i = 0, ptr1 = strtok(value, ","); (i < CS_MAXLOCALS) && (ptr1); ptr1 = strtok(NULL, ",")) {
|
---|
494 | cfg->locals[n++] = a2i(ptr1, 8);
|
---|
495 | }
|
---|
496 | cfg->num_locals = n;
|
---|
497 | }
|
---|
498 | }
|
---|
499 | #endif
|
---|
500 |
|
---|
501 | static void config_check_token(char *token, char *value, int tag)
|
---|
502 | {
|
---|
503 | switch (tag) {
|
---|
504 | case TAG_GLOBAL:
|
---|
505 | config_check_t_global(token, value);
|
---|
506 | break;
|
---|
507 | case TAG_MONITOR:
|
---|
508 | config_check_t_monitor(token, value);
|
---|
509 | break;
|
---|
510 | case TAG_CAMD33:
|
---|
511 | config_check_t_camd33(token, value);
|
---|
512 | break;
|
---|
513 | case TAG_CAMD35:
|
---|
514 | case TAG_CS357X:
|
---|
515 | config_check_t_camd35(token, value);
|
---|
516 | break;
|
---|
517 | case TAG_NEWCAMD:
|
---|
518 | config_check_t_newcamd(token, value);
|
---|
519 | break;
|
---|
520 | case TAG_RADEGAST:
|
---|
521 | config_check_t_radegast(token, value);
|
---|
522 | break;
|
---|
523 | case TAG_SERIAL:
|
---|
524 | config_check_t_serial(token, value);
|
---|
525 | break;
|
---|
526 | case TAG_CS378X:
|
---|
527 | config_check_t_camd35_tcp(token, value);
|
---|
528 | break;
|
---|
529 | #ifdef CS_WITH_GBOX
|
---|
530 | case TAG_GBOX:
|
---|
531 | config_check_t_gbox(token, value);
|
---|
532 | break;
|
---|
533 | #endif
|
---|
534 | #ifdef CS_ANTICASC
|
---|
535 | case TAG_ANTICASC:
|
---|
536 | config_check_t_ac(token, value);
|
---|
537 | break;
|
---|
538 | #endif
|
---|
539 | }
|
---|
540 | }
|
---|
541 |
|
---|
542 | void config_init_cam_common_len4caid()
|
---|
543 | {
|
---|
544 | int nr;
|
---|
545 | FILE *fp;
|
---|
546 | char *value;
|
---|
547 |
|
---|
548 | memset(cam_common_len4caid, 0, sizeof (ushort) << 8);
|
---|
549 | sprintf(token, "%s%s", cs_confdir, cs_l4ca);
|
---|
550 | if (!(fp = fopen(token, "r")))
|
---|
551 | return;
|
---|
552 | for (nr = 0; fgets(token, sizeof (token), fp);) {
|
---|
553 | int i, c;
|
---|
554 | char *ptr;
|
---|
555 |
|
---|
556 | if (!(value = strchr(token, ':')))
|
---|
557 | continue;
|
---|
558 | *value++ = '\0';
|
---|
559 | if ((ptr = strchr(value, '#')))
|
---|
560 | *ptr = '\0';
|
---|
561 | if (strlen(trim(token)) != 2)
|
---|
562 | continue;
|
---|
563 | if (strlen(trim(value)) != 4)
|
---|
564 | continue;
|
---|
565 | if ((i = byte_atob(token)) < 0)
|
---|
566 | continue;
|
---|
567 | if ((c = word_atob(value)) < 0)
|
---|
568 | continue;
|
---|
569 | cam_common_len4caid[i] = c;
|
---|
570 | nr++;
|
---|
571 | }
|
---|
572 | fclose(fp);
|
---|
573 | log_normal("%d lengths for caid guessing loaded", nr);
|
---|
574 | }
|
---|
575 |
|
---|
576 | int config_search_boxkey(ushort caid, ulong provid, char *key)
|
---|
577 | {
|
---|
578 | int i, rc = 0;
|
---|
579 | FILE *fp;
|
---|
580 | char c_caid[512];
|
---|
581 |
|
---|
582 | sprintf(c_caid, "%s%s", cs_confdir, cs_cert);
|
---|
583 | if ((fp = fopen(c_caid, "r"))) {
|
---|
584 | for (; (!rc) && fgets(c_caid, sizeof (c_caid), fp);) {
|
---|
585 | char *c_provid, *c_key;
|
---|
586 |
|
---|
587 | if ((c_provid = strchr(c_caid, '#')))
|
---|
588 | *c_provid = '\0';
|
---|
589 | if (!(c_provid = strchr(c_caid, ':')))
|
---|
590 | continue;
|
---|
591 | *c_provid++ = '\0';
|
---|
592 | if (!(c_key = strchr(c_provid, ':')))
|
---|
593 | continue;
|
---|
594 | *c_key++ = '\0';
|
---|
595 | if (word_atob(trim(c_caid)) != caid)
|
---|
596 | continue;
|
---|
597 | if ((i = (strlen(trim(c_key)) >> 1)) > 256)
|
---|
598 | continue;
|
---|
599 | if (cs_atob((uchar *) key, c_key, i) < 0) {
|
---|
600 | log_normal("wrong key in \"%s\"", cs_cert);
|
---|
601 | continue;
|
---|
602 | }
|
---|
603 | rc = 1;
|
---|
604 | }
|
---|
605 | fclose(fp);
|
---|
606 | }
|
---|
607 | #ifdef OSCAM_INBUILD_KEYS
|
---|
608 | for (i = 0; (!rc) && (npkey[i].keylen); i++)
|
---|
609 | if (rc = ((caid == npkey[i].caid) && (provid == npkey[i].provid)))
|
---|
610 | memcpy(key, npkey[i].key, npkey[i].keylen);
|
---|
611 | #endif
|
---|
612 | return (rc);
|
---|
613 | }
|
---|
614 |
|
---|
615 | int config_init()
|
---|
616 | {
|
---|
617 | int tag = TAG_GLOBAL;
|
---|
618 | FILE *fp;
|
---|
619 | char *value;
|
---|
620 |
|
---|
621 | #ifndef CS_EMBEDDED
|
---|
622 | # ifdef PRIO_PROCESS
|
---|
623 | errno = 0;
|
---|
624 | if ((cfg->nice = getpriority(PRIO_PROCESS, 0)) == (-1))
|
---|
625 | if (errno)
|
---|
626 | # endif
|
---|
627 | #endif
|
---|
628 | cfg->nice = 99;
|
---|
629 | cfg->ctimeout = CS_CLIENT_TIMEOUT;
|
---|
630 | cfg->ftimeout = CS_CLIENT_TIMEOUT / 2;
|
---|
631 | cfg->cmaxidle = CS_CLIENT_MAXIDLE;
|
---|
632 | cfg->delay = CS_DELAY;
|
---|
633 | cfg->bindwait = CS_BIND_TIMEOUT;
|
---|
634 | cfg->resolvedelay = CS_RESOLVE_DELAY;
|
---|
635 | cfg->mon_level = 2;
|
---|
636 | cfg->mon_hideclient_to = 0;
|
---|
637 | cfg->srtimeout = 1500;
|
---|
638 | cfg->ulparent = 0;
|
---|
639 | #ifdef CS_ANTICASC
|
---|
640 | cfg->ac_enabled = 0;
|
---|
641 | cfg->ac_users = 0;
|
---|
642 | cfg->ac_stime = 2;
|
---|
643 | cfg->ac_samples = 10;
|
---|
644 | cfg->ac_denysamples = 8;
|
---|
645 | cfg->ac_fakedelay = 1000;
|
---|
646 | strcpy(cfg->ac_logfile, "./oscam_ac.log");
|
---|
647 | #endif
|
---|
648 | sprintf(token, "%s%s", cs_confdir, cs_conf);
|
---|
649 | if (!(fp = fopen(token, "r"))) {
|
---|
650 | fprintf(stderr, "Cannot open config file '%s' (errno=%d)\n", token, errno);
|
---|
651 | exit(1);
|
---|
652 | }
|
---|
653 | while (fgets(token, sizeof (token), fp)) {
|
---|
654 | int i, l;
|
---|
655 |
|
---|
656 | if ((l = strlen(trim(token))) < 3)
|
---|
657 | continue;
|
---|
658 | if ((token[0] == '[') && (token[l - 1] == ']')) {
|
---|
659 | for (token[l - 1] = 0, tag = -1, i = TAG_GLOBAL; cctag[i]; i++)
|
---|
660 | if (!strcmp(cctag[i], strtolower(token + 1)))
|
---|
661 | tag = i;
|
---|
662 | continue;
|
---|
663 | }
|
---|
664 | if (!(value = strchr(token, '=')))
|
---|
665 | continue;
|
---|
666 | *value++ = '\0';
|
---|
667 | config_check_token(trim(strtolower(token)), trim(value), tag);
|
---|
668 | }
|
---|
669 | fclose(fp);
|
---|
670 | log_init(logfile);
|
---|
671 | if (cfg->ftimeout >= cfg->ctimeout) {
|
---|
672 | cfg->ftimeout = cfg->ctimeout - 100;
|
---|
673 | log_normal("WARNING: fallbacktimeout adjusted to %lu ms (must be smaller than clienttimeout (%lu ms))", cfg->ftimeout, cfg->ctimeout);
|
---|
674 | }
|
---|
675 | if (cfg->ftimeout < cfg->srtimeout) {
|
---|
676 | cfg->ftimeout = cfg->srtimeout + 100;
|
---|
677 | log_normal("WARNING: fallbacktimeout adjusted to %lu ms (must be greater than serialreadertimeout (%lu ms))", cfg->ftimeout, cfg->srtimeout);
|
---|
678 | }
|
---|
679 | if (cfg->ctimeout < cfg->srtimeout) {
|
---|
680 | cfg->ctimeout = cfg->srtimeout + 100;
|
---|
681 | log_normal("WARNING: clienttimeout adjusted to %lu ms (must be greater than serialreadertimeout (%lu ms))", cfg->ctimeout, cfg->srtimeout);
|
---|
682 | }
|
---|
683 | #ifdef CS_ANTICASC
|
---|
684 | if (cfg->ac_denysamples + 1 > cfg->ac_samples) {
|
---|
685 | cfg->ac_denysamples = cfg->ac_samples - 1;
|
---|
686 | log_normal("WARNING: DenySamples adjusted to %d", cfg->ac_denysamples);
|
---|
687 | }
|
---|
688 | #endif
|
---|
689 | return 0;
|
---|
690 | }
|
---|
691 |
|
---|
692 | static void config_check_account(char *token, char *value, struct s_auth *account)
|
---|
693 | {
|
---|
694 | int i;
|
---|
695 | char *ptr1;
|
---|
696 |
|
---|
697 | if (!strcmp(token, "user"))
|
---|
698 | strncpy(account->usr, value, sizeof (account->usr) - 1);
|
---|
699 | if (!strcmp(token, "pwd"))
|
---|
700 | strncpy(account->pwd, value, sizeof (account->pwd) - 1);
|
---|
701 | if (!strcmp(token, "hostname"))
|
---|
702 | strncpy((char *) account->dyndns, value, sizeof (account->dyndns) - 1);
|
---|
703 | if (!strcmp(token, "betatunnel"))
|
---|
704 | config_check_tuntab(value, &account->ttab);
|
---|
705 | if (!strcmp(token, "uniq"))
|
---|
706 | account->uniq = atoi(value);
|
---|
707 | if (!strcmp(token, "sleep"))
|
---|
708 | account->tosleep = atoi(value);
|
---|
709 | if (!strcmp(token, "monlevel"))
|
---|
710 | account->monlvl = atoi(value);
|
---|
711 | if (!strcmp(token, "caid"))
|
---|
712 | config_check_caidtab(value, &account->ctab);
|
---|
713 | /*
|
---|
714 | * case insensitive
|
---|
715 | */
|
---|
716 | strtolower(value);
|
---|
717 | if (!strcmp(token, "au"))
|
---|
718 | for (i = 0; i < CS_MAXREADER; i++)
|
---|
719 | if ((reader[i].label[0]) && (!strncmp(reader[i].label, value, strlen(reader[i].label))))
|
---|
720 | account->au = i;
|
---|
721 | if (!strcmp(token, "group"))
|
---|
722 | for (ptr1 = strtok(value, ","); ptr1; ptr1 = strtok(NULL, ",")) {
|
---|
723 | int g;
|
---|
724 |
|
---|
725 | g = atoi(ptr1);
|
---|
726 | if ((g > 0) && (g < 33))
|
---|
727 | account->grp |= (1 << (g - 1));
|
---|
728 | }
|
---|
729 | if (!strcmp(token, "services"))
|
---|
730 | config_check_services(value, &account->sidtabok, &account->sidtabno);
|
---|
731 | if (!strcmp(token, "ident"))
|
---|
732 | config_check_ftab(value, &account->ftab, "user", account->usr, "provid");
|
---|
733 | if (!strcmp(token, "class"))
|
---|
734 | config_check_cltab(value, &account->cltab);
|
---|
735 | if (!strcmp(token, "chid"))
|
---|
736 | config_check_ftab(value, &account->fchid, "user", account->usr, "chid");
|
---|
737 |
|
---|
738 | #ifdef CS_ANTICASC
|
---|
739 | if (!strcmp(token, "numusers"))
|
---|
740 | account->ac_users = atoi(value);
|
---|
741 | if (!strcmp(token, "penalty"))
|
---|
742 | account->ac_penalty = atoi(value);
|
---|
743 | #endif
|
---|
744 | }
|
---|
745 |
|
---|
746 | int config_init_userdb()
|
---|
747 | {
|
---|
748 | int tag = 0, nr, nro;
|
---|
749 |
|
---|
750 | FILE *fp;
|
---|
751 | char *value;
|
---|
752 | struct s_auth *ptr;
|
---|
753 | struct s_auth *account = (struct s_auth *) 0;
|
---|
754 |
|
---|
755 | sprintf(token, "%s%s", cs_confdir, cs_user);
|
---|
756 | if (!(fp = fopen(token, "r"))) {
|
---|
757 | log_normal("Cannot open file \"%s\" (errno=%d)", token, errno);
|
---|
758 | return (1);
|
---|
759 | }
|
---|
760 | for (nro = 0, ptr = cfg->account; ptr; nro++) {
|
---|
761 | struct s_auth *ptr_next;
|
---|
762 |
|
---|
763 | ptr_next = ptr->next;
|
---|
764 | free(ptr);
|
---|
765 | ptr = ptr_next;
|
---|
766 | }
|
---|
767 | nr = 0;
|
---|
768 | while (fgets(token, sizeof (token), fp)) {
|
---|
769 | int i, l;
|
---|
770 | void *ptr;
|
---|
771 |
|
---|
772 | if ((l = strlen(trim(token))) < 3)
|
---|
773 | continue;
|
---|
774 | if ((token[0] == '[') && (token[l - 1] == ']')) {
|
---|
775 | token[l - 1] = 0;
|
---|
776 | tag = (!strcmp("account", strtolower(token + 1)));
|
---|
777 | if (!(ptr = malloc(sizeof (struct s_auth)))) {
|
---|
778 | log_normal("Error allocating memory (errno=%d)", errno);
|
---|
779 | return (1);
|
---|
780 | }
|
---|
781 | if (account)
|
---|
782 | account->next = ptr;
|
---|
783 | else
|
---|
784 | cfg->account = ptr;
|
---|
785 | account = ptr;
|
---|
786 | memset(account, 0, sizeof (struct s_auth));
|
---|
787 | account->au = (-1);
|
---|
788 | account->monlvl = cfg->mon_level;
|
---|
789 | account->tosleep = cfg->tosleep;
|
---|
790 | for (i = 1; i < CS_MAXCAIDTAB; account->ctab.mask[i++] = 0xffff);
|
---|
791 | for (i = 1; i < CS_MAXTUNTAB; account->ttab.bt_srvid[i++] = 0x0000);
|
---|
792 | nr++;
|
---|
793 | #ifdef CS_ANTICASC
|
---|
794 | account->ac_users = cfg->ac_users;
|
---|
795 | account->ac_penalty = cfg->ac_penalty;
|
---|
796 | account->ac_idx = nr;
|
---|
797 | #endif
|
---|
798 | continue;
|
---|
799 | }
|
---|
800 | if (!tag)
|
---|
801 | continue;
|
---|
802 | if (!(value = strchr(token, '=')))
|
---|
803 | continue;
|
---|
804 | *value++ = '\0';
|
---|
805 | config_check_account(trim(strtolower(token)), trim(value), account);
|
---|
806 | }
|
---|
807 | fclose(fp);
|
---|
808 | log_normal("userdb reloaded: %d accounts freed, %d accounts loaded", nro, nr);
|
---|
809 | return (0);
|
---|
810 | }
|
---|
811 |
|
---|
812 | static void config_check_entry4sidtab(char *value, struct s_sidtab *sidtab, int what)
|
---|
813 | {
|
---|
814 | int i, b;
|
---|
815 | char *ptr;
|
---|
816 | ushort *slist = (ushort *) 0;
|
---|
817 | ulong *llist = (ulong *) 0;
|
---|
818 | ulong caid;
|
---|
819 | char buf[512];
|
---|
820 |
|
---|
821 | strncpy(buf, value, sizeof (buf));
|
---|
822 | b = (what == 1) ? sizeof (ulong) : sizeof (ushort);
|
---|
823 | for (i = 0, ptr = strtok(value, ","); ptr; ptr = strtok(NULL, ",")) {
|
---|
824 | caid = a2i(ptr, b);
|
---|
825 | if (!errno)
|
---|
826 | i++;
|
---|
827 | }
|
---|
828 | if (!i)
|
---|
829 | return;
|
---|
830 | if (b == sizeof (ushort))
|
---|
831 | slist = malloc(i * sizeof (ushort));
|
---|
832 | else
|
---|
833 | llist = malloc(i * sizeof (ulong));
|
---|
834 | strcpy(value, buf);
|
---|
835 | for (i = 0, ptr = strtok(value, ","); ptr; ptr = strtok(NULL, ",")) {
|
---|
836 | caid = a2i(ptr, b);
|
---|
837 | if (errno)
|
---|
838 | continue;
|
---|
839 | if (b == sizeof (ushort))
|
---|
840 | slist[i++] = (ushort) caid;
|
---|
841 | else
|
---|
842 | llist[i++] = caid;
|
---|
843 | }
|
---|
844 | switch (what) {
|
---|
845 | case 0:
|
---|
846 | sidtab->caid = slist;
|
---|
847 | sidtab->num_caid = i;
|
---|
848 | break;
|
---|
849 | case 1:
|
---|
850 | sidtab->provid = llist;
|
---|
851 | sidtab->num_provid = i;
|
---|
852 | break;
|
---|
853 | case 2:
|
---|
854 | sidtab->srvid = slist;
|
---|
855 | sidtab->num_srvid = i;
|
---|
856 | break;
|
---|
857 | }
|
---|
858 | }
|
---|
859 |
|
---|
860 | static void config_check_sidtab(char *token, char *value, struct s_sidtab *sidtab)
|
---|
861 | {
|
---|
862 | if (!strcmp(token, "caid"))
|
---|
863 | config_check_entry4sidtab(value, sidtab, 0);
|
---|
864 | if (!strcmp(token, "provid"))
|
---|
865 | config_check_entry4sidtab(value, sidtab, 1);
|
---|
866 | if (!strcmp(token, "ident"))
|
---|
867 | config_check_entry4sidtab(value, sidtab, 1);
|
---|
868 | if (!strcmp(token, "srvid"))
|
---|
869 | config_check_entry4sidtab(value, sidtab, 2);
|
---|
870 | }
|
---|
871 |
|
---|
872 | int config_init_sidtab()
|
---|
873 | {
|
---|
874 | int nr, nro;
|
---|
875 | FILE *fp;
|
---|
876 | char *value;
|
---|
877 | struct s_sidtab *ptr;
|
---|
878 | struct s_sidtab *sidtab = (struct s_sidtab *) 0;
|
---|
879 |
|
---|
880 | sprintf(token, "%s%s", cs_confdir, cs_sidt);
|
---|
881 | if (!(fp = fopen(token, "r"))) {
|
---|
882 | log_normal("Cannot open file \"%s\" (errno=%d)", token, errno);
|
---|
883 | return (1);
|
---|
884 | }
|
---|
885 | for (nro = 0, ptr = cfg->sidtab; ptr; nro++) {
|
---|
886 | struct s_sidtab *ptr_next;
|
---|
887 |
|
---|
888 | ptr_next = ptr->next;
|
---|
889 | if (ptr->caid)
|
---|
890 | free(ptr->caid);
|
---|
891 | if (ptr->provid)
|
---|
892 | free(ptr->provid);
|
---|
893 | if (ptr->srvid)
|
---|
894 | free(ptr->srvid);
|
---|
895 | free(ptr);
|
---|
896 | ptr = ptr_next;
|
---|
897 | }
|
---|
898 | nr = 0;
|
---|
899 | while (fgets(token, sizeof (token), fp)) {
|
---|
900 | int l;
|
---|
901 | void *ptr;
|
---|
902 |
|
---|
903 | if ((l = strlen(trim(token))) < 3)
|
---|
904 | continue;
|
---|
905 | if ((token[0] == '[') && (token[l - 1] == ']')) {
|
---|
906 | token[l - 1] = 0;
|
---|
907 | if (!(ptr = malloc(sizeof (struct s_sidtab)))) {
|
---|
908 | log_normal("Error allocating memory (errno=%d)", errno);
|
---|
909 | return (1);
|
---|
910 | }
|
---|
911 | if (sidtab)
|
---|
912 | sidtab->next = ptr;
|
---|
913 | else
|
---|
914 | cfg->sidtab = ptr;
|
---|
915 | sidtab = ptr;
|
---|
916 | nr++;
|
---|
917 | memset(sidtab, 0, sizeof (struct s_sidtab));
|
---|
918 | strncpy(sidtab->label, strtolower(token + 1), sizeof (sidtab->label));
|
---|
919 | continue;
|
---|
920 | }
|
---|
921 | if (!sidtab)
|
---|
922 | continue;
|
---|
923 | if (!(value = strchr(token, '=')))
|
---|
924 | continue;
|
---|
925 | *value++ = '\0';
|
---|
926 | config_check_sidtab(trim(strtolower(token)), trim(strtolower(value)), sidtab);
|
---|
927 | }
|
---|
928 | fclose(fp);
|
---|
929 |
|
---|
930 | #ifdef DEBUG_SIDTAB
|
---|
931 | config_show_sidtab(cfg->sidtab);
|
---|
932 | #endif
|
---|
933 | log_normal("services reloaded: %d services freed, %d services loaded", nro, nr);
|
---|
934 | return (0);
|
---|
935 | }
|
---|
936 |
|
---|
937 | int config_init_srvid()
|
---|
938 | {
|
---|
939 | int nr;
|
---|
940 | FILE *fp;
|
---|
941 | char *value;
|
---|
942 | static struct s_srvid *srvid = (struct s_srvid *) 0;
|
---|
943 |
|
---|
944 | sprintf(token, "%s%s", cs_confdir, cs_srid);
|
---|
945 | if (!(fp = fopen(token, "r"))) {
|
---|
946 | log_normal("can't open file \"%s\" (err=%d), no service-id's loaded", token, errno);
|
---|
947 | return (0);
|
---|
948 | }
|
---|
949 | nr = 0;
|
---|
950 | while (fgets(token, sizeof (token), fp)) {
|
---|
951 | int l;
|
---|
952 | void *ptr;
|
---|
953 |
|
---|
954 | if ((l = strlen(trim(token))) < 6)
|
---|
955 | continue;
|
---|
956 | if (!(value = strchr(token, ':')))
|
---|
957 | continue;
|
---|
958 | *value++ = '\0';
|
---|
959 | if (strlen(token) != 4)
|
---|
960 | continue;
|
---|
961 | if (!(ptr = malloc(sizeof (struct s_srvid)))) {
|
---|
962 | log_normal("Error allocating memory (errno=%d)", errno);
|
---|
963 | return (1);
|
---|
964 | }
|
---|
965 | if (srvid)
|
---|
966 | srvid->next = ptr;
|
---|
967 | else
|
---|
968 | cfg->srvid = ptr;
|
---|
969 | srvid = ptr;
|
---|
970 | memset(srvid, 0, sizeof (struct s_srvid));
|
---|
971 | srvid->srvid = word_atob(token);
|
---|
972 | strncpy(srvid->name, value, sizeof (srvid->name) - 1);
|
---|
973 | nr++;
|
---|
974 | }
|
---|
975 | fclose(fp);
|
---|
976 | log_normal("%d service-id's loaded", nr);
|
---|
977 | return (0);
|
---|
978 | }
|
---|
979 |
|
---|
980 | static void config_check_reader(char *token, char *value, struct s_reader *rdr)
|
---|
981 | {
|
---|
982 | int i;
|
---|
983 | char *ptr;
|
---|
984 |
|
---|
985 | /*
|
---|
986 | * case sensitive first
|
---|
987 | */
|
---|
988 | if (!strcmp(token, "device"))
|
---|
989 | for (i = 0, ptr = strtok(value, ","); (i < 3) && (ptr); ptr = strtok(NULL, ","), i++) {
|
---|
990 | trim(ptr);
|
---|
991 | switch (i) {
|
---|
992 | case 0:
|
---|
993 | strncpy(rdr->device, ptr, sizeof (rdr->device) - 1);
|
---|
994 | break;
|
---|
995 | case 1:
|
---|
996 | rdr->r_port = atoi(ptr);
|
---|
997 | break;
|
---|
998 | case 2:
|
---|
999 | rdr->l_port = atoi(ptr);
|
---|
1000 | break;
|
---|
1001 | }
|
---|
1002 | }
|
---|
1003 | if (!strcmp(token, "key")) {
|
---|
1004 | if (key_atob14(value, rdr->ncd_key)) {
|
---|
1005 | fprintf(stderr, "Configuration newcamd: Error in Key\n");
|
---|
1006 | exit(1);
|
---|
1007 | }
|
---|
1008 | }
|
---|
1009 | #ifdef CS_WITH_GBOX
|
---|
1010 | if (!strcmp(token, "password"))
|
---|
1011 | strncpy((char *) rdr->gbox_pwd, (const char *) i2b(4, a2i(value, 4)), 4);
|
---|
1012 | if (!strcmp(token, "premium"))
|
---|
1013 | rdr->gbox_prem = 1;
|
---|
1014 | #endif
|
---|
1015 | if (!strcmp(token, "account"))
|
---|
1016 | for (i = 0, ptr = strtok(value, ","); (i < 2) && (ptr); ptr = strtok(NULL, ","), i++) {
|
---|
1017 | trim(ptr);
|
---|
1018 | switch (i) {
|
---|
1019 | case 0:
|
---|
1020 | strncpy(rdr->r_usr, ptr, sizeof (rdr->r_usr) - 1);
|
---|
1021 | break;
|
---|
1022 | case 1:
|
---|
1023 | strncpy(rdr->r_pwd, ptr, sizeof (rdr->r_pwd) - 1);
|
---|
1024 | break;
|
---|
1025 | }
|
---|
1026 | }
|
---|
1027 | if (!strcmp(token, "pincode"))
|
---|
1028 | strncpy(rdr->pincode, value, sizeof (rdr->pincode) - 1);
|
---|
1029 | /*
|
---|
1030 | * case insensitive
|
---|
1031 | */
|
---|
1032 | strtolower(value);
|
---|
1033 |
|
---|
1034 | if (!strcmp(token, "services"))
|
---|
1035 | config_check_services(value, &rdr->sidtabok, &rdr->sidtabno);
|
---|
1036 | if (!strcmp(token, "inactivitytimeout"))
|
---|
1037 | rdr->tcp_ito = atoi(value);
|
---|
1038 | if (!strcmp(token, "reconnecttimeout"))
|
---|
1039 | rdr->tcp_rto = atoi(value);
|
---|
1040 | if (!strcmp(token, "disableserverfilter"))
|
---|
1041 | rdr->ncd_disable_server_filt = atoi(value);
|
---|
1042 |
|
---|
1043 | if (!strcmp(token, "label"))
|
---|
1044 | strncpy(rdr->label, value, sizeof (rdr->label) - 1);
|
---|
1045 | if (!strcmp(token, "fallback"))
|
---|
1046 | rdr->fallback = atoi(value) ? 1 : 0;
|
---|
1047 | if (!strcmp(token, "logport"))
|
---|
1048 | rdr->log_port = atoi(value);
|
---|
1049 | if (!strcmp(token, "caid"))
|
---|
1050 | config_check_caidtab(value, &rdr->ctab);
|
---|
1051 | if (!strcmp(token, "boxid"))
|
---|
1052 | rdr->boxid = a2i(value, 4);
|
---|
1053 | if (!strcmp(token, "aeskey")) {
|
---|
1054 | if (key_atob(value, rdr->aes_key)) {
|
---|
1055 | fprintf(stderr, "Configuration reader: Error in AES Key\n");
|
---|
1056 | exit(1);
|
---|
1057 | }
|
---|
1058 | }
|
---|
1059 | if (!strcmp(token, "detect")) {
|
---|
1060 | strtoupper(value);
|
---|
1061 |
|
---|
1062 | for (i = 0; RDR_CD_TXT[i]; i++) {
|
---|
1063 | if (!strcmp(value, RDR_CD_TXT[i]))
|
---|
1064 | rdr->detect = i;
|
---|
1065 | else if ((value[0] == '!') && (!strcmp(value + 1, RDR_CD_TXT[i])))
|
---|
1066 | rdr->detect = i | 0x80;
|
---|
1067 | }
|
---|
1068 | }
|
---|
1069 | if (!strcmp(token, "frequency")) {
|
---|
1070 | char *endptr;
|
---|
1071 | double mhz = strtod(value, &endptr);
|
---|
1072 | if (*endptr == '\0') {
|
---|
1073 | rdr->frequency = mhz * 1000000;
|
---|
1074 | }
|
---|
1075 | }
|
---|
1076 | if (!strcmp(token, "card_frequency")) {
|
---|
1077 | char *endptr;
|
---|
1078 | double mhz = strtod(value, &endptr);
|
---|
1079 | if (*endptr == '\0') {
|
---|
1080 | rdr->card_frequency = mhz * 1000000;
|
---|
1081 | }
|
---|
1082 | }
|
---|
1083 | if (!strcmp(token, "protocol")) {
|
---|
1084 | if (!strcmp(value, "phoenix"))
|
---|
1085 | rdr->type = R_PHOENIX;
|
---|
1086 | if (!strcmp(value, "smartmouse"))
|
---|
1087 | rdr->type = R_SMARTMOUSE;
|
---|
1088 | if (!strcmp(value, "internal"))
|
---|
1089 | rdr->type = R_INTERN;
|
---|
1090 | if (!strcmp(value, "intern"))
|
---|
1091 | rdr->type = R_INTERN;
|
---|
1092 | if (!strcmp(value, "smartreader+"))
|
---|
1093 | rdr->type = R_SMARTREADER;
|
---|
1094 |
|
---|
1095 | if (!strcmp(value, "serial"))
|
---|
1096 | rdr->type = R_SERIAL;
|
---|
1097 |
|
---|
1098 | if (!strcmp(value, "camd35"))
|
---|
1099 | rdr->type = R_CAMD35;
|
---|
1100 | if (!strcmp(value, "cs378x"))
|
---|
1101 | rdr->type = R_CS378X;
|
---|
1102 | if (!strcmp(value, "cs357x"))
|
---|
1103 | rdr->type = R_CAMD35;
|
---|
1104 | #ifdef CS_WITH_GBOX
|
---|
1105 | if (!strcmp(value, "gbox"))
|
---|
1106 | rdr->type = R_GBOX;
|
---|
1107 | #endif
|
---|
1108 | if (!strcmp(value, "newcamd") || !strcmp(value, "newcamd525")) {
|
---|
1109 | rdr->type = R_NEWCAMD;
|
---|
1110 | rdr->ncd_proto = NCD_525;
|
---|
1111 | }
|
---|
1112 | if (!strcmp(value, "newcamd524")) {
|
---|
1113 | rdr->type = R_NEWCAMD;
|
---|
1114 | rdr->ncd_proto = NCD_524;
|
---|
1115 | }
|
---|
1116 | }
|
---|
1117 | if (!strcmp(token, "ident"))
|
---|
1118 | config_check_ftab(value, &rdr->ftab, "reader", rdr->label, "provid");
|
---|
1119 | if (!strcmp(token, "class"))
|
---|
1120 | config_check_cltab(value, &rdr->cltab);
|
---|
1121 | if (!strcmp(token, "chid"))
|
---|
1122 | config_check_ftab(value, &rdr->fchid, "reader", rdr->label, "chid");
|
---|
1123 | if (!strcmp(token, "showcls"))
|
---|
1124 | rdr->show_cls = atoi(value);
|
---|
1125 | if (!strcmp(token, "maxqlen"))
|
---|
1126 | rdr->maxqlen = atoi(value);
|
---|
1127 | if (rdr->maxqlen < 0 || rdr->maxqlen > CS_MAXQLEN)
|
---|
1128 | rdr->maxqlen = CS_MAXQLEN;
|
---|
1129 |
|
---|
1130 | if (!strcmp(token, "group"))
|
---|
1131 | for (ptr = strtok(value, ","); ptr; ptr = strtok(NULL, ",")) {
|
---|
1132 | int g;
|
---|
1133 |
|
---|
1134 | g = atoi(ptr);
|
---|
1135 | if ((g > 0) && (g < 33))
|
---|
1136 | rdr->grp |= (1 << (g - 1));
|
---|
1137 | }
|
---|
1138 | if (!strcmp(token, "emmcache"))
|
---|
1139 | for (i = 0, ptr = strtok(value, ","); (i < 3) && (ptr); ptr = strtok(NULL, ","), i++)
|
---|
1140 | switch (i) {
|
---|
1141 | case 0:
|
---|
1142 | rdr->cachemm = atoi(ptr);
|
---|
1143 | break;
|
---|
1144 | case 1:
|
---|
1145 | rdr->rewritemm = atoi(ptr);
|
---|
1146 | break;
|
---|
1147 | case 2:
|
---|
1148 | rdr->logemm = atoi(ptr);
|
---|
1149 | break;
|
---|
1150 | }
|
---|
1151 | if (!strcmp(token, "blocknano"))
|
---|
1152 | for (ptr = strtok(value, ","); ptr; ptr = strtok(NULL, ","))
|
---|
1153 | if ((i = byte_atob(ptr)) >= 0)
|
---|
1154 | rdr->b_nano[i] = 1;
|
---|
1155 | }
|
---|
1156 |
|
---|
1157 | int config_init_readerdb()
|
---|
1158 | {
|
---|
1159 | int tag = 0, nr;
|
---|
1160 | FILE *fp;
|
---|
1161 | char *value;
|
---|
1162 |
|
---|
1163 | sprintf(token, "%s%s", cs_confdir, cs_srvr);
|
---|
1164 | if (!(fp = fopen(token, "r"))) {
|
---|
1165 | log_normal("can't open file \"%s\" (errno=%d)\n", token, errno);
|
---|
1166 | return (1);
|
---|
1167 | }
|
---|
1168 | nr = 0;
|
---|
1169 | while (fgets(token, sizeof (token), fp)) {
|
---|
1170 | int i, l;
|
---|
1171 |
|
---|
1172 | if ((l = strlen(trim(token))) < 3)
|
---|
1173 | continue;
|
---|
1174 | if ((token[0] == '[') && (token[l - 1] == ']')) {
|
---|
1175 | token[l - 1] = 0;
|
---|
1176 | tag = (!strcmp("reader", strtolower(token + 1)));
|
---|
1177 | if (reader[nr].label[0] && reader[nr].type)
|
---|
1178 | nr++;
|
---|
1179 | memset(&reader[nr], 0, sizeof (struct s_reader));
|
---|
1180 | reader[nr].tcp_rto = 30;
|
---|
1181 | reader[nr].show_cls = 10;
|
---|
1182 | reader[nr].maxqlen = CS_MAXQLEN;
|
---|
1183 | reader[nr].frequency = 3571200;
|
---|
1184 | reader[nr].card_frequency = 3571200;
|
---|
1185 | strcpy(reader[nr].pincode, "none");
|
---|
1186 | for (i = 1; i < CS_MAXCAIDTAB; reader[nr].ctab.mask[i++] = 0xffff);
|
---|
1187 | continue;
|
---|
1188 | }
|
---|
1189 | if (!tag)
|
---|
1190 | continue;
|
---|
1191 | if (!(value = strchr(token, '=')))
|
---|
1192 | continue;
|
---|
1193 | *value++ = '\0';
|
---|
1194 | config_check_reader(trim(strtolower(token)), trim(value), &reader[nr]);
|
---|
1195 | }
|
---|
1196 | fclose(fp);
|
---|
1197 | return (0);
|
---|
1198 | }
|
---|
1199 |
|
---|
1200 | #ifdef CS_ANTICASC
|
---|
1201 | void config_init_ac()
|
---|
1202 | {
|
---|
1203 | int nr;
|
---|
1204 | FILE *fp;
|
---|
1205 |
|
---|
1206 | sprintf(token, "%s%s", cs_confdir, cs_ac);
|
---|
1207 | if (!(fp = fopen(token, "r"))) {
|
---|
1208 | log_normal("can't open file \"%s\" (errno=%d) anti-cascading table not loaded", token, errno);
|
---|
1209 | return;
|
---|
1210 | }
|
---|
1211 |
|
---|
1212 | for (nr = 0; fgets(token, sizeof (token), fp);) {
|
---|
1213 | int i, skip;
|
---|
1214 | ushort caid, sid, chid, dwtime;
|
---|
1215 | ulong provid;
|
---|
1216 | char *ptr, *ptr1;
|
---|
1217 | struct s_cpmap *ptr_cpmap;
|
---|
1218 | static struct s_cpmap *cpmap = (struct s_cpmap *) 0;
|
---|
1219 |
|
---|
1220 | if (strlen(token) < 4)
|
---|
1221 | continue;
|
---|
1222 |
|
---|
1223 | caid = sid = chid = dwtime = 0;
|
---|
1224 | provid = 0;
|
---|
1225 | skip = 0;
|
---|
1226 | ptr1 = 0;
|
---|
1227 | for (i = 0, ptr = strtok(token, "="); (i < 2) && (ptr); ptr = strtok(NULL, "="), i++) {
|
---|
1228 | trim(ptr);
|
---|
1229 | if (*ptr == ';' || *ptr == '#' || *ptr == '-') {
|
---|
1230 | skip = 1;
|
---|
1231 | break;
|
---|
1232 | }
|
---|
1233 | switch (i) {
|
---|
1234 | case 0:
|
---|
1235 | ptr1 = ptr;
|
---|
1236 | break;
|
---|
1237 | case 1:
|
---|
1238 | dwtime = atoi(ptr);
|
---|
1239 | break;
|
---|
1240 | }
|
---|
1241 | }
|
---|
1242 |
|
---|
1243 | if (!skip) {
|
---|
1244 | for (i = 0, ptr = strtok(ptr1, ":"); (i < 4) && (ptr); ptr = strtok(NULL, ":"), i++) {
|
---|
1245 | trim(ptr);
|
---|
1246 | switch (i) {
|
---|
1247 | case 0:
|
---|
1248 | if (*ptr == '*')
|
---|
1249 | caid = 0;
|
---|
1250 | else
|
---|
1251 | caid = a2i(ptr, 4);
|
---|
1252 | break;
|
---|
1253 | case 1:
|
---|
1254 | if (*ptr == '*')
|
---|
1255 | provid = 0;
|
---|
1256 | else
|
---|
1257 | provid = a2i(ptr, 6);
|
---|
1258 | break;
|
---|
1259 | case 2:
|
---|
1260 | if (*ptr == '*')
|
---|
1261 | sid = 0;
|
---|
1262 | else
|
---|
1263 | sid = a2i(ptr, 4);
|
---|
1264 | break;
|
---|
1265 | case 3:
|
---|
1266 | if (*ptr == '*')
|
---|
1267 | chid = 0;
|
---|
1268 | else
|
---|
1269 | chid = a2i(ptr, 4);
|
---|
1270 | break;
|
---|
1271 | }
|
---|
1272 | }
|
---|
1273 | if (!(ptr_cpmap = (struct s_cpmap *) malloc(sizeof (struct s_cpmap)))) {
|
---|
1274 | log_normal("Error allocating memory (errno=%d)", errno);
|
---|
1275 | return;
|
---|
1276 | }
|
---|
1277 | if (cpmap)
|
---|
1278 | cpmap->next = ptr_cpmap;
|
---|
1279 | else
|
---|
1280 | cfg->cpmap = ptr_cpmap;
|
---|
1281 | cpmap = ptr_cpmap;
|
---|
1282 |
|
---|
1283 | cpmap->caid = caid;
|
---|
1284 | cpmap->provid = provid;
|
---|
1285 | cpmap->sid = sid;
|
---|
1286 | cpmap->chid = chid;
|
---|
1287 | cpmap->dwtime = dwtime;
|
---|
1288 | cpmap->next = 0;
|
---|
1289 |
|
---|
1290 | log_debug("nr=%d, caid=%04X, provid=%06X, sid=%04X, chid=%04X, dwtime=%d", nr, caid, provid, sid, chid, dwtime);
|
---|
1291 | nr++;
|
---|
1292 | }
|
---|
1293 | }
|
---|
1294 | fclose(fp);
|
---|
1295 | }
|
---|
1296 | #endif
|
---|