?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- fix Building without Nagra not possible at Nagra_Merlin https://trac.streamboard...
[oscam.git] / module-webif.c
blobd10e4e04ef3826b7f4173c7c1ba2db749e2ecf68
1 #define MODULE_LOG_PREFIX "webif"
2
3 #include "globals.h"
4
5 #ifdef WEBIF
6 //
7 // OSCam HTTP server module
8 //
9 #include <locale.h>
10 #include "cscrypt/md5.h"
11 #include "module-anticasc.h"
12 #include "module-cacheex.h"
13 #include "module-cccam.h"
14 #include "module-cccam-data.h"
15 #include "module-dvbapi.h"
16 #include "module-newcamd.h"
17 #include "module-stat.h"
18 #include "module-webif.h"
19 #include "module-webif-lib.h"
20 #include "module-webif-tpl.h"
21 #include "oscam-conf-mk.h"
22 #include "oscam-config.h"
23 #include "oscam-files.h"
24 #include "oscam-garbage.h"
25 #include "oscam-cache.h"
26 #include "oscam-client.h"
27 #include "oscam-lock.h"
28 #include "oscam-net.h"
29 #include "oscam-reader.h"
30 #include "oscam-string.h"
31 #include "oscam-time.h"
32 #include "oscam-work.h"
33 #ifdef MODULE_GBOX
34 #include "module-gbox-sms.h"
35 #include "module-gbox.h"
36 #include "module-gbox-cards.h"
37 #endif
38
39 extern const struct s_cardreader *cardreaders[];
40 extern char cs_confdir[];
41 extern uint32_t ecmcwcache_size;
42 extern uint32_t cfg_sidtab_generation;
43 extern int32_t exit_oscam;
44 extern uint8_t cacheex_peer_id[8];
45
46 extern char *entitlement_type[];
47 extern char *RDR_CD_TXT[];
48 int8_t isactive;
49 int32_t ssl_active = 0;
50 char noncekey[33];
51 pthread_key_t getkeepalive;
52 static pthread_key_t getip;
53 pthread_key_t getssl;
54 static CS_MUTEX_LOCK http_lock;
55 CS_MUTEX_LOCK *lock_cs;
56
57 static uint8_t useLocal = 1;
58 #define PRINTF_LOCAL_D useLocal ? "%'d" : "%d"
59 #define PRINTF_LOCAL_F useLocal ? "%'.0f" : "%.0f"
60 #define PRINTF_LOCAL_MB useLocal ? "%'.2f MB" : "%.2f MB"
61
62 static int8_t httpthread_running = 0;
63 static pthread_t httpthread;
64 static int32_t sock;
65 enum refreshtypes { REFR_ACCOUNTS, REFR_READERS, REFR_CLIENTS, REFR_SERVER, REFR_ANTICASC, REFR_SERVICES };
66
67 //initialize structs for calculating cpu-usage depending on time between refresh of status_page
68 static struct pstat p_stat_cur;
69 static struct pstat p_stat_old;
70
71 static bool use_srvid2 = false;
72
73 /* constants for menuactivating */
74 #define MNU_STATUS 0
75 #define MNU_LIVELOG 1
76 #define MNU_CONFIG 2
77 #define MNU_READERS 3
78 #define MNU_USERS 4
79 #define MNU_SERVICES 5
80 #define MNU_FILES 6
81 #define MNU_FAILBAN 7
82 #define MNU_CACHEEX 8
83 #define MNU_SCRIPT 9
84 #define MNU_SHUTDOWN 10
85 #define MNU_TOTAL_ITEMS 11 // sum of items above
86
87 /* constants for config.html submenuactivating */
88 #define MNU_CFG_GLOBAL 0
89 #define MNU_CFG_ANTICASC 1
90 #define MNU_CFG_CACHE 2
91 #define MNU_CFG_LOADBAL 3
92 #define MNU_CFG_CAMD33 4
93 #define MNU_CFG_CAMD35 5
94 #define MNU_CFG_CAMD35TCP 6
95 #define MNU_CFG_CCCAM 7
96 #define MNU_CFG_NEWCAMD 8
97 #define MNU_CFG_GBOX 9
98 #define MNU_CFG_RADEGAST 10
99 #define MNU_CFG_SCAM 11
100 #define MNU_CFG_SERIAL 12
101 #define MNU_CFG_DVBAPI 13
102 #define MNU_CFG_LCD 14
103 #define MNU_CFG_MONITOR 15
104 #define MNU_CFG_WEBIF 16
105 #define MNU_CFG_STREAMRELAY 17
106
107 /* constants for files.html submenuactivating */
108 #define MNU_CFG_FVERSION 0
109 #define MNU_CFG_FCONF 1
110 #define MNU_CFG_FUSER 2
111 #define MNU_CFG_FSERVER 3
112 #define MNU_CFG_FSRVID 4
113 #define MNU_CFG_FDVBAPI 5
114 #define MNU_CFG_FACLOG 6
115 #define MNU_CFG_FLOGFILE 7
116 #define MNU_CFG_FUSERFILE 8
117 #define MNU_CFG_FSERVICES 9
118 #define MNU_CFG_FPROVID 10
119 #define MNU_CFG_FTIERS 11
120 #define MNU_CFG_FRATELIMIT 12
121 #define MNU_CFG_FWHITELIST 13
122 #define MNU_CFG_FSRVID2 14
123 #define MNU_CFG_FFAKECWS 15
124 #define MNU_CFG_FCSS 16
125 #define MNU_CFG_FTWIN 17
126 #define MNU_CFG_FKEYCW 18
127
128 /* constants for files.html for GBOX submenuactivating */
129 #define MNU_GBX_FSCINF 19
130 #define MNU_GBX_FSHRINF 20
131 #define MNU_GBX_FSHRONL 21
132 #define MNU_GBX_FVERS 22
133 #define MNU_GBX_FATTACK 23
134 #define MNU_GBX_FSMSLOG 24
135 #define MNU_GBX_FSMSACK 25
136 #define MNU_GBX_FSMSNACK 26
137 #define MNU_GBX_FSTAINF 27
138 #define MNU_GBX_FEXPINF 28
139 #define MNU_GBX_INFOLOG 29
140 #define MNU_CFG_FSOFTCAMKEY 30
141
142 #define MNU_CFG_TOTAL_ITEMS 31 // sum of items above. Use it for "All inactive" in function calls too.
143
144 static void set_status_info_var(struct templatevars *vars, char *varname, int no_data, char *fmt, double value)
145 {
146 if (no_data)
147 tpl_addVar(vars, TPLADD, varname, "N/A");
148 else
149 tpl_printf(vars, TPLADD, varname, fmt, value);
150 }
151
152 /*
153 * Creates vars Memory/CPU/OSCAM info in for status_page
154 * if check_available == 0 N/A will be displayed
155 * Bit mapping
156 * mem 0 total, 1 used & free, 2 buff, cached & free incl. buff, 3 share
157 * swap 4 total, 5 used & free,
158 * proc 6 count
159 * cpu 7 load
160 * oscam 8 vsize & rssize, 9 cpu user, 10 cpu sys, 11 cpu sum, 12 cpu refreshtime
161 * unused 13 - 15
162 */
163 static void set_status_info(struct templatevars *vars, struct pstat stats){
164 set_status_info_var(vars, "MEM_CUR_TOTAL", stats.check_available & (1 << 0), PRINTF_LOCAL_MB , (double)stats.mem_total/(1024.0*1024.0));
165 set_status_info_var(vars, "MEM_CUR_FREE", stats.check_available & (1 << 1), PRINTF_LOCAL_MB , (double)stats.mem_free/(1024.0*1024.0));
166 set_status_info_var(vars, "MEM_CUR_USED", stats.check_available & (1 << 1), PRINTF_LOCAL_MB , (double)stats.mem_used/(1024.0*1024.0));
167 set_status_info_var(vars, "MEM_CUR_BUFF", stats.check_available & (1 << 2), PRINTF_LOCAL_MB , (double)stats.mem_buff/(1024.0*1024.0));
168 set_status_info_var(vars, "MEM_CUR_CACHED", stats.check_available & (1 << 2), PRINTF_LOCAL_MB , (double)stats.mem_cached/(1024.0*1024.0));
169 set_status_info_var(vars, "MEM_CUR_FREEM", stats.check_available & (1 << 2), PRINTF_LOCAL_MB , (double)stats.mem_freem/(1024.0*1024.0));
170 set_status_info_var(vars, "MEM_CUR_SHARE", stats.check_available & (1 << 3), PRINTF_LOCAL_MB , (double)stats.mem_share/(1024.0*1024.0));
171 set_status_info_var(vars, "MEM_CUR_TOTSW", stats.check_available & (1 << 4), PRINTF_LOCAL_MB , (double)stats.mem_total_swap/(1024.0*1024.0));
172 set_status_info_var(vars, "MEM_CUR_FRESW", stats.check_available & (1 << 5), PRINTF_LOCAL_MB , (double)stats.mem_free_swap/(1024.0*1024.0));
173 set_status_info_var(vars, "MEM_CUR_USESW", stats.check_available & (1 << 5), PRINTF_LOCAL_MB , (double)stats.mem_used_swap/(1024.0*1024.0));
174
175 set_status_info_var(vars, "SERVER_PROCS", stats.check_available & (1 << 6), PRINTF_LOCAL_F , stats.info_procs);
176
177 set_status_info_var(vars, "CPU_LOAD_0", stats.check_available & (1 << 7), "%.2f" , stats.cpu_avg[0]);
178 set_status_info_var(vars, "CPU_LOAD_1", stats.check_available & (1 << 7), "%.2f" , stats.cpu_avg[1]);
179 set_status_info_var(vars, "CPU_LOAD_2", stats.check_available & (1 << 7), "%.2f" , stats.cpu_avg[2]);
180
181 set_status_info_var(vars, "OSCAM_VMSIZE", stats.check_available & (1 << 8), PRINTF_LOCAL_MB , (double)stats.vsize/(1024.0*1024.0));
182 set_status_info_var(vars, "OSCAM_RSSSIZE", stats.check_available & (1 << 8), PRINTF_LOCAL_MB , (double)stats.rss/(1024.0*1024.0));
183 set_status_info_var(vars, "OSCAM_CPU_USER", stats.check_available & (1 << 9), "%.2f %%" , stats.cpu_usage_user);
184 set_status_info_var(vars, "OSCAM_CPU_SYS", stats.check_available & (1 << 10), "%.2f %%" , stats.cpu_usage_sys);
185 double sum_cpu = stats.cpu_usage_sys + stats.cpu_usage_user;
186 set_status_info_var(vars, "OSCAM_CPU_SUM", stats.check_available & (1 << 11), "%.2f %%" , sum_cpu);
187
188 if (stats.check_available & (1 << 12))
189 {
190 tpl_addVar(vars, TPLADD, "OSCAM_REFRESH" , "N/A");
191 }
192 else
193 {
194 tpl_printf(vars, TPLADD, "OSCAM_REFRESH" , "%02"PRId64":%02"PRId64":%02"PRId64"h",
195 stats.gone_refresh / 3600,
196 (stats.gone_refresh / 60) % 60,
197 stats.gone_refresh % 60);
198 }
199 }
200
201 static void clear_account_stats(struct s_auth *account)
202 {
203 account->cwfound = 0;
204 account->cwcache = 0;
205 account->cwnot = 0;
206 account->cwtun = 0;
207 account->cwignored = 0;
208 account->cwtout = 0;
209 account->emmok = 0;
210 account->emmnok = 0;
211 #ifdef CW_CYCLE_CHECK
212 account->cwcycledchecked = 0;
213 account->cwcycledok = 0;
214 account->cwcyclednok = 0;
215 account->cwcycledign = 0;
216 #endif
217 cacheex_clear_account_stats(account);
218 }
219
220 static void clear_all_account_stats(void)
221 {
222 struct s_auth *account = cfg.account;
223 while(account)
224 {
225 clear_account_stats(account);
226 account = account->next;
227 }
228 }
229
230 #ifdef CS_CACHEEX
231 static void cacheex_clear_all_stats(void)
232 {
233 struct s_auth *account = cfg.account;
234 while(account)
235 {
236 cacheex_clear_account_stats(account);
237 account = account->next;
238 }
239 struct s_client *cl;
240 for(cl = first_client->next; cl ; cl = cl->next)
241 {
242 cacheex_clear_client_stats(cl);
243 ll_clear_data(cl->ll_cacheex_stats);
244 }
245 cacheex_clear_client_stats(first_client);
246 }
247 #endif
248
249 static void clear_info_clients_stats(void)
250 {
251 first_client->cwfound = 0;
252 first_client->cwcache = 0;
253 first_client->cwnot = 0;
254 first_client->cwtun = 0;
255 first_client->cwignored = 0;
256 first_client->cwtout = 0;
257 first_client->emmok = 0;
258 first_client->emmnok = 0;
259 cacheex_clear_client_stats(first_client);
260 }
261
262 static void clear_info_readers_stats(void)
263 {
264 int8_t i;
265 cs_writelock(__func__, &readerlist_lock);
266 LL_ITER itr = ll_iter_create(configured_readers);
267 struct s_reader *rdr;
268 while((rdr = ll_iter_next(&itr)))
269 {
270 rdr->webif_ecmsok = 0;
271 rdr->webif_ecmsnok = 0;
272 rdr->webif_ecmstout = 0;
273 rdr->webif_ecmsfilteredhead = 0;
274 rdr->webif_ecmsfilteredlen = 0;
275
276 for(i = 0; i < 4; i++)
277 {
278 rdr->webif_emmerror[i] = 0;
279 rdr->webif_emmwritten[i] = 0;
280 rdr->webif_emmskipped[i] = 0;
281 rdr->webif_emmblocked[i] = 0;
282 }
283 }
284 cs_writeunlock(__func__, &readerlist_lock);
285 }
286
287 static void set_ecm_info(struct templatevars * vars)
288 {
289 //if one of the stats overloaded, reset all stats!
290 if(first_client->cwfound<0
291 || first_client->cwnot<0
292 || first_client->cwignored<0
293 || first_client->cwtout<0
294 || first_client->cwcache<0
295 || first_client->cwtun<0
296 || first_client->emmok<0
297 || first_client->emmnok<0
298 #ifdef CS_CACHEEX
299 || first_client->cwcacheexgot<0
300 || first_client->cwcacheexpush<0
301 || first_client->cwcacheexhit<0
302 #ifdef CS_CACHEEX_AIO
303 || first_client->cwcacheexgotlg<0
304 || first_client->cwcacheexpushlg<0
305 #endif
306 #endif
307 ){
308 clear_info_clients_stats();
309 }
310 //end reset stats
311
312 int ecm = 0, emm = 0;
313 double ecmsum = first_client->cwfound + first_client->cwcache + first_client->cwnot + first_client->cwtout; //dont count TUN its included
314 if(ecmsum < 1) {ecmsum = 1; ecm = 1;}
315 double ecmpos = first_client->cwfound + first_client->cwcache; // dont count TUN its included
316 if(ecmpos < 1) {ecmpos = 1;}
317 double ecmneg = first_client->cwnot + first_client->cwtout; //dont count IGN its not part of neagtiv
318 if(ecmneg < 1) {ecmneg = 1;}
319 double emmsum = first_client->emmok + first_client->emmnok;
320 if(emmsum < 1) {emmsum = 1; emm = 1;}
321
322 tpl_printf(vars, TPLADD, "TOTAL_ECM_MIN", "%d", first_client->n_request[0]);
323 tpl_printf(vars, TPLADD, "TOTAL_CW", PRINTF_LOCAL_F, !ecm ? ecmsum : 0);
324 tpl_printf(vars, TPLADD, "TOTAL_CWOK", PRINTF_LOCAL_F, (double)first_client->cwfound);
325 tpl_printf(vars, TPLADD, "TOTAL_CWNOK", PRINTF_LOCAL_F, (double)first_client->cwnot);
326 tpl_printf(vars, TPLADD, "TOTAL_CWIGN", PRINTF_LOCAL_F, (double)first_client->cwignored);
327 tpl_printf(vars, TPLADD, "TOTAL_CWTOUT", PRINTF_LOCAL_F, (double)first_client->cwtout);
328 tpl_printf(vars, TPLADD, "TOTAL_CWCACHE", PRINTF_LOCAL_F, (double)first_client->cwcache);
329 tpl_printf(vars, TPLADD, "TOTAL_CWTUN", PRINTF_LOCAL_F, (double)first_client->cwtun);
330 tpl_printf(vars, TPLADD, "TOTAL_CWPOS", PRINTF_LOCAL_F, (double)first_client->cwfound + (double)first_client->cwcache);
331 tpl_printf(vars, TPLADD, "TOTAL_CWNEG", PRINTF_LOCAL_F, (double)first_client->cwnot + (double)first_client->cwtout);
332 tpl_printf(vars, TPLADD, "TOTAL_EM", PRINTF_LOCAL_F, !emm ? emmsum : 0);
333 tpl_printf(vars, TPLADD, "TOTAL_EMOK", PRINTF_LOCAL_F, (double)first_client->emmok);
334 tpl_printf(vars, TPLADD, "TOTAL_EMNOK", PRINTF_LOCAL_F, (double)first_client->emmnok);
335 tpl_printf(vars, TPLADD, "REL_CWOK", "%.2f", (double)first_client->cwfound * 100 / ecmsum);
336 tpl_printf(vars, TPLADD, "REL_CWNOK", "%.2f", (double)first_client->cwnot * 100 / ecmsum);
337 //tpl_printf(vars, TPLADD, "REL_CWIGN", "%.2f", (double)first_client->cwignored * 100 / ecmsum);
338 tpl_printf(vars, TPLADD, "REL_CWTOUT", "%.2f", (double)first_client->cwtout * 100 / ecmsum);
339 tpl_printf(vars, TPLADD, "REL_CWCACHE", "%.2f", (double)first_client->cwcache * 100 / ecmsum);
340 tpl_printf(vars, TPLADD, "REL_CWTUN", "%.2f", (double)first_client->cwtun * 100 / ecmsum);
341 tpl_printf(vars, TPLADD, "REL_CWPOS", "%.2f", (double)(first_client->cwfound + first_client->cwcache) * 100 / ecmsum);
342 tpl_printf(vars, TPLADD, "REL_CWNEG", "%.2f", (double)(first_client->cwnot + first_client->cwtout) * 100 / ecmsum);
343 tpl_printf(vars, TPLADD, "REL_EMOK", "%.2f", (double)first_client->emmok * 100 / emmsum);
344 tpl_printf(vars, TPLADD, "REL_EMNOK", "%.2f", (double)first_client->emmnok * 100 / emmsum);
345 tpl_printf(vars, TPLADD, "REL_CWPOSOK", "%.2f", (double)first_client->cwfound * 100 / ecmpos);
346 tpl_printf(vars, TPLADD, "REL_CWPOSCACHE", "%.2f", (double)first_client->cwcache * 100 / ecmpos);
347 tpl_printf(vars, TPLADD, "REL_CWNEGNOK", "%.2f", (double)first_client->cwnot * 100 / ecmneg);
348 //tpl_printf(vars, TPLADD, "REL_CWNEGIGN", "%.2f", (double)first_client->cwignored * 100 / ecmneg);
349 tpl_printf(vars, TPLADD, "REL_CWNEGTOUT", "%.2f", (double)first_client->cwtout * 100 / ecmneg);
350
351 double totalrdrneg = 0, totalrdrpos = 0;
352 double totalrdrok = 0, totalrdrnok = 0, totalrdrtout = 0;
353 double flen = 0, fhead = 0;
354 double teruk = 0, terg = 0, ters = 0, teruq = 0;
355 double twruk = 0, twrg = 0, twrs = 0, twruq = 0;
356 double tskuk = 0, tskg = 0, tsks = 0, tskuq = 0;
357 double tbluk = 0, tblg = 0, tbls = 0, tbluq = 0;
358
359 cs_readlock(__func__, &readerlist_lock);
360 LL_ITER itr = ll_iter_create(configured_readers);
361 struct s_reader *rdr;
362 while((rdr = ll_iter_next(&itr)))
363 {
364 if (rdr->webif_ecmsok) { totalrdrok += rdr->webif_ecmsok; }
365 if (rdr->webif_ecmsnok) { totalrdrnok += rdr->webif_ecmsnok; }
366 if (rdr->webif_ecmstout) { totalrdrtout += rdr->webif_ecmstout; }
367
368 if (rdr->webif_ecmsfilteredlen) { flen += rdr->webif_ecmsfilteredlen; }
369 if (rdr->webif_ecmsfilteredhead) { fhead += rdr->webif_ecmsfilteredhead; }
370
371 if (rdr->webif_emmerror[0]) { teruk += rdr->webif_emmerror[0]; }
372 if (rdr->webif_emmerror[1]) { teruq += rdr->webif_emmerror[1]; }
373 if (rdr->webif_emmerror[2]) { ters += rdr->webif_emmerror[2]; }
374 if (rdr->webif_emmerror[3]) { terg += rdr->webif_emmerror[3]; }
375
376 if (rdr->webif_emmwritten[0]) { twruk += rdr->webif_emmwritten[0]; }
377 if (rdr->webif_emmwritten[1]) { twruq += rdr->webif_emmwritten[1]; }
378 if (rdr->webif_emmwritten[2]) { twrs += rdr->webif_emmwritten[2]; }
379 if (rdr->webif_emmwritten[3]) { twrg += rdr->webif_emmwritten[3]; }
380
381 if (rdr->webif_emmskipped[0]) { tskuk += rdr->webif_emmskipped[0]; }
382 if (rdr->webif_emmskipped[1]) { tskuq += rdr->webif_emmskipped[1]; }
383 if (rdr->webif_emmskipped[2]) { tsks += rdr->webif_emmskipped[2]; }
384 if (rdr->webif_emmskipped[3]) { tskg += rdr->webif_emmskipped[3]; }
385
386 if (rdr->webif_emmblocked[0]) { tbluk += rdr->webif_emmblocked[0]; }
387 if (rdr->webif_emmblocked[1]) { tbluq += rdr->webif_emmblocked[1]; }
388 if (rdr->webif_emmblocked[2]) { tbls += rdr->webif_emmblocked[2]; }
389 if (rdr->webif_emmblocked[3]) { tblg += rdr->webif_emmblocked[3]; }
390 }
391 cs_readunlock(__func__, &readerlist_lock);
392
393 totalrdrneg = totalrdrnok + totalrdrtout;
394 totalrdrpos = totalrdrok;
395 ecmsum = totalrdrok + totalrdrnok + totalrdrtout;
396
397 tpl_printf(vars, TPLADD, "TOTAL_CWOK_READERS", PRINTF_LOCAL_F, totalrdrok);
398 tpl_printf(vars, TPLADD, "TOTAL_CWNOK_READERS", PRINTF_LOCAL_F, totalrdrnok);
399 tpl_printf(vars, TPLADD, "TOTAL_CWTOUT_READERS", PRINTF_LOCAL_F, totalrdrtout);
400 tpl_printf(vars, TPLADD, "REL_CWOK_READERS", "%.2f", ecmsum ? totalrdrok * 100 / ecmsum : 0);
401 tpl_printf(vars, TPLADD, "REL_CWNOK_READERS", "%.2f", ecmsum ? totalrdrnok * 100 / ecmsum : 0);
402 tpl_printf(vars, TPLADD, "REL_CWTOUT_READERS", "%.2f", ecmsum ? totalrdrtout * 100 / ecmsum : 0);
403 tpl_printf(vars, TPLADD, "TOTAL_CWPOS_READERS", PRINTF_LOCAL_F, totalrdrpos);
404 tpl_printf(vars, TPLADD, "TOTAL_CWNEG_READERS", PRINTF_LOCAL_F, totalrdrneg);
405 tpl_printf(vars, TPLADD, "REL_CWPOS_READERS", "%.2f", ecmsum ? totalrdrpos * 100 / ecmsum : 0);
406 tpl_printf(vars, TPLADD, "REL_CWNEG_READERS", "%.2f", ecmsum ? totalrdrneg * 100 / ecmsum : 0);
407 tpl_printf(vars, TPLADD, "TOTAL_ELENR", PRINTF_LOCAL_F, flen);
408 tpl_printf(vars, TPLADD, "TOTAL_EHEADR", PRINTF_LOCAL_F, fhead);
409 tpl_printf(vars, TPLADD, "TOTAL_SUM_ALL_READERS_ECM", PRINTF_LOCAL_F, ecmsum);
410
411 tpl_printf(vars, TPLADD, "TOTAL_EMMERRORUK_READERS", PRINTF_LOCAL_F, teruk);
412 tpl_printf(vars, TPLADD, "TOTAL_EMMERRORG_READERS", PRINTF_LOCAL_F, terg);
413 tpl_printf(vars, TPLADD, "TOTAL_EMMERRORS_READERS", PRINTF_LOCAL_F, ters);
414 tpl_printf(vars, TPLADD, "TOTAL_EMMERRORUQ_READERS", PRINTF_LOCAL_F, teruq);
415 tpl_printf(vars, TPLADD, "TOTAL_EMMWRITTENUK_READERS", PRINTF_LOCAL_F, twruk);
416 tpl_printf(vars, TPLADD, "TOTAL_EMMWRITTENG_READERS", PRINTF_LOCAL_F, twrg);
417 tpl_printf(vars, TPLADD, "TOTAL_EMMWRITTENS_READERS", PRINTF_LOCAL_F, twrs);
418 tpl_printf(vars, TPLADD, "TOTAL_EMMWRITTENUQ_READERS", PRINTF_LOCAL_F, twruq);
419 tpl_printf(vars, TPLADD, "TOTAL_EMMSKIPPEDUK_READERS", PRINTF_LOCAL_F, tskuk);
420 tpl_printf(vars, TPLADD, "TOTAL_EMMSKIPPEDG_READERS", PRINTF_LOCAL_F, tskg);
421 tpl_printf(vars, TPLADD, "TOTAL_EMMSKIPPEDS_READERS", PRINTF_LOCAL_F, tsks);
422 tpl_printf(vars, TPLADD, "TOTAL_EMMSKIPPEDUQ_READERS", PRINTF_LOCAL_F, tskuq);
423 tpl_printf(vars, TPLADD, "TOTAL_EMMBLOCKEDUK_READERS", PRINTF_LOCAL_F, tbluk);
424 tpl_printf(vars, TPLADD, "TOTAL_EMMBLOCKEDG_READERS", PRINTF_LOCAL_F, tblg);
425 tpl_printf(vars, TPLADD, "TOTAL_EMMBLOCKEDS_READERS", PRINTF_LOCAL_F, tbls);
426 tpl_printf(vars, TPLADD, "TOTAL_EMMBLOCKEDUQ_READERS", PRINTF_LOCAL_F, tbluq);
427
428 emmsum = teruk + terg + ters + teruq + twruk + twrg + twrs + twruq + tskuk + tskg + tsks + tskuq + tbluk + tblg + tbls + tbluq;
429
430 tpl_printf(vars, TPLADD, "TOTAL_SUM_ALL_READERS_EMM", PRINTF_LOCAL_F, emmsum);
431 }
432
433 static void refresh_oscam(enum refreshtypes refreshtype)
434 {
435
436 switch(refreshtype)
437 {
438 case REFR_ACCOUNTS:
439 cs_log("Refresh Accounts requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
440 cs_accounts_chk();
441 break;
442
443 case REFR_READERS:
444 cs_log("Refresh Readers requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
445 reload_readerdb();
446 break;
447
448 case REFR_CLIENTS:
449 cs_log("Refresh Clients requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
450 cs_reinit_clients(cfg.account);
451 break;
452
453 case REFR_SERVER:
454 cs_log("Refresh Server requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
455 //kill(first_client->pid, SIGHUP);
456 //todo how I can refresh the server after global settings
457 break;
458
459 case REFR_SERVICES:
460 cs_log("Refresh Services requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
461 //init_sidtab();
462 cs_accounts_chk();
463 break;
464
465 #ifdef CS_ANTICASC
466 case REFR_ANTICASC:
467 cs_log("Refresh Anticascading requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
468 ac_init_stat();
469 struct s_client *cl;
470 struct s_auth *account;
471 for(cl = first_client->next; cl ; cl = cl->next)
472 {
473 if(cl->typ == 'c' && (account = cl->account))
474 {
475 cl->ac_limit = (account->ac_users * 100 + 80) * cfg.ac_stime;
476 }
477 }
478 break;
479 #endif
480 default:
481 break;
482 }
483 }
484 /*
485 * load historical values from ringbuffer and return it in the right order
486 * as string. Value should be freed with free_mk_t()
487 */
488 static char *get_ecm_historystring(struct s_client *cl)
489 {
490
491 if(cl)
492 {
493 int32_t k, i, pos = 0, needed = 1, v;
494 char *value, *dot = "";
495 int32_t ptr = cl->cwlastresptimes_last;
496
497 needed = CS_ECM_RINGBUFFER_MAX * 6; //5 digits + delimiter
498 if(!cs_malloc(&value, needed)) { return ""; }
499
500 k = ptr + 1;
501 for(i = 0; i < CS_ECM_RINGBUFFER_MAX; i++)
502 {
503 if(k >= CS_ECM_RINGBUFFER_MAX)
504 { k = 0; }
505 v = cl->cwlastresptimes[k].duration;
506 if(v > 0 && v < (int32_t)cfg.ctimeout * 5)
507 {
508 pos += snprintf(value + pos, needed - pos, "%s%d", dot, v);
509 dot = ",";
510 }
511 k++;
512 }
513 if(cs_strlen(value) == 0)
514 {
515 NULLFREE(value);
516 return "";
517 }
518 else { return value; }
519
520 }
521 else
522 {
523 return "";
524 }
525 }
526
527 static char *get_ecm_fullhistorystring(struct s_client *cl)
528 {
529
530 if(cl)
531 {
532 int32_t k, i, pos = 0, needed = 1, v;
533 char *value, *dot = "";
534 int32_t ptr = cl->cwlastresptimes_last;
535
536 needed = CS_ECM_RINGBUFFER_MAX * 20; //5 digits + : + returncode(2) + : + time(10) + delimiter
537 if(!cs_malloc(&value, needed)) { return ""; }
538
539 k = ptr + 1;
540 for(i = 0; i < CS_ECM_RINGBUFFER_MAX; i++)
541 {
542 if(k >= CS_ECM_RINGBUFFER_MAX)
543 { k = 0; }
544 v = cl->cwlastresptimes[k].duration;
545 if(v > 0 && v < (int32_t)cfg.ctimeout * 5)
546 {
547 pos += snprintf(value + pos, needed - pos, "%s%d:%d:%ld", dot, cl->cwlastresptimes[k].duration, cl->cwlastresptimes[k].rc, cl->cwlastresptimes[k].timestamp);
548 dot = ",";
549 }
550 k++;
551 }
552
553 return (value);
554
555 }
556 else
557 {
558 return "";
559 }
560 }
561
562 /*
563 * Set the active menu to a different CSS class
564 */
565 static void setActiveMenu(struct templatevars *vars, int8_t active)
566 {
567 int8_t i;
568 for(i = 0; i < MNU_TOTAL_ITEMS; i++)
569 {
570 tpl_printf(vars, TPLADD, "TMP", "MENUACTIVE%d", i);
571 if(i == active)
572 { tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "menu_selected"); }
573 else
574 { tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "menu"); }
575 }
576 #ifdef WEBIF_LIVELOG
577 tpl_addVar(vars, TPLADD, "LOGPAGEMENU", tpl_getTpl(vars, "LOGMENU"));
578 #endif
579 }
580
581 /*
582 * Set the active submenu to a different CSS class
583 */
584 static void setActiveSubMenu(struct templatevars *vars, int8_t active)
585 {
586 int8_t i;
587 for(i = 0; i < MNU_CFG_TOTAL_ITEMS; i++)
588 {
589 tpl_printf(vars, TPLADD, "TMP", "CMENUACTIVE%d", i);
590 if(i == active)
591 { tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "configmenu_selected"); }
592 else
593 { tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "configmenu"); }
594 }
595 }
596
597 static void webif_save_config(char *section, struct templatevars *vars, struct uriparams *params)
598 {
599 if(!streq(getParam(params, "action"), "execute"))
600 { return; }
601 if(cfg.http_readonly)
602 {
603 tpl_addMsg(vars, "WebIf is in readonly mode. No changes are possible!");
604 return;
605 }
606 int i;
607 int cnt = (*params).paramcount;
608 for(i = 0; i < cnt; i++)
609 {
610 char *token = (*params).params[i];
611 char *value = (*params).values[i];
612 if(!streq(token, "part") && !streq(token, "action"))
613 { config_set(section, token, value); }
614 }
615 if(write_config() == 0)
616 {
617 tpl_addMsg(vars, "Configuration was saved.");
618 enum refreshtypes ref_type = REFR_SERVER;
619 if(streq(getParam(params, "part"), "anticasc"))
620 { ref_type = REFR_ANTICASC; }
621 refresh_oscam(ref_type);
622 }
623 else
624 {
625 tpl_addMsg(vars, "ERROR: Failed to write config file!!!");
626 }
627 }
628
629 static char *send_oscam_config_global(struct templatevars *vars, struct uriparams *params)
630 {
631 setActiveSubMenu(vars, MNU_CFG_GLOBAL);
632
633 webif_save_config("global", vars, params);
634
635 if(IP_ISSET(cfg.srvip))
636 { tpl_addVar(vars, TPLADD, "SERVERIP", cs_inet_ntoa(cfg.srvip)); }
637 tpl_printf(vars, TPLADD, "NICE", "%d", cfg.nice);
638 tpl_printf(vars, TPLADD, "BINDWAIT", "%d", cfg.bindwait);
639
640 tpl_printf(vars, TPLADD, "TMP", "NETPRIO%d", cfg.netprio);
641 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
642
643 tpl_printf(vars, TPLADD, "PIDFILE", "%s", ESTR(cfg.pidfile));
644
645
646 if(cfg.usrfile != NULL) { tpl_addVar(vars, TPLADD, "USERFILE", cfg.usrfile); }
647 if(cfg.disableuserfile == 0) { tpl_addVar(vars, TPLADD, "DISABLEUSERFILECHECKED", "checked"); }
648 if(cfg.usrfileflag == 1) { tpl_addVar(vars, TPLADD, "USERFILEFLAGCHECKED", "selected"); }
649 if(cfg.mailfile != NULL) { tpl_addVar(vars, TPLADD, "MAILFILE", cfg.mailfile); }
650 if(cfg.disablemail == 0) { tpl_addVar(vars, TPLADD, "DISABLEMAILCHECKED", "checked"); }
651
652 char *value = mk_t_logfile();
653 tpl_addVar(vars, TPLADD, "LOGFILE", value);
654 free_mk_t(value);
655 if(cfg.disablelog == 0) { tpl_addVar(vars, TPLADD, "DISABLELOGCHECKED", "checked"); }
656 tpl_printf(vars, TPLADD, "MAXLOGSIZE", "%d", cfg.max_log_size);
657
658 tpl_addVar(vars, TPLADD, "LOGDUPSCHECKED", (cfg.logduplicatelines == 1) ? "checked" : "");
659 tpl_printf(vars, TPLADD, "INITIALDEBUGLEVEL", "%u", cfg.initial_debuglevel);
660
661 if(cfg.cwlogdir != NULL) { tpl_addVar(vars, TPLADD, "CWLOGDIR", cfg.cwlogdir); }
662 if(cfg.emmlogdir != NULL) { tpl_addVar(vars, TPLADD, "EMMLOGDIR", cfg.emmlogdir); }
663 tpl_addVar(vars, TPLADD, "ECMFMT", cfg.ecmfmt);
664 tpl_printf(vars, TPLADD, "LOGHISTORYLINES", "%u", cfg.loghistorylines);
665 if(cfg.sysloghost != NULL) { tpl_addVar(vars, TPLADD, "SYSLOGHOST", cfg.sysloghost); }
666 tpl_printf(vars, TPLADD, "SYSLOGPORT", "%u", cfg.syslogport);
667
668
669 tpl_printf(vars, TPLADD, "CLIENTTIMEOUT", "%u", cfg.ctimeout);
670 tpl_printf(vars, TPLADD, "FALLBACKTIMEOUT", "%u", cfg.ftimeout);
671 tpl_printf(vars, TPLADD, "CLIENTMAXIDLE", "%u", cfg.cmaxidle);
672
673
674 value = mk_t_caidvaluetab(&cfg.ftimeouttab);
675 tpl_addVar(vars, TPLADD, "FALLBACKTIMEOUT_PERCAID", value);
676 free_mk_t(value);
677
678 tpl_printf(vars, TPLADD, "SLEEP", "%d", cfg.tosleep);
679 tpl_addVar(vars, TPLADD, "UNLOCKPARENTALCHECKED", (cfg.ulparent == 1) ? "checked" : "");
680
681 if(cfg.reload_useraccounts) { tpl_addVar(vars, TPLADD, "RELOADUSERACCOUNTSCHECKED", "checked"); }
682 if(cfg.reload_readers) { tpl_addVar(vars, TPLADD, "RELOADREADERSCHECKED", "checked"); }
683 if(cfg.reload_provid) { tpl_addVar(vars, TPLADD, "RELOADPROVIDCHECKED", "checked"); }
684 if(cfg.reload_services_ids) { tpl_addVar(vars, TPLADD, "RELOADSERVICESIDSCHECKED", "checked"); }
685 if(cfg.reload_tier_ids) { tpl_addVar(vars, TPLADD, "RELOADTIERUDSCHECKED", "checked"); }
686 if(cfg.reload_fakecws) { tpl_addVar(vars, TPLADD, "RELOADFAKECWSCHECKED", "checked"); }
687 if(cfg.reload_ac_stat) { tpl_addVar(vars, TPLADD, "RELOADACSTATCHECKED", "checked"); }
688 if(cfg.reload_log) { tpl_addVar(vars, TPLADD, "RELOADLOGCHECKED", "checked"); }
689
690 if(cfg.block_same_ip) { tpl_addVar(vars, TPLADD, "BLOCKSAMEIPCHECKED", "checked"); }
691 if(cfg.block_same_name) { tpl_addVar(vars, TPLADD, "BLOCKSAMENAMECHECKED", "checked"); }
692
693 if(cfg.waitforcards == 1) { tpl_addVar(vars, TPLADD, "WAITFORCARDSCHECKED", "checked"); }
694 tpl_printf(vars, TPLADD, "EXTRADELAY", "%d", cfg.waitforcards_extra_delay);
695 if(cfg.preferlocalcards == 1)
696 {
697 tpl_addVar(vars, TPLADD, "PREFERCACHEEX", "selected");
698 }
699 else if(cfg.preferlocalcards == 2)
700 {
701 tpl_addVar(vars, TPLADD, "PREFERLOCALCARDS", "selected");
702 }
703
704 if(cfg.c35_suppresscmd08)
705 { tpl_addVar(vars, TPLADD, "SUPPRESSCMD08", "checked"); }
706
707 if(cfg.getblockemmauprovid > 0)
708 {
709 tpl_addVar(vars, TPLADD, "GETBLOCKEMMAUPROVID", "checked");
710 }
711
712 if(cfg.reader_restart_seconds)
713 { tpl_printf(vars, TPLADD, "READERRESTARTSECONDS", "%d", cfg.reader_restart_seconds); }
714
715 tpl_addVar(vars, TPLADD, "DROPDUPSCHECKED", (cfg.dropdups == 1) ? "checked" : "");
716
717 if(cfg.resolve_gethostbyname == 1)
718 { tpl_addVar(vars, TPLADD, "RESOLVER1", "selected"); }
719 else
720 { tpl_addVar(vars, TPLADD, "RESOLVER0", "selected"); }
721
722 tpl_printf(vars, TPLADD, "FAILBANTIME", "%d", cfg.failbantime);
723 tpl_printf(vars, TPLADD, "FAILBANCOUNT", "%d", cfg.failbancount);
724
725 tpl_addVar(vars, TPLADD, "DCHECKCSELECTED", (cfg.double_check == 1) ? "checked" : "");
726
727 value = mk_t_ftab(&cfg.double_check_caid);
728 tpl_addVar(vars, TPLADD, "DOUBLECHECKCAID", value);
729 free_mk_t(value);
730
731 tpl_addVar(vars, TPLADD, "DISABLECRCCWSCHECKEDGLOBAL", (cfg.disablecrccws == 1) ? "checked" : "");
732
733 value = mk_t_ftab(&cfg.disablecrccws_only_for);
734 tpl_addVar(vars, TPLADD, "IGNCHKSUMONLYFORGLOBAL", value);
735 free_mk_t(value);
736
737 #ifdef LEDSUPPORT
738 if(cfg.enableled == 1)
739 { tpl_addVar(vars, TPLADD, "ENABLELEDSELECTED1", "selected"); }
740 else if(cfg.enableled == 2)
741 { tpl_addVar(vars, TPLADD, "ENABLELEDSELECTED2", "selected"); }
742 #endif
743
744 return tpl_getTpl(vars, "CONFIGGLOBAL");
745 }
746
747 #ifdef WITH_LB
748 static char *send_oscam_config_loadbalancer(struct templatevars *vars, struct uriparams *params)
749 {
750 setActiveSubMenu(vars, MNU_CFG_LOADBAL);
751
752 if(cs_strlen(getParam(params, "button")) > 0)
753 {
754 if(cfg.http_readonly)
755 {
756 tpl_addMsg(vars, "WebIf is in readonly mode. No changes are possible!");
757 }
758 else
759 {
760 if(strcmp(getParam(params, "button"), "Load Stats") == 0)
761 {
762 clear_all_stat();
763 load_stat_from_file();
764 tpl_addMsg(vars, "Stats loaded from file");
765 }
766
767 if(strcmp(getParam(params, "button"), "Save Stats") == 0)
768 {
769 save_stat_to_file(1);
770 tpl_addMsg(vars, "Stats saved to file");
771 }
772
773 if(strcmp(getParam(params, "button"), "Clear Stats") == 0)
774 {
775 clear_all_stat();
776 tpl_addMsg(vars, "Stats cleared completly");
777 }
778
779 if(strcmp(getParam(params, "button"), "Clear Timeouts") == 0)
780 {
781 clean_all_stats_by_rc(E_TIMEOUT, 0);
782 tpl_addMsg(vars, "Timeout cleared from Stats");
783 }
784
785 if(strcmp(getParam(params, "button"), "Clear Not Found") == 0)
786 {
787 clean_all_stats_by_rc(E_NOTFOUND, 0);
788 tpl_addMsg(vars, "Not Found cleared from Stats");
789 }
790
791 if(strcmp(getParam(params, "button"), "Clear Invalid") == 0)
792 {
793 clean_all_stats_by_rc(E_INVALID, 0);
794 tpl_addMsg(vars, "Invalid cleared from Stats");
795 }
796 }
797 }
798
799 webif_save_config("global", vars, params);
800
801 tpl_printf(vars, TPLADD, "TMP", "LBMODE%d", cfg.lb_mode);
802 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
803
804 tpl_printf(vars, TPLADD, "LBSAVE", "%d", cfg.lb_save);
805 if(cfg.lb_savepath) { tpl_addVar(vars, TPLADD, "LBSAVEPATH", cfg.lb_savepath); }
806
807 tpl_printf(vars, TPLADD, "LBNBESTREADERS", "%d", cfg.lb_nbest_readers);
808 char *value = mk_t_caidvaluetab(&cfg.lb_nbest_readers_tab);
809 tpl_addVar(vars, TPLADD, "LBNBESTPERCAID", value);
810 free_mk_t(value);
811 tpl_printf(vars, TPLADD, "LBNFBREADERS", "%d", cfg.lb_nfb_readers);
812 tpl_printf(vars, TPLADD, "LBMAXREADERS", "%d", cfg.lb_max_readers);
813 tpl_printf(vars, TPLADD, "LBMINECMCOUNT", "%d", cfg.lb_min_ecmcount);
814 tpl_printf(vars, TPLADD, "LBMAXECEMCOUNT", "%d", cfg.lb_max_ecmcount);
815 tpl_printf(vars, TPLADD, "LBRETRYLIMIT", "%d", cfg.lb_retrylimit);
816
817 value = mk_t_caidvaluetab(&cfg.lb_retrylimittab);
818 tpl_addVar(vars, TPLADD, "LBRETRYLIMITS", value);
819 free_mk_t(value);
820
821 tpl_printf(vars, TPLADD, "LBREOPENSECONDS", "%d", cfg.lb_reopen_seconds);
822 tpl_printf(vars, TPLADD, "LBCLEANUP", "%d", cfg.lb_stat_cleanup);
823
824 tpl_addVar(vars, TPLADD, "LBREOPENINVALID", (cfg.lb_reopen_invalid == 1) ? "checked" : "");
825 tpl_addVar(vars, TPLADD, "LBFORCEALWAYS", (cfg.lb_force_reopen_always == 1) ? "checked" : "");
826
827 value = mk_t_caidtab(&cfg.lb_noproviderforcaid);
828 tpl_addVar(vars, TPLADD, "LBNOPROVIDERFORCAID", value);
829 free_mk_t(value);
830
831 tpl_addVar(vars, TPLADD, "LBAUTOBETATUNNEL", (cfg.lb_auto_betatunnel == 1) ? "checked" : "");
832
833 if(cfg.lb_auto_betatunnel_mode)
834 {
835 tpl_printf(vars, TPLADD, "TMP", "LBAUTOBETATUNNELMODE%d", cfg.lb_auto_betatunnel_mode);
836 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
837 }
838
839 tpl_printf(vars, TPLADD, "LBPREFERBETA", "%d", cfg.lb_auto_betatunnel_prefer_beta);
840
841 tpl_addVar(vars, TPLADD, "LBAUTOTIMEOUT", (cfg.lb_auto_timeout == 1) ? "checked" : "");
842
843 tpl_printf(vars, TPLADD, "LBAUTOTIMEOUTP", "%d", cfg.lb_auto_timeout_p);
844 tpl_printf(vars, TPLADD, "LBAUTOTIMEOUTT", "%d", cfg.lb_auto_timeout_t);
845
846 tpl_addVar(vars, TPLADDONCE, "CONFIG_CONTROL", tpl_getTpl(vars, "CONFIGLOADBALANCERCTRL"));
847
848 return tpl_getTpl(vars, "CONFIGLOADBALANCER");
849 }
850 #endif
851
852 #ifdef MODULE_CAMD33
853 static char *send_oscam_config_camd33(struct templatevars *vars, struct uriparams *params)
854 {
855 int32_t i;
856
857 setActiveSubMenu(vars, MNU_CFG_CAMD33);
858
859 webif_save_config("camd33", vars, params);
860
861 if(cfg.c33_port)
862 {
863 tpl_printf(vars, TPLADD, "PORT", "%d", cfg.c33_port);
864 if(IP_ISSET(cfg.c33_srvip)) { tpl_addVar(vars, TPLADD, "SERVERIP", cs_inet_ntoa(cfg.c33_srvip)); }
865 tpl_addVar(vars, TPLADD, "PASSIVECHECKED", (cfg.c33_passive == 1) ? "checked" : "");
866
867 for(i = 0; i < (int) sizeof(cfg.c33_key); ++i) { tpl_printf(vars, TPLAPPEND, "KEY", "%02X", cfg.c33_key[i]); }
868 char *value = mk_t_iprange(cfg.c33_plain);
869 tpl_addVar(vars, TPLADD, "NOCRYPT", value);
870 free_mk_t(value);
871 }
872
873 return tpl_getTpl(vars, "CONFIGCAMD33");
874 }
875 #endif
876
877 #ifdef MODULE_CAMD35
878 static char *send_oscam_config_camd35(struct templatevars *vars, struct uriparams *params)
879 {
880 setActiveSubMenu(vars, MNU_CFG_CAMD35);
881
882 webif_save_config("cs357x", vars, params);
883
884 if(cfg.c35_port)
885 {
886 tpl_printf(vars, TPLADD, "PORT", "%d", cfg.c35_port);
887 if(IP_ISSET(cfg.c35_srvip))
888 { tpl_addVar(vars, TPLAPPEND, "SERVERIP", cs_inet_ntoa(cfg.c35_srvip)); }
889
890 if(cfg.c35_udp_suppresscmd08)
891 { tpl_addVar(vars, TPLADD, "SUPPRESSCMD08UDP", "checked"); }
892
893 }
894 return tpl_getTpl(vars, "CONFIGCAMD35");
895 }
896 #endif
897
898 #ifdef MODULE_CAMD35_TCP
899 static char *send_oscam_config_camd35tcp(struct templatevars *vars, struct uriparams *params)
900 {
901 setActiveSubMenu(vars, MNU_CFG_CAMD35TCP);
902
903 webif_save_config("cs378x", vars, params);
904
905 if((cfg.c35_tcp_ptab.nports > 0) && (cfg.c35_tcp_ptab.ports[0].s_port > 0))
906 {
907
908 char *value = mk_t_camd35tcp_port();
909 tpl_addVar(vars, TPLADD, "PORT", value);
910 free_mk_t(value);
911
912 if(IP_ISSET(cfg.c35_tcp_srvip))
913 { tpl_addVar(vars, TPLAPPEND, "SERVERIP", cs_inet_ntoa(cfg.c35_tcp_srvip)); }
914
915 if(cfg.c35_tcp_suppresscmd08)
916 { tpl_addVar(vars, TPLADD, "SUPPRESSCMD08TCP", "checked"); }
917 }
918 return tpl_getTpl(vars, "CONFIGCAMD35TCP");
919 }
920 #endif
921
922 static char *send_oscam_config_cache(struct templatevars *vars, struct uriparams *params)
923 {
924 setActiveSubMenu(vars, MNU_CFG_CACHE);
925
926 webif_save_config("cache", vars, params);
927
928 tpl_printf(vars, TPLADD, "CACHEDELAY", "%u", cfg.delay);
929
930 tpl_printf(vars, TPLADD, "MAXCACHETIME", "%d", cfg.max_cache_time);
931
932 #ifdef CS_CACHEEX
933 char *value = NULL;
934
935 #ifdef CS_CACHEEX_AIO
936 value = mk_t_cacheex_cwcheck_valuetab(&cfg.cw_cache_settings);
937 tpl_addVar(vars, TPLADD, "CWCACHESETTINGS", value);
938 free_mk_t(value);
939
940 tpl_printf(vars, TPLADD, "CWCACHESIZE", "%d", cfg.cw_cache_size);
941
942 tpl_printf(vars, TPLADD, "CWCACHEMEMORY", "%d", cfg.cw_cache_memory);
943
944 tpl_printf(vars, TPLADD, "ECMCACHESIZE", "%d", cfg.ecm_cache_size);
945
946 tpl_printf(vars, TPLADD, "ECMCACHEMEMORY", "%d", cfg.ecm_cache_memory);
947
948 tpl_printf(vars, TPLADD, "ECMDROPTIME", "%d", cfg.ecm_cache_droptime);
949 #endif
950
951 value = mk_t_cacheex_valuetab(&cfg.cacheex_wait_timetab);
952 tpl_addVar(vars, TPLADD, "WAIT_TIME", value);
953 free_mk_t(value);
954
955 #ifdef CS_CACHEEX_AIO
956 tpl_printf(vars, TPLADD, "WAITTIME_BLOCK_START", "%d", cfg.waittime_block_start);
957
958 tpl_printf(vars, TPLADD, "WAITTIME_BLOCK_TIME", "%d", cfg.waittime_block_time);
959 #endif
960
961 value = mk_t_caidvaluetab(&cfg.cacheex_mode1_delay_tab);
962 tpl_addVar(vars, TPLADD, "CACHEEXMODE1DELAY", value);
963 free_mk_t(value);
964
965 #ifdef CS_CACHEEX_AIO
966 value = mk_t_caidvaluetab(&cfg.cacheex_nopushafter_tab);
967 tpl_addVar(vars, TPLADD, "CACHEEXNOPUSHAFTER", value);
968 free_mk_t(value);
969 #endif
970
971 tpl_printf(vars, TPLADD, "MAX_HIT_TIME", "%d", cfg.max_hitcache_time);
972
973 tpl_addVar(vars, TPLADD, "CACHEEXSTATSSELECTED", (cfg.cacheex_enable_stats == 1) ? "checked" : "");
974
975 tpl_addVar(vars, TPLADD, "WTTCHECKED", (cfg.wait_until_ctimeout == 1) ? "checked" : "");
976
977 #ifdef CS_CACHEEX_AIO
978 tpl_addVar(vars, TPLADD, "CACHEEXDROPDIFFS", (cfg.cacheex_dropdiffs == 1) ? "checked" : "");
979
980 value = mk_t_group(cfg.cacheex_push_lg_groups);
981 tpl_addVar(vars, TPLADD, "CACHEEXPUSHLGGRPS", value);
982 free_mk_t(value);
983
984 tpl_addVar(vars, TPLADD, "LGONLYREMOTESETTINGSCHECKED", (cfg.cacheex_lg_only_remote_settings == 1) ? "checked" : "");
985
986 tpl_addVar(vars, TPLADD, "LOCALGENERATEDONLYCHECKED", (cfg.cacheex_localgenerated_only == 1) ? "checked" : "");
987
988 value = mk_t_ftab(&cfg.cacheex_lg_only_tab);
989 tpl_addVar(vars, TPLADD, "LGONLYTAB", value);
990 free_mk_t(value);
991
992 tpl_addVar(vars, TPLADD, "LOCALGENERATEDONLYINCHECKED", (cfg.cacheex_localgenerated_only_in == 1) ? "checked" : "");
993
994 tpl_addVar(vars, TPLADD, "LGONLYINAIOONLYCHECKED", (cfg.cacheex_lg_only_in_aio_only == 1) ? "checked" : "");
995
996 value = mk_t_ftab(&cfg.cacheex_lg_only_in_tab);
997 tpl_addVar(vars, TPLADD, "LGONLYINTAB", value);
998 free_mk_t(value);
999
1000 value = mk_t_cacheex_hitvaluetab(&cfg.cacheex_filter_caidtab);
1001 tpl_addVar(vars, TPLADD, "CACHEEXECMFILTER", value);
1002 free_mk_t(value);
1003
1004 value = mk_t_cacheex_hitvaluetab(&cfg.cacheex_filter_caidtab_aio);
1005 tpl_addVar(vars, TPLADD, "CACHEEXECMFILTERAIO", value);
1006 free_mk_t(value);
1007 #endif
1008
1009 if(cfg.csp_port)
1010 { tpl_printf(vars, TPLADD, "PORT", "%d", cfg.csp_port); }
1011
1012 if(IP_ISSET(cfg.csp_srvip))
1013 { tpl_addVar(vars, TPLAPPEND, "SERVERIP", cs_inet_ntoa(cfg.csp_srvip)); }
1014
1015 value = mk_t_cacheex_hitvaluetab(&cfg.csp.filter_caidtab);
1016 tpl_addVar(vars, TPLADD, "CSP_ECM_FILTER", value);
1017 free_mk_t(value);
1018
1019 value = mk_t_cacheex_cwcheck_valuetab(&cfg.cacheex_cwcheck_tab);
1020 tpl_addVar(vars, TPLADD, "CACHEEXCWCHECK", value);
1021 free_mk_t(value);
1022
1023 tpl_addVar(vars, TPLADD, "ARCHECKED", (cfg.csp.allow_request == 1) ? "checked" : "");
1024 tpl_addVar(vars, TPLADD, "ARFCHECKED", (cfg.csp.allow_reforward == 1) ? "checked" : "");
1025 tpl_addVar(vars, TPLADD, "BLOCKFAKECWSCHECKED", (cfg.csp.block_fakecws == 1) ? "checked" : "");
1026 #endif
1027
1028 #ifdef CW_CYCLE_CHECK
1029 #ifndef CS_CACHEEX
1030 char *value = NULL;
1031 #endif
1032
1033 tpl_addVar(vars, TPLADD, "CWCYCLECHECK", (cfg.cwcycle_check_enable == 1) ? "checked" : "");
1034
1035 value = mk_t_caidtab(&cfg.cwcycle_check_caidtab);
1036 tpl_addVar(vars, TPLADD, "CWCYCLECHECKCAID", value);
1037 free_mk_t(value);
1038
1039 tpl_printf(vars, TPLADD, "MAXCYCLELIST", "%d", cfg.maxcyclelist);
1040 tpl_printf(vars, TPLADD, "KEEPCYCLETIME", "%d", cfg.keepcycletime);
1041
1042 if(cfg.onbadcycle)
1043 {
1044 tpl_printf(vars, TPLADD, "TMP", "ONBADCYCLE%d", cfg.onbadcycle);
1045 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1046 }
1047
1048 tpl_addVar(vars, TPLADD, "DROPOLD", (cfg.cwcycle_dropold == 1) ? "checked" : "");
1049
1050 if(cfg.cwcycle_sensitive)
1051 {
1052 tpl_printf(vars, TPLADD, "TMP", "CWCSEN%d", cfg.cwcycle_sensitive);
1053 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1054 }
1055
1056 tpl_addVar(vars, TPLADD, "ALLOWBADFROMFFB", (cfg.cwcycle_allowbadfromffb == 1) ? "checked" : "");
1057
1058 tpl_addVar(vars, TPLADD, "USECWCFROMCE", (cfg.cwcycle_usecwcfromce == 1) ? "checked" : "");
1059
1060
1061 #endif
1062
1063 #ifdef CS_CACHEEX_AIO
1064 return tpl_getTpl(vars, "CONFIGCACHEAIO");
1065 #else
1066 return tpl_getTpl(vars, "CONFIGCACHE");
1067 #endif
1068 }
1069
1070 #ifdef MODULE_NEWCAMD
1071 static char *send_oscam_config_newcamd(struct templatevars *vars, struct uriparams *params)
1072 {
1073 int32_t i;
1074
1075 setActiveSubMenu(vars, MNU_CFG_NEWCAMD);
1076
1077 webif_save_config("newcamd", vars, params);
1078
1079 if((cfg.ncd_ptab.nports > 0) && (cfg.ncd_ptab.ports[0].s_port > 0))
1080 {
1081
1082 char *value = mk_t_newcamd_port();
1083 tpl_addVar(vars, TPLADD, "PORT", value);
1084 free_mk_t(value);
1085
1086 if(IP_ISSET(cfg.ncd_srvip))
1087 { tpl_addVar(vars, TPLADD, "SERVERIP", cs_inet_ntoa(cfg.ncd_srvip)); }
1088
1089 for(i = 0; i < (int32_t)sizeof(cfg.ncd_key); i++)
1090 { tpl_printf(vars, TPLAPPEND, "KEY", "%02X", cfg.ncd_key[i]); }
1091
1092 value = mk_t_iprange(cfg.ncd_allowed);
1093 tpl_addVar(vars, TPLADD, "ALLOWED", value);
1094 free_mk_t(value);
1095
1096 if(cfg.ncd_keepalive)
1097 { tpl_addVar(vars, TPLADD, "KEEPALIVE", "checked"); }
1098 if(cfg.ncd_mgclient)
1099 { tpl_addVar(vars, TPLADD, "MGCLIENTCHK", "checked"); }
1100 }
1101 return tpl_getTpl(vars, "CONFIGNEWCAMD");
1102 }
1103 #endif
1104
1105 #ifdef MODULE_GBOX
1106 static char *send_oscam_config_gbox(struct templatevars *vars, struct uriparams *params)
1107 {
1108 uint8_t i=0;
1109 char local_gbox_save_gsms[2],local_gbox_msg_type[3], local_gbox_dest_peers[GBOX_MAX_DEST_PEERS*5], tmp_gbox_dest_peers[GBOX_MAX_DEST_PEERS*5] ;
1110 int n=0, len_gbox_save_gsms=0, len_gbox_msg_type=0, len_gbox_dest_peers=0, len_gbox_msg_txt=0;
1111 char *ptr1, *saveptr1, *isbroadcast = NULL;
1112 const char *s;
1113 uint16_t gbox_dest_peers_tmp;
1114
1115 setActiveSubMenu(vars, MNU_CFG_GBOX);
1116 webif_save_config("gbox", vars, params);
1117 /*
1118 * Action when GetOnlinePeers is pressed
1119 */
1120 if(streq(getParam(params, "action"), "Online peers"))
1121 {
1122 gbox_get_online_peers();
1123 // init var
1124 len_gbox_save_gsms=cs_strlen(getParam(params, "gbox_msg_type"));
1125 len_gbox_msg_type=cs_strlen(getParam(params, "gbox_msg_type"));
1126 len_gbox_msg_txt=cs_strlen(getParam(params, "gbox_msg_txt"));
1127 if(len_gbox_msg_txt>GBOX_MAX_MSG_TXT) { len_gbox_msg_txt=GBOX_MAX_MSG_TXT; }
1128 // retrieve value from Webif
1129 cs_strncpy(local_gbox_save_gsms, getParam(params, "gbox_save_gsms"), len_gbox_save_gsms+1);
1130 cfg.gbox_save_gsms=atoi(local_gbox_save_gsms);
1131 cs_strncpy(local_gbox_msg_type, getParam(params, "gbox_msg_type"), len_gbox_msg_type+1);
1132 cfg.gbox_msg_type=atoi(local_gbox_msg_type);
1133 cs_strncpy(cfg.gbox_msg_txt,getParam(params, "gbox_msg_txt"), len_gbox_msg_txt+1);
1134 }
1135 /*
1136 * Action when ResetGSMS button is pressed
1137 */
1138 if(streq(getParam(params, "action"), "resetallgsms"))
1139 {
1140 cfg.gbox_save_gsms = 0;
1141 cfg.gbox_msg_type = 0;
1142 for(i = 0; i < GBOX_MAX_DEST_PEERS; i++)
1143 {
1144 cfg.gbox_dest_peers[i]='\0';
1145 }
1146 cfg.gbox_dest_peers_num=0;
1147 for(i = 0; i < GBOX_MAX_MSG_TXT; i++)
1148 {
1149 cfg.gbox_msg_txt[i]='\0';
1150 }
1151 tpl_addMsg(vars, "GBOX: Reset GSMS datas done!");
1152 }
1153 /*
1154 * Action when Send GSMS is pressed
1155 */
1156 if(streq(getParam(params, "action"), "Send GSMS"))
1157 {
1158 // init var
1159 len_gbox_msg_type=cs_strlen(getParam(params, "gbox_msg_type"));
1160 len_gbox_dest_peers=cs_strlen(trim(getParam(params, "gbox_dest_peers")));
1161 len_gbox_msg_txt=cs_strlen(getParam(params, "gbox_msg_txt"));
1162 if(len_gbox_msg_txt>GBOX_MAX_MSG_TXT) { len_gbox_msg_txt=GBOX_MAX_MSG_TXT; }
1163 // retrieve value from Webif
1164 cs_strncpy(local_gbox_msg_type, getParam(params, "gbox_msg_type"), len_gbox_msg_type+1);
1165 cfg.gbox_msg_type=atoi(local_gbox_msg_type);
1166 cs_strncpy(local_gbox_dest_peers, strtoupper(trim(getParam(params, "gbox_dest_peers"))), len_gbox_dest_peers+1);
1167 cs_strncpy(tmp_gbox_dest_peers, strtoupper(trim(getParam(params, "gbox_dest_peers"))), len_gbox_dest_peers+1);
1168 cs_strncpy(cfg.gbox_msg_txt,getParam(params, "gbox_msg_txt"), len_gbox_msg_txt+1);
1169 n=0;
1170 for (ptr1 = strtok_r(tmp_gbox_dest_peers, ",", &saveptr1); (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
1171 {
1172 s=trim(ptr1);
1173 if ((n < GBOX_MAX_DEST_PEERS) && (s[strspn(s, "0123456789abcdefABCDEF")] == 0))
1174 { cfg.gbox_dest_peers[n++] = a2i(trim(ptr1), cs_strlen(trim(ptr1))); }
1175 }
1176 cfg.gbox_dest_peers_num = n;
1177 /*
1178 Start sending GBox SMS
1179 */
1180 if((cs_strlen(cfg.gbox_msg_txt) > 5))
1181 {
1182 isbroadcast=strstr(local_gbox_dest_peers, "FFFF");
1183 if(isbroadcast == NULL)
1184 {
1185 n =0;
1186 for (i = 0, ptr1 = strtok_r(local_gbox_dest_peers, ",", &saveptr1); (i < 4) && (ptr1); ptr1 = strtok_r(NULL, ",", &saveptr1))
1187 {
1188 s=ptr1;
1189 if ((n < GBOX_MAX_DEST_PEERS) && (s[strspn(s, "0123456789abcdefABCDEF")] == 0))
1190 {
1191 gbox_dest_peers_tmp = a2i(ptr1, 4);
1192 if(gbox_direct_send_gsms(gbox_dest_peers_tmp, cfg.gbox_msg_type, cfg.gbox_msg_txt)) { cs_log("GBOX message sent to[%04X] type[%d] text[%s] ", gbox_dest_peers_tmp, cfg.gbox_msg_type, cfg.gbox_msg_txt);}
1193 n++;
1194 }
1195 }
1196 tpl_addMsg(vars, "GBOX Send SMS: individual messages started.");
1197 }
1198 else
1199 {
1200 if(gbox_direct_send_gsms(0xFFFF, cfg.gbox_msg_type, cfg.gbox_msg_txt)) { cs_log("GBOX broadcast message sent type[%d] text[%s] ", cfg.gbox_msg_type, cfg.gbox_msg_txt);}
1201 tpl_addMsg(vars, "GBOX Send SMS: broadcast started.");
1202 }
1203 }
1204 else
1205 {
1206 cs_log("GBox SMS: destination peers or message text not specified or too short");
1207 tpl_addMsg(vars, "GBOX: Send SMS failed - error in input fields: dest peers or text message.");
1208 }
1209 }
1210
1211 tpl_addVar(vars, TPLADD, "HOSTNAME", xml_encode(vars, cfg.gbox_hostname));
1212 char *value0 = mk_t_gbox_port();
1213 tpl_addVar(vars, TPLAPPEND, "PORT", value0);
1214 free_mk_t(value0);
1215 tpl_printf(vars, TPLADD, "MYGBOXPASSWORD", "%08X", cfg.gbox_password);
1216 tpl_printf(vars, TPLADD, "MYGBOXID", "%04X", gbox_get_local_gbox_id());
1217 tpl_printf(vars, TPLADD, "GBOXRECONNECT", "%d", cfg.gbox_reconnect);
1218 tpl_printf(vars, TPLADD, "GBOXMYVERS", "%02X", cfg.gbox_my_vers);
1219 tpl_printf(vars, TPLAPPEND, "GBOXMYCPUAPI", "%02X", cfg.gbox_my_cpu_api);
1220 #ifdef MODULE_CCCAM
1221 if(cfg.cc_gbx_reshare_en == 1) { tpl_addVar(vars, TPLADD, "GBOXCCCRESHARE", "checked"); }
1222 tpl_addVar(vars, TPLAPPEND, "CCCDEPENDINGCONFIG", tpl_getTpl(vars, "CCCAMRESHAREBIT"));
1223 #endif
1224 if(cfg.log_hello == 1) { tpl_addVar(vars, TPLADD, "GBOXLOGHELLO", "checked"); }
1225 if(cfg.gsms_dis == 1) { tpl_addVar(vars, TPLADD, "GBOXGSMSDISABLE", "checked"); }
1226 if(cfg.dis_attack_txt == 1) { tpl_addVar(vars, TPLADD, "GBOXDISATTACKTXT", "checked"); }
1227 if(cfg.gbox_tmp_dir != NULL) { tpl_addVar(vars, TPLADD, "GBOXTMPDIR", cfg.gbox_tmp_dir); }
1228 char *value1 = mk_t_gbox_proxy_card();
1229 tpl_addVar(vars, TPLAPPEND, "GBOXPROXYCARD", value1);
1230 free_mk_t(value1);
1231 char *value2 = mk_t_gbox_ignored_peer();
1232 tpl_addVar(vars, TPLAPPEND, "GBOXIGNOREDPEER", value2);
1233 free_mk_t(value2);
1234 char *value3 = mk_t_gbox_block_ecm();
1235 tpl_addVar(vars, TPLAPPEND, "GBOXBLOCKECM", value3);
1236 free_mk_t(value3);
1237 char *value4 = mk_t_accept_remm_peer();
1238 tpl_addVar(vars, TPLAPPEND, "GBOXACCEPTREMM", value4);
1239 free_mk_t(value4);
1240 /*
1241 * GBOX SMS
1242 */
1243 tpl_addVar(vars, TPLADD, "GBOXSAVEGSMS", (cfg.gbox_save_gsms == 1) ? "checked" : "");
1244 if(cfg.gbox_msg_type == 0)
1245 {
1246 tpl_addVar(vars, TPLADD, "GBOXMSGTYPENORMAL", "selected");
1247 }
1248 else if(cfg.gbox_msg_type == 1)
1249 {
1250 tpl_addVar(vars, TPLADD, "GBOXMSGTYPEOSD", "selected");
1251 }
1252 char *gmsg_dest_peers = mk_t_gbox_dest_peers();
1253 tpl_addVar(vars, TPLADD, "GBOXMSGDESTPEERS", gmsg_dest_peers);
1254 free_mk_t(gmsg_dest_peers);
1255 tpl_addVar(vars, TPLADD, "GBOXMSGTXT", cfg.gbox_msg_txt);
1256
1257 return tpl_getTpl(vars, "CONFIGGBOX");
1258 }
1259 #endif
1260
1261 #ifdef MODULE_RADEGAST
1262 static char *send_oscam_config_radegast(struct templatevars *vars, struct uriparams *params)
1263 {
1264 setActiveSubMenu(vars, MNU_CFG_RADEGAST);
1265
1266 webif_save_config("radegast", vars, params);
1267
1268 tpl_printf(vars, TPLADD, "PORT", "%d", cfg.rad_port);
1269 if(IP_ISSET(cfg.rad_srvip))
1270 { tpl_addVar(vars, TPLADD, "SERVERIP", cs_inet_ntoa(cfg.rad_srvip)); }
1271 tpl_addVar(vars, TPLADD, "USERNAME", xml_encode(vars, cfg.rad_usr));
1272
1273 char *value = mk_t_iprange(cfg.rad_allowed);
1274 tpl_addVar(vars, TPLADD, "ALLOWED", value);
1275 free_mk_t(value);
1276
1277 return tpl_getTpl(vars, "CONFIGRADEGAST");
1278 }
1279 #endif
1280
1281 #ifdef MODULE_SCAM
1282 static char *send_oscam_config_scam(struct templatevars *vars, struct uriparams *params)
1283 {
1284 setActiveSubMenu(vars, MNU_CFG_SCAM);
1285
1286 webif_save_config("scam", vars, params);
1287
1288 tpl_printf(vars, TPLADD, "PORT", "%d", cfg.scam_port);
1289 if(IP_ISSET(cfg.scam_srvip))
1290 { tpl_addVar(vars, TPLADD, "SERVERIP", cs_inet_ntoa(cfg.scam_srvip)); }
1291
1292 char *value = mk_t_iprange(cfg.scam_allowed);
1293 tpl_addVar(vars, TPLADD, "ALLOWED", value);
1294 free_mk_t(value);
1295
1296 return tpl_getTpl(vars, "CONFIGSCAM");
1297 }
1298 #endif
1299
1300 #ifdef MODULE_STREAMRELAY
1301 static char *send_oscam_config_streamrelay(struct templatevars *vars, struct uriparams *params)
1302 {
1303 char *value;
1304
1305 setActiveSubMenu(vars, MNU_CFG_STREAMRELAY);
1306
1307 webif_save_config("streamrelay", vars, params);
1308
1309 tpl_printf(vars, TPLADD, "STREAM_SOURCE_HOST", "%s", cfg.stream_source_host);
1310 tpl_printf(vars, TPLADD, "STREAM_SOURCE_PORT", "%d", cfg.stream_source_port);
1311 if(cfg.stream_source_auth_user)
1312 { tpl_printf(vars, TPLADD, "STREAM_SOURCE_AUTH_USER", "%s", cfg.stream_source_auth_user); }
1313 if(cfg.stream_source_auth_password)
1314 { tpl_printf(vars, TPLADD, "STREAM_SOURCE_AUTH_PASSWORD", "%s", cfg.stream_source_auth_password); }
1315 #ifdef MODULE_RADEGAST
1316 tpl_addVar(vars, TPLADD, "STREAM_CLIENT_SOURCE_HOST", (cfg.stream_client_source_host == 1) ? "checked" : "");
1317 #endif
1318 tpl_printf(vars, TPLADD, "STREAM_RELAY_PORT", "%d", cfg.stream_relay_port);
1319 tpl_printf(vars, TPLADD, "STREAM_RELAY_BUFFER_TIME", "%d", cfg.stream_relay_buffer_time);
1320
1321 tpl_printf(vars, TPLADD, "TMP", "STREAMRELAYENABLEDSELECTED%d", cfg.stream_relay_enabled);
1322 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1323
1324 value = mk_t_caidtab(&cfg.stream_relay_ctab);
1325 tpl_addVar(vars, TPLADD, "STREAM_RELAY_CTAB", value);
1326 free_mk_t(value);
1327
1328 return tpl_getTpl(vars, "CONFIGSTREAMRELAY");
1329 }
1330 #endif
1331
1332 #ifdef MODULE_CCCAM
1333 static char *send_oscam_config_cccam(struct templatevars *vars, struct uriparams *params)
1334 {
1335
1336 setActiveSubMenu(vars, MNU_CFG_CCCAM);
1337
1338 if(strcmp(getParam(params, "button"), "Refresh list") == 0)
1339 {
1340 cs_log_dbg(D_TRACE, "Entitlements: Refresh Shares start");
1341 #ifdef MODULE_CCCSHARE
1342 refresh_shares();
1343 #endif
1344 cs_log_dbg(D_TRACE, "Entitlements: Refresh Shares finished");
1345 tpl_addMsg(vars, "Refresh Shares started");
1346 }
1347
1348 webif_save_config("cccam", vars, params);
1349
1350 if(streq(getParam(params, "action"), "execute") && !cfg.http_readonly)
1351 { cc_update_nodeid(); }
1352
1353 char *value = mk_t_cccam_port();
1354 tpl_addVar(vars, TPLAPPEND, "PORT", value);
1355 free_mk_t(value);
1356
1357 if(IP_ISSET(cfg.cc_srvip))
1358 { tpl_addVar(vars, TPLADD, "SERVERIP", cs_inet_ntoa(cfg.cc_srvip)); }
1359
1360 tpl_printf(vars, TPLADD, "RESHARE", "%d", cfg.cc_reshare);
1361
1362 if(!strcmp((char *)cfg.cc_version, "2.0.11"))
1363 {
1364 tpl_addVar(vars, TPLADD, "VERSIONSELECTED0", "selected");
1365 }
1366 else if(!strcmp((char *)cfg.cc_version, "2.1.1"))
1367 {
1368 tpl_addVar(vars, TPLADD, "VERSIONSELECTED1", "selected");
1369 }
1370 else if(!strcmp((char *)cfg.cc_version, "2.1.2"))
1371 {
1372 tpl_addVar(vars, TPLADD, "VERSIONSELECTED2", "selected");
1373 }
1374 else if(!strcmp((char *)cfg.cc_version, "2.1.3"))
1375 {
1376 tpl_addVar(vars, TPLADD, "VERSIONSELECTED3", "selected");
1377 }
1378 else if(!strcmp((char *)cfg.cc_version, "2.1.4"))
1379 {
1380 tpl_addVar(vars, TPLADD, "VERSIONSELECTED4", "selected");
1381 }
1382 else if(!strcmp((char *)cfg.cc_version, "2.2.0"))
1383 {
1384 tpl_addVar(vars, TPLADD, "VERSIONSELECTED5", "selected");
1385 }
1386 else if(!strcmp((char *)cfg.cc_version, "2.2.1"))
1387 {
1388 tpl_addVar(vars, TPLADD, "VERSIONSELECTED6", "selected");
1389 }
1390 else if(!strcmp((char *)cfg.cc_version, "2.3.0"))
1391 {
1392 tpl_addVar(vars, TPLADD, "VERSIONSELECTED7", "selected");
1393 }
1394 else if(!strcmp((char *)cfg.cc_version, "2.3.1"))
1395 {
1396 tpl_addVar(vars, TPLADD, "VERSIONSELECTED8", "selected");
1397 }
1398 else if(!strcmp((char *)cfg.cc_version, "2.3.2"))
1399 {
1400 tpl_addVar(vars, TPLADD, "VERSIONSELECTED9", "selected");
1401 }
1402
1403 tpl_printf(vars, TPLADD, "UPDATEINTERVAL", "%d", cfg.cc_update_interval);
1404 tpl_printf(vars, TPLADD, "RECV_TIMEOUT", "%u", cfg.cc_recv_timeout);
1405
1406 tpl_addVar(vars, TPLADD, "STEALTH", (cfg.cc_stealth == 1) ? "checked" : "");
1407
1408 tpl_printf(vars, TPLADD, "NODEID", "%02X%02X%02X%02X%02X%02X%02X%02X",
1409 cfg.cc_fixed_nodeid[0], cfg.cc_fixed_nodeid[1], cfg.cc_fixed_nodeid[2], cfg.cc_fixed_nodeid[3],
1410 cfg.cc_fixed_nodeid[4], cfg.cc_fixed_nodeid[5], cfg.cc_fixed_nodeid[6], cfg.cc_fixed_nodeid[7]);
1411
1412 tpl_printf(vars, TPLADD, "TMP", "MINIMIZECARDSELECTED%d", cfg.cc_minimize_cards);
1413 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1414
1415 tpl_printf(vars, TPLADD, "TMP", "RESHAREMODE%d", cfg.cc_reshare_services);
1416 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1417
1418 tpl_printf(vars, TPLADD, "TMP", "IGNRSHRSELECTED%d", cfg.cc_ignore_reshare);
1419 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1420
1421 tpl_addVar(vars, TPLADD, "FORWARDORIGINCARD", (cfg.cc_forward_origin_card == 1) ? "checked" : "");
1422
1423 tpl_addVar(vars, TPLADD, "KEEPCONNECTED", (cfg.cc_keep_connected == 1) ? "checked" : "");
1424
1425 tpl_addVar(vars, TPLADDONCE, "CONFIG_CONTROL", tpl_getTpl(vars, "CONFIGCCCAMCTRL"));
1426
1427 return tpl_getTpl(vars, "CONFIGCCCAM");
1428 }
1429 #endif
1430
1431 static bool is_ext(const char *path, const char *ext)
1432 {
1433 size_t lenpath = cs_strlen(path);
1434 size_t lenext = cs_strlen(ext);
1435 if(lenext > lenpath)
1436 { return 0; }
1437 return memcmp(path + lenpath - lenext, ext, lenext) == 0;
1438 }
1439
1440 static char *send_oscam_config_webif(struct templatevars *vars, struct uriparams *params)
1441 {
1442 int32_t i;
1443
1444 setActiveSubMenu(vars, MNU_CFG_WEBIF);
1445
1446 webif_save_config("webif", vars, params);
1447
1448 tpl_printf(vars, TPLADD, "HTTPPORT", "%s%d", cfg.http_use_ssl ? "+" : "", cfg.http_port);
1449 if(IP_ISSET(cfg.http_srvip))
1450 { tpl_addVar(vars, TPLAPPEND, "SERVERIP", cs_inet_ntoa(cfg.http_srvip)); }
1451
1452 tpl_addVar(vars, TPLADD, "HTTPUSER", cfg.http_user);
1453 tpl_addVar(vars, TPLADD, "HTTPPASSWORD", cfg.http_pwd);
1454 tpl_addVar(vars, TPLADD, "HTTPOSCAMLABEL", cfg.http_oscam_label);
1455
1456 // css style selector
1457 tpl_printf(vars, TPLADD, "CSSOPTIONS", "\t\t\t\t\t\t<option value=\"\"%s>embedded</option>\n",
1458 !cfg.http_css ? " selected" : "");
1459
1460 if(cfg.http_tpl)
1461 {
1462 char path[255];
1463 tpl_getFilePathInSubdir(cfg.http_tpl, "", "style", ".css", path, 255);
1464 if(file_exists(path))
1465 tpl_printf(vars, TPLAPPEND, "CSSOPTIONS", "\t\t\t\t\t\t<option value=\"%s\"%s>%s (template)</option>\n",
1466 path,
1467 cfg.http_css && strstr(cfg.http_css, path) ? " selected" : "",
1468 path);
1469 }
1470
1471 struct dirent **namelist;
1472 int count;
1473 count = scandir(cs_confdir, &namelist, 0, alphasort );
1474
1475 if( count >= 0 )
1476 {
1477 for( i = 0 ; i < count; i++ )
1478 {
1479 if(is_ext(namelist[i]->d_name, ".css"))
1480 {
1481 tpl_printf(vars, TPLAPPEND, "CSSOPTIONS", "\t\t\t\t\t\t<option value=\"%s%s\"%s>%s%s</option>\n",
1482 cs_confdir,
1483 namelist[i]->d_name,
1484 cfg.http_css && strstr(cfg.http_css, namelist[i]->d_name) ? " selected" : "",
1485 cs_confdir, namelist[i]->d_name);
1486 }
1487 free( namelist[i] );
1488 }
1489 free(namelist);
1490 }
1491
1492 if(cfg.http_prepend_embedded_css)
1493 { tpl_addVar(vars, TPLADD, "HTTPPREPENDEMBEDDEDCSS", "checked"); }
1494
1495 tpl_addVar(vars, TPLADD, "HTTPHELPLANG", cfg.http_help_lang);
1496 tpl_addVar(vars, TPLADD, "HTTPLOCALE", cfg.http_locale);
1497 tpl_printf(vars, TPLADD, "HTTPEMMUCLEAN", "%d", cfg.http_emmu_clean);
1498 tpl_printf(vars, TPLADD, "HTTPEMMSCLEAN", "%d", cfg.http_emms_clean);
1499 tpl_printf(vars, TPLADD, "HTTPEMMGCLEAN", "%d", cfg.http_emmg_clean);
1500 tpl_printf(vars, TPLADD, "HTTPREFRESH", "%d", cfg.http_refresh);
1501 tpl_printf(vars, TPLADD, "HTTPPOLLREFRESH", "%d", cfg.poll_refresh);
1502 tpl_addVar(vars, TPLADD, "HTTPTPL", cfg.http_tpl);
1503 tpl_addVar(vars, TPLADD, "HTTPPICONPATH", cfg.http_piconpath);
1504 tpl_addVar(vars, TPLADD, "HTTPSCRIPT", cfg.http_script);
1505 tpl_addVar(vars, TPLADD, "HTTPJSCRIPT", cfg.http_jscript);
1506 #ifndef WEBIF_JQUERY
1507 tpl_addVar(vars, TPLADD, "HTTPEXTERNJQUERY", cfg.http_extern_jquery);
1508 #endif
1509 tpl_printf(vars, TPLADD, "HTTPPICONSIZE", "%d", cfg.http_picon_size);
1510
1511 if(cfg.http_hide_idle_clients > 0) { tpl_addVar(vars, TPLADD, "CHECKED", "checked"); }
1512 tpl_addVar(vars, TPLADD, "HTTPHIDETYPE", cfg.http_hide_type);
1513 if(cfg.http_status_log > 0) { tpl_addVar(vars, TPLADD, "SHOWLOGCHECKED", "checked"); }
1514 if(cfg.http_showpicons > 0) { tpl_addVar(vars, TPLADD, "SHOWPICONSCHECKED", "checked"); }
1515 if(cfg.http_showmeminfo > 0) { tpl_addVar(vars, TPLADD, "SHOWMEMINFOCHECKED", "checked"); }
1516 if(cfg.http_showuserinfo > 0) { tpl_addVar(vars, TPLADD, "SHOWUSERINFOCHECKED", "checked"); }
1517 if(cfg.http_showreaderinfo > 0) { tpl_addVar(vars, TPLADD, "SHOWREADERINFOCHECKED", "checked"); }
1518 if(cfg.http_showcacheexinfo > 0) { tpl_addVar(vars, TPLADD, "SHOWCACHEEXINFOCHECKED", "checked"); }
1519 if(cfg.http_showloadinfo > 0) { tpl_addVar(vars, TPLADD, "SHOWLOADINFOCHECKED", "checked"); }
1520 if(cfg.http_showecminfo > 0) { tpl_addVar(vars, TPLADD, "SHOWECMINFOCHECKED", "checked"); }
1521
1522 char *value = mk_t_iprange(cfg.http_allowed);
1523 tpl_addVar(vars, TPLADD, "HTTPALLOW", value);
1524 free_mk_t(value);
1525
1526 for(i = 0; i < MAX_HTTP_DYNDNS; i++)
1527 {
1528 if(cfg.http_dyndns[i][0])
1529 {
1530 tpl_addVar(vars, TPLAPPEND, "HTTPDYNDNS", i > 0 ? "," : "");
1531 tpl_addVar(vars, TPLAPPEND, "HTTPDYNDNS", (char *)cfg.http_dyndns[i]);
1532 }
1533 }
1534
1535 tpl_addVar(vars, TPLADD, "HTTPSAVEFULLSELECT", (cfg.http_full_cfg == 1) ? "checked" : "");
1536 tpl_addVar(vars, TPLADD, "HTTPOVERWRITEBAKFILE", (cfg.http_overwrite_bak_file == 1) ? "checked" : "");
1537 tpl_addVar(vars, TPLADD, "HTTPREADONLY", (cfg.http_readonly == 1) ? "checked" : "");
1538
1539
1540 #ifdef WITH_SSL
1541 if(cfg.http_cert != NULL) { tpl_addVar(vars, TPLADD, "HTTPCERT", cfg.http_cert); }
1542 tpl_addVar(vars, TPLADD, "HTTPFORCESECUREMODESELECT", (cfg.https_force_secure_mode == 1) ? "checked" : "");
1543 #endif
1544
1545 #ifndef WEBIF_JQUERY
1546 tpl_addVar(vars, TPLADDONCE, "CONFIGWEBIFJQUERY", tpl_getTpl(vars, "CONFIGWEBIFJQUERYBIT"));
1547 #endif
1548
1549 tpl_printf(vars, TPLADD, "AULOW", "%d", cfg.aulow);
1550 tpl_printf(vars, TPLADD, "HIDECLIENTTO", "%d", cfg.hideclient_to);
1551
1552 return tpl_getTpl(vars, "CONFIGWEBIF");
1553 }
1554
1555 #ifdef LCDSUPPORT
1556 static char *send_oscam_config_lcd(struct templatevars *vars, struct uriparams *params)
1557 {
1558 setActiveSubMenu(vars, MNU_CFG_LCD);
1559
1560 webif_save_config("lcd", vars, params);
1561
1562 tpl_addVar(vars, TPLADD, "ENABLELCDSELECTED", (cfg.enablelcd == 1) ? "checked" : "");
1563
1564 if(cfg.lcd_output_path != NULL)
1565 { tpl_addVar(vars, TPLADD, "LCDOUTPUTPATH", cfg.lcd_output_path); }
1566
1567 tpl_addVar(vars, TPLADD, "LCDHIDEIDLE", (cfg.lcd_hide_idle == 1) ? "checked" : "");
1568
1569 tpl_printf(vars, TPLADD, "LCDREFRESHINTERVAL", "%d", cfg.lcd_write_intervall);
1570
1571 return tpl_getTpl(vars, "CONFIGLCD");
1572 }
1573 #endif
1574
1575 #ifdef MODULE_MONITOR
1576 static char *send_oscam_config_monitor(struct templatevars *vars, struct uriparams *params)
1577 {
1578 setActiveSubMenu(vars, MNU_CFG_MONITOR);
1579
1580 webif_save_config("monitor", vars, params);
1581
1582 tpl_printf(vars, TPLADD, "MONPORT", "%d", cfg.mon_port);
1583 if(IP_ISSET(cfg.mon_srvip))
1584 { tpl_addVar(vars, TPLADD, "SERVERIP", cs_inet_ntoa(cfg.mon_srvip)); }
1585
1586 tpl_printf(vars, TPLADD, "AULOW", "%d", cfg.aulow);
1587 tpl_printf(vars, TPLADD, "HIDECLIENTTO", "%d", cfg.hideclient_to);
1588
1589 char *value = mk_t_iprange(cfg.mon_allowed);
1590 tpl_addVar(vars, TPLADD, "NOCRYPT", value);
1591 free_mk_t(value);
1592
1593 //Monlevel selector
1594 tpl_printf(vars, TPLADD, "TMP", "MONSELECTED%d", cfg.mon_level);
1595 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1596
1597 return tpl_getTpl(vars, "CONFIGMONITOR");
1598 }
1599 #endif
1600
1601 #ifdef MODULE_SERIAL
1602 static char *send_oscam_config_serial(struct templatevars *vars, struct uriparams *params)
1603 {
1604 setActiveSubMenu(vars, MNU_CFG_SERIAL);
1605
1606 webif_save_config("serial", vars, params);
1607
1608 if(cfg.ser_device)
1609 {
1610 char sdevice[cs_strlen(cfg.ser_device)];
1611 cs_strncpy(sdevice, cfg.ser_device, sizeof(sdevice));
1612 char *ptr, *saveptr1 = NULL;
1613 char delimiter[2];
1614 delimiter[0] = 1;
1615 delimiter[1] = '\0';
1616 for(ptr = strtok_r(sdevice, delimiter, &saveptr1); ptr; ptr = strtok_r(NULL, delimiter, &saveptr1))
1617 {
1618 tpl_addVar(vars, TPLADD, "SERIALDEVICE", xml_encode(vars, ptr));
1619 tpl_addVar(vars, TPLAPPEND, "DEVICES", tpl_getTpl(vars, "CONFIGSERIALDEVICEBIT"));
1620 }
1621 }
1622
1623 tpl_addVar(vars, TPLADD, "SERIALDEVICE", "");
1624 tpl_addVar(vars, TPLAPPEND, "DEVICES", tpl_getTpl(vars, "CONFIGSERIALDEVICEBIT"));
1625
1626 return tpl_getTpl(vars, "CONFIGSERIAL");
1627 }
1628 #endif
1629
1630 #ifdef HAVE_DVBAPI
1631 extern const char *boxdesc[];
1632
1633 static char *send_oscam_config_dvbapi(struct templatevars *vars, struct uriparams *params)
1634 {
1635 int32_t i;
1636
1637 setActiveSubMenu(vars, MNU_CFG_DVBAPI);
1638
1639 webif_save_config("dvbapi", vars, params);
1640
1641 if(cfg.dvbapi_enabled > 0)
1642 { tpl_addVar(vars, TPLADD, "ENABLEDCHECKED", "checked"); }
1643
1644 if(cfg.dvbapi_au > 0)
1645 { tpl_addVar(vars, TPLADD, "AUCHECKED", "checked"); }
1646
1647 if(cfg.dvbapi_delayer > 0)
1648 { tpl_printf(vars, TPLADD, "DELAYER", "%d", cfg.dvbapi_delayer); }
1649
1650 tpl_printf(vars, TPLADD, "BOXTYPE", "<option value=\"\"%s>None</option>\n", cfg.dvbapi_boxtype == 0 ? " selected" : "");
1651 for(i = 1; i <= BOXTYPES; i++)
1652 {
1653 tpl_printf(vars, TPLAPPEND, "BOXTYPE", "<option%s>%s</option>\n", cfg.dvbapi_boxtype == i ? " selected" : "", boxdesc[i]);
1654 }
1655
1656 tpl_addVar(vars, TPLADD, "USERNAME", xml_encode(vars, cfg.dvbapi_usr));
1657
1658 //PMT Mode
1659 tpl_printf(vars, TPLADD, "TMP", "PMTMODESELECTED%d", cfg.dvbapi_pmtmode);
1660 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1661
1662 //Request Mode
1663 tpl_printf(vars, TPLADD, "TMP", "REQMODESELECTED%d", cfg.dvbapi_requestmode);
1664 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1665
1666 //ecminfo_file
1667 if(cfg.dvbapi_ecminfo_file > 0)
1668 { tpl_addVar(vars, TPLADD, "ECMINFOFILECHECKED", "checked"); }
1669
1670 //ecminfo_type
1671 tpl_printf(vars, TPLADD, "TMP", "ECMINFOTYPESELECTED%d", cfg.dvbapi_ecminfo_type);
1672 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1673
1674 //read_sdt
1675 tpl_printf(vars, TPLADD, "TMP", "READSDTSELECTED%d", cfg.dvbapi_read_sdt);
1676 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1677
1678 //extended_cw_api
1679 tpl_printf(vars, TPLADD, "TMP", "EXTENDEDCWAPISELECTED%d", cfg.dvbapi_extended_cw_api);
1680 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1681
1682 //write_sdt_prov
1683 if(cfg.dvbapi_write_sdt_prov > 0)
1684 { tpl_addVar(vars, TPLADD, "WRITESDTPROVCHECKED", "checked"); }
1685
1686 #ifdef MODULE_STREAMRELAY
1687 //demuxer_fix
1688 if(cfg.dvbapi_demuxer_fix > 0)
1689 { tpl_addVar(vars, TPLADD, "DEMUXERFIXCHECKED", "checked"); }
1690 #endif
1691
1692 //TCP listen port
1693 if(cfg.dvbapi_listenport > 0)
1694 { tpl_printf(vars, TPLADD, "LISTENPORT", "%d", cfg.dvbapi_listenport); }
1695
1696 return tpl_getTpl(vars, "CONFIGDVBAPI");
1697 }
1698 #endif
1699
1700 #ifdef CS_ANTICASC
1701 static char *send_oscam_config_anticasc(struct templatevars *vars, struct uriparams *params)
1702 {
1703 setActiveSubMenu(vars, MNU_CFG_ANTICASC);
1704
1705 webif_save_config("anticasc", vars, params);
1706
1707 if(cfg.ac_enabled > 0) { tpl_addVar(vars, TPLADD, "CHECKED", "checked"); }
1708 tpl_printf(vars, TPLADD, "NUMUSERS", "%d", cfg.ac_users);
1709 tpl_printf(vars, TPLADD, "SAMPLETIME", "%d", cfg.ac_stime);
1710 tpl_printf(vars, TPLADD, "SAMPLES", "%d", cfg.ac_samples);
1711
1712 tpl_printf(vars, TPLADD, "TMP", "PENALTY%d", cfg.ac_penalty);
1713 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1714
1715 if(cfg.ac_logfile)
1716 { tpl_addVar(vars, TPLADD, "ACLOGFILE", cfg.ac_logfile); }
1717 tpl_printf(vars, TPLADD, "FAKEDELAY", "%d", cfg.ac_fakedelay);
1718 tpl_printf(vars, TPLADD, "DENYSAMPLES", "%d", cfg.ac_denysamples);
1719
1720 if(cfg.acosc_enabled == 1)
1721 { tpl_addVar(vars, TPLADD, "ACOSC_CHECKED", "checked"); }
1722 tpl_printf(vars, TPLADD, "ACOSC_MAX_ECMS_PER_MINUTE", "%d", cfg.acosc_max_ecms_per_minute);
1723 tpl_printf(vars, TPLADD, "ACOSC_MAX_ACTIVE_SIDS", "%d", cfg.acosc_max_active_sids);
1724 tpl_printf(vars, TPLADD, "ACOSC_ZAP_LIMIT", "%d", cfg.acosc_zap_limit);
1725 tpl_printf(vars, TPLADD, "TMP", "ACOSC_PENALTY%d", cfg.acosc_penalty);
1726 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
1727 tpl_printf(vars, TPLADD, "ACOSC_PENALTY_DURATION", "%d", cfg.acosc_penalty_duration);
1728 tpl_printf(vars, TPLADD, "ACOSC_DELAY", "%d", cfg.acosc_delay);
1729
1730 return tpl_getTpl(vars, "CONFIGANTICASC");
1731 }
1732 #endif
1733
1734 static char *send_oscam_config(struct templatevars *vars, struct uriparams *params)
1735 {
1736
1737 setActiveMenu(vars, MNU_CONFIG);
1738
1739 char *part = getParam(params, "part");
1740 if(!strcmp(part, "webif")) { return send_oscam_config_webif(vars, params); }
1741 #ifdef MODULE_MONITOR
1742 else if(!strcmp(part, "monitor")) { return send_oscam_config_monitor(vars, params); }
1743 #endif
1744 #ifdef LCDSUPPORT
1745 else if(!strcmp(part, "lcd")) { return send_oscam_config_lcd(vars, params); }
1746 #endif
1747 #ifdef MODULE_CAMD33
1748 else if(!strcmp(part, "camd33")) { return send_oscam_config_camd33(vars, params); }
1749 #endif
1750 #ifdef MODULE_CAMD35
1751 else if(!strcmp(part, "camd35")) { return send_oscam_config_camd35(vars, params); }
1752 #endif
1753 #ifdef MODULE_CAMD35_TCP
1754 else if(!strcmp(part, "camd35tcp")) { return send_oscam_config_camd35tcp(vars, params); }
1755 #endif
1756 else if(!strcmp(part, "cache")) { return send_oscam_config_cache(vars, params); }
1757 #ifdef MODULE_NEWCAMD
1758 else if(!strcmp(part, "newcamd")) { return send_oscam_config_newcamd(vars, params); }
1759 #endif
1760 #ifdef MODULE_RADEGAST
1761 else if(!strcmp(part, "radegast")) { return send_oscam_config_radegast(vars, params); }
1762 #endif
1763 #ifdef MODULE_SCAM
1764 else if(!strcmp(part, "scam")) { return send_oscam_config_scam(vars, params); }
1765 #endif
1766 #ifdef MODULE_STREAMRELAY
1767 else if(!strcmp(part, "streamrelay")) { return send_oscam_config_streamrelay(vars, params); }
1768 #endif
1769 #ifdef MODULE_CCCAM
1770 else if(!strcmp(part, "cccam")) { return send_oscam_config_cccam(vars, params); }
1771 #endif
1772 #ifdef MODULE_GBOX
1773 else if(!strcmp(part, "gbox")) { return send_oscam_config_gbox(vars, params); }
1774 #endif
1775 #ifdef HAVE_DVBAPI
1776 else if(!strcmp(part, "dvbapi")) { return send_oscam_config_dvbapi(vars, params); }
1777 #endif
1778 #ifdef CS_ANTICASC
1779 else if(!strcmp(part, "anticasc")) { return send_oscam_config_anticasc(vars, params); }
1780 #endif
1781 #ifdef MODULE_SERIAL
1782 else if(!strcmp(part, "serial")) { return send_oscam_config_serial(vars, params); }
1783 #endif
1784 #ifdef WITH_LB
1785 else if(!strcmp(part, "loadbalancer")) { return send_oscam_config_loadbalancer(vars, params); }
1786 #endif
1787 else { return send_oscam_config_global(vars, params); }
1788 }
1789
1790 static void inactivate_reader(struct s_reader *rdr)
1791 {
1792 struct s_client *cl = rdr->client;
1793 if(cl)
1794 { kill_thread(cl); }
1795 }
1796
1797 static bool picon_exists(char *name)
1798 {
1799 char picon_name[255], path[255];
1800 char *tpl_path;
1801 tpl_path = cfg.http_piconpath ? cfg.http_piconpath : cfg.http_tpl;
1802 if(!tpl_path)
1803 { return false; }
1804 snprintf(picon_name, sizeof(picon_name) - 1, "IC_%s", name);
1805 return cs_strlen(tpl_getTplPath(picon_name, tpl_path, path, sizeof(path) - 1)) && file_exists(path);
1806 }
1807
1808 static void clear_rdr_stats(struct s_reader *rdr)
1809 {
1810 int i;
1811 for(i = 0; i < 4; i++)
1812 {
1813 rdr->emmerror[i] = 0;
1814 rdr->emmwritten[i] = 0;
1815 rdr->emmskipped[i] = 0;
1816 rdr->emmblocked[i] = 0;
1817 }
1818 rdr->ecmsok = 0;
1819 #ifdef CS_CACHEEX_AIO
1820 rdr->ecmsoklg = 0;
1821 #endif
1822 rdr->ecmsnok = 0;
1823 rdr->ecmstout = 0;
1824 rdr->ecmshealthok = 0;
1825 #ifdef CS_CACHEEX_AIO
1826 rdr->ecmshealthoklg = 0;
1827 #endif
1828 rdr->ecmshealthnok = 0;
1829 rdr->ecmshealthtout = 0;
1830 rdr->ecmsfilteredhead = 0;
1831 rdr->ecmsfilteredlen = 0;
1832 }
1833
1834 static void clear_all_rdr_stats(void)
1835 {
1836 struct s_reader *rdr;
1837 LL_ITER itr = ll_iter_create(configured_readers);
1838 while((rdr = ll_iter_next(&itr)))
1839 {
1840 clear_rdr_stats(rdr);
1841 }
1842 }
1843
1844 static char *send_oscam_reader(struct templatevars *vars, struct uriparams *params, int32_t apicall)
1845 {
1846 struct s_reader *rdr;
1847 int32_t i;
1848 uint8_t md5tmp[MD5_DIGEST_LENGTH];
1849 char *status;
1850
1851 if(!apicall) { setActiveMenu(vars, MNU_READERS); }
1852 if(!apicall)
1853 {
1854 if(strcmp(getParam(params, "action"), "resetallrdrstats") == 0)
1855 {
1856 clear_all_rdr_stats();
1857 }
1858 }
1859
1860 tpl_addVar(vars, TPLADD, "READERACTIONCOLS", config_enabled(WITH_LB) ? "6" : "5");
1861
1862 if(strcmp(getParam(params, "action"), "resetuserstats") == 0)
1863 {
1864 clear_info_clients_stats();
1865 }
1866 if(strcmp(getParam(params, "action"), "resetreaderstats") == 0)
1867 {
1868 clear_info_readers_stats();
1869 }
1870 if(strcmp(getParam(params, "action"), "reloadreaders") == 0)
1871 {
1872 if(!cfg.http_readonly)
1873 { refresh_oscam(REFR_READERS); }
1874 }
1875 if((strcmp(getParam(params, "action"), "disable") == 0) || (strcmp(getParam(params, "action"), "enable") == 0))
1876 {
1877 if(cfg.http_readonly)
1878 {
1879 tpl_addMsg(vars, "WebIf is in readonly mode. Enabling or disabling readers is not possible!");
1880 }
1881 else
1882 {
1883 rdr = get_reader_by_label(getParam(params, "label"));
1884 if(rdr)
1885 {
1886 if(strcmp(getParam(params, "action"), "enable") == 0)
1887 {
1888 if(!rdr->enable)
1889 {
1890 rdr->enable = 1;
1891 }
1892 }
1893 else
1894 {
1895 if(rdr->enable)
1896 {
1897 rdr->enable = 0;
1898 }
1899 }
1900 if(rdr->typ != R_GBOX)
1901 {
1902 restart_cardreader(rdr, 1);
1903 }
1904 #ifdef MODULE_GBOX
1905 else
1906 {
1907 restart_gbox_peer(rdr->label, 0, 0);
1908 cs_log("gbox -> you must restart oscam so that setting becomes effective");
1909 }
1910 #endif
1911
1912 cs_log("reader %s %s by WebIf", rdr->label, rdr->enable == 1 ? "enabled":"disabled");
1913
1914 if(write_server() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
1915
1916 #ifdef MODULE_GBOX
1917 if(!is_network_reader(rdr) && !rdr->enable)
1918 {
1919 gbx_local_card_stat(LOCALCARDDISABLED, 0);
1920 }
1921 #endif
1922 }
1923 }
1924 }
1925
1926 if(strcmp(getParam(params, "action"), "delete") == 0)
1927 {
1928 if(cfg.http_readonly)
1929 {
1930 tpl_addMsg(vars, "WebIf is in readonly mode. No deletion will be made!");
1931 }
1932 else
1933 {
1934 rdr = get_reader_by_label(getParam(params, "label"));
1935 if(rdr)
1936 {
1937 inactivate_reader(rdr);
1938 ll_remove(configured_readers, rdr);
1939
1940 free_reader(rdr);
1941
1942 if(write_server() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
1943 }
1944 }
1945 }
1946
1947 if(strcmp(getParam(params, "action"), "reread") == 0)
1948 {
1949 rdr = get_reader_by_label(getParam(params, "label"));
1950 if(rdr)
1951 {
1952 struct s_client *cl = rdr->client;
1953 //reset the counters
1954 for(i = 0; i < 4; i++)
1955 {
1956 rdr->emmerror[i] = 0;
1957 rdr->emmwritten[i] = 0;
1958 rdr->emmskipped[i] = 0;
1959 rdr->emmblocked[i] = 0;
1960 }
1961
1962 if(rdr->enable == 1 && cl && cl->typ == 'r')
1963 {
1964 add_job(cl, ACTION_READER_CARDINFO, NULL, 0);
1965 }
1966 }
1967 }
1968
1969 LL_ITER itr = ll_iter_create(configured_readers);
1970
1971 if(!apicall)
1972 {
1973 for(i = 0, rdr = ll_iter_next(&itr); rdr && rdr->label[0]; rdr = ll_iter_next(&itr), i++) { ; }
1974 tpl_printf(vars, TPLADD, "NEXTREADER", "Reader-%d", i); //Next Readername
1975 }
1976
1977 int jsondelimiter = 0;
1978 int existing_insert = 0;
1979
1980 int32_t total_readers = 0;
1981 int32_t disabled_readers = 0;
1982 int32_t active_readers = 0;
1983 int32_t connected_readers = 0;
1984
1985 ll_iter_reset(&itr); //going to iterate all configured readers
1986 while((rdr = ll_iter_next(&itr)))
1987 {
1988 #ifdef CS_CACHEEX_AIO
1989 const char *proto = reader_get_type_desc(rdr, 0);
1990 #endif
1991 struct s_client *cl = rdr->client;
1992 if(rdr->label[0] && rdr->typ)
1993 {
1994 #ifdef CS_CACHEEX_AIO
1995 char *new_proto;
1996 #if defined(MODULE_CAMD35) || defined (MODULE_CAMD35_TCP)
1997 if(rdr->cacheex.feature_bitfield || (cl && cl->c35_extmode > 1))
1998 #else
1999 if(rdr->cacheex.feature_bitfield)
2000 #endif
2001 {
2002 const char *aio_suffix = " (cx-aio)";
2003
2004 if(cs_malloc(&new_proto, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
2005 if (!cs_strncat(new_proto, (char *)proto, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
2006 cs_log("FIXME!");
2007 }
2008 if (!cs_strncat(new_proto, (char *)aio_suffix, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
2009 cs_log("FIXME!");
2010 }
2011 }
2012 }
2013 #endif
2014 total_readers += 1;
2015
2016 // used for API and WebIf
2017 tpl_addVar(vars, TPLADD, "READERNAME", xml_encode(vars, rdr->label));
2018
2019 MD5((uint8_t *)rdr->label, cs_strlen(rdr->label), md5tmp);
2020 int z;
2021 tpl_addVar(vars, TPLADD, "LABELMD5","id_");
2022 for (z = 0; z < MD5_DIGEST_LENGTH; z++)
2023 {
2024 tpl_printf(vars, TPLAPPEND, "LABELMD5", "%02x", md5tmp[z]);
2025 }
2026 #ifdef MODULE_GBOX
2027 if(apicall)
2028 {
2029 tpl_addVar(vars, TPLADD, "LASTGSMS", "");
2030 tpl_addVar(vars, TPLADD, "LASTGSMS", rdr->last_gsms);
2031 }
2032 #endif
2033 if(apicall)
2034 {
2035 tpl_printf(vars, TPLADD, "PICONENABLED", "%d", cfg.http_showpicons?1:0);
2036 }
2037 tpl_addVar(vars, TPLADD, "READERNAMEENC", urlencode(vars, rdr->label));
2038 if(!existing_insert)
2039 {
2040 tpl_printf(vars, TPLADD, "EXISTING_INS", "'%s'", urlencode(vars, rdr->label));
2041 existing_insert++;
2042 }else
2043 {
2044 tpl_printf(vars, TPLAPPEND, "EXISTING_INS", ",'%s'", urlencode(vars, rdr->label));
2045 }
2046 tpl_addVar(vars, TPLADD, "READERCLASS", rdr->enable ? "enabledreader" : "disabledreader");
2047
2048 if(rdr->enable) { active_readers += 1; }
2049 else { disabled_readers += 1; }
2050
2051 if(rdr->tcp_connected)
2052 {
2053 connected_readers += 1;
2054
2055 #ifdef CS_CACHEEX_AIO
2056 if(rdr->cacheex.feature_bitfield)
2057 {
2058 tpl_addVar(vars, TPLADD, "CLIENTPROTOSORT", (const char*)new_proto);
2059 tpl_addVar(vars, TPLADD, "CLIENTPROTO", (const char*)new_proto);
2060 if(cfg.http_showpicons)
2061 {
2062 char picon_name[32];
2063 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", new_proto);
2064 if(picon_exists(picon_name))
2065 {
2066 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s",(char*)new_proto);
2067 }
2068 }
2069
2070 if(rdr->cacheex.feature_bitfield & 32)
2071 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", rdr->cacheex.aio_version);
2072 else if(cl->reader->cacheex.feature_bitfield)
2073 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", "[cx-aio < 9.2.3]");
2074 }
2075 else
2076 {
2077 tpl_addVar(vars, TPLADD, "CLIENTPROTOSORT", proto);
2078 tpl_addVar(vars, TPLADD, "CLIENTPROTO", proto);
2079 if(cfg.http_showpicons)
2080 {
2081 char picon_name[32];
2082 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", proto);
2083 if(picon_exists(picon_name))
2084 {
2085 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s",(char *)proto);
2086 }
2087 }
2088 }
2089 #else
2090 tpl_addVar(vars, TPLADD, "CLIENTPROTO", reader_get_type_desc(rdr, 0));
2091 tpl_addVar(vars, TPLADD, "CLIENTPROTOSORT", reader_get_type_desc(rdr, 0));
2092 if(cfg.http_showpicons)
2093 {
2094 char picon_name[32];
2095 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", reader_get_type_desc(rdr, 0));
2096 if(picon_exists(picon_name))
2097 {
2098 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s", reader_get_type_desc(rdr, 0));
2099 }
2100 }
2101 #endif
2102 switch(rdr->card_status)
2103 {
2104 case CARD_INSERTED:
2105 status = "<B>online</B>";
2106 tpl_addVar(vars, TPLADD, "RSTATUS", status);
2107 tpl_addVar(vars, TPLADD, "READERCLASS", "r_connected");
2108 break;
2109
2110 case NO_CARD:
2111 case UNKNOWN:
2112 case READER_DEVICE_ERROR:
2113 case CARD_NEED_INIT:
2114 case CARD_FAILURE:
2115 default:
2116 status = "<B>connected</B>";
2117 tpl_addVar(vars, TPLADD, "RSTATUS", status);
2118 tpl_addVar(vars, TPLADD, "READERCLASS", "r_undefined");
2119 break;
2120 }
2121
2122 tpl_addVar(vars, TPLADD, "READERIP", cs_inet_ntoa(rdr->client->ip));
2123 }
2124 else
2125 {
2126 /* default initial values */
2127 tpl_addVar(vars, TPLADDONCE, "RSTATUS", "offline");
2128 tpl_addVar(vars, TPLADDONCE, "READERIP", "");
2129 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTO", "");
2130 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTOSORT", "");
2131 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTOTITLE", "");
2132 tpl_addVar(vars, TPLADDONCE, "PROTOICON", "");
2133
2134 if(!is_network_reader(rdr) && rdr->enable)
2135 {
2136 switch(rdr->card_status)
2137 {
2138 case CARD_INSERTED:
2139 status = "<B>active</B>";
2140 tpl_addVar(vars, TPLADD, "RSTATUS", status);
2141 tpl_addVar(vars, TPLADD, "READERCLASS", "r_connected");
2142 break;
2143
2144 case NO_CARD:
2145 case UNKNOWN:
2146 case READER_DEVICE_ERROR:
2147 case CARD_NEED_INIT:
2148 case CARD_FAILURE:
2149 default:
2150 status = "<B>connected</B>";
2151 tpl_addVar(vars, TPLADD, "RSTATUS", status);
2152 tpl_addVar(vars, TPLADD, "READERCLASS", "r_undefined");
2153 break;
2154 }
2155
2156 tpl_addVar(vars, TPLADD, "CLIENTPROTO", reader_get_type_desc(rdr, 0));
2157 tpl_addVar(vars, TPLADD, "CLIENTPROTOSORT", reader_get_type_desc(rdr, 0));
2158 if(cfg.http_showpicons)
2159 {
2160 char picon_name[32];
2161 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", reader_get_type_desc(rdr, 0));
2162 if(picon_exists(picon_name))
2163 {
2164 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s", reader_get_type_desc(rdr, 0));
2165 }
2166 }
2167 }
2168 }
2169
2170 if(rdr->description)
2171 tpl_printf(vars, TPLADD, "DESCRIPTION","%s(%s)",!apicall?"&#13;":"",xml_encode(vars, rdr->description));
2172 else
2173 tpl_addVar(vars, TPLADD, "DESCRIPTION", "");
2174
2175 if(cfg.http_showpicons && !apicall)
2176 {
2177 tpl_addVar(vars, TPLADD, "READERBIT", tpl_getTpl(vars, picon_exists(xml_encode(vars, rdr->label)) ? "READERNAMEBIT" : "READERNOICON"));
2178 #ifdef CS_CACHEEX_AIO
2179 if(rdr->cacheex.feature_bitfield)
2180 {
2181 tpl_addVar(vars, TPLADD, "CLIENTPROTO", picon_exists(xml_encode(vars, (const char*)new_proto)) ? tpl_getTpl(vars, "READERCTYPBIT") : tpl_getTpl(vars, "READERCTYPNOICON"));
2182 }
2183 else
2184 {
2185 #endif
2186 tpl_addVar(vars, TPLADD, "CLIENTPROTO", picon_exists(xml_encode(vars, reader_get_type_desc(rdr, 0))) ? tpl_getTpl(vars, "READERCTYPBIT") : tpl_getTpl(vars, "READERCTYPNOICON"));
2187 #ifdef CS_CACHEEX_AIO
2188 }
2189 #endif
2190 }
2191 else
2192 tpl_addVar(vars, TPLADD, "READERBIT", tpl_getTpl(vars, "READERLABEL"));
2193
2194 char *value = mk_t_group(rdr->grp);
2195 tpl_addVar(vars, TPLADD, "GROUPS", value);
2196 free_mk_t(value);
2197 tpl_printf(vars, TPLADD, "EMMERRORUK", PRINTF_LOCAL_D, rdr->emmerror[UNKNOWN]);
2198 tpl_printf(vars, TPLADD, "EMMERRORG", PRINTF_LOCAL_D, rdr->emmerror[GLOBAL]);
2199 tpl_printf(vars, TPLADD, "EMMERRORS", PRINTF_LOCAL_D, rdr->emmerror[SHARED]);
2200 tpl_printf(vars, TPLADD, "EMMERRORUQ", PRINTF_LOCAL_D, rdr->emmerror[UNIQUE]);
2201
2202 tpl_printf(vars, TPLADD, "EMMWRITTENUK", PRINTF_LOCAL_D, rdr->emmwritten[UNKNOWN]);
2203 tpl_printf(vars, TPLADD, "EMMWRITTENG", PRINTF_LOCAL_D, rdr->emmwritten[GLOBAL]);
2204 tpl_printf(vars, TPLADD, "EMMWRITTENS", PRINTF_LOCAL_D, rdr->emmwritten[SHARED]);
2205 tpl_printf(vars, TPLADD, "EMMWRITTENUQ", PRINTF_LOCAL_D, rdr->emmwritten[UNIQUE]);
2206
2207 tpl_printf(vars, TPLADD, "EMMSKIPPEDUK", PRINTF_LOCAL_D, rdr->emmskipped[UNKNOWN]);
2208 tpl_printf(vars, TPLADD, "EMMSKIPPEDG", PRINTF_LOCAL_D, rdr->emmskipped[GLOBAL]);
2209 tpl_printf(vars, TPLADD, "EMMSKIPPEDS", PRINTF_LOCAL_D, rdr->emmskipped[SHARED]);
2210 tpl_printf(vars, TPLADD, "EMMSKIPPEDUQ", PRINTF_LOCAL_D, rdr->emmskipped[UNIQUE]);
2211
2212 tpl_printf(vars, TPLADD, "EMMBLOCKEDUK", PRINTF_LOCAL_D, rdr->emmblocked[UNKNOWN]);
2213 tpl_printf(vars, TPLADD, "EMMBLOCKEDG", PRINTF_LOCAL_D, rdr->emmblocked[GLOBAL]);
2214 tpl_printf(vars, TPLADD, "EMMBLOCKEDS", PRINTF_LOCAL_D, rdr->emmblocked[SHARED]);
2215 tpl_printf(vars, TPLADD, "EMMBLOCKEDUQ", PRINTF_LOCAL_D, rdr->emmblocked[UNIQUE]);
2216
2217 tpl_printf(vars, TPLADD, "ECMSOK", PRINTF_LOCAL_D, rdr->ecmsok);
2218 tpl_printf(vars, TPLADD, "ECMSOKREL", " (%.2f %%)", rdr->ecmshealthok);
2219 #ifdef CS_CACHEEX_AIO
2220 tpl_printf(vars, TPLADD, "ECMSOKLG", PRINTF_LOCAL_D, rdr->ecmsoklg);
2221 tpl_printf(vars, TPLADD, "ECMSOKLGREL", " (%.2f %%)", rdr->ecmshealthoklg);
2222 #endif
2223 tpl_printf(vars, TPLADD, "ECMSNOK", PRINTF_LOCAL_D, rdr->ecmsnok);
2224 tpl_printf(vars, TPLADD, "ECMSNOKREL", " (%.2f %%)",rdr->ecmshealthnok);
2225 tpl_printf(vars, TPLADD, "ECMSTOUT", PRINTF_LOCAL_D, rdr->ecmstout);
2226 tpl_printf(vars, TPLADD, "ECMSTOUTREL", " (%.2f %%)",rdr->ecmshealthtout);
2227 tpl_printf(vars, TPLADD, "ECMSFILTEREDHEAD", PRINTF_LOCAL_D, rdr->ecmsfilteredhead);
2228 tpl_printf(vars, TPLADD, "ECMSFILTEREDLEN", PRINTF_LOCAL_D, rdr->ecmsfilteredlen);
2229 #ifdef WITH_LB
2230 tpl_printf(vars, TPLADD, "LBWEIGHT", "%d", rdr->lb_weight);
2231 #endif
2232 if(!is_network_reader(rdr)) //reader is physical
2233 {
2234 tpl_addVar(vars, TPLADD, "REFRICO", "image?i=ICREF");
2235 tpl_addVar(vars, TPLADD, "READERREFRESH", tpl_getTpl(vars, "READERREFRESHBIT"));
2236 tpl_addVar(vars, TPLADD, "ENTICO", "image?i=ICENT");
2237 tpl_addVar(vars, TPLADD, "ENTITLEMENT", tpl_getTpl(vars, "READERENTITLEBIT"));
2238 }
2239 else
2240 {
2241 tpl_addVar(vars, TPLADD, "READERREFRESH", "");
2242 if(rdr->typ == R_CCCAM)
2243 {
2244 tpl_addVar(vars, TPLADD, "ENTICO", "image?i=ICENT");
2245 tpl_addVar(vars, TPLADD, "ENTITLEMENT", tpl_getTpl(vars, "READERENTITLEBIT"));
2246 }
2247 else
2248 {
2249 tpl_addVar(vars, TPLADD, "ENTITLEMENT", "");
2250 }
2251 }
2252
2253 if(rdr->enable == 0)
2254 {
2255 tpl_addVar(vars, TPLADD, "SWITCHICO", "image?i=ICENA");
2256 tpl_addVar(vars, TPLADD, "SWITCHTITLE", "Enable");
2257 tpl_addVar(vars, TPLADD, "SWITCH", "enable");
2258 tpl_addVar(vars, TPLADD, "WRITEEMM", "");
2259 }
2260 else
2261 {
2262 tpl_addVar(vars, TPLADD, "SWITCHICO", "image?i=ICDIS");
2263 tpl_addVar(vars, TPLADD, "SWITCHTITLE", "Disable");
2264 tpl_addVar(vars, TPLADD, "SWITCH", "disable");
2265
2266 tpl_addVar(vars, TPLADD, "EMMICO", "image?i=ICEMM");
2267 tpl_addVar(vars, TPLADD, "WRITEEMM", tpl_getTpl(vars, "READERWRITEEMMBIT"));
2268 }
2269
2270 if(!apicall)
2271 {
2272 // Add to WebIf Template
2273 #ifdef CS_CACHEEX_AIO
2274 tpl_addVar(vars, TPLAPPEND, "READERLIST", tpl_getTpl(vars, "READERSBITAIO"));
2275 #else
2276 tpl_addVar(vars, TPLAPPEND, "READERLIST", tpl_getTpl(vars, "READERSBIT"));
2277 #endif
2278 }
2279 else
2280 {
2281
2282 // used only for API
2283 tpl_addVar(vars, TPLADD, "APIREADERENABLED", !rdr->enable ? "0" : "1");
2284 if(cl)
2285 {
2286 tpl_printf(vars, TPLADD, "APIREADERTYPE", "%c", cl->typ ? cl->typ : 'x');
2287 }
2288
2289 if(apicall==1)
2290 {
2291 // Add to API Template
2292 tpl_addVar(vars, TPLAPPEND, "APIREADERLIST", tpl_getTpl(vars, "APIREADERSBIT"));
2293 }
2294 if(apicall==2)
2295 {
2296 tpl_printf(vars, TPLAPPEND, "APIREADERLIST","%s%s",jsondelimiter?",":"", tpl_getTpl(vars, "JSONREADERBIT"));
2297 jsondelimiter++;
2298 }
2299 }
2300 #ifdef CS_CACHEEX_AIO
2301 if(rdr->cacheex.feature_bitfield)
2302 {
2303 free(new_proto);
2304 }
2305 #endif
2306 }
2307 }
2308
2309 tpl_printf(vars, TPLADD, "TOTAL_READERS", "%d", total_readers);
2310 tpl_printf(vars, TPLADD, "TOTAL_DISABLED_READERS", "%d", disabled_readers);
2311 tpl_printf(vars, TPLADD, "TOTAL_ACTIVE_READERS", "%d", active_readers);
2312 tpl_printf(vars, TPLADD, "TOTAL_CONNECTED_READERS", "%d", connected_readers);
2313
2314 //CM info
2315 tpl_addVar(vars, TPLADD, "DISPLAYUSERINFO", "hidden"); // no userinfo in readers
2316 set_ecm_info(vars);
2317
2318 if(!apicall)
2319 {
2320 #ifdef MODULE_CAMD33
2321 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>camd33</option>\n");
2322 #endif
2323 #ifdef MODULE_CAMD35
2324 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>cs357x</option>\n");
2325 #endif
2326 #ifdef MODULE_CAMD35_TCP
2327 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>cs378x</option>\n");
2328 #endif
2329 #ifdef MODULE_NEWCAMD
2330 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>newcamd</option>\n");
2331 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>newcamd524</option>\n");
2332 #endif
2333 #ifdef MODULE_CCCAM
2334 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>cccam</option>\n");
2335 #endif
2336 #ifdef MODULE_GBOX
2337 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>gbox</option>\n");
2338 #endif
2339 #ifdef MODULE_RADEGAST
2340 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>radegast</option>\n");
2341 #endif
2342 #ifdef MODULE_SERIAL
2343 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>serial</option>\n");
2344 #endif
2345 #ifdef MODULE_CONSTCW
2346 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>constcw</option>\n");
2347 #endif
2348 #ifdef MODULE_SCAM
2349 tpl_addVar(vars, TPLAPPEND, "ADDPROTOCOL", "<option>scam</option>\n");
2350 #endif
2351
2352 for(i = 0; cardreaders[i]; i++)
2353 {
2354 tpl_printf(vars, TPLAPPEND, "ADDPROTOCOL", "<option>%s</option>\n", xml_encode(vars, cardreaders[i]->desc));
2355 }
2356 #ifdef CS_CACHEEX_AIO
2357 return tpl_getTpl(vars, "READERSAIO");
2358 #else
2359 return tpl_getTpl(vars, "READERS");
2360 #endif
2361 }
2362 else
2363 {
2364 if(apicall == 1)
2365 {
2366 return tpl_getTpl(vars, "APIREADERS");
2367 }
2368 else
2369 {
2370 return tpl_getTpl(vars, "JSONREADER");
2371 }
2372 }
2373 }
2374
2375 static char *send_oscam_reader_config(struct templatevars *vars, struct uriparams *params)
2376 {
2377 int32_t i;
2378 int32_t apicall = 0;
2379 char *reader_ = getParam(params, "label");
2380 char *value;
2381
2382 struct s_reader *rdr;
2383
2384 if(!apicall) { setActiveMenu(vars, MNU_READERS); }
2385
2386 if(strcmp(getParam(params, "action"), "Add") == 0)
2387 {
2388 // Add new reader
2389 struct s_reader *newrdr;
2390 if(!cs_malloc(&newrdr, sizeof(struct s_reader))) { return "0"; }
2391 for(i = 0; i < (*params).paramcount; ++i)
2392 {
2393 if(strcmp((*params).params[i], "action"))
2394 { chk_reader((*params).params[i], (*params).values[i], newrdr); }
2395 }
2396 module_reader_set(newrdr);
2397 reader_ = newrdr->label;
2398 reader_set_defaults(newrdr);
2399 newrdr->enable = 0; // do not start the reader because must configured before
2400 ll_append(configured_readers, newrdr);
2401 tpl_addMsg(vars, "New Reader has been added with default settings");
2402 }
2403 else if(strcmp(getParam(params, "action"), "Save") == 0)
2404 {
2405
2406 rdr = get_reader_by_label(getParam(params, "label"));
2407 if(!rdr)
2408 { return NULL; }
2409 //if (is_network_reader(rdr))
2410 // inactivate_reader(rdr); //Stop reader before reinitialization
2411 char servicelabels[1024] = "";
2412 char servicelabelslb[1024] = "";
2413
2414 for(i = 0; i < (*params).paramcount; ++i)
2415 {
2416 if((strcmp((*params).params[i], "reader")) && (strcmp((*params).params[i], "action")))
2417 {
2418 if(!strcmp((*params).params[i], "services"))
2419 { snprintf(servicelabels + cs_strlen(servicelabels), sizeof(servicelabels) - cs_strlen(servicelabels), "%s,", (*params).values[i]); }
2420 else if(!strcmp((*params).params[i], "lb_whitelist_services"))
2421 { snprintf(servicelabelslb + cs_strlen(servicelabelslb), sizeof(servicelabelslb) - cs_strlen(servicelabelslb), "%s,", (*params).values[i]); }
2422 else
2423 /*if(cs_strlen((*params).values[i]) > 0)*/
2424 { chk_reader((*params).params[i], (*params).values[i], rdr); }
2425 }
2426 //printf("param %s value %s\n",(*params).params[i], (*params).values[i]);
2427 }
2428 chk_reader("services", servicelabels, rdr);
2429 chk_reader("lb_whitelist_services", servicelabelslb, rdr);
2430
2431 if(is_network_reader(rdr) || rdr->typ == R_EMU) //physical readers make trouble if re-started
2432 {
2433 if(rdr)
2434 {
2435 if(rdr->typ != R_GBOX)
2436 {
2437 restart_cardreader(rdr, 1);
2438 }
2439 #ifdef MODULE_GBOX
2440 else
2441 {
2442 //cs_log("SAVE - single gbox reader %s restarted by WebIf", rdr->label);
2443 restart_gbox_peer(rdr->label, 0, 0);
2444 }
2445 #endif
2446 }
2447 }
2448
2449 if(write_server() != 0) { tpl_addMsg(vars, "Write Config failed!"); } else { tpl_addMsg(vars, "Reader config updated and saved"); }
2450
2451 }
2452
2453 rdr = get_reader_by_label(reader_);
2454 if(!rdr)
2455 { return NULL; }
2456
2457 // Label, Description
2458 tpl_addVar(vars, TPLADD, "READERNAME", xml_encode(vars, rdr->label));
2459 tpl_addVar(vars, TPLADD, "DESCRIPTION", xml_encode(vars, rdr->description));
2460
2461 // enabled
2462 if(!apicall)
2463 {
2464 tpl_addVar(vars, TPLADD, "ENABLED", (rdr->enable == 1) ? "checked" : "");
2465 }
2466 else
2467 {
2468 tpl_addVar(vars, TPLADD, "ENABLEDVALUE", (rdr->enable == 1) ? "1" : "0");
2469 }
2470
2471 tpl_addVar(vars, TPLADD, "PASSWORD", xml_encode(vars, rdr->r_pwd));
2472 tpl_addVar(vars, TPLADD, "USERNAME", xml_encode(vars, rdr->r_usr));
2473 tpl_addVar(vars, TPLADD, "PASS", xml_encode(vars, rdr->r_pwd));
2474
2475 // Key Newcamd
2476 for(i = 0; i < (int32_t)sizeof(rdr->ncd_key); i++)
2477 { tpl_printf(vars, TPLAPPEND, "NCD_KEY", "%02X", rdr->ncd_key[i]); }
2478
2479 // Pincode
2480 tpl_addVar(vars, TPLADD, "PINCODE", rdr->pincode);
2481
2482 // Emmfile Path
2483 if(rdr->emmfile) { tpl_addVar(vars, TPLADD, "EMMFILE", (char *)rdr->emmfile); }
2484
2485 // Inactivity timeout
2486 tpl_printf(vars, TPLADD, "INACTIVITYTIMEOUT", "%d", rdr->tcp_ito);
2487
2488 // Receive timeout
2489 tpl_printf(vars, TPLADD, "RECEIVETIMEOUT", "%d", rdr->tcp_rto);
2490
2491 // keepalive
2492 tpl_addVar(vars, TPLADD, "RDRKEEPALIVE", (rdr->keepalive == 1) ? "checked" : "");
2493
2494 // Connect on init (newcamd)
2495 if(!apicall)
2496 {
2497 tpl_addVar(vars, TPLADD, "CONNECTONINITCHECKED", (rdr->ncd_connect_on_init == 1) ? "checked" : "");
2498 }
2499 else
2500 {
2501 tpl_addVar(vars, TPLADD, "CONNECTONINITCHECKED", (rdr->ncd_connect_on_init == 1) ? "1" : "0");
2502 }
2503
2504 // Reset Cycle
2505 tpl_printf(vars, TPLADD, "RESETCYCLE", "%d", rdr->resetcycle);
2506
2507 // Disable Serverfilter
2508 if(!apicall)
2509 {
2510 tpl_addVar(vars, TPLADD, "DISABLESERVERFILTERCHECKED", (rdr->ncd_disable_server_filt == 1) ? "checked" : "");
2511 }
2512 else
2513 {
2514 tpl_addVar(vars, TPLADD, "DISABLESERVERFILTERVALUE", (rdr->ncd_disable_server_filt == 1) ? "1" : "0");
2515 }
2516
2517 #ifdef MODULE_GHTTP
2518 // Use SSL
2519 if(!apicall)
2520 {
2521 tpl_addVar(vars, TPLADD, "USESSLCHECKED", (rdr->ghttp_use_ssl == 1) ? "checked" : "");
2522 }
2523 else
2524 {
2525 tpl_addVar(vars, TPLADD, "USESSLVALUE", (rdr->ghttp_use_ssl == 1) ? "1" : "0");
2526 }
2527 #endif
2528
2529 // Fallback
2530 if(!apicall)
2531 {
2532 tpl_addVar(vars, TPLADD, "FALLBACKCHECKED", (rdr->fallback == 1) ? "checked" : "");
2533 }
2534 else
2535 {
2536 tpl_addVar(vars, TPLADD, "FALLBACKVALUE", (rdr->fallback == 1) ? "1" : "0");
2537 }
2538
2539 // Fallback per caid
2540 value = mk_t_ftab(&rdr->fallback_percaid);
2541 tpl_addVar(vars, TPLADD, "FALLBACK_PERCAID", value);
2542 free_mk_t(value);
2543
2544 // disable checksum test only for selected caid/provid
2545 value = mk_t_ftab(&rdr->disablecrccws_only_for);
2546 tpl_addVar(vars, TPLADD, "IGN_CHKSUM_ONLYFOR", value);
2547 free_mk_t(value);
2548
2549 #ifdef WITH_LB
2550 tpl_addVar(vars, TPLADD, "LBFORCEFALLBACK", (rdr->lb_force_fallback == 1) ? "checked" : "");
2551 #endif
2552
2553 #ifdef CS_CACHEEX
2554 // Cacheex
2555 if(!apicall)
2556 {
2557 tpl_printf(vars, TPLADD, "TMP", "CACHEEXSELECTED%d", rdr->cacheex.mode);
2558 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
2559 }
2560 else
2561 {
2562 tpl_printf(vars, TPLADD, "CACHEEX", "%d", rdr->cacheex.mode);
2563 }
2564 tpl_printf(vars, TPLADD, "CACHEEX_MAXHOP", "%d", rdr->cacheex.maxhop);
2565 #ifdef CS_CACHEEX_AIO
2566 tpl_printf(vars, TPLADD, "CACHEEX_MAXHOP_LG", "%d", rdr->cacheex.maxhop_lg);
2567 #endif
2568 value = mk_t_cacheex_hitvaluetab(&rdr->cacheex.filter_caidtab);
2569 //if (cs_strlen(value) > 0)
2570 tpl_printf(vars, TPLADD, "CACHEEX_ECM_FILTER", "%s", value);
2571 free_mk_t(value);
2572
2573 tpl_addVar(vars, TPLADD, "DCCHECKED", (rdr->cacheex.drop_csp == 1) ? "checked" : "");
2574 tpl_addVar(vars, TPLADD, "ARCHECKED", (rdr->cacheex.allow_request == 1) ? "checked" : "");
2575 tpl_addVar(vars, TPLADD, "AFCHECKED", (rdr->cacheex.allow_filter == 1) ? "checked" : "");
2576 #ifdef CS_CACHEEX_AIO
2577 tpl_addVar(vars, TPLADD, "AMCHECKED", (rdr->cacheex.allow_maxhop == 1) ? "checked" : "");
2578 #endif
2579 tpl_addVar(vars, TPLADD, "BLOCKFAKECWSCHECKED", (rdr->cacheex.block_fakecws == 1) ? "checked" : "");
2580 #ifdef CS_CACHEEX_AIO
2581 tpl_addVar(vars, TPLADD, "USECWCHECKFORPUSHCHECKED", (rdr->cacheex.cw_check_for_push == 1) ? "checked" : "");
2582 tpl_addVar(vars, TPLADD, "LGONLYREMOTESETTINGSCHECKED", (rdr->cacheex.lg_only_remote_settings == 1) ? "checked" : "");
2583 tpl_addVar(vars, TPLADD, "LOCALGENERATEDONLYCHECKED", (rdr->cacheex.localgenerated_only == 1) ? "checked" : "");
2584
2585 value = mk_t_ftab(&rdr->cacheex.lg_only_tab);
2586 tpl_addVar(vars, TPLADD, "LGONLYTAB", value);
2587 free_mk_t(value);
2588
2589 tpl_addVar(vars, TPLADD, "LOCALGENERATEDONLYINCHECKED", (rdr->cacheex.localgenerated_only_in == 1) ? "checked" : "");
2590
2591 tpl_addVar(vars, TPLADD, "LGONLYINAIOONLYCHECKED", (rdr->cacheex.lg_only_in_aio_only == 1) ? "checked" : "");
2592
2593 value = mk_t_ftab(&rdr->cacheex.lg_only_in_tab);
2594 tpl_addVar(vars, TPLADD, "LGONLYINTAB", value);
2595 free_mk_t(value);
2596
2597 value = mk_t_caidvaluetab(&rdr->cacheex.cacheex_nopushafter_tab);
2598 tpl_addVar(vars, TPLADD, "CACHEEXNOPUSHAFTER", value);
2599 free_mk_t(value);
2600 #endif
2601 #endif
2602
2603 // BoxID
2604 if(rdr->boxid)
2605 { tpl_printf(vars, TPLADD, "BOXID", "%08X", rdr->boxid); }
2606
2607 // Filt 07
2608 if(!apicall)
2609 {
2610 tpl_addVar(vars, TPLADD, "FIX07CHECKED", (rdr->fix_07 == 1) ? "checked" : "");
2611 }
2612 else
2613 {
2614 tpl_addVar(vars, TPLADD, "FIX07VALUE", (rdr->fix_07 == 1) ? "1" : "0");
2615 }
2616
2617
2618 // Fix 9993
2619 if(!apicall)
2620 {
2621 tpl_addVar(vars, TPLADD, "FIX9993CHECKED", (rdr->fix_9993 == 1) ? "checked" : "");
2622 }
2623 else
2624 {
2625 tpl_addVar(vars, TPLADD, "FIX9993VALUE", (rdr->fix_9993 == 1) ? "1" : "0");
2626 }
2627
2628 // Drop CWs with wrong checksum:
2629 if(!apicall)
2630 {
2631 tpl_addVar(vars, TPLADD, "DROPBADCWSCHECKED", (rdr->dropbadcws == 1) ? "checked" : "");
2632 }
2633 else
2634 {
2635 tpl_addVar(vars, TPLADD, "DROPBADCWSVALUE", (rdr->dropbadcws == 1) ? "1" : "0");
2636 }
2637
2638 // Disable CWs checksum test:
2639 if(!apicall)
2640 {
2641 tpl_addVar(vars, TPLADD, "DISABLECRCCWSCHECKED", (rdr->disablecrccws == 1) ? "checked" : "");
2642 }
2643 else
2644 {
2645 tpl_addVar(vars, TPLADD, "DISABLECRCCWSVALUE", (rdr->disablecrccws == 1) ? "1" : "0");
2646 }
2647
2648 // Set reader to use GPIO
2649 if(!apicall)
2650 {
2651 tpl_addVar(vars, TPLADD, "USE_GPIOCHECKED", rdr->use_gpio ? "checked" : "");
2652 }
2653 else
2654 {
2655 tpl_addVar(vars, TPLADD, "USE_GPIOVALUE", rdr->use_gpio ? "1" : "0");
2656 }
2657
2658 // AUdisabled
2659 if(!apicall)
2660 {
2661 tpl_addVar(vars, TPLADD, "AUDISABLED", (rdr->audisabled == 1) ? "checked" : "");
2662 }
2663 else
2664 {
2665 tpl_addVar(vars, TPLADD, "AUDISABLEDVALUE", (rdr->audisabled == 1) ? "1" : "0");
2666 }
2667
2668 tpl_printf(vars, TPLADD, "TMP", "AUTYPE%d", rdr->autype);
2669 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
2670
2671 // AUprovid
2672 if(rdr->auprovid)
2673 { tpl_printf(vars, TPLADD, "AUPROVID", "%06X", rdr->auprovid); }
2674
2675 if(rdr->ecmnotfoundlimit)
2676 { tpl_printf(vars, TPLADD, "ECMNOTFOUNDLIMIT", "%u", rdr->ecmnotfoundlimit); }
2677
2678 // Force Irdeto
2679 if(!apicall)
2680 {
2681 tpl_addVar(vars, TPLADD, "FORCEIRDETOCHECKED", (rdr->force_irdeto == 1) ? "checked" : "");
2682 }
2683 else
2684 {
2685 tpl_addVar(vars, TPLADD, "FORCEIRDETOVALUE", (rdr->force_irdeto == 1) ? "1" : "0");
2686 }
2687
2688 // needsemmfirst
2689
2690 if(!apicall)
2691 {
2692 tpl_addVar(vars, TPLADD, "NEEDSEMMFIRST", (rdr->needsemmfirst == 1) ? "checked" : "");
2693 }
2694 else
2695 {
2696 tpl_addVar(vars, TPLADD, "NEEDSEMMFIRST", (rdr->needsemmfirst == 1) ? "1" : "0");
2697 }
2698
2699 #ifdef READER_CRYPTOWORKS
2700 // needsglobalfirst
2701 if(!apicall)
2702 {
2703 tpl_addVar(vars, TPLADD, "NEEDSGLOBALFIRST", (rdr->needsglobalfirst == 1) ? "checked" : "");
2704 }
2705 else
2706 {
2707 tpl_addVar(vars, TPLADD, "NEEDSGLOBALFIRST", (rdr->needsglobalfirst == 1) ? "1" : "0");
2708 }
2709 #endif
2710
2711 // RSA Key
2712 for(i = 0; i < rdr->rsa_mod_length; i++)
2713 { tpl_printf(vars, TPLAPPEND, "RSAKEY", "%02X", rdr->rsa_mod[i]); }
2714
2715 // 3DES Key
2716 for(i = 0; i < rdr->des_key_length; i++)
2717 { tpl_printf(vars, TPLAPPEND, "DESKEY", "%02X", rdr->des_key[i]); }
2718
2719 // BoxKey
2720 for(i = 0; i < rdr->boxkey_length ; i++)
2721 { tpl_printf(vars, TPLAPPEND, "BOXKEY", "%02X", rdr->boxkey[i]); }
2722
2723 #ifdef READER_CONAX
2724 for(i = 0; i < rdr->cwpk_mod_length; i++)
2725 { tpl_printf(vars, TPLAPPEND, "CWPKKEY", "%02X", rdr->cwpk_mod[i]); }
2726 #endif
2727
2728 #ifdef READER_NAGRA
2729 // nuid (CAK6.3)
2730 for(i = 0; i < rdr->cak63nuid_length; i++)
2731 { tpl_printf(vars, TPLAPPEND, "CAK63NUID", "%02X", rdr->cak63nuid[i]); }
2732
2733 // cwekey (CAK6.3)
2734 for(i = 0; i < rdr->cak63cwekey_length; i++)
2735 { tpl_printf(vars, TPLAPPEND, "CAK63CWEKEY", "%02X", rdr->cak63cwekey[i]); }
2736 #endif
2737
2738 #ifdef READER_NAGRA_MERLIN
2739 int32_t j;
2740
2741 // idird (CAK7)
2742 for(i = 0; i < rdr->idird_length; i++)
2743 { tpl_printf(vars, TPLAPPEND, "IDIRD", "%02X", rdr->idird[i]); }
2744
2745 // cmd0e_provider (CAK7)
2746 for(i = 0; i < rdr->cmd0eprov_length; i++)
2747 { tpl_printf(vars, TPLAPPEND, "CMD0EPROV", "%02X", rdr->cmd0eprov[i]); }
2748
2749 // mod1 (CAK7)
2750 for(i = 0; i < rdr->mod1_length ; i++)
2751 { tpl_printf(vars, TPLAPPEND, "MOD1", "%02X", rdr->mod1[i]); }
2752
2753 // mod2 (CAK7)
2754 for(i = 0; i < rdr->mod2_length ; i++)
2755 { tpl_printf(vars, TPLAPPEND, "MOD2", "%02X", rdr->mod2[i]); }
2756
2757 // key3588 (CAK7)
2758 for(i = 0; i < rdr->key3588_length; i++)
2759 { tpl_printf(vars, TPLAPPEND, "KEY3588", "%02X", rdr->key3588[i]); }
2760
2761 // key3310 (CAK7)
2762 for(i = 0; i < rdr->key3310_length; i++)
2763 { tpl_printf(vars, TPLAPPEND, "KEY3310", "%02X", rdr->key3310[i]); }
2764
2765 // key3460 (CAK7)
2766 for(i = 0; i < rdr->key3460_length; i++)
2767 { tpl_printf(vars, TPLAPPEND, "KEY3460", "%02X", rdr->key3460[i]); }
2768
2769 // data50 (CAK7)
2770 for(i = 0; i < rdr->data50_length; i++)
2771 { tpl_printf(vars, TPLAPPEND, "DATA50", "%02X", rdr->data50[i]); }
2772
2773 // mod50 (CAK7)
2774 for(i = 0; i < rdr->mod50_length; i++)
2775 { tpl_printf(vars, TPLAPPEND, "MOD50", "%02X", rdr->mod50[i]); }
2776
2777 // nuid (CAK7)
2778 for(i = 0; i < rdr->nuid_length; i++)
2779 { tpl_printf(vars, TPLAPPEND, "NUID", "%02X", rdr->nuid[i]); }
2780
2781 // OTP CSC (CAK7)
2782 for(i = 0; i < rdr->otpcsc_length; i++)
2783 { tpl_printf(vars, TPLAPPEND, "OTPCSC", "%02X", rdr->otpcsc[i]); }
2784
2785 // OTA CSC (CAK7)
2786 for(i = 0; i < rdr->otacsc_length; i++)
2787 { tpl_printf(vars, TPLAPPEND, "OTACSC", "%02X", rdr->otacsc[i]); }
2788
2789 // Force Pairing Type (CAK7)
2790 for(i = 0; i < rdr->forcepair_length; i++)
2791 { tpl_printf(vars, TPLAPPEND, "FORCEPAIR", "%02X", rdr->forcepair[i]); }
2792
2793 // cwekeys (CAK7)
2794 for(j = 0; j < 8; j++)
2795 {
2796 char key[8] = "CWEKEYX";
2797 key[6] = '0' + j;
2798 for(i = 0; i < rdr->cwekey_length[j]; i++)
2799 { tpl_printf(vars, TPLAPPEND, key, "%02X", rdr->cwekey[j][i]); }
2800 }
2801
2802 // force_cw_swap
2803 if(rdr->forcecwswap)
2804 { tpl_addVar(vars, TPLADD, "FORCECWSWAPCHECKED", "checked"); }
2805
2806 // only_even_SA
2807 if(rdr->evensa)
2808 { tpl_addVar(vars, TPLADD, "EVENSACHECKED", "checked"); }
2809
2810 // force_EMM_82
2811 if(rdr->forceemmg)
2812 { tpl_addVar(vars, TPLADD, "FORCEEMMGCHECKED", "checked"); }
2813
2814 // OTA_CWPKs
2815 if(rdr->cwpkota)
2816 { tpl_addVar(vars, TPLADD, "CWPKOTACHECKED", "checked"); }
2817 #endif
2818
2819 // CWPK CaID (CAK7)
2820 for(i = 0; i < rdr->cwpkcaid_length ; i++)
2821 { tpl_printf(vars, TPLAPPEND, "CWPKCAID", "%02X", rdr->cwpkcaid[i]); }
2822
2823 // cak7_mode
2824 if(rdr->cak7_mode)
2825 { tpl_addVar(vars, TPLADD, "NAGRACAK7MODECHECKED", "checked"); }
2826
2827 // ins7E
2828 if(rdr->ins7E[0x1A])
2829 {
2830 for(i = 0; i < 26 ; i++) { tpl_printf(vars, TPLAPPEND, "INS7E", "%02X", rdr->ins7E[i]); }
2831 }
2832 // ins42
2833 if(rdr->ins42[0x25])
2834 {
2835 for(i = 0; i < 37 ; i++) { tpl_printf(vars, TPLAPPEND, "INS42", "%02X", rdr->ins42[i]); }
2836 }
2837
2838 // ins7E11
2839 if(rdr->ins7E11[0x01])
2840 {
2841 tpl_printf(vars, TPLAPPEND, "INS7E11", "%02X", rdr->ins7E11[0]);
2842 }
2843
2844 // ins2e06
2845 if(rdr->ins2e06[0x04])
2846 {
2847 for(i = 0; i < 4 ; i++) { tpl_printf(vars, TPLAPPEND, "INS2E06", "%02X", rdr->ins2e06[i]); }
2848 }
2849
2850 // k1 for generic pairing mode
2851 if(rdr->k1_generic[0x10])
2852 {
2853 for(i = 0; i < rdr->k1_generic[0x10] ; i++) { tpl_printf(vars, TPLAPPEND, "K1_GENERIC", "%02X", rdr->k1_generic[i]); }
2854 }
2855
2856 // k1 for unique pairing mode
2857 if(rdr->k1_unique[0x10])
2858 {
2859 for(i = 0; i < rdr->k1_unique[0x10] ; i++) { tpl_printf(vars, TPLAPPEND, "K1_UNIQUE", "%02X", rdr->k1_unique[i]); }
2860 }
2861
2862 // ATR
2863 if(rdr->atr[0])
2864 for(i = 0; i < rdr->atrlen / 2; i++)
2865 { tpl_printf(vars, TPLAPPEND, "ATR", "%02X", rdr->atr[i]); }
2866
2867 // ECM Whitelist
2868 value = mk_t_ecm_whitelist(&rdr->ecm_whitelist);
2869 tpl_addVar(vars, TPLADD, "ECMWHITELIST", value);
2870 free_mk_t(value);
2871
2872 // ECM Header Whitelist
2873 value = mk_t_ecm_hdr_whitelist(&rdr->ecm_hdr_whitelist);
2874 tpl_addVar(vars, TPLADD, "ECMHEADERWHITELIST", value);
2875 free_mk_t(value);
2876
2877 // Deprecated
2878 if(!apicall)
2879 {
2880 tpl_addVar(vars, TPLADD, "DEPRECATEDCHECKED", (rdr->deprecated == 1) ? "checked" : "");
2881 }
2882 else
2883 {
2884 tpl_addVar(vars, TPLADD, "DEPRECATEDVALUE", (rdr->deprecated == 1) ? "1" : "0");
2885 }
2886
2887 // Smargopatch
2888 if(!apicall)
2889 {
2890 tpl_addVar(vars, TPLADD, "SMARGOPATCHCHECKED", (rdr->smargopatch == 1) ? "checked" : "");
2891 }
2892 else
2893 {
2894 tpl_addVar(vars, TPLADD, "SMARGOPATCHVALUE", (rdr->smargopatch == 1) ? "1" : "0");
2895 }
2896
2897 // Autospeed
2898 if(!apicall)
2899 {
2900 tpl_addVar(vars, TPLADD, "AUTOSPEEDCHECKED", (rdr->autospeed == 1) ? "checked" : "");
2901 }
2902 else
2903 {
2904 tpl_addVar(vars, TPLADD, "AUTOSPEEDVALUE", (rdr->autospeed == 1) ? "1" : "0");
2905 }
2906 // sc8in1 dtrrts patch
2907 if(!apicall)
2908 {
2909 tpl_addVar(vars, TPLADD, "SC8IN1DTRRTSPATCHCHECKED", (rdr->sc8in1_dtrrts_patch == 1) ? "checked" : "");
2910 }
2911 else
2912 {
2913 tpl_addVar(vars, TPLADD, "SC8IN1DTRRTSPATCHVALUE", (rdr->sc8in1_dtrrts_patch == 1) ? "1" : "0");
2914 }
2915
2916 if(!apicall)
2917 {
2918 tpl_addVar(vars, TPLADD, "READOLDCLASSES", (rdr->read_old_classes == 1) ? "checked" : "");
2919 }
2920 else
2921 {
2922 tpl_addVar(vars, TPLADD, "READOLDCLASSES", (rdr->read_old_classes == 1) ? "1" : "0");
2923 }
2924
2925 // Detect
2926 if(rdr->detect & 0x80)
2927 { tpl_printf(vars, TPLADD, "DETECT", "!%s", RDR_CD_TXT[rdr->detect & 0x7f]); }
2928 else
2929 { tpl_addVar(vars, TPLADD, "DETECT", RDR_CD_TXT[rdr->detect & 0x7f]); }
2930
2931 // Ratelimit
2932 if(rdr->ratelimitecm)
2933 {
2934 tpl_printf(vars, TPLADD, "RATELIMITECM", "%d", rdr->ratelimitecm);
2935 // ECMUNIQUE
2936 if(!apicall)
2937 {
2938 tpl_addVar(vars, TPLADD, "ECMUNIQUECHECKED", (rdr->ecmunique == 1) ? "checked" : "");
2939 }
2940 else
2941 {
2942 tpl_addVar(vars, TPLADD, "ECMUNIQUE", (rdr->ecmunique == 1) ? "1" : "0");
2943 }
2944 tpl_printf(vars, TPLADD, "RATELIMITTIME", "%d", rdr->ratelimittime);
2945 tpl_printf(vars, TPLADD, "SRVIDHOLDTIME", "%d", rdr->srvidholdtime);
2946 }
2947 // Cooldown
2948 if(rdr->cooldown[0] && rdr->cooldown[1])
2949 {
2950 tpl_printf(vars, TPLADD, "COOLDOWNDELAY", "%d", rdr->cooldown[0]);
2951 tpl_printf(vars, TPLADD, "COOLDOWNTIME", "%d", rdr->cooldown[1]);
2952 }
2953 // Frequencies
2954 tpl_printf(vars, TPLADD, "MHZ", "%d", rdr->mhz);
2955 tpl_printf(vars, TPLADD, "CARDMHZ", "%d", rdr->cardmhz);
2956
2957 // Device
2958 if(!apicall)
2959 {
2960 tpl_addVar(vars, TPLADD, "DEVICE", xml_encode(vars, rdr->device));
2961 }
2962 else
2963 {
2964 tpl_addVar(vars, TPLADD, "DEVICE", rdr->device);
2965 }
2966
2967 if(rdr->r_port)
2968 { tpl_printf(vars, TPLAPPEND, "DEVICE", ",%d", rdr->r_port); }
2969 if(rdr->l_port)
2970 {
2971 if(rdr->r_port)
2972 { tpl_printf(vars, TPLAPPEND, "DEVICE", ",%d", rdr->l_port); }
2973 else
2974 { tpl_printf(vars, TPLAPPEND, "DEVICE", ",,%d", rdr->l_port); }
2975 }
2976
2977 // Group
2978 value = mk_t_group(rdr->grp);
2979 tpl_addVar(vars, TPLADD, "GRP", value);
2980 free_mk_t(value);
2981
2982 #ifdef WITH_LB
2983 if(rdr->lb_weight)
2984 { tpl_printf(vars, TPLADD, "LBWEIGHT", "%d", rdr->lb_weight); }
2985 #endif
2986
2987 //services
2988 if(!apicall)
2989 {
2990 struct s_sidtab *sidtab = cfg.sidtab;
2991 //build matrix
2992 i = 0;
2993 while(sidtab != NULL)
2994 {
2995 tpl_addVar(vars, TPLADD, "SIDLABEL", xml_encode(vars, sidtab->label));
2996 if(rdr->sidtabs.ok & ((SIDTABBITS)1 << i)) { tpl_addVar(vars, TPLADD, "CHECKED", "checked"); }
2997 else { tpl_addVar(vars, TPLADD, "CHECKED", ""); }
2998 tpl_addVar(vars, TPLAPPEND, "SIDS", tpl_getTpl(vars, "READERCONFIGSIDOKBIT"));
2999 if(rdr->sidtabs.no & ((SIDTABBITS)1 << i)) { tpl_addVar(vars, TPLADD, "CHECKED", "checked"); }
3000 else { tpl_addVar(vars, TPLADD, "CHECKED", ""); }
3001 tpl_addVar(vars, TPLAPPEND, "SIDS", tpl_getTpl(vars, "READERCONFIGSIDNOBIT"));
3002 if(rdr->lb_sidtabs.ok & ((SIDTABBITS)1 << i)) { tpl_addVar(vars, TPLADD, "CHECKED", "checked"); }
3003 else { tpl_addVar(vars, TPLADD, "CHECKED", ""); }
3004 tpl_addVar(vars, TPLAPPEND, "SIDS", tpl_getTpl(vars, "READERCONFIGSIDLBOKBIT"));
3005 sidtab = sidtab->next;
3006 i++;
3007 }
3008 if(i){
3009 tpl_addVar(vars, TPLADD, "READERCONFIGSIDINS", tpl_getTpl(vars, "READERCONFIGSID"));
3010 }
3011 }
3012 else
3013 {
3014 value = mk_t_service(&rdr->sidtabs);
3015 if(cs_strlen(value) > 0)
3016 { tpl_addVar(vars, TPLADD, "SERVICES", value); }
3017 free_mk_t(value);
3018 }
3019
3020 // CAID
3021 value = mk_t_caidtab(&rdr->ctab);
3022 tpl_addVar(vars, TPLADD, "CAIDS", value);
3023 free_mk_t(value);
3024
3025 // AESkeys
3026 value = mk_t_aeskeys(rdr);
3027 tpl_addVar(vars, TPLADD, "AESKEYS", value);
3028 free_mk_t(value);
3029
3030 //ident
3031 value = mk_t_ftab(&rdr->ftab);
3032 tpl_addVar(vars, TPLADD, "IDENTS", value);
3033 free_mk_t(value);
3034
3035 //CHID
3036 value = mk_t_ftab(&rdr->fchid);
3037 tpl_addVar(vars, TPLADD, "CHIDS", value);
3038 free_mk_t(value);
3039
3040 //Local cards
3041 value = mk_t_ftab(&rdr->localcards);
3042 tpl_addVar(vars, TPLADD, "LOCALCARDS", value);
3043 free_mk_t(value);
3044
3045 //class
3046 value = mk_t_cltab(&rdr->cltab);
3047 tpl_addVar(vars, TPLADD, "CLASS", value);
3048 free_mk_t(value);
3049
3050 if(rdr->cachemm || rdr->logemm)
3051 { tpl_printf(vars, TPLADD, "EMMCACHE", "%d,%d,%d,%d", rdr->cachemm, rdr->rewritemm, rdr->logemm, rdr->deviceemm); }
3052
3053 //savenano
3054 value = mk_t_nano(rdr->s_nano);
3055 tpl_addVar(vars, TPLADD, "SAVENANO", value);
3056 free_mk_t(value);
3057
3058 //blocknano
3059 value = mk_t_nano(rdr->b_nano);
3060 tpl_addVar(vars, TPLADD, "BLOCKNANO", value);
3061 free_mk_t(value);
3062
3063 // Blocke EMM
3064 if(!apicall)
3065 {
3066 tpl_addVar(vars, TPLADD, "BLOCKEMMUNKNOWNCHK", (rdr->blockemm & EMM_UNKNOWN) ? "checked" : "");
3067 tpl_addVar(vars, TPLADD, "BLOCKEMMUNIQCHK", (rdr->blockemm & EMM_UNIQUE) ? "checked" : "");
3068 tpl_addVar(vars, TPLADD, "BLOCKEMMSHAREDCHK", (rdr->blockemm & EMM_SHARED) ? "checked" : "");
3069 tpl_addVar(vars, TPLADD, "BLOCKEMMGLOBALCHK", (rdr->blockemm & EMM_GLOBAL) ? "checked" : "");
3070 }
3071 else
3072 {
3073 tpl_addVar(vars, TPLADD, "BLOCKEMMUNKNOWNVALUE", (rdr->blockemm & EMM_UNKNOWN) ? "1" : "0");
3074 tpl_addVar(vars, TPLADD, "BLOCKEMMUNIQVALUE", (rdr->blockemm & EMM_UNIQUE) ? "1" : "0");
3075 tpl_addVar(vars, TPLADD, "BLOCKEMMSHAREDVALUE", (rdr->blockemm & EMM_SHARED) ? "1" : "0");
3076 tpl_addVar(vars, TPLADD, "BLOCKEMMGLOBALVALUE", (rdr->blockemm & EMM_GLOBAL) ? "1" : "0");
3077 }
3078
3079 // Save EMM
3080 if(!apicall)
3081 {
3082 tpl_addVar(vars, TPLADD, "SAVEEMMUNKNOWNCHK", (rdr->saveemm & EMM_UNKNOWN) ? "checked" : "");
3083 tpl_addVar(vars, TPLADD, "SAVEEMMUNIQCHK", (rdr->saveemm & EMM_UNIQUE) ? "checked" : "");
3084 tpl_addVar(vars, TPLADD, "SAVEEMMSHAREDCHK", (rdr->saveemm & EMM_SHARED) ? "checked" : "");
3085 tpl_addVar(vars, TPLADD, "SAVEEMMGLOBALCHK", (rdr->saveemm & EMM_GLOBAL) ? "checked" : "");
3086 }
3087 else
3088 {
3089 tpl_addVar(vars, TPLADD, "SAVEEMMUNKNOWNVALUE", (rdr->saveemm & EMM_UNKNOWN) ? "1" : "0");
3090 tpl_addVar(vars, TPLADD, "SAVEEMMUNIQVALUE", (rdr->saveemm & EMM_UNIQUE) ? "1" : "0");
3091 tpl_addVar(vars, TPLADD, "SAVEEMMSHAREDVALUE", (rdr->saveemm & EMM_SHARED) ? "1" : "0");
3092 tpl_addVar(vars, TPLADD, "SAVEEMMGLOBALVALUE", (rdr->saveemm & EMM_GLOBAL) ? "1" : "0");
3093 }
3094
3095 value = mk_t_emmbylen(rdr);
3096 if(cs_strlen(value) > 0)
3097 { tpl_addVar(vars, TPLADD, "BLOCKEMMBYLEN", value); }
3098 free_mk_t(value);
3099
3100 #ifdef MODULE_CCCAM
3101 if(!strcmp(rdr->cc_version, "2.0.11"))
3102 {
3103 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED0", "selected");
3104 }
3105 else if(!strcmp(rdr->cc_version, "2.1.1"))
3106 {
3107 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED1", "selected");
3108 }
3109 else if(!strcmp(rdr->cc_version, "2.1.2"))
3110 {
3111 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED2", "selected");
3112 }
3113 else if(!strcmp(rdr->cc_version, "2.1.3"))
3114 {
3115 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED3", "selected");
3116 }
3117 else if(!strcmp(rdr->cc_version, "2.1.4"))
3118 {
3119 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED4", "selected");
3120 }
3121 else if(!strcmp(rdr->cc_version, "2.2.0"))
3122 {
3123 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED5", "selected");
3124 }
3125 else if(!strcmp(rdr->cc_version, "2.2.1"))
3126 {
3127 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED6", "selected");
3128 }
3129 else if(!strcmp(rdr->cc_version, "2.3.0"))
3130 {
3131 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED7", "selected");
3132 }
3133 else if(!strcmp(rdr->cc_version, "2.3.1"))
3134 {
3135 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED8", "selected");
3136 }
3137 else if(!strcmp(rdr->cc_version, "2.3.2"))
3138 {
3139 tpl_addVar(vars, TPLADD, "CCCVERSIONSELECTED9", "selected");
3140 }
3141 #endif
3142
3143 tpl_printf(vars, TPLADD, "TMP", "NDSVERSION%d", rdr->ndsversion);
3144 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3145
3146 tpl_printf(vars, TPLADD, "TMP", "NDSREADTIERS%d", rdr->readtiers);
3147 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3148
3149 tpl_printf(vars, TPLADD, "TMP", "NAGRAREAD%d", rdr->nagra_read);
3150 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3151
3152 if(rdr->detect_seca_nagra_tunneled_card)
3153 { tpl_addVar(vars, TPLADD, "NAGRADETECTSECACARDCHECKED", "checked"); }
3154
3155 #ifdef MODULE_CCCAM
3156 tpl_printf(vars, TPLADD, "CCCMAXHOPS", "%d", rdr->cc_maxhops);
3157 tpl_printf(vars, TPLADD, "CCCMINDOWN", "%d", rdr->cc_mindown);
3158 tpl_printf(vars, TPLADD, "CCCRESHARE", "%d", rdr->cc_reshare);
3159 tpl_printf(vars, TPLADD, "RESHARE", "%d", cfg.cc_reshare);
3160 tpl_printf(vars, TPLADD, "CCCRECONNECT", "%d", rdr->cc_reconnect);
3161
3162 if(rdr->cc_want_emu)
3163 { tpl_addVar(vars, TPLADD, "CCCWANTEMUCHECKED", "checked"); }
3164 if(rdr->cc_keepalive)
3165 { tpl_addVar(vars, TPLADD, "KEEPALIVECHECKED", "checked"); }
3166 #endif
3167
3168 #ifdef MODULE_GBOX
3169 tpl_printf(vars, TPLADD, "GBOXMAXDISTANCE", "%d", rdr->gbox_maxdist);
3170 tpl_printf(vars, TPLADD, "GBOXMAXECMSEND", "%d", rdr->gbox_maxecmsend);
3171 tpl_printf(vars, TPLADD, "GBOXRESHARE", "%d", rdr->gbox_reshare);
3172 tpl_printf(vars, TPLADD, "PEERGBOXID", "%04X", gbox_convert_password_to_id((uint32_t)a2i(rdr->r_pwd, 4)));
3173 tpl_addVar(vars, TPLADD, "PEERONLSTAT", (get_peer_onl_status(gbox_convert_password_to_id((uint32_t)a2i(rdr->r_pwd, 4)))) ? "checked" : "");
3174 tpl_printf(vars, TPLADD, "FORCEREMM", "%d", rdr->gbox_force_remm);
3175 tpl_printf(vars, TPLADD, "CMDHERE", rdr->send_offline_cmd ? "checked" : "");
3176
3177 if(rdr->blockemm & 0x80)
3178 {
3179 tpl_addVar(vars, TPLADD, "REMMCNLDCHK", "checked");
3180 tpl_printf(vars, TPLADD, "GBOXREMMPEER", "%04X", rdr->gbox_remm_peer);
3181 tpl_addVar(vars, TPLADD, "REMMUNIQCHK", (rdr->blockemm & EMM_UNIQUE) ? "" : "checked");
3182 tpl_addVar(vars, TPLADD, "REMMSHAREDCHK", (rdr->blockemm & EMM_SHARED) ? "" : "checked");
3183 tpl_addVar(vars, TPLADD, "REMMGLOBALCHK", (rdr->blockemm & EMM_GLOBAL) ? "" : "checked");
3184 tpl_addVar(vars, TPLADD, "REMMEMMUNKNOWNCHK", (rdr->blockemm & EMM_UNKNOWN) ? "" : "checked");
3185 }
3186 if(rdr->gbox_gsms_peer)
3187 {
3188 tpl_printf(vars, TPLADD, "LASTGSMS", "%s", rdr->last_gsms);
3189 tpl_printf(vars, TPLADD, "GBOXGSMSPEER", "%04X", rdr->gbox_gsms_peer);
3190 }
3191 #endif
3192
3193 #ifdef READER_DRECAS
3194 tpl_addVar(vars, TPLADD, "STMKEYS", rdr->stmkeys);
3195 #endif
3196
3197 #if defined(READER_DRE) || defined(READER_DRECAS)
3198 tpl_addVar(vars, TPLADD, "USERSCRIPT", rdr->userscript);
3199 #endif
3200
3201 #ifdef WITH_EMU
3202 //emu_auproviders
3203 value = mk_t_ftab(&rdr->emu_auproviders);
3204 tpl_addVar(vars, TPLADD, "EMUAUPROVIDERS", value);
3205 free_mk_t(value);
3206
3207 // Date-coded BISS keys
3208 if(!apicall)
3209 {
3210 tpl_addVar(vars, TPLADD, "EMUDATECODEDENABLED", (rdr->emu_datecodedenabled == 1) ? "checked" : "");
3211 }
3212 else
3213 {
3214 tpl_addVar(vars, TPLADD, "EMUDATECODEDENABLED", (rdr->emu_datecodedenabled == 1) ? "1" : "0");
3215 }
3216 #endif
3217
3218 tpl_addVar(vars, TPLADD, "PROTOCOL", reader_get_type_desc(rdr, 0));
3219
3220 // Show only parameters which needed for the reader
3221 switch(rdr->typ)
3222 {
3223 case R_CONSTCW:
3224 case R_DB2COM1:
3225 case R_DB2COM2:
3226 case R_MOUSE :
3227 case R_DRECAS :
3228 case R_MP35:
3229 case R_SC8in1 :
3230 case R_SMART :
3231 case R_INTERNAL:
3232 case R_SERIAL :
3233 case R_PCSC :
3234 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGSTDHWREADERBIT"));
3235 break;
3236 case R_CAMD35 :
3237 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGCAMD35BIT"));
3238 break;
3239 case R_EMU :
3240 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGEMUBIT"));
3241 break;
3242 case R_CS378X :
3243 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGCS378XBIT"));
3244 break;
3245 case R_RADEGAST:
3246 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGRADEGASTBIT"));
3247 break;
3248 case R_SCAM:
3249 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGSCAMBIT"));
3250 break;
3251 case R_GHTTP:
3252 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGGHTTPBIT"));
3253 break;
3254 case R_GBOX:
3255 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGGBOXBIT"));
3256 #if defined (MODULE_CCCAM) && defined (MODULE_GBOX)
3257 if(cfg.cc_gbx_reshare_en)
3258 {
3259 tpl_printf(vars, TPLADD, "GBOXCCCAMRESHARE", "%d", rdr->gbox_cccam_reshare);
3260 value = mk_t_ftab(&rdr->ccc_gbx_reshare_ident);
3261 tpl_addVar(vars, TPLADD, "CCCGBXRESHAREIDENT", value);
3262 free_mk_t(value);
3263 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "GBOXCCCAMRESHAREBIT"));
3264 }
3265 #endif
3266 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERINFOGBOXREMM"));
3267 break;
3268 case R_NEWCAMD:
3269 if(rdr->ncd_proto == NCD_525)
3270 {
3271 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGNCD525BIT"));
3272 }
3273 else if(rdr->ncd_proto == NCD_524)
3274 {
3275 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGNCD524BIT"));
3276 }
3277 break;
3278 #ifdef MODULE_CCCAM
3279 case R_CCCAM :
3280 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGCCCAMBIT"));
3281 break;
3282 #endif
3283 default :
3284 tpl_addMsg(vars, "Error: protocol not resolvable");
3285 break;
3286
3287 }
3288
3289 #ifdef MODULE_CCCAM
3290 if(rdr->typ != R_CCCAM && rdr->typ != R_GBOX)
3291 {
3292 tpl_printf(vars, TPLADD, "CCCHOP", "%d", rdr->cc_hop);
3293 tpl_addVar(vars, TPLAPPEND, "READERDEPENDINGCONFIG", tpl_getTpl(vars, "READERCONFIGHOPBIT"));
3294 }
3295 #endif
3296
3297 #ifdef CS_CACHEEX_AIO
3298 return tpl_getTpl(vars, "READERCONFIGAIO");
3299 #else
3300 return tpl_getTpl(vars, "READERCONFIG");
3301 #endif
3302 }
3303
3304 static char *send_oscam_reader_stats(struct templatevars *vars, struct uriparams *params, int32_t apicall)
3305 {
3306
3307 if(!apicall) { setActiveMenu(vars, MNU_READERS); }
3308
3309 int8_t error;
3310 struct s_client *cl = NULL;
3311 struct s_reader *rdr;
3312
3313 rdr = get_reader_by_label(getParam(params, "label"));
3314 error = (rdr ? 0 : 1);
3315
3316 if(!error && rdr)
3317 {
3318 cl = rdr->client;
3319 error = (cl ? 0 : 1);
3320 }
3321
3322 if(error)
3323 {
3324 tpl_addVar(vars, TPLAPPEND, "READERSTATSROW", tpl_getTpl(vars, "READERSTATSROWBIT"));
3325 if(!apicall)
3326 { return tpl_getTpl(vars, "READERSTATS"); }
3327 else
3328 { return tpl_getTpl(vars, "APIREADERSTATS"); }
3329 }
3330
3331 #ifdef WITH_LB
3332 char *stxt[] = {"found", "cache1", "cache2", "cache3",
3333 "not found", "timeout", "sleeping",
3334 "fake", "invalid", "corrupt", "no card", "expdate",
3335 "disabled", "stopped"
3336 };
3337
3338 if(strcmp(getParam(params, "action"), "resetstat") == 0)
3339 {
3340 char *rcs = getParam(params, "rc");
3341 int32_t retval = 0;
3342 if(cs_strlen(rcs) > 0)
3343 {
3344 int8_t rc;
3345 rc = atoi(rcs);
3346 retval = clean_stat_by_rc(rdr, rc, 0);
3347 cs_log("Reader %s stats %d %s entr%s deleted by WebIF from %s",
3348 rdr->label, retval, stxt[rc],
3349 retval == 1 ? "y" : "ies",
3350 cs_inet_ntoa(GET_IP()));
3351 }
3352 else
3353 {
3354 clear_reader_stat(rdr);
3355 cs_log("Reader %s stats resetted by WebIF from %s", rdr->label, cs_inet_ntoa(GET_IP()));
3356 }
3357
3358 }
3359
3360 if(strcmp(getParam(params, "action"), "deleterecord") == 0)
3361 {
3362 char *record = getParam(params, "record");
3363 if(cs_strlen(record) > 0)
3364 {
3365 int32_t retval = 0;
3366 uint32_t caid, provid, sid, cid, len;
3367 sscanf(record, "%4x@%6x:%4x:%4x:%4x", &caid, &provid, &sid, &cid, &len);
3368 retval = clean_stat_by_id(rdr, caid, provid, sid, cid, len);
3369 cs_log("Reader %s stats %d entr%s deleted by WebIF from %s",
3370 rdr->label, retval,
3371 retval == 1 ? "y" : "ies",
3372 cs_inet_ntoa(GET_IP()));
3373 }
3374 }
3375
3376 if(strcmp(getParam(params, "action"), "updateecmlen") == 0)
3377 {
3378 update_ecmlen_from_stat(rdr);
3379 write_server();
3380 }
3381
3382 #endif
3383
3384 tpl_addVar(vars, TPLADD, "READERNAME", xml_encode(vars, rdr->label));
3385 tpl_addVar(vars, TPLADD, "LABEL", xml_encode(vars, rdr->label));
3386 tpl_addVar(vars, TPLADD, "ENCODEDLABEL", urlencode(vars, rdr->label));
3387
3388 if(apicall)
3389 {
3390 int32_t i, emmcount = 0;
3391 char *ttxt[] = {"unknown", "unique", "shared", "global"};
3392
3393 for(i = 0; i < 4; i++)
3394 {
3395 tpl_addVar(vars, TPLADD, "EMMRESULT", "error");
3396 tpl_addVar(vars, TPLADD, "EMMTYPE", ttxt[i]);
3397 tpl_printf(vars, TPLADD, "EMMCOUNT", "%d", rdr->emmerror[i]);
3398 tpl_addVar(vars, TPLAPPEND, "EMMSTATS", tpl_getTpl(vars, "APIREADERSTATSEMMBIT"));
3399 emmcount += rdr->emmerror[i];
3400 tpl_printf(vars, TPLADD, "TOTALERROR", "%d", emmcount);
3401 }
3402 emmcount = 0;
3403 for(i = 0; i < 4; i++)
3404 {
3405 tpl_addVar(vars, TPLADD, "EMMRESULT", "written");
3406 tpl_addVar(vars, TPLADD, "EMMTYPE", ttxt[i]);
3407 tpl_printf(vars, TPLADD, "EMMCOUNT", "%d", rdr->emmwritten[i]);
3408 tpl_addVar(vars, TPLAPPEND, "EMMSTATS", tpl_getTpl(vars, "APIREADERSTATSEMMBIT"));
3409 emmcount += rdr->emmwritten[i];
3410 tpl_printf(vars, TPLADD, "TOTALWRITTEN", "%d", emmcount);
3411 }
3412 emmcount = 0;
3413 for(i = 0; i < 4; i++)
3414 {
3415 tpl_addVar(vars, TPLADD, "EMMRESULT", "skipped");
3416 tpl_addVar(vars, TPLADD, "EMMTYPE", ttxt[i]);
3417 tpl_printf(vars, TPLADD, "EMMCOUNT", "%d", rdr->emmskipped[i]);
3418 tpl_addVar(vars, TPLAPPEND, "EMMSTATS", tpl_getTpl(vars, "APIREADERSTATSEMMBIT"));
3419 emmcount += rdr->emmskipped[i];
3420 tpl_printf(vars, TPLADD, "TOTALSKIPPED", "%d", emmcount);
3421 }
3422 emmcount = 0;
3423 for(i = 0; i < 4; i++)
3424 {
3425 tpl_addVar(vars, TPLADD, "EMMRESULT", "blocked");
3426 tpl_addVar(vars, TPLADD, "EMMTYPE", ttxt[i]);
3427 tpl_printf(vars, TPLADD, "EMMCOUNT", "%d", rdr->emmblocked[i]);
3428 tpl_addVar(vars, TPLAPPEND, "EMMSTATS", tpl_getTpl(vars, "APIREADERSTATSEMMBIT"));
3429 emmcount += rdr->emmblocked[i];
3430 tpl_printf(vars, TPLADD, "TOTALBLOCKED", "%d", emmcount);
3431 }
3432 }
3433
3434 if(apicall)
3435 {
3436 char *txt = "UNDEF";
3437 switch(rdr->card_status)
3438 {
3439 case NO_CARD:
3440 if(rdr->typ == R_GBOX)
3441 { txt = "ONL no crd"; }
3442 else
3443 { txt = "OFF"; }
3444 break;
3445 case UNKNOWN:
3446 txt = "UNKNOWN";
3447 break;
3448 case READER_DEVICE_ERROR:
3449 txt = "READER DEVICE ERROR";
3450 break;
3451 case CARD_NEED_INIT:
3452 if(rdr->typ == R_GBOX)
3453 { txt = "OFFLINE"; }
3454 else
3455 { txt = "NEEDINIT"; }
3456 break;
3457 case CARD_INSERTED:
3458 if(cl->typ == 'p')
3459 {
3460 if(rdr->typ == R_GBOX)
3461 { txt = "ONL w/crd"; }
3462 else
3463 { txt = "CONNECTED"; }
3464 }
3465 else
3466 { txt = "CARDOK"; }
3467 break;
3468 case CARD_FAILURE:
3469 txt = "ERROR";
3470 break;
3471 default:
3472 txt = "UNDEF";
3473 }
3474 tpl_addVar(vars, TPLADD, "READERSTATUS", txt);
3475 tpl_printf(vars, TPLADD, "READERCAID", "%04X", rdr->caid);
3476 }
3477
3478 int32_t rowcount = 0;
3479 uint64_t ecmcount = 0;
3480 time_t lastaccess = 0;
3481
3482 #ifdef WITH_LB
3483 int32_t rc2hide = (-1);
3484 if(cs_strlen(getParam(params, "hide")) > 0)
3485 { rc2hide = atoi(getParam(params, "hide")); }
3486
3487 int32_t rc2show = (-1);
3488 if(cs_strlen(getParam(params, "show")) > 0)
3489 { rc2show = atoi(getParam(params, "show")); }
3490
3491 if(rdr->lb_stat)
3492 {
3493 int32_t statsize;
3494 // @todo alno: sort by click, 0=ascending, 1=descending (maybe two buttons or reverse on second click)
3495 READER_STAT **statarray = get_sorted_stat_copy(rdr, 0, &statsize);
3496 char channame[CS_SERVICENAME_SIZE];
3497 for(; rowcount < statsize; ++rowcount)
3498 {
3499 READER_STAT *s = statarray[rowcount];
3500 if(!(s->rc == rc2hide) && ((rc2show == -1) || (s->rc == rc2show)))
3501 {
3502 struct tm lt;
3503 localtime_r(&s->last_received.time, &lt); // fixme we need walltime!
3504 ecmcount += s->ecm_count;
3505 if(!apicall)
3506 {
3507 tpl_printf(vars, TPLADD, "CHANNEL", "%04X@%06X:%04X:%04X", s->caid, s->prid, s->srvid, s->chid);
3508 tpl_addVar(vars, TPLADD, "CHANNELNAME", xml_encode(vars, get_servicename(cur_client(), s->srvid, s->prid, s->caid, channame, sizeof(channame))));
3509 tpl_printf(vars, TPLADD, "ECMLEN", "%04hX", s->ecmlen);
3510 tpl_addVar(vars, TPLADD, "RC", stxt[s->rc]);
3511 tpl_printf(vars, TPLADD, "TIME", PRINTF_LOCAL_D " ms", s->time_avg);
3512 if(s->time_stat[s->time_idx])
3513 { tpl_printf(vars, TPLADD, "TIMELAST", PRINTF_LOCAL_D " ms", s->time_stat[s->time_idx]); }
3514 else
3515 { tpl_addVar(vars, TPLADD, "TIMELAST", ""); }
3516 tpl_printf(vars, TPLADD, "COUNT", PRINTF_LOCAL_D, s->ecm_count);
3517
3518 if(s->last_received.time)
3519 {
3520 tpl_printf(vars, TPLADD, "LAST", "%02d.%02d.%02d %02d:%02d:%02d", lt.tm_mday, lt.tm_mon + 1, lt.tm_year % 100, lt.tm_hour, lt.tm_min, lt.tm_sec);
3521
3522 }
3523 else
3524 {
3525 tpl_addVar(vars, TPLADD, "LAST", "never");
3526 }
3527 }
3528 else
3529 {
3530 tpl_printf(vars, TPLADD, "ECMCAID", "%04X", s->caid);
3531 tpl_printf(vars, TPLADD, "ECMPROVID", "%06X", s->prid);
3532 tpl_printf(vars, TPLADD, "ECMSRVID", "%04X", s->srvid);
3533 tpl_printf(vars, TPLADD, "ECMLEN", "%04hX", s->ecmlen);
3534 tpl_addVar(vars, TPLADD, "ECMCHANNELNAME", xml_encode(vars, get_servicename(cur_client(), s->srvid, s->prid, s->caid, channame, sizeof(channame))));
3535 tpl_printf(vars, TPLADD, "ECMTIME", PRINTF_LOCAL_D, s->time_avg);
3536 tpl_printf(vars, TPLADD, "ECMTIMELAST", PRINTF_LOCAL_D, s->time_stat[s->time_idx]);
3537 tpl_printf(vars, TPLADD, "ECMRC", "%d", s->rc);
3538 tpl_addVar(vars, TPLADD, "ECMRCS", stxt[s->rc]);
3539 if(s->last_received.time)
3540 {
3541 char tbuffer [30];
3542 strftime(tbuffer, 30, "%Y-%m-%dT%H:%M:%S%z", &lt);
3543 tpl_addVar(vars, TPLADD, "ECMLAST", tbuffer);
3544 }
3545 else
3546 {
3547 tpl_addVar(vars, TPLADD, "ECMLAST", "");
3548 }
3549 tpl_printf(vars, TPLADD, "ECMCOUNT", PRINTF_LOCAL_D, s->ecm_count);
3550
3551 if(s->last_received.time > lastaccess)
3552 { lastaccess = s->last_received.time; }
3553 }
3554
3555 if(!apicall)
3556 {
3557 if(s->rc == E_NOTFOUND)
3558 {
3559 tpl_addVar(vars, TPLAPPEND, "READERSTATSROWNOTFOUND", tpl_getTpl(vars, "READERSTATSBIT"));
3560 tpl_addVar(vars, TPLADD, "RESETA", urlencode(vars, rdr->label));
3561 tpl_addVar(vars, TPLADD, "READERSTATSNFHEADLINE", tpl_getTpl(vars, "READERSTATSROWNOTFOUNDBIT"));
3562 }
3563 else if(s->rc == E_TIMEOUT)
3564 {
3565 tpl_addVar(vars, TPLAPPEND, "READERSTATSROWTIMEOUT", tpl_getTpl(vars, "READERSTATSBIT"));
3566 tpl_addVar(vars, TPLADD, "RESETB", urlencode(vars, rdr->label));
3567 tpl_addVar(vars, TPLADD, "READERSTATSTOHEADLINE", tpl_getTpl(vars, "READERSTATSROWTIMEOUTBIT"));
3568 }
3569 else if(s->rc == E_INVALID)
3570 {
3571 tpl_addVar(vars, TPLAPPEND, "READERSTATSROWINVALID", tpl_getTpl(vars, "READERSTATSBIT"));
3572 tpl_addVar(vars, TPLADD, "RESETC", urlencode(vars, rdr->label));
3573 tpl_addVar(vars, TPLADD, "READERSTATSIVHEADLINE", tpl_getTpl(vars, "READERSTATSROWINVALIDBIT"));
3574 }
3575 else
3576 { tpl_addVar(vars, TPLAPPEND, "READERSTATSROWFOUND", tpl_getTpl(vars, "READERSTATSBIT")); }
3577 }
3578 else
3579 {
3580
3581 tpl_addVar(vars, TPLAPPEND, "ECMSTATS", tpl_getTpl(vars, "APIREADERSTATSECMBIT"));
3582 }
3583 }
3584 }
3585 NULLFREE(statarray);
3586 }
3587 else
3588 #endif
3589 tpl_addVar(vars, TPLAPPEND, "READERSTATSROW", tpl_getTpl(vars, "READERSTATSNOSTATS"));
3590
3591 tpl_printf(vars, TPLADD, "ROWCOUNT", "%d", rowcount);
3592
3593 if(lastaccess > 0)
3594 {
3595 char tbuffer [30];
3596 struct tm lt;
3597 localtime_r(&lastaccess, &lt);
3598 strftime(tbuffer, 30, "%Y-%m-%dT%H:%M:%S%z", &lt);
3599 tpl_addVar(vars, TPLADD, "LASTACCESS", tbuffer);
3600 }
3601 else
3602 {
3603 tpl_addVar(vars, TPLADD, "LASTACCESS", "");
3604 }
3605
3606 if(apicall)
3607 {
3608 if(cl)
3609 {
3610 char *value = get_ecm_historystring(cl);
3611 tpl_addVar(vars, TPLADD, "ECMHISTORY", value);
3612 free_mk_t(value);
3613 }
3614 }
3615
3616 tpl_printf(vars, TPLADD, "TOTALECM", "%'" PRIu64, ecmcount);
3617
3618 if(!apicall)
3619 { return tpl_getTpl(vars, "READERSTATS"); }
3620 else
3621 { return tpl_getTpl(vars, "APIREADERSTATS"); }
3622 }
3623
3624 static char *send_oscam_user_config_edit(struct templatevars *vars, struct uriparams *params, int32_t apicall)
3625 {
3626 struct s_auth *account, *ptr, *chk;
3627 char user[sizeof(first_client->account->usr)];
3628
3629 int32_t i;
3630 int existing_insert = 0;
3631
3632 if(!apicall) { setActiveMenu(vars, MNU_USERS); }
3633
3634 if(strcmp(getParam(params, "action"), "Save As") == 0) { cs_strncpy(user, getParam(params, "newuser"), sizeof(user)); }
3635 else { cs_strncpy(user, getParam(params, "user"), sizeof(user)); }
3636
3637 account = NULL;
3638 for(chk = cfg.account; chk != NULL; chk = chk->next)
3639 {
3640 if(strcmp(user, chk->usr) == 0)
3641 { account = chk; }
3642 if(!existing_insert)
3643 {
3644 tpl_printf(vars, TPLADD, "EXISTING_INS", "'%s'", urlencode(vars, chk->usr));
3645 existing_insert++;
3646 }
3647 else
3648 {
3649 tpl_printf(vars, TPLAPPEND, "EXISTING_INS", ",'%s'", urlencode(vars, chk->usr));
3650 }
3651 }
3652
3653 // Create a new user if it doesn't yet
3654 if(account == NULL)
3655 {
3656 i = 1;
3657 while(cs_strlen(user) < 1)
3658 {
3659 snprintf(user, sizeof(user) / sizeof(char) - 1, "NEWUSER%d", i);
3660 for(account = cfg.account; account != NULL && strcmp(user, account->usr) != 0; account = account->next) { ; }
3661 if(account != NULL) { user[0] = '\0'; }
3662 ++i;
3663 }
3664 if(!cs_malloc(&account, sizeof(struct s_auth))) { return "0"; }
3665 if(cfg.account == NULL) { cfg.account = account; }
3666 else
3667 {
3668 for(ptr = cfg.account; ptr != NULL && ptr->next != NULL; ptr = ptr->next) { ; }
3669 ptr->next = account;
3670 }
3671 account_set_defaults(account);
3672 account->disabled = 1;
3673 cs_strncpy((char *)account->usr, user, sizeof(account->usr));
3674 if(!account->grp)
3675 { account->grp = 1; }
3676 if(write_userdb() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
3677 else if(strcmp(getParam(params, "action"), "Save As") == 0) { tpl_addMsg(vars, "New user has been added with cloned settings"); }
3678 else { tpl_addMsg(vars, "New user has been added with default settings"); }
3679 // no need to refresh anything here as the account is disabled by default and there's no client with this new account anyway!
3680 }
3681
3682 if((strcmp(getParam(params, "action"), "Save") == 0) || (strcmp(getParam(params, "action"), "Save As") == 0))
3683 {
3684 char servicelabels[1024] = "";
3685
3686 for(i = 0; i < (*params).paramcount; i++)
3687 {
3688 if((strcmp((*params).params[i], "action")) &&
3689 (strcmp((*params).params[i], "user")) &&
3690 (strcmp((*params).params[i], "newuser")) &&
3691 (strcmp((*params).params[i], "part")))
3692 {
3693
3694 if(!strcmp((*params).params[i], "services"))
3695 { snprintf(servicelabels + cs_strlen(servicelabels), sizeof(servicelabels) - cs_strlen(servicelabels), "%s,", (*params).values[i]); }
3696 else
3697 { chk_account((*params).params[i], (*params).values[i], account); }
3698 }
3699 }
3700 chk_account("services", servicelabels, account);
3701
3702 refresh_oscam(REFR_CLIENTS);
3703
3704 if(write_userdb() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
3705 else if(strcmp(getParam(params, "action"), "Save As") != 0) { tpl_addMsg(vars, "User Account updated and saved"); }
3706 }
3707
3708 tpl_addVar(vars, TPLADD, "USERNAME", xml_encode(vars, account->usr));
3709 tpl_addVar(vars, TPLADD, "PASSWORD", xml_encode(vars, account->pwd));
3710 tpl_addVar(vars, TPLADD, "DESCRIPTION", xml_encode(vars, account->description));
3711
3712 //Disabled
3713 if(!apicall)
3714 {
3715 if(account->disabled)
3716 { tpl_addVar(vars, TPLADD, "DISABLEDCHECKED", "checked"); }
3717 }
3718 else
3719 {
3720 tpl_printf(vars, TPLADD, "DISABLEDVALUE", "%d", account->disabled);
3721 }
3722
3723 //Expirationdate
3724 struct tm timeinfo;
3725 cs_gmtime_r(&account->expirationdate, &timeinfo);
3726 char buf [80];
3727 strftime(buf, 80, "%Y-%m-%d", &timeinfo);
3728 if(strcmp(buf, "1970-01-01")) { tpl_addVar(vars, TPLADD, "EXPDATE", buf); }
3729
3730 //Allowed TimeFrame
3731 char *allowedtf = mk_t_allowedtimeframe(account);
3732 tpl_printf(vars, TPLADD, "ALLOWEDTIMEFRAME", "%s", allowedtf);
3733 free_mk_t(allowedtf);
3734
3735 //Group
3736 char *value = mk_t_group(account->grp);
3737 tpl_addVar(vars, TPLADD, "GROUPS", value);
3738 free_mk_t(value);
3739
3740 // allowed protocols
3741 value = mk_t_allowedprotocols(account);
3742 tpl_addVar(vars, TPLADD, "ALLOWEDPROTOCOLS", value);
3743 free_mk_t(value);
3744
3745 //Hostname
3746 tpl_addVar(vars, TPLADD, "DYNDNS", xml_encode(vars, account->dyndns));
3747
3748 //Uniq
3749 if(!apicall)
3750 {
3751 tpl_printf(vars, TPLADD, "TMP", "UNIQSELECTED%d", account->uniq);
3752 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3753 }
3754 else
3755 {
3756 tpl_printf(vars, TPLADD, "UNIQVALUE", "%d", account->uniq);
3757 }
3758
3759 //Sleep
3760 if(!account->tosleep) { tpl_addVar(vars, TPLADD, "SLEEP", "0"); }
3761 else { tpl_printf(vars, TPLADD, "SLEEP", "%d", account->tosleep); }
3762
3763 //Monlevel selector
3764 if(!apicall)
3765 {
3766 tpl_printf(vars, TPLADD, "TMP", "MONSELECTED%d", account->monlvl);
3767 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3768 }
3769 else
3770 {
3771 tpl_printf(vars, TPLADD, "MONVALUE", "%d", account->monlvl);
3772 }
3773
3774 //Au
3775 if(account->autoau == 1)
3776 { tpl_addVar(vars, TPLADD, "AUREADER", "1"); }
3777 else if(account->aureader_list)
3778 {
3779 value = mk_t_aureader(account);
3780 tpl_addVar(vars, TPLADD, "AUREADER", value);
3781 free_mk_t(value);
3782 }
3783
3784 if(!apicall)
3785 {
3786 /* SERVICES */
3787 struct s_sidtab *sidtab = cfg.sidtab;
3788 //build matrix
3789 i = 0;
3790 while(sidtab != NULL)
3791 {
3792 tpl_addVar(vars, TPLADD, "SIDLABEL", xml_encode(vars, sidtab->label));
3793 if(account->sidtabs.ok & ((SIDTABBITS)1 << i)) { tpl_addVar(vars, TPLADD, "CHECKED", "checked"); }
3794 else { tpl_addVar(vars, TPLADD, "CHECKED", ""); }
3795 tpl_addVar(vars, TPLAPPEND, "SIDS", tpl_getTpl(vars, "USEREDITSIDOKBIT"));
3796 if(account->sidtabs.no & ((SIDTABBITS)1 << i)) { tpl_addVar(vars, TPLADD, "CHECKED", "checked"); }
3797 else { tpl_addVar(vars, TPLADD, "CHECKED", ""); }
3798 tpl_addVar(vars, TPLAPPEND, "SIDS", tpl_getTpl(vars, "USEREDITSIDNOBIT"));
3799 sidtab = sidtab->next;
3800 i++;
3801 }
3802 if(i){
3803 tpl_addVar(vars, TPLADD, "USEREDITSIDINS", tpl_getTpl(vars, "USEREDITSID"));
3804 }
3805 }
3806 else
3807 {
3808 value = mk_t_service(&account->sidtabs);
3809 if(cs_strlen(value) > 0)
3810 { tpl_addVar(vars, TPLADD, "SERVICES", value); }
3811 free_mk_t(value);
3812 }
3813
3814 // CAID
3815 value = mk_t_caidtab(&account->ctab);
3816 tpl_addVar(vars, TPLADD, "CAIDS", value);
3817 free_mk_t(value);
3818
3819 //ident
3820 value = mk_t_ftab(&account->ftab);
3821 tpl_addVar(vars, TPLADD, "IDENTS", value);
3822 free_mk_t(value);
3823
3824 //CHID
3825 value = mk_t_ftab(&account->fchid);
3826 tpl_addVar(vars, TPLADD, "CHIDS", value);
3827 free_mk_t(value);
3828
3829 //class
3830 value = mk_t_cltab(&account->cltab);
3831 tpl_addVar(vars, TPLADD, "CLASS", value);
3832 free_mk_t(value);
3833
3834 //Betatunnel
3835 value = mk_t_tuntab(&account->ttab);
3836 tpl_addVar(vars, TPLADD, "BETATUNNELS", value);
3837 free_mk_t(value);
3838
3839 //SUPPRESSCMD08
3840 if(!apicall)
3841 {
3842 if(account->c35_suppresscmd08)
3843 { tpl_addVar(vars, TPLADD, "SUPPRESSCMD08", "selected"); }
3844 }
3845 else
3846 {
3847 tpl_printf(vars, TPLADD, "SUPPRESSCMD08VALUE", "%d", account->c35_suppresscmd08);
3848 }
3849
3850 //Sleepsend
3851 if(account->c35_sleepsend)
3852 {
3853 tpl_printf(vars, TPLADD, "SLEEPSEND", "selected");
3854 }
3855
3856 //max_connections
3857 tpl_printf(vars, TPLADD, "MAXCONNECTIONS", "%d", account->max_connections);
3858
3859 //User Max Idle
3860 tpl_printf(vars, TPLADD, "UMAXIDLE", "%d", account->umaxidle);
3861
3862 //EMM Reassembly selector
3863 if(!apicall)
3864 {
3865 tpl_printf(vars, TPLADD, "TMP", "EMMRSELECTED%d", account->emm_reassembly);
3866 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3867 }
3868 else
3869 {
3870 tpl_printf(vars, TPLADD, "EMMRVALUE", "%d", account->emm_reassembly);
3871 }
3872
3873 //Prefer local cards
3874 if(!apicall)
3875 {
3876 tpl_printf(vars, TPLADD, "TMP", "PREFERLOCALCARDS%d", account->preferlocalcards);
3877 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3878 char *tmp = NULL;
3879 switch(cfg.preferlocalcards)
3880 {
3881 case -1:
3882 tmp = "-1 - Use Global prefer local cards";
3883 break;
3884 case 0:
3885 tmp = "0 - local cards like proxied";
3886 break;
3887 case 1:
3888 tmp = "1 - prefer cache-ex then local cards";
3889 break;
3890 case 2:
3891 tmp = "2 - prefer local cards above cache-ex";
3892 break;
3893 }
3894 tpl_addVar(vars, TPLADD, "CFGPREFERLOCALCARDS", tmp);
3895 }
3896 else
3897 {
3898 tpl_printf(vars, TPLADD, "PREFERLOCALCARDSVALUE", "%d", account->preferlocalcards);
3899 }
3900
3901 #ifdef CS_CACHEEX
3902 // Cacheex
3903 if(!apicall)
3904 {
3905 tpl_printf(vars, TPLADD, "TMP", "CACHEEXSELECTED%d", account->cacheex.mode);
3906 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3907
3908 }
3909 else
3910 {
3911 tpl_printf(vars, TPLADD, "CACHEEX", "%d", account->cacheex.mode);
3912 }
3913 tpl_printf(vars, TPLADD, "CACHEEX_MAXHOP", "%d", account->cacheex.maxhop);
3914 #ifdef CS_CACHEEX_AIO
3915 tpl_printf(vars, TPLADD, "CACHEEX_MAXHOP_LG", "%d", account->cacheex.maxhop_lg);
3916 #endif
3917
3918 value = mk_t_cacheex_hitvaluetab(&account->cacheex.filter_caidtab);
3919 //if (cs_strlen(value) > 0)
3920 tpl_printf(vars, TPLADD, "CACHEEX_ECM_FILTER", "%s", value);
3921 free_mk_t(value);
3922
3923 tpl_addVar(vars, TPLADD, "DCCHECKED", (account->cacheex.drop_csp == 1) ? "checked" : "");
3924 tpl_addVar(vars, TPLADD, "ARCHECKED", (account->cacheex.allow_request == 1) ? "checked" : "");
3925 tpl_addVar(vars, TPLADD, "AFCHECKED", (account->cacheex.allow_filter == 1) ? "checked" : "");
3926 #ifdef CS_CACHEEX_AIO
3927 tpl_addVar(vars, TPLADD, "AMCHECKED", (account->cacheex.allow_maxhop == 1) ? "checked" : "");
3928 #endif
3929 tpl_addVar(vars, TPLADD, "BLOCKFAKECWSCHECKED", (account->cacheex.block_fakecws == 1) ? "checked" : "");
3930 #ifdef CS_CACHEEX_AIO
3931 tpl_addVar(vars, TPLADD, "USECWCHECKFORPUSHCHECKED", (account->cacheex.cw_check_for_push == 1) ? "checked" : "");
3932 tpl_addVar(vars, TPLADD, "LGONLYREMOTESETTINGSCHECKED", (account->cacheex.lg_only_remote_settings == 1) ? "checked" : "");
3933 tpl_addVar(vars, TPLADD, "LOCALGENERATEDONLYCHECKED", (account->cacheex.localgenerated_only == 1) ? "checked" : "");
3934
3935 value = mk_t_ftab(&account->cacheex.lg_only_tab);
3936 tpl_addVar(vars, TPLADD, "LGONLYTAB", value);
3937 free_mk_t(value);
3938
3939 tpl_addVar(vars, TPLADD, "LOCALGENERATEDONLYINCHECKED", (account->cacheex.localgenerated_only_in == 1) ? "checked" : "");
3940
3941 tpl_addVar(vars, TPLADD, "LGONLYINAIOONLYCHECKED", (account->cacheex.lg_only_in_aio_only == 1) ? "checked" : "");
3942
3943 value = mk_t_ftab(&account->cacheex.lg_only_in_tab);
3944 tpl_addVar(vars, TPLADD, "LGONLYINTAB", value);
3945 free_mk_t(value);
3946
3947 value = mk_t_caidvaluetab(&account->cacheex.cacheex_nopushafter_tab);
3948 tpl_addVar(vars, TPLADD, "CACHEEXNOPUSHAFTER", value);
3949 free_mk_t(value);
3950 #endif
3951 tpl_addVar(vars, TPLADD, "NWTCHECKED", (account->no_wait_time == 1) ? "checked" : "");
3952 tpl_addVar(vars, TPLADD, "DISABLECRCCEX4USER", (account->disablecrccacheex == 1) ? "checked" : "");
3953 value = mk_t_ftab(&account->disablecrccacheex_only_for);
3954 tpl_addVar(vars, TPLADD, "IGNCRCCEX4USERONLYFOR", value);
3955 free_mk_t(value);
3956
3957 #endif
3958
3959 #ifdef CW_CYCLE_CHECK
3960 tpl_addVar(vars, TPLADD, "USERCWCYCLEDISABLE", (account->cwc_disable == 1) ? "checked" : "");
3961 #endif
3962
3963 //Keepalive
3964 if(!apicall)
3965 {
3966 if(account->ncd_keepalive)
3967 { tpl_addVar(vars, TPLADD, "KEEPALIVE", "checked"); }
3968 }
3969 else
3970 {
3971 tpl_printf(vars, TPLADD, "KEEPALIVEVALUE", "%d", account->ncd_keepalive);
3972 }
3973
3974 #ifdef CS_ANTICASC
3975 tpl_printf(vars, TPLADD, "AC_USERS", "%d", account->ac_users);
3976 tpl_printf(vars, TPLADD, "CFGNUMUSERS", "%d", cfg.ac_users);
3977 if(!apicall)
3978 {
3979 tpl_printf(vars, TPLADD, "TMP", "PENALTY%d", account->ac_penalty);
3980 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
3981 char *tmp = NULL;
3982 switch(cfg.ac_penalty)
3983 {
3984 case 0:
3985 tmp = "(0) Only write to log";
3986 break;
3987 case 1:
3988 tmp = "(1) NULL CW";
3989 break;
3990 case 2:
3991 tmp = "(2) Ban";
3992 break;
3993 case 3:
3994 tmp = "(3) Real CW delayed";
3995 break;
3996 }
3997 tpl_addVar(vars, TPLADD, "CFGPENALTY", tmp);
3998 }
3999 else
4000 {
4001 tpl_printf(vars, TPLADD, "PENALTYVALUE", "%d", account->ac_penalty);
4002 }
4003 tpl_printf(vars, TPLADD, "ACOSC_MAX_ECMS_PER_MINUTE", "%d", account->acosc_max_ecms_per_minute);
4004 tpl_printf(vars, TPLADD, "ACOSC_MAX_ACTIVE_SIDS", "%d", account->acosc_max_active_sids);
4005 tpl_printf(vars, TPLADD, "CFG_ACOSC_MAX_ECMS_PER_MINUTE", "%d", cfg.acosc_max_ecms_per_minute);
4006 tpl_printf(vars, TPLADD, "CFG_ACOSC_MAX_ACTIVE_SIDS", "%d", cfg.acosc_max_active_sids);
4007 tpl_printf(vars, TPLADD, "ACOSC_ZAP_LIMIT", "%d", account->acosc_zap_limit);
4008 tpl_printf(vars, TPLADD, "CFG_ACOSC_ZAP_LIMIT", "%d", cfg.acosc_zap_limit);
4009 if(!apicall)
4010 {
4011 tpl_printf(vars, TPLADD, "TMP", "ACOSC_PENALTY%d", account->acosc_penalty);
4012 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
4013 char *tmp = NULL;
4014 switch(cfg.acosc_penalty)
4015 {
4016 case -1:
4017 tmp = "(-1) Use Global Value";
4018 break;
4019 case 0:
4020 tmp = "(0) Only write to log";
4021 break;
4022 case 1:
4023 tmp = "(1) NULL CW";
4024 break;
4025 case 2:
4026 tmp = "(2) Ban";
4027 break;
4028 case 3:
4029 tmp = "(3) CW delayed";
4030 break;
4031 case 4:
4032 tmp = "(4) Hidecards";
4033 break;
4034 }
4035 tpl_addVar(vars, TPLADD, "CFG_ACOSC_PENALTY", tmp);
4036 } else
4037 {
4038 tpl_printf(vars, TPLADD, "ACOSC_PENALTYVALUE", "%d", account->acosc_penalty);
4039 }
4040
4041 tpl_printf(vars, TPLADD, "ACOSC_PENALTY_DURATION", "%d", account->acosc_penalty_duration);
4042 tpl_printf(vars, TPLADD, "CFG_ACOSC_PENALTY_DURATION", "%d", cfg.acosc_penalty_duration);
4043 tpl_printf(vars, TPLADD, "ACOSC_DELAY", "%d", account->acosc_delay);
4044 tpl_printf(vars, TPLADD, "CFG_ACOSC_DELAY", "%d", cfg.acosc_delay);
4045 #endif
4046
4047 #ifdef MODULE_CCCAM
4048 tpl_printf(vars, TPLADD, "CCCMAXHOPS", "%d", account->cccmaxhops);
4049 tpl_printf(vars, TPLADD, "CCCRESHARE", "%d", account->cccreshare);
4050 tpl_printf(vars, TPLADD, "RESHARE", "%d", cfg.cc_reshare);
4051
4052 //CCcam Ignore Reshare
4053 tpl_printf(vars, TPLADD, "TMP", "CCCIGNRSHRSELECTED%d", account->cccignorereshare);
4054 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
4055 tpl_addVar(vars, TPLADD, "CFGIGNORERESHARE",
4056 cfg.cc_ignore_reshare == 0 ?
4057 "0 - use reshare level of Server" : "1 - use reshare level of Reader or User");
4058
4059 //CCcam Stealth Mode
4060 tpl_printf(vars, TPLADD, "TMP", "CCCSTEALTHSELECTED%d", account->cccstealth);
4061 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMP"), "selected");
4062
4063 tpl_addVar(vars, TPLADD, "STEALTH", cfg.cc_stealth ? "enable" : "disable");
4064 #endif
4065
4066 //Failban
4067 tpl_printf(vars, TPLADD, "FAILBAN", "%d", account->failban);
4068
4069 if(!apicall)
4070 {
4071 #ifdef CS_CACHEEX_AIO
4072 return tpl_getTpl(vars, "USEREDITAIO");
4073 #else
4074 return tpl_getTpl(vars, "USEREDIT");
4075 #endif
4076 }
4077 else
4078 {
4079 return tpl_getTpl(vars, "APIUSEREDIT");
4080 }
4081
4082 }
4083
4084 static void webif_add_client_proto(struct templatevars *vars, struct s_client *cl, const char *proto, int8_t apicall)
4085 {
4086 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTO", "");
4087 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTOSORT", "");
4088 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTOTITLE", "");
4089 tpl_addVar(vars, TPLADDONCE, "PROTOICON", "");
4090 if(!cl) { return; }
4091 #ifdef MODULE_NEWCAMD
4092 if(streq(proto, "newcamd") && cl->typ == 'c')
4093 {
4094 tpl_printf(vars, TPLADD, "CLIENTPROTO", "%s (%s)", proto, newcamd_get_client_name(cl->ncd_client_id));
4095 tpl_printf(vars, TPLADD, "CLIENTPROTOSORT", "%s (%s)", proto, newcamd_get_client_name(cl->ncd_client_id));
4096 if(cfg.http_showpicons )
4097 {
4098 char picon_name[32];
4099 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s_%s", (char *)proto, newcamd_get_client_name(cl->ncd_client_id));
4100 if(picon_exists(picon_name))
4101 {
4102 if (!apicall)
4103 {
4104 tpl_addVar(vars, TPLADD, "NCMDA", (char *)proto);
4105 tpl_addVar(vars, TPLADD, "NCMDB", (char *)newcamd_get_client_name(cl->ncd_client_id));
4106 tpl_addVar(vars, TPLADD, "CLIENTPROTO", tpl_getTpl(vars, "PROTONEWCAMDPIC"));
4107 }
4108 else
4109 {
4110 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s_%s",(char *)proto, (char *)newcamd_get_client_name(cl->ncd_client_id));
4111 }
4112 }
4113 else
4114 {
4115 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s_%s.tpl", proto, newcamd_get_client_name(cl->ncd_client_id));
4116 }
4117 }
4118 return;
4119 }
4120 #endif
4121 #ifdef MODULE_CCCAM
4122 if(strncmp(proto, "cccam", 5) == 0)
4123 {
4124 struct cc_data *cc = cl->cc;
4125 if(cc && *cc->remote_version && *cc->remote_build)
4126 {
4127 tpl_printf(vars, TPLADD, "CLIENTPROTO", "%s (%s-%s)", proto, cc->remote_version, cc->remote_build);
4128 tpl_printf(vars, TPLADD, "CLIENTPROTOSORT", "%s (%s-%s)", proto, cc->remote_version, cc->remote_build);
4129 if(cccam_client_multics_mode(cl))
4130 {
4131 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "Multics, revision r%d", cc->multics_version[0] | (cc->multics_version[1] << 8));
4132 }
4133 else
4134 {
4135 #endif
4136 #ifdef CS_CACHEEX_AIO
4137 #if defined(MODULE_CCCAM) && defined(CS_CACHEEX)
4138 if(cl->reader && cl->reader->cacheex.feature_bitfield)
4139 {
4140 if(cl->reader->cacheex.feature_bitfield & 32)
4141 {
4142 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio %s]", (cc->extended_mode ? cc->remote_oscam : ""), cl->reader->cacheex.aio_version);
4143 }
4144 else if(cl->reader->cacheex.feature_bitfield)
4145 {
4146 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio < 9.2.3]", (cc->extended_mode ? cc->remote_oscam : ""));
4147 }
4148 }
4149 else if(cl->account && cl->account->cacheex.feature_bitfield)
4150 {
4151 if(cl->account->cacheex.feature_bitfield & 32)
4152 {
4153 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio %s]", (cc->extended_mode ? cc->remote_oscam : ""), cl->account->cacheex.aio_version);
4154 }
4155 else if(cl->account->cacheex.feature_bitfield)
4156 {
4157 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio < 9.2.3]", (cc->extended_mode ? cc->remote_oscam : ""));
4158 }
4159 }
4160 else
4161 {
4162 #endif
4163 #endif
4164 #ifdef MODULE_CCCAM
4165 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", cc->extended_mode ? cc->remote_oscam : "");
4166 #endif
4167 #ifdef CS_CACHEEX_AIO
4168 #if defined(MODULE_CCCAM) && defined(CS_CACHEEX)
4169 }
4170 #endif
4171 #endif
4172 #ifdef MODULE_CCCAM
4173 }
4174
4175 if(cfg.http_showpicons)
4176 {
4177 char picon_name[32];
4178
4179 int8_t is_other_proto = 0;
4180 if(cccam_client_multics_mode(cl)) { is_other_proto = 1; }
4181
4182 switch(is_other_proto)
4183 {
4184 case 1:
4185 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s_r_%d", proto, cc->multics_version[0] | (cc->multics_version[1] << 8));
4186 if(picon_exists(picon_name))
4187 {
4188 if (!apicall)
4189 {
4190 tpl_addVar(vars, TPLADD, "CCA", (char *)proto);
4191 tpl_addVar(vars, TPLADD, "CCB", "r");
4192 tpl_printf(vars, TPLADD, "CCC", "%d", cc->multics_version[0] | (cc->multics_version[1] << 8));
4193 tpl_addVar(vars, TPLADD, "CCD", "");
4194 tpl_addVar(vars, TPLADD, "CLIENTPROTO", tpl_getTpl(vars, "PROTOCCCAMPIC"));
4195 }
4196 else
4197 {
4198 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s_r_%d",(char *)proto, cc->multics_version[0] | (cc->multics_version[1] << 8));
4199 }
4200 }
4201 else
4202 {
4203 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "Multics, revision r%d missing icon: IC_%s_r_%d.tpl",
4204 cc->multics_version[0] | (cc->multics_version[1] << 8), proto, cc->multics_version[0] | (cc->multics_version[1] << 8));
4205 }
4206 break;
4207
4208 default:
4209 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s_%s_%s", proto, cc->remote_version, cc->remote_build);
4210 if(picon_exists(picon_name))
4211 {
4212 if (!apicall)
4213 {
4214 tpl_addVar(vars, TPLADD, "CCA", (char *)proto);
4215 tpl_addVar(vars, TPLADD, "CCB", cc->remote_version);
4216 tpl_addVar(vars, TPLADD, "CCC", cc->remote_build);
4217 #ifdef CS_CACHEEX_AIO
4218 #if defined(MODULE_CCCAM) && defined(CS_CACHEEX)
4219 if(cl->reader && cl->reader->cacheex.feature_bitfield)
4220 {
4221 if(cl->reader->cacheex.feature_bitfield & 32)
4222 {
4223 tpl_printf(vars, TPLADD, "CCD", "%s [cx-aio %s]", (cc->extended_mode ? cc->remote_oscam : ""), cl->reader->cacheex.aio_version);
4224 }
4225 else if(cl->reader->cacheex.feature_bitfield)
4226 {
4227 tpl_printf(vars, TPLADD, "CCD", "%s [cx-aio < 9.2.3]", (cc->extended_mode ? cc->remote_oscam : ""));
4228 }
4229 }
4230 else if(cl->account && cl->account->cacheex.feature_bitfield)
4231 {
4232 if(cl->account->cacheex.feature_bitfield & 32)
4233 {
4234 tpl_printf(vars, TPLADD, "CCD", "%s [cx-aio %s]", (cc->extended_mode ? cc->remote_oscam : ""), cl->account->cacheex.aio_version);
4235 }
4236 else if(cl->account->cacheex.feature_bitfield)
4237 {
4238 tpl_printf(vars, TPLADD, "CCD", "%s [cx-aio < 9.2.3]", (cc->extended_mode ? cc->remote_oscam : ""));
4239 }
4240 }
4241 else
4242 {
4243 #endif
4244 #endif
4245 tpl_addVar(vars, TPLADD, "CCD", cc->extended_mode ? cc->remote_oscam : "");
4246 #ifdef CS_CACHEEX_AIO
4247 #if defined(MODULE_CCCAM) && defined(CS_CACHEEX)
4248 }
4249 #endif
4250 #endif
4251 tpl_addVar(vars, TPLADD, "CLIENTPROTO", tpl_getTpl(vars, "PROTOCCCAMPIC"));
4252 }
4253 else
4254 {
4255 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s_%s_%s",(char *)proto, cc->remote_version, cc->remote_build);
4256 }
4257 }
4258 else
4259 {
4260 #endif
4261 #ifdef CS_CACHEEX_AIO
4262 #if defined(MODULE_CCCAM) && defined(CS_CACHEEX)
4263 if(cl->reader && cl->reader->cacheex.feature_bitfield)
4264 {
4265 if(cl->reader->cacheex.feature_bitfield & 32)
4266 {
4267 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio %s] missing icon: IC_%s_%s_%s.tpl", (cc->extended_mode ? cc->remote_oscam : ""), cl->reader->cacheex.aio_version, proto, cc->remote_version, cc->remote_build);
4268 }
4269 else if(cl->reader->cacheex.feature_bitfield)
4270 {
4271 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio < 9.2.3] missing icon: IC_%s_%s_%s.tpl", (cc->extended_mode ? cc->remote_oscam : ""), proto, cc->remote_version, cc->remote_build);
4272 }
4273 }
4274 else if(cl->account && cl->account->cacheex.feature_bitfield)
4275 {
4276 if(cl->account->cacheex.feature_bitfield & 32)
4277 {
4278 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio %s] missing icon: IC_%s_%s_%s.tpl", (cc->extended_mode ? cc->remote_oscam : ""), cl->account->cacheex.aio_version, proto, cc->remote_version, cc->remote_build);
4279 }
4280 else if(cl->account->cacheex.feature_bitfield)
4281 {
4282 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s [cx-aio < 9.2.3] missing icon: IC_%s_%s_%s.tpl", (cc->extended_mode ? cc->remote_oscam : ""), proto, cc->remote_version, cc->remote_build);
4283 }
4284 }
4285 else
4286 {
4287 #endif
4288 #endif
4289 #ifdef MODULE_CCCAM
4290 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "%s missing icon: IC_%s_%s_%s.tpl",
4291 cc->extended_mode ? cc->remote_oscam : "", proto, cc->remote_version, cc->remote_build);
4292 #ifdef CS_CACHEEX_AIO
4293 #if defined(MODULE_CCCAM) && defined(CS_CACHEEX)
4294 }
4295 #endif
4296 #endif
4297 }
4298 break;
4299 }
4300 }
4301 }
4302 return;
4303 }
4304 #endif
4305 #ifdef CS_CACHEEX_AIO
4306 #if (defined(MODULE_CAMD35) || defined(MODULE_CAMD35_TCP)) && defined(CS_CACHEEX)
4307 if(strncmp(proto, "cs3", 3) == 0)
4308 {
4309 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTO", (char *)proto);
4310
4311 char aiover[32];
4312 aiover[0] = '\0';
4313
4314 if(cl->account && cl->cacheex_aio_checked)
4315 {
4316 if(cl->account->cacheex.feature_bitfield & 32)
4317 {
4318 snprintf(aiover, sizeof(aiover) / sizeof(char) -1, "%s", cl->account->cacheex.aio_version);
4319 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", aiover);
4320 }
4321 else if(cl->account->cacheex.feature_bitfield)
4322 {
4323 snprintf(aiover, sizeof(aiover) / sizeof(char) -1, "%s", "[cx-aio: < 9.2.3]");
4324 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", aiover);
4325 }
4326 else
4327 {
4328 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", "");
4329 }
4330 }
4331
4332 if(cl->reader && cl->cacheex_aio_checked)
4333 {
4334 if(cl->reader->cacheex.feature_bitfield & 32)
4335 {
4336 snprintf(aiover, sizeof(aiover) / sizeof(char) -1, "%s", cl->reader->cacheex.aio_version);
4337 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", aiover);
4338 }
4339 else if(cl->reader->cacheex.feature_bitfield)
4340 {
4341 snprintf(aiover, sizeof(aiover) / sizeof(char) -1, "%s", "[cx-aio: < 9.2.3]");
4342 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", aiover);
4343 }
4344 else
4345 {
4346 tpl_addVar(vars, TPLADD, "CLIENTPROTOTITLE", "");
4347 }
4348 }
4349
4350 if(cfg.http_showpicons)
4351 {
4352 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTO", (char *)proto);
4353
4354 char picon_name[32];
4355 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", proto);
4356 if(picon_exists(picon_name))
4357 {
4358 if (!apicall)
4359 {
4360 tpl_addVar(vars, TPLADD, "CAMD3A", (char *)proto);
4361 if(aiover[0] == '\0')
4362 tpl_addVar(vars, TPLADD, "AIOVER", "");
4363 else
4364 tpl_printf(vars, TPLADD, "AIOVER", "[cx-aio %s]", aiover);
4365
4366 tpl_addVar(vars, TPLADD, "CLIENTPROTO", tpl_getTpl(vars, "PROTOCAMD3AIOPIC"));
4367 }
4368 else
4369 {
4370 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s",(char *)proto);
4371 }
4372 }
4373 else
4374 {
4375 if(cl->account && cl->cacheex_aio_checked)
4376 {
4377 if(cl->account->cacheex.feature_bitfield & 32)
4378 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s.tpl [cx-aio %s]", proto, cl->account->cacheex.aio_version);
4379 else if(cl->account->cacheex.feature_bitfield)
4380 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s.tpl [cx-aio < 9.2.3]", proto);
4381 else
4382 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s.tpl", proto);
4383 }
4384
4385 if(cl->reader && cl->cacheex_aio_checked)
4386 {
4387 if(cl->reader->cacheex.feature_bitfield & 32)
4388 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s.tpl [cx-aio %s]", proto, cl->reader->cacheex.aio_version);
4389 else if(cl->reader->cacheex.feature_bitfield)
4390 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s.tpl [cx-aio < 9.2.3]", proto);
4391 else
4392 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s.tpl", proto);
4393 }
4394 }
4395 }
4396 return;
4397 }
4398 #endif
4399 #endif
4400
4401 #ifdef HAVE_DVBAPI
4402 if(streq(proto, "dvbapi") && cl->typ == 'c' && strcmp(dvbapi_get_client_name(), ""))
4403 {
4404 if (!apicall)
4405 tpl_printf(vars, TPLADD, "CLIENTPROTO", "<A HREF=\"#\" CLASS=\"tooltip\">%s<SPAN>client: %s<BR>protocol version: %d</SPAN></A>", proto, dvbapi_get_client_name(), dvbapi_get_client_proto_version());
4406 else
4407 tpl_printf(vars, TPLADD, "CLIENTPROTO", "%s (client: %s, protocol version: %d)", proto, dvbapi_get_client_name(), dvbapi_get_client_proto_version());
4408 tpl_printf(vars, TPLADD, "CLIENTPROTOSORT", "%s", proto);
4409 return;
4410 }
4411 #endif
4412 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTO", (char *)proto);
4413 tpl_addVar(vars, TPLADDONCE, "CLIENTPROTOSORT", (char *)proto);
4414 if(cfg.http_showpicons)
4415 {
4416 char picon_name[32];
4417 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", proto);
4418 if(picon_exists(picon_name))
4419 {
4420 if (!apicall)
4421 {
4422 tpl_addVar(vars, TPLADD, "OTHER", (char *)proto);
4423 tpl_addVar(vars, TPLADD, "CLIENTPROTO", tpl_getTpl(vars, "PROTOOTHERPIC"));
4424 }
4425 else
4426 {
4427 tpl_printf(vars, TPLADDONCE, "PROTOICON", "%s",(char *)proto);
4428 }
4429 }
4430 else
4431 {
4432 tpl_printf(vars, TPLADD, "CLIENTPROTOTITLE", "missing icon: IC_%s.tpl", proto);
4433 }
4434 }
4435 }
4436
4437 static void kill_account_thread(struct s_auth *account)
4438 {
4439 struct s_client *cl;
4440 for(cl = first_client->next; cl ; cl = cl->next)
4441 {
4442 if(cl->account == account)
4443 {
4444 if(get_module(cl)->type & MOD_CONN_NET)
4445 {
4446 kill_thread(cl);
4447 }
4448 else
4449 {
4450 cl->account = first_client->account;
4451 }
4452 }
4453 }
4454 }
4455
4456 static char *send_oscam_user_config(struct templatevars *vars, struct uriparams *params, int32_t apicall)
4457 {
4458 struct s_auth *account;
4459 struct s_client *cl;
4460 char *user = getParam(params, "user");
4461 int32_t found = 0;
4462 uint8_t md5tmp[MD5_DIGEST_LENGTH];
4463
4464 if(!apicall)
4465 {
4466 setActiveMenu(vars, MNU_USERS);
4467 }
4468 if(strcmp(getParam(params, "action"), "reinit") == 0)
4469 {
4470 if(!cfg.http_readonly)
4471 { refresh_oscam(REFR_ACCOUNTS); }
4472 }
4473 if(strcmp(getParam(params, "action"), "delete") == 0)
4474 {
4475 if(cfg.http_readonly)
4476 {
4477 tpl_addMsg(vars, "WebIf is in readonly mode. No deletion will be made!");
4478 }
4479 else
4480 {
4481 struct s_auth *account_prev = NULL;
4482
4483 for(account = cfg.account; (account); account = account->next)
4484 {
4485 if(strcmp(account->usr, user) == 0)
4486 {
4487 if(account_prev == NULL)
4488 { cfg.account = account->next; }
4489 else
4490 { account_prev->next = account->next; }
4491 ll_clear(account->aureader_list);
4492 kill_account_thread(account);
4493 add_garbage(account);
4494 found = 1;
4495 break;
4496 }
4497 account_prev = account;
4498 }
4499 if(found > 0)
4500 {
4501 if(write_userdb() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
4502 }
4503 else { tpl_addMsg(vars, "Sorry but the specified user doesn't exist. No deletion will be made!"); }
4504 }
4505 }
4506
4507 if((strcmp(getParam(params, "action"), "disable") == 0) || (strcmp(getParam(params, "action"), "enable") == 0))
4508 {
4509 account = get_account_by_name(getParam(params, "user"));
4510 if(account)
4511 {
4512 if(strcmp(getParam(params, "action"), "disable") == 0)
4513 {
4514 account->disabled = 1;
4515 kill_account_thread(account);
4516 }
4517 else
4518 { account->disabled = 0; }
4519 if(write_userdb() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
4520 }
4521 else
4522 {
4523 tpl_addMsg(vars, "Sorry but the specified user doesn't exist. No deletion will be made!");
4524 }
4525 }
4526
4527 if(strcmp(getParam(params, "action"), "resetstats") == 0)
4528 {
4529 account = get_account_by_name(getParam(params, "user"));
4530 if(account) { clear_account_stats(account); }
4531 }
4532
4533 if(strcmp(getParam(params, "action"), "resetuserstats") == 0)
4534 {
4535 clear_info_clients_stats();
4536 }
4537
4538 if(strcmp(getParam(params, "action"), "resetreaderstats") == 0)
4539 {
4540 clear_info_readers_stats();
4541 }
4542
4543 if(strcmp(getParam(params, "action"), "resetalluserstats") == 0)
4544 {
4545 clear_all_account_stats();
4546 }
4547
4548 if((strcmp(getParam(params, "part"), "adduser") == 0) && (!cfg.http_readonly))
4549 {
4550 tpl_addVar(vars, TPLAPPEND, "NEWUSERFORM", tpl_getTpl(vars, "ADDNEWUSER"));
4551 }
4552
4553 /* List accounts*/
4554 char *status, *expired, *classname, *lastchan;
4555 time_t now = time((time_t *)0);
4556 int32_t isec = 0, chsec = 0;
4557
4558 char *filter = NULL;
4559 int32_t clientcount = 0;
4560 if(apicall)
4561 {
4562 filter = getParam(params, "label");
4563 }
4564 int8_t grp_set = 0;
4565 int8_t expdate_set = 0;
4566 int32_t total_users = 0;
4567 int32_t disabled_users = 0;
4568 int32_t expired_users = 0;
4569 int32_t expired_or_disabled_users = 0;
4570 int32_t connected_users = 0;
4571 int32_t online_users = 0;
4572 int32_t casc_users = 0;
4573 int32_t casc_users2 = 0;
4574 int32_t n_request = 0;
4575 int existing_insert = 0;
4576
4577 for(account = cfg.account; (account); account = account->next)
4578 {
4579 if(account->expirationdate){
4580 expdate_set = 1;
4581 }
4582
4583 if(account->next){
4584 if(account->grp != account->next->grp){
4585 grp_set = 1;
4586 }
4587 }
4588 if(expdate_set && grp_set)
4589 break;
4590 }
4591
4592 for(account = cfg.account; (account); account = account->next)
4593 {
4594 //clear for next client
4595 total_users++;
4596 isactive = 1;
4597
4598 status = "offline";
4599 classname = "offline";
4600 isec = 0;
4601 chsec = 0;
4602
4603 //reset caid/srevid template variables
4604 tpl_addVar(vars, TPLADD, "CLIENTCAID", "");
4605 tpl_addVar(vars, TPLADD, "CLIENTPROVID", "");
4606 tpl_addVar(vars, TPLADD, "CLIENTSRVID", "");
4607 tpl_addVar(vars, TPLADD, "LASTCHANNEL", "");
4608 tpl_addVar(vars, TPLADD, "LASTCHANNELSORT", "");
4609 tpl_addVar(vars, TPLADD, "USERMD5", "");
4610 tpl_addVar(vars, TPLADD, "CWLASTRESPONSET", "");
4611 tpl_addVar(vars, TPLADD, "CWLASTRESPONSETMS", "");
4612 tpl_addVar(vars, TPLADD, "CLIENTIP", "");
4613 tpl_addVar(vars, TPLADD, "LASTCHANNELTITLE", "");
4614 tpl_addVar(vars, TPLADD, "LASTCHANNELSORT", "");
4615 tpl_addVar(vars, TPLADD, "CLIENTTIMEONCHANNELAPI", "");
4616 tpl_addVar(vars, TPLADD, "CLIENTTIMEONCHANNEL", "");
4617 tpl_addVar(vars, TPLADD, "CLIENTTIMETOSLEEP", "");
4618 tpl_addVar(vars, TPLADD, "CLIENTTIMETOSLEEPAPI", "");
4619 tpl_addVar(vars, TPLADD, "IDLESECS", "");
4620 tpl_addVar(vars, TPLADD, "UNOTIFY", "");
4621
4622 if(account->expirationdate && account->expirationdate < now)
4623 {
4624 expired = " (expired)";
4625 classname = "expired";
4626 expired_users++;
4627 isactive = 0;
4628 }
4629 else
4630 {
4631 expired = "";
4632 }
4633
4634 if(account->disabled != 0)
4635 {
4636 expired = " (disabled)";
4637 classname = "disabled";
4638 tpl_addVar(vars, TPLADD, "SWITCHICO", "image?i=ICENA");
4639 tpl_addVar(vars, TPLADD, "SWITCHTITLE", "Enable");
4640 tpl_addVar(vars, TPLADD, "SWITCH", "enable");
4641 disabled_users++;
4642 isactive = 0;
4643 }
4644 else
4645 {
4646 tpl_addVar(vars, TPLADD, "SWITCHICO", "image?i=ICDIS");
4647 tpl_addVar(vars, TPLADD, "SWITCHTITLE", "Disable");
4648 tpl_addVar(vars, TPLADD, "SWITCH", "disable");
4649 }
4650 if((account->expirationdate && account->expirationdate < now)||account->disabled != 0)
4651 {
4652 expired_or_disabled_users++;
4653 }
4654
4655 int32_t lastresponsetm = 0, latestactivity = 0;
4656 const char *proto = "";
4657 double cwrate = 0.0, cwrate2 = 0.0;
4658
4659 //search account in active clients
4660 isactive = 0;
4661 int16_t nrclients = 0;
4662 struct s_client *latestclient = NULL;
4663 for(cl = first_client->next; cl ; cl = cl->next)
4664 {
4665 if(cl->account && !strcmp(cl->account->usr, account->usr))
4666 {
4667 if(cl->lastecm > latestactivity || cl->login > latestactivity)
4668 {
4669 if(cl->lastecm > cl->login) { latestactivity = cl->lastecm; }
4670 else { latestactivity = cl->login; }
4671 latestclient = cl;
4672 }
4673 nrclients++;
4674 }
4675 }
4676 if(account->cwfound + account->cwnot + account->cwcache > 0)
4677 {
4678 cwrate = now - account->firstlogin;
4679 cwrate /= (account->cwfound + account->cwnot + account->cwcache);
4680 }
4681
4682 casc_users = 0;
4683 casc_users2 = 0;
4684 int8_t conn = 0;
4685 if(latestclient != NULL)
4686 {
4687 char channame[CS_SERVICENAME_SIZE];
4688 status = (!apicall) ? "<B>connected</B>" : "connected";
4689 if(account->expirationdate && account->expirationdate < now) { classname = "expired"; }
4690 else { classname = "connected";conn = 1; }
4691
4692 proto = client_get_proto(latestclient);
4693 int clientcaid = latestclient->last_caid;
4694 int clientsrvid = latestclient->last_srvid;
4695 int clientprovid = latestclient->last_provid;
4696 tpl_printf(vars, TPLADD, "CLIENTCAID", "%04X", clientcaid);
4697 tpl_printf(vars, TPLADD, "CLIENTPROVID", "%06X", clientprovid);
4698 tpl_printf(vars, TPLADD, "CLIENTSRVID", "%04X", clientsrvid);
4699
4700 if(clientsrvid != NO_SRVID_VALUE || clientcaid != NO_CAID_VALUE)
4701 {
4702 lastchan = xml_encode(vars, get_servicename(latestclient, clientsrvid, clientprovid, clientcaid, channame, sizeof(channame)));
4703 tpl_addVar(vars, TPLADD, "LASTCHANNELSORT", lastchan);
4704 }
4705 else
4706 {
4707 lastchan = "";
4708 tpl_addVar(vars, TPLADD, "LASTCHANNELSORT", "~~~~~");
4709 }
4710
4711 tpl_addVar(vars, TPLADDONCE, "LASTCHANNEL", lastchan);
4712 tpl_addVar(vars, TPLADD, "LASTCHANNELTITLE", lastchan);
4713
4714 if(cfg.http_showpicons )
4715 {
4716 char picon_name[128];
4717 char picon_channame[128];
4718 int8_t picon_ok = 0;
4719
4720 get_picon_servicename_or_null(latestclient, clientsrvid, clientprovid, clientcaid, picon_channame, sizeof(picon_channame));
4721 if(picon_channame[0])
4722 {
4723 snprintf(picon_name, sizeof(picon_name) / sizeof(char), "%s", picon_channame);
4724 picon_ok = picon_exists(picon_name);
4725
4726 if(!picon_ok && picon_servicename_remve_hd(picon_channame, sizeof(picon_channame)))
4727 {
4728 snprintf(picon_name, sizeof(picon_name) / sizeof(char), "%s", picon_channame);
4729 picon_ok = picon_exists(picon_name);
4730 }
4731 }
4732 if(!picon_ok)
4733 {
4734 snprintf(picon_name, sizeof(picon_name) / sizeof(char), "%04X_%06X_%04X", clientcaid, clientprovid, clientsrvid);
4735 picon_ok = picon_exists(picon_name);
4736 }
4737 if(!picon_ok)
4738 {
4739 snprintf(picon_name, sizeof(picon_name) / sizeof(char), "%04X_%04X", clientcaid, clientsrvid);
4740 picon_ok = picon_exists(picon_name);
4741 }
4742 if(!picon_ok)
4743 {
4744 snprintf(picon_name, sizeof(picon_name) / sizeof(char), "0000_%04X", clientsrvid);
4745 picon_ok = picon_exists(picon_name);
4746 }
4747 if(picon_ok)
4748 {
4749 tpl_addVar(vars, TPLADDONCE, "LCA", picon_name);
4750 tpl_addVar(vars, TPLADDONCE, "LCB", lastchan);
4751 if(!apicall)
4752 {
4753 tpl_addVar(vars, TPLADDONCE, "LASTCHANNEL", tpl_getTpl(vars, "USERCONFIGLASTCHANEL"));
4754 }
4755 }
4756 else
4757 {
4758 tpl_printf(vars, TPLADD, "LASTCHANNELTITLE", "missing icon: IC_%s.tpl", picon_name);
4759 }
4760 }
4761
4762 lastresponsetm = latestclient->cwlastresptime;
4763 tpl_addVar(vars, TPLADD, "CLIENTIP", cs_inet_ntoa(latestclient->ip));
4764 connected_users++;
4765 casc_users = ll_count(latestclient->cascadeusers);
4766 LL_ITER it = ll_iter_create(latestclient->cascadeusers);
4767 struct s_cascadeuser *cu;
4768 while((cu = ll_iter_next(&it)))
4769 {
4770 if(cu->cwrate > 0)
4771 { casc_users2++; }
4772 }
4773 if(latestactivity > 0)
4774 {
4775 isec = now - latestactivity;
4776 chsec = latestclient->lastswitch ? now - latestclient->lastswitch : 0;
4777 if(isec < cfg.hideclient_to)
4778 {
4779 isactive = 1;
4780 status = (!apicall) ? "<B>online</B>" : "online";
4781 if(account->expirationdate && account->expirationdate < now) { classname = "expired"; }
4782 else { classname = "online"; }
4783 if(latestclient->cwfound + latestclient->cwnot + latestclient->cwcache > 0)
4784 {
4785 cwrate2 = now - latestclient->login;
4786 cwrate2 /= (latestclient->cwfound + latestclient->cwnot + latestclient->cwcache);
4787 tpl_printf(vars, TPLADDONCE, "CWRATE2", " (%.2f)", cwrate2);
4788 online_users++;
4789 }
4790 }
4791 }
4792 }
4793
4794 n_request = 0;
4795 if(latestclient != NULL){
4796 n_request = latestclient->n_request[0];
4797 }
4798
4799 tpl_addVar(vars, TPLADD, "EXPIREVIEW", expdate_set ? "" : "exp");
4800 tpl_addVar(vars, TPLADD, "GRPVIEW", grp_set ? "" : "grp");
4801 #ifdef CS_ANTICASC
4802 tpl_addVar(vars, TPLADD, "ANTICASCVIEW", cfg.ac_enabled ? "" : "acas");
4803 #endif
4804 tpl_printf(vars, TPLADD, "CWOK", PRINTF_LOCAL_D, account->cwfound);
4805 tpl_printf(vars, TPLADD, "CWNOK", PRINTF_LOCAL_D, account->cwnot);
4806 tpl_printf(vars, TPLADD, "CWIGN", PRINTF_LOCAL_D, account->cwignored);
4807 tpl_printf(vars, TPLADD, "CWTOUT", PRINTF_LOCAL_D, account->cwtout);
4808 #ifdef CW_CYCLE_CHECK
4809 tpl_addVar(vars, TPLADD, "CWCCYCVIEW", cfg.cwcycle_check_enable ? "" : "cwc");
4810 tpl_printf(vars, TPLADD, "CWCYCLECHECKED", "%d", account->cwcycledchecked);
4811 tpl_printf(vars, TPLADD, "CWCYCLEOK", "%d", account->cwcycledok);
4812 tpl_printf(vars, TPLADD, "CWCYCLENOK", "%d", account->cwcyclednok);
4813 tpl_printf(vars, TPLADD, "CWCYCLEIGN", "%d", account->cwcycledign);
4814 #endif
4815 tpl_printf(vars, TPLADD, "CWCACHE", PRINTF_LOCAL_D, account->cwcache);
4816 tpl_printf(vars, TPLADD, "CWTUN", PRINTF_LOCAL_D, account->cwtun);
4817 tpl_printf(vars, TPLADD, "EMMOK", PRINTF_LOCAL_D, account->emmok);
4818 tpl_printf(vars, TPLADD, "EMMNOK", PRINTF_LOCAL_D, account->emmnok);
4819 tpl_printf(vars, TPLADD, "CWRATE", "%.2f", cwrate);
4820 tpl_printf(vars, TPLADD, "CASCUSERS", "%d", casc_users);
4821 tpl_printf(vars, TPLADD, "CASCUSERS2", "%d", casc_users2);
4822 tpl_printf(vars, TPLADD, "CASCUSERSCOMB", "%d/%d", casc_users, casc_users2);
4823 tpl_printf(vars, TPLADD, "N_REQUEST_MIN", "%d", n_request);
4824
4825 if(isactive > 0 || conn > 0)
4826 {
4827 if(casc_users+casc_users2>0)
4828 {
4829 tpl_printf(vars, TPLADD, "CWLASTRESPONSET", "%d", lastresponsetm);
4830 tpl_printf(vars, TPLADD, "CWLASTRESPONSETMS", PRINTF_LOCAL_D " ms", lastresponsetm);
4831 }
4832 tpl_addVar(vars, TPLADD, "IDLESECS", sec2timeformat(vars, isec));
4833 }
4834
4835 if(isactive > 0)
4836 {
4837 tpl_printf(vars, TPLADD, "CLIENTTIMEONCHANNELAPI", "%d", chsec);
4838 tpl_addVar(vars, TPLADD, "CLIENTTIMEONCHANNEL", sec2timeformat(vars, chsec));
4839
4840 if(account->tosleep)
4841 {
4842 if(account->tosleep >0){
4843 tpl_printf(vars, TPLADD, "CLIENTTIMETOSLEEP", "Sleeping in %d minutes", account->tosleep - (chsec / 60));
4844 } else {
4845 tpl_addVar(vars, TPLADD, "CLIENTTIMETOSLEEP", "Sleeping");
4846 }
4847 tpl_printf(vars, TPLADD, "CLIENTTIMETOSLEEPAPI", "%d", account->tosleep - (chsec / 60));
4848 } else {
4849 tpl_addVar(vars, TPLADD, "CLIENTTIMETOSLEEPAPI", "undefined");
4850 }
4851 }
4852 #ifdef CS_CACHEEX_AIO
4853 #if defined(MODULE_CAMD35) || defined (MODULE_CAMD35_TCP)
4854 if(latestclient != NULL && (latestclient->account->cacheex.feature_bitfield || latestclient->c35_extmode > 1))
4855 #else
4856 if(latestclient != NULL && (latestclient->account->cacheex.feature_bitfield))
4857 #endif
4858 {
4859 const char *aio_suffix = " (cx-aio)";
4860 char *new_proto;
4861 if(cs_malloc(&new_proto, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
4862 if (!cs_strncat(new_proto, (char *)proto, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
4863 cs_log("FIXME!");
4864 }
4865 if (cs_strncat(new_proto, (char *)aio_suffix, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
4866 webif_add_client_proto(vars, latestclient, (const char *)new_proto, apicall);
4867 } else {
4868 cs_log("FIXME!");
4869 }
4870 free(new_proto);
4871 }
4872 } else {
4873 #endif
4874 webif_add_client_proto(vars, latestclient, proto, apicall);
4875 #ifdef CS_CACHEEX_AIO
4876 }
4877 #endif
4878
4879 tpl_addVar(vars, TPLADD, "CLASSNAME", classname);
4880 MD5((uint8_t *)account->usr, cs_strlen(account->usr), md5tmp);
4881 int z;
4882 tpl_addVar(vars, TPLADD, "USERMD5","id_");
4883 for (z = 0; z < MD5_DIGEST_LENGTH; z++)
4884 {
4885 tpl_printf(vars, TPLAPPEND, "USERMD5", "%02x", md5tmp[z]);
4886 }
4887 tpl_addVar(vars, TPLADD, "USERNAME", xml_encode(vars, account->usr));
4888 tpl_addVar(vars, TPLADD, "USERNAMEENC", urlencode(vars, account->usr));
4889 if(!existing_insert)
4890 {
4891 tpl_printf(vars, TPLADD, "EXISTING_INS", "'%s'", urlencode(vars, account->usr));
4892 existing_insert++;
4893 }else
4894 {
4895 tpl_printf(vars, TPLAPPEND, "EXISTING_INS", ",'%s'", urlencode(vars, account->usr));
4896 }
4897
4898 if(account->description)
4899 tpl_printf(vars, TPLADD, "DESCRIPTION","%s(%s)",!apicall?"&#13;":"",xml_encode(vars, account->description));
4900 else
4901 tpl_addVar(vars, TPLADD, "DESCRIPTION", "");
4902
4903 if(cfg.http_showpicons && !apicall)
4904 tpl_addVar(vars, TPLADD, "USERBIT", tpl_getTpl(vars, picon_exists(xml_encode(vars, account->usr)) ? "USERICON" : "USERNOICON"));
4905 else
4906 tpl_addVar(vars, TPLADD, "USERBIT", tpl_getTpl(vars, "USERLABEL"));
4907
4908 char *value = mk_t_group(account->grp);
4909 tpl_addVar(vars, TPLADD, "GROUPS", value);
4910 free_mk_t(value);
4911 tpl_addVar(vars, TPLADD, "STATUS", status);
4912 tpl_addVar(vars, TPLAPPEND, "STATUS", expired);
4913
4914 if(nrclients > 1)
4915 {
4916 tpl_printf(vars, TPLADD, "UNOTIFY", "%d", nrclients);
4917 tpl_addVar(vars, TPLADDONCE, "CLIENTCOUNTNOTIFIER", tpl_getTpl(vars, "CLIENTCOUNTNOTIFIERBIT"));
4918 }
4919
4920 //Expirationdate
4921 struct tm timeinfo;
4922 cs_gmtime_r(&account->expirationdate, &timeinfo);
4923 char buf [80];
4924 strftime(buf, 80, "%Y-%m-%d", &timeinfo);
4925 if(strcmp(buf, "1970-01-01")) { tpl_addVar(vars, TPLADD, "EXPDATE", buf); }
4926 else { tpl_addVar(vars, TPLADD, "EXPDATE", ""); }
4927
4928 // append row to table template
4929 if(!apicall)
4930 { tpl_addVar(vars, TPLAPPEND, "USERCONFIGS", tpl_getTpl(vars, "USERCONFIGLISTBIT")); }
4931 else if(!filter || strcmp(filter, account->usr) == 0 || strcmp(filter, "all") == 0 || cs_strlen(filter) == 0)
4932 {
4933 if(apicall == 1){
4934 tpl_addVar(vars, TPLAPPEND, "APIUSERCONFIGS", tpl_getTpl(vars, "APIUSERCONFIGLISTBIT"));
4935 } else if (apicall == 2){
4936 tpl_printf(vars, TPLADD, "JSONDELIMITER", "%s", (total_users > 1)?",":"");
4937 tpl_addVar(vars, TPLAPPEND, "APIUSERCONFIGS", tpl_getTpl(vars, "JSONUSERBIT"));
4938 }
4939 ++clientcount;
4940 }
4941 }
4942
4943 tpl_printf(vars, TPLADD, "TOTAL_USERS", "%d", total_users);
4944 tpl_printf(vars, TPLADD, "TOTAL_DISABLED", "%d", disabled_users);
4945 tpl_printf(vars, TPLADD, "TOTAL_EXPIRED", "%d", expired_users);
4946 tpl_printf(vars, TPLADD, "TOTAL_ACTIVE", "%d", total_users - expired_or_disabled_users);
4947 tpl_printf(vars, TPLADD, "TOTAL_CONNECTED", "%d", connected_users);
4948 tpl_printf(vars, TPLADD, "TOTAL_ONLINE", "%d", online_users);
4949
4950 //CM info
4951 tpl_addVar(vars, TPLADD, "DISPLAYREADERINFO", "hidden"); // no readerinfo in users
4952 set_ecm_info(vars);
4953
4954 if(!apicall)
4955 { return tpl_getTpl(vars, "USERCONFIGLIST"); }
4956 else
4957 {
4958 if(!filter || clientcount > 0)
4959 {
4960 return tpl_getTpl(vars, (apicall==1)?"APIUSERCONFIGLIST":"JSONUSER");
4961 }
4962 else
4963 {
4964 tpl_printf(vars, TPLADD, "APIERRORMESSAGE", "Invalid client %s", xml_encode(vars, filter));
4965 return tpl_getTpl(vars, "APIERROR");
4966 }
4967 }
4968
4969 }
4970
4971 #define ENTITLEMENT_PAGE_SIZE 500
4972
4973 #ifdef MODULE_CCCSHARE
4974 static void print_cards(struct templatevars *vars, struct uriparams *params, struct cc_card **cardarray, int32_t cardsize,
4975 int8_t show_global_list, struct s_reader *rdr, int32_t offset, int32_t apicall)
4976 {
4977 if(cardarray)
4978 {
4979 uint8_t serbuf[8];
4980 int32_t i, count = 0;
4981 char provname[83];
4982 struct cc_card *card;
4983 int32_t cardcount = 0;
4984 int32_t providercount = 0;
4985 int32_t nodecount = 0;
4986
4987 char *provider = "";
4988
4989 // @todo alno: sort by click, 0=ascending, 1=descending (maybe two buttons or reverse on second click)
4990 for(i = offset; i < cardsize; ++i)
4991 {
4992 card = cardarray[i];
4993 if(count == ENTITLEMENT_PAGE_SIZE)
4994 { break; }
4995 count++;
4996
4997 if(!apicall)
4998 {
4999 if(show_global_list)
5000 { rdr = card->origin_reader; }
5001 if(rdr)
5002 { tpl_printf(vars, TPLADD, "HOST", "%s:%d", xml_encode(vars, rdr->device), rdr->r_port); }
5003 tpl_printf(vars, TPLADD, "CAID", "%04X", card->caid);
5004 tpl_printf(vars, TPLADD, "CARDTYPE", "%02X", card->card_type);
5005 }
5006 else
5007 {
5008 tpl_printf(vars, TPLADD, "APICARDNUMBER", "%d", cardcount);
5009 tpl_printf(vars, TPLADD, "APICAID", "%04X", card->caid);
5010 tpl_printf(vars, TPLADD, "APICARDTYPE", "%02X", card->card_type);
5011 }
5012
5013 if(cc_UA_valid(card->hexserial)) //Add UA:
5014 {
5015 cc_UA_cccam2oscam(card->hexserial, serbuf, card->caid);
5016 char tmp[20];
5017 tpl_printf(vars, TPLAPPEND, "HOST", "<BR>\nUA_OSCam:%s", cs_hexdump(0, serbuf, 8, tmp, 20));
5018 tpl_printf(vars, TPLAPPEND, "HOST", "<BR>\nUA_CCcam:%s", cs_hexdump(0, card->hexserial, 8, tmp, 20));
5019 }
5020 if(!apicall)
5021 {
5022 int32_t n;
5023 char channame[CS_SERVICENAME_SIZE];
5024 int8_t sidname = 0;
5025 LL_ITER its = ll_iter_create(card->goodsids);
5026 struct cc_srvid *srv;
5027 n = 0;
5028 if(strcmp(getParam(params, "button"), "Show detail list") == 0)
5029 { sidname = 1; }
5030
5031 tpl_addVar(vars, TPLADD, "SERVICESGOOD", "");
5032 while((srv = ll_iter_next(&its)))
5033 {
5034 if(sidname)
5035 {
5036 tpl_printf(vars, TPLAPPEND, "SERVICESGOOD", "%04X - %s<BR>", srv->sid, xml_encode(vars, get_servicename(cur_client(), srv->sid, 0, card->caid, channame, sizeof(channame))));
5037 } else {
5038 tpl_printf(vars, TPLAPPEND, "SERVICESGOOD", "%04X%s", srv->sid, ++n % 10 == 0 ? "<BR>\n" : " ");
5039 }
5040 }
5041
5042 its = ll_iter_create(card->badsids);
5043 n = 0;
5044 tpl_addVar(vars, TPLADD, "SERVICESBAD", "");
5045 while((srv = ll_iter_next(&its)))
5046 {
5047 if(sidname)
5048 {
5049 tpl_printf(vars, TPLAPPEND, "SERVICESBAD", "%04X - %s<BR>", srv->sid, xml_encode(vars, get_servicename(cur_client(), srv->sid, 0, card->caid, channame, sizeof(channame))));
5050 } else {
5051 tpl_printf(vars, TPLAPPEND, "SERVICESBAD", "%04X%s", srv->sid, ++n % 10 == 0 ? "<BR>\n" : " ");
5052 }
5053 }
5054 }
5055
5056 tpl_addVar(vars, TPLADD, "SYSTEM", get_cardsystem_desc_by_caid(card->caid));
5057
5058 tpl_printf(vars, TPLADD, "SHAREID", "%08X", card->id);
5059 tpl_printf(vars, TPLADD, "REMOTEID", "%08X", card->remote_id);
5060 tpl_printf(vars, TPLADD, "UPHOPS", "%d", card->hop);
5061 tpl_printf(vars, TPLADD, "MAXDOWN", "%d", card->reshare);
5062
5063 LL_ITER pit = ll_iter_create(card->providers);
5064 struct cc_provider *prov;
5065
5066 providercount = 0;
5067
5068 if(!apicall)
5069 { tpl_addVar(vars, TPLADD, "PROVIDERS", ""); }
5070 else
5071 { tpl_addVar(vars, TPLADD, "PROVIDERLIST", ""); }
5072
5073 while((prov = ll_iter_next(&pit)))
5074 {
5075 provider = xml_encode(vars, get_provider(prov->prov, card->caid, provname, sizeof(provname)));
5076
5077 if(!apicall)
5078 {
5079 if(prov->sa[0] || prov->sa[1] || prov->sa[2] || prov->sa[3])
5080 {
5081 tpl_printf(vars, TPLAPPEND, "PROVIDERS", "%s SA:%02X%02X%02X%02X<BR>\n", provider, prov->sa[0], prov->sa[1], prov->sa[2], prov->sa[3]);
5082 }
5083 else
5084 {
5085 tpl_printf(vars, TPLAPPEND, "PROVIDERS", "%s<BR>\n", provider);
5086 }
5087 }
5088 else
5089 {
5090 if(prov->sa[0] || prov->sa[1] || prov->sa[2] || prov->sa[3])
5091 { tpl_printf(vars, TPLADD, "APIPROVIDERSA", "%02X%02X%02X%02X", prov->sa[0], prov->sa[1], prov->sa[2], prov->sa[3]); }
5092 else
5093 { tpl_addVar(vars, TPLADD, "APIPROVIDERSA", ""); }
5094 tpl_printf(vars, TPLADD, "APIPROVIDERCAID", "%04X", card->caid);
5095 tpl_printf(vars, TPLADD, "APIPROVIDERPROVID", "%06X", prov->prov);
5096 tpl_printf(vars, TPLADD, "APIPROVIDERNUMBER", "%d", providercount);
5097 tpl_addVar(vars, TPLADD, "APIPROVIDERNAME", xml_encode(vars, provider));
5098 tpl_addVar(vars, TPLAPPEND, "PROVIDERLIST", tpl_getTpl(vars, "APICCCAMCARDPROVIDERBIT"));
5099
5100 }
5101 providercount++;
5102 tpl_printf(vars, TPLADD, "APITOTALPROVIDERS", "%d", providercount);
5103 }
5104
5105 LL_ITER nit = ll_iter_create(card->remote_nodes);
5106 uint8_t *node;
5107
5108 nodecount = 0;
5109 if(!apicall) { tpl_addVar(vars, TPLADD, "NODES", ""); }
5110 else { tpl_addVar(vars, TPLADD, "NODELIST", ""); }
5111
5112 while((node = ll_iter_next(&nit)))
5113 {
5114
5115 if(!apicall)
5116 {
5117 tpl_printf(vars, TPLAPPEND, "NODES", "%02X%02X%02X%02X%02X%02X%02X%02X<BR>\n",
5118 node[0], node[1], node[2], node[3], node[4], node[5], node[6], node[7]);
5119 }
5120 else
5121 {
5122 tpl_printf(vars, TPLADD, "APINODE", "%02X%02X%02X%02X%02X%02X%02X%02X", node[0], node[1], node[2], node[3], node[4], node[5], node[6], node[7]);
5123 tpl_printf(vars, TPLADD, "APINODENUMBER", "%d", nodecount);
5124 tpl_addVar(vars, TPLAPPEND, "NODELIST", tpl_getTpl(vars, "APICCCAMCARDNODEBIT"));
5125 }
5126 nodecount++;
5127 tpl_printf(vars, TPLADD, "APITOTALNODES", "%d", nodecount);
5128 }
5129
5130 if(!apicall)
5131 { tpl_addVar(vars, TPLAPPEND, "CCCAMSTATSENTRY", tpl_getTpl(vars, "ENTITLEMENTCCCAMENTRYBIT")); }
5132 else
5133 { tpl_addVar(vars, TPLAPPEND, "CARDLIST", tpl_getTpl(vars, "APICCCAMCARDBIT")); }
5134
5135 cardcount++;
5136 }
5137 // set previous Link if needed
5138 if(offset >= ENTITLEMENT_PAGE_SIZE)
5139 {
5140 tpl_printf(vars, TPLAPPEND, "CONTROLS", "<A HREF=\"entitlements.html?offset=%d&globallist=%s&amp;label=%s\"> << PREVIOUS < </A>",
5141 offset - ENTITLEMENT_PAGE_SIZE,
5142 getParam(params, "globallist"),
5143 urlencode(vars, getParam(params, "label")));
5144 }
5145
5146 // set next link if needed
5147 if(cardsize > count && offset < cardsize)
5148 {
5149 tpl_printf(vars, TPLAPPEND, "CONTROLS", "<A HREF=\"entitlements.html?offset=%d&globallist=%s&amp;label=%s\"> > NEXT >> </A>",
5150 offset + ENTITLEMENT_PAGE_SIZE,
5151 getParam(params, "globallist"),
5152 urlencode(vars, getParam(params, "label")));
5153 }
5154
5155 if(!apicall)
5156 {
5157 tpl_printf(vars, TPLADD, "TOTALS", "card count=%d", cardsize);
5158 tpl_addVar(vars, TPLADD, "ENTITLEMENTCONTENT", tpl_getTpl(vars, "ENTITLEMENTCCCAMBIT"));
5159 }
5160 else
5161 {
5162 tpl_printf(vars, TPLADD, "APITOTALCARDS", "%d", cardsize);
5163 }
5164
5165 }
5166 else
5167 {
5168 if(!apicall)
5169 {
5170 tpl_addVar(vars, TPLADD, "ENTITLEMENTCONTENT", tpl_getTpl(vars, "ENTITLEMENTGENERICBIT"));
5171 tpl_addVar(vars, TPLADD, "LOGHISTORY", "no cards found<BR>\n");
5172 }
5173 else
5174 {
5175 tpl_printf(vars, TPLADD, "APITOTALCARDS", "%d", 0);
5176 }
5177 }
5178
5179 }
5180 #endif
5181
5182 static char *send_oscam_entitlement(struct templatevars *vars, struct uriparams *params, int32_t apicall)
5183 {
5184 if(!apicall) { setActiveMenu(vars, MNU_READERS); }
5185 char *reader_ = getParam(params, "label");
5186 #ifdef MODULE_CCCAM
5187 char *sharelist_ = getParam(params, "globallist");
5188 int32_t show_global_list = sharelist_ && sharelist_[0] == '1';
5189
5190 struct s_reader *rdr = get_reader_by_label(getParam(params, "label"));
5191 if(show_global_list || cs_strlen(reader_) || (rdr && rdr->typ == R_CCCAM))
5192 {
5193
5194 if(show_global_list || (rdr && rdr->typ == R_CCCAM && rdr->enable))
5195 {
5196
5197 if(show_global_list)
5198 {
5199 tpl_addVar(vars, TPLADD, "READERNAME", "GLOBAL");
5200 tpl_addVar(vars, TPLADD, "APIHOST", "GLOBAL");
5201 tpl_addVar(vars, TPLADD, "APIHOSTPORT", "GLOBAL");
5202 }
5203 else
5204 {
5205 tpl_addVar(vars, TPLADD, "READERNAME", xml_encode(vars, rdr->label));
5206 tpl_addVar(vars, TPLADD, "APIHOST", xml_encode(vars, rdr->device));
5207 tpl_printf(vars, TPLADD, "APIHOSTPORT", "%d", rdr->r_port);
5208 }
5209
5210 #ifdef MODULE_CCCSHARE
5211 int32_t offset = atoi(getParam(params, "offset")); //should be 0 if parameter is missed on very first call
5212 int32_t cardsize;
5213 if(show_global_list)
5214 {
5215 int32_t i;
5216 LLIST **sharelist = get_and_lock_sharelist();
5217 LLIST *sharelist2 = ll_create("web-sharelist");
5218 for(i = 0; i < CAID_KEY; i++)
5219 {
5220 if(sharelist[i])
5221 { ll_putall(sharelist2, sharelist[i]); }
5222 }
5223 unlock_sharelist();
5224 struct cc_card **cardarray = get_sorted_card_copy(sharelist2, 0, &cardsize);
5225 ll_destroy(&sharelist2);
5226 print_cards(vars, params, cardarray, cardsize, 1, NULL, offset, apicall);
5227 NULLFREE(cardarray);
5228 }
5229 else
5230 {
5231 struct s_client *rc = rdr->client;
5232 struct cc_data *rcc = (rc) ? rc->cc : NULL;
5233 if(rcc && rcc->cards)
5234 {
5235 struct cc_card **cardarray = get_sorted_card_copy(rcc->cards, 0, &cardsize);
5236 print_cards(vars, params, cardarray, cardsize, 0, rdr, offset, apicall);
5237 NULLFREE(cardarray);
5238 }
5239 }
5240 #endif
5241
5242 }
5243 else
5244 {
5245 #else
5246 if(cs_strlen(reader_))
5247 {
5248 {
5249 struct s_reader *rdr;
5250 #endif
5251 tpl_addVar(vars, TPLADD, "LOGHISTORY", "->");
5252 // normal non-cccam reader
5253
5254 rdr = get_reader_by_label(reader_);
5255
5256 if(rdr)
5257 {
5258 struct s_client *cl = rdr->client;
5259 if(rdr->ll_entitlements)
5260 {
5261
5262 time_t now = time((time_t *)0);
5263
5264 struct tm start_t, end_t;
5265 LL_ITER itr = ll_iter_create(rdr->ll_entitlements);
5266 S_ENTITLEMENT *item;
5267
5268 tpl_addVar(vars, TPLAPPEND, "LOGHISTORY", "<BR><BR>New Structure:<BR>");
5269 char tbuffer[83];
5270 #ifdef WITH_EMU
5271 char keyBuffer[1024];
5272 #endif
5273 int jsondelimiter = 0;
5274 while((item = ll_iter_next(&itr)))
5275 {
5276 #ifdef WITH_EMU
5277 if(item->isKey)
5278 {
5279 tpl_addVar(vars, TPLADD, "ENTSTARTDATE", "");
5280 tpl_addVar(vars, TPLADD, "ENTENDDATE", "");
5281 cs_hexdump(0, item->key, item->keyLength, keyBuffer, sizeof(keyBuffer));
5282 tpl_addVar(vars, TPLADD, "ENTEXPIERED", "e_valid");
5283 tpl_printf(vars, TPLADD, "ENTCAID", "%04X", item->caid);
5284 tpl_printf(vars, TPLADD, "ENTPROVID", "%08X", item->provid);
5285 tpl_addVar(vars, TPLADD, "ENTID", item->name);
5286 tpl_addVar(vars, TPLADD, "ENTCLASS", keyBuffer);
5287 if(item->isData) { tpl_addVar(vars, TPLADD, "ENTTYPE", "data"); }
5288 else { tpl_addVar(vars, TPLADD, "ENTTYPE", "key"); }
5289 tpl_addVar(vars, TPLADD, "ENTRESNAME", "");
5290
5291 if((strcmp(getParam(params, "hideexpired"), "1") != 0) || (item->end > now))
5292 { tpl_addVar(vars, TPLAPPEND, "READERENTENTRY", tpl_getTpl(vars, "ENTITLEMENTITEMBIT")); }
5293
5294 continue;
5295 }
5296 #endif
5297
5298 localtime_r(&item->start, &start_t);
5299 localtime_r(&item->end, &end_t);
5300
5301 if(!apicall)
5302 { strftime(tbuffer, 30, "%Y-%m-%d", &start_t); }
5303 else
5304 { strftime(tbuffer, 30, "%Y-%m-%dT%H:%M:%S%z", &start_t); }
5305 tpl_addVar(vars, TPLADD, "ENTSTARTDATE", tbuffer);
5306
5307 if(!apicall)
5308 { strftime(tbuffer, 30, "%Y-%m-%d", &end_t); }
5309 else
5310 { strftime(tbuffer, 30, "%Y-%m-%dT%H:%M:%S%z", &end_t); }
5311 tpl_addVar(vars, TPLADD, "ENTENDDATE", tbuffer);
5312
5313 tpl_addVar(vars, TPLADD, "ENTEXPIERED", item->end > now ? "e_valid" : "e_expired");
5314 tpl_printf(vars, TPLADD, "ENTCAID", "%04X", item->caid);
5315 tpl_printf(vars, TPLADD, "ENTPROVID", "%06X", item->provid);
5316 tpl_printf(vars, TPLADD, "ENTID", "%08X%08X", (uint32_t)(item->id >> 32), (uint32_t)item->id);
5317 tpl_printf(vars, TPLADD, "ENTCLASS", "%08X", item->class);
5318 tpl_addVar(vars, TPLADD, "ENTTYPE", entitlement_type[item->type]);
5319
5320 char *entresname;
5321 entresname = xml_encode(vars, get_tiername((uint16_t)(item->id & 0xFFFF), item->caid, tbuffer));
5322 if(!tbuffer[0])
5323 { entresname = xml_encode(vars, get_provider(item->provid, item->caid, tbuffer, sizeof(tbuffer))); }
5324 tpl_addVar(vars, TPLADD, "ENTRESNAME", entresname);
5325
5326 if((strcmp(getParam(params, "hideexpired"), "1") != 0) || (item->end > now))
5327 { tpl_addVar(vars, TPLAPPEND, "READERENTENTRY", tpl_getTpl(vars, "ENTITLEMENTITEMBIT")); }
5328
5329 if(apicall==2)
5330 {
5331 tpl_printf(vars, TPLAPPEND, "APIENTITLEMENTLIST","%s%s",jsondelimiter?",":"", tpl_getTpl(vars, "JSONENTITLEMENTBIT"));
5332 jsondelimiter++;
5333 }
5334 }
5335 }
5336
5337 if(cl && cl->typ)
5338 { tpl_printf(vars, TPLADD, "READERTYPE", "%c", cl->typ); }
5339 else
5340 { tpl_addVar(vars, TPLADD, "READERTYPE", "null"); }
5341 tpl_addVar(vars, TPLADD, "READERNAME", xml_encode(vars, rdr->label));
5342
5343 int8_t i, j;
5344 for(i = 0; i < 15; i++) { tpl_printf(vars, TPLAPPEND, "READERROM", "%c", rdr->rom[i]); }
5345 if(rdr->hexserial[0] || rdr->hexserial[1]) { i = 0; }
5346 else { i = 2; }
5347 if(rdr->hexserial[6] || rdr->hexserial[7]) { j = 8; }
5348 else { j = 6; }
5349 for(; i < j; i++) { tpl_printf(vars, TPLAPPEND, "READERSERIAL", "%02X%s", rdr->hexserial[i], i < j - 1 ? " " : ""); }
5350 for(i = 0; i < rdr->nprov; i++)
5351 {
5352 for(j = 0; j < 4; j++) { tpl_printf(vars, TPLAPPEND, "READERPROVIDS", "%02X ", rdr->prid[i][j]); }
5353 tpl_addVar(vars, TPLAPPEND, "READERPROVIDS", i == 0 ? "(sysid)<BR>\n" : "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<BR>\n");
5354 }
5355
5356 //CountryCode Vg card
5357 char add_nds_line = 0;
5358 if(rdr->VgCountryC[0])
5359 {
5360 for(i = 0; i < 3; i++) { tpl_printf(vars, TPLAPPEND, "READERCOUNTRYC", "%c", rdr->VgCountryC[i]); }
5361 add_nds_line = 1;
5362 }
5363 else
5364 {
5365 tpl_addVar(vars, TPLADD, "READERCOUNTRYC", "n/a");
5366 }
5367
5368 //regional code for Vg card
5369 if(rdr->VgRegionC[0])
5370 {
5371 for(i = 0; i < 8; i++) { tpl_printf(vars, TPLAPPEND, "READER_RCODE", "%c", rdr->VgRegionC[i]); }
5372 add_nds_line = 1;
5373 }
5374 else
5375 {
5376 tpl_addVar(vars, TPLADD, "READER_RCODE", "n/a");
5377 }
5378
5379 //Pin Vg card
5380 if(rdr->VgPin)
5381 {
5382 tpl_printf(vars, TPLAPPEND, "READERPIN", "%04i", rdr->VgPin);
5383 add_nds_line = 1;
5384 }
5385 else
5386 {
5387 tpl_addVar(vars, TPLADD, "READERPIN", "n/a");
5388 }
5389
5390 //Fuse Vg card
5391 if(rdr->VgFuse)
5392 {
5393 tpl_printf(vars, TPLAPPEND, "READERFUSE", "%02X", rdr->VgFuse);
5394 add_nds_line = 1;
5395 }
5396
5397 if(caid_is_videoguard(rdr->caid))
5398 {
5399 tpl_printf(vars, TPLAPPEND, "READERPAYLOAD", "%02X %02X %02X %02X %02X %02X", rdr->VgLastPayload[0],
5400 rdr->VgLastPayload[1], rdr->VgLastPayload[2], rdr->VgLastPayload[3], rdr->VgLastPayload[4], rdr->VgLastPayload[5]);
5401 add_nds_line = 1;
5402 }
5403
5404 //credit on Vg card
5405 if(rdr->VgCredit)
5406 {
5407 tpl_printf(vars, TPLAPPEND, "READERCREDIT", "%i", rdr->VgCredit);
5408 add_nds_line = 1;
5409 }
5410 else
5411 {
5412 tpl_addVar(vars, TPLADD, "READERCREDIT", "n/a");
5413 }
5414
5415 if(rdr->card_valid_to)
5416 {
5417 struct tm vto_t;
5418 char vtobuffer[30];
5419 localtime_r(&rdr->card_valid_to, &vto_t);
5420 strftime(vtobuffer, 30, "%Y-%m-%d", &vto_t);
5421 tpl_addVar(vars, TPLADD, "READERCARDVALIDTO", vtobuffer);
5422 }
5423 else
5424 {
5425 tpl_addVar(vars, TPLADD, "READERCARDVALIDTO", "n/a");
5426 }
5427
5428 if(rdr->irdId[0])
5429 {
5430 for(i = 0; i < 4; i++) { tpl_printf(vars, TPLAPPEND, "READERIRDID", "%02X ", rdr->irdId[i]); }
5431 }
5432 else
5433 {
5434 tpl_addVar(vars, TPLADD, "READERIRDID", "n/a");
5435 }
5436
5437 if(rdr->card_atr_length)
5438 for(i = 0; i < rdr->card_atr_length; i++) { tpl_printf(vars, TPLAPPEND, "READERATR", "%02X ", rdr->card_atr[i]); }
5439
5440 if(caid_is_seca(rdr->caid) || caid_is_viaccess(rdr->caid))
5441 {
5442 if(rdr->maturity == 0xF)
5443 {
5444 tpl_printf(vars, TPLAPPEND, "READERMATURITY", "%s ", "no limit");
5445 }
5446 else
5447 {
5448 tpl_printf(vars, TPLAPPEND, "READERMATURITY", "%d+", rdr->maturity);
5449 }
5450 }
5451 else
5452 {
5453 tpl_printf(vars, TPLAPPEND, "READERMATURITY", "%s ", "n/a");
5454 }
5455
5456 if (rdr->csystem)
5457 tpl_addVar(vars, TPLADD, "READERCSYSTEM", rdr->csystem->desc);
5458
5459 if(add_nds_line)
5460 {
5461 tpl_addVar(vars, TPLADD, "ENTITLEMENTCONTENTNDS", tpl_getTpl(vars, "ENTITLEMENTBITNDS"));
5462 }
5463 tpl_addVar(vars, TPLADD, "ENTITLEMENTCONTENT", tpl_getTpl(vars, "ENTITLEMENTBIT"));
5464 }
5465 else
5466 {
5467 tpl_addMsg(vars, "Reader does not exist or is not started!");
5468 }
5469 }
5470
5471 }
5472 else
5473 {
5474 tpl_addVar(vars, TPLADD, "ENTITLEMENTCONTENT", tpl_getTpl(vars, "ENTITLEMENTGENERICBIT"));
5475 }
5476
5477 if(!apicall)
5478 { return tpl_getTpl(vars, "ENTITLEMENTS"); }
5479 else
5480 {
5481 if(apicall==1)
5482 { return tpl_getTpl(vars, "APICCCAMCARDLIST"); }
5483 else
5484 { return tpl_getTpl(vars, "JSONENTITLEMENTS"); }
5485 }
5486 }
5487
5488 #ifdef WEBIF_LIVELOG
5489 static char *send_oscam_logpoll(struct templatevars * vars, struct uriparams * params)
5490 {
5491
5492 uint64_t lastid = 0;
5493
5494 #ifdef WITH_DEBUG
5495 tpl_addVar(vars, TPLADD, "LOG_DEBUGMENU", tpl_getTpl(vars, "LOGDEBUGMENU"));
5496 #endif
5497 tpl_addVar(vars, TPLADD, "LOG_SIZEMENU", tpl_getTpl(vars, "LOGSIZEMENU"));
5498 tpl_addVar(vars, TPLADD, "TITLEADD1", "Move mouse over log-window to stop scroll");
5499
5500 if(strcmp(getParam(params, "lastid"), "start") == 0){
5501 setActiveMenu(vars, MNU_LIVELOG);
5502 return tpl_getTpl(vars, "LOGPAGE");
5503 }
5504 else
5505 {
5506 lastid = strtoull(getParam(params, "lastid"), NULL, 10);
5507 }
5508
5509 char *dot = ""; //Delimiter
5510
5511 #ifdef WITH_DEBUG
5512 char *debuglvl = getParam(params, "debug");
5513 if(cs_strlen(debuglvl) > 0) {
5514 int32_t dblvl = atoi(debuglvl);
5515 if(cs_dblevel != dblvl) {
5516 if(dblvl >= 0 && dblvl <= 65535) { cs_dblevel = dblvl; }
5517 cs_log("%s debug_level=%d", "all", cs_dblevel);
5518 }
5519 }
5520 tpl_printf(vars, TPLAPPEND, "DATA","%s\"debug\":\"%d\"", dot, cs_dblevel);
5521 dot = ",";
5522 tpl_printf(vars, TPLAPPEND, "DATA","%s\"maxdebug\":\"%d\"",dot, MAX_DEBUG_LEVELS);
5523 #endif
5524
5525 if(cfg.loghistorylines == 0){
5526 tpl_printf(vars, TPLAPPEND, "DATA","%s\"logdisabled\":\"1\"",dot);
5527 return tpl_getTpl(vars, "POLL");
5528 }
5529
5530 if(log_history)
5531 {
5532 LL_ITER it = ll_iter_create(log_history);
5533 struct s_log_history *hist;
5534
5535 tpl_printf(vars, TPLAPPEND, "DATA", "%s\"lines\":[", dot);
5536
5537 dot = "";
5538
5539 while((hist = (struct s_log_history*)ll_iter_next(&it)))
5540 {
5541 char p_usr[32];
5542 size_t pos1 = strcspn(hist->txt, "\t") + 1;
5543 cs_strncpy(p_usr, hist->txt , pos1 > sizeof(p_usr) ? sizeof(p_usr) : pos1);
5544
5545 char *p_txt = hist->txt + pos1;
5546
5547 pos1 = strcspn(p_txt, "\n") + 1;
5548 char str_out[pos1];
5549 cs_strncpy(str_out, p_txt, pos1);
5550 uint64_t id = hist->counter;
5551
5552 size_t b64_str_in = cs_strlen(xml_encode(vars, str_out));
5553 size_t b64_str_out = 32 + BASE64_LENGTH(b64_str_in);
5554 char *b64_str_out_buf;
5555 if(!cs_malloc(&b64_str_out_buf, b64_str_out))
5556 { continue; }
5557 base64_encode(xml_encode(vars, str_out), b64_str_in, b64_str_out_buf, b64_str_out);
5558
5559 if(id > lastid){
5560 tpl_printf(vars, TPLAPPEND, "DATA","%s{\"id\":\"%" PRIu64 "\",\"usr\":\"%s\",\"line\":\"%s\"}",
5561 dot,
5562 id,
5563 urlencode(vars, xml_encode(vars, p_usr)),
5564 b64_str_out_buf);
5565 dot = ","; // next in Array with leading delimiter
5566 }
5567 NULLFREE(b64_str_out_buf);
5568 }
5569 }
5570
5571 tpl_addVar(vars, TPLAPPEND, "DATA", "]");
5572 return tpl_getTpl(vars, "POLL");
5573 }
5574 #endif
5575
5576 static char *send_oscam_status(struct templatevars * vars, struct uriparams * params, int32_t apicall)
5577 {
5578 int32_t i;
5579 const char *usr;
5580 int32_t lsec, isec, chsec, con, cau = 0;
5581 time_t now = time((time_t *)0);
5582 struct tm lt;
5583 int delimiter=0;
5584
5585 if(!apicall)
5586 {
5587 setActiveMenu(vars, MNU_STATUS);
5588 if (config_enabled(WITH_LB))
5589 tpl_addVar(vars, TPLADD, "STATUSCOL14HEAD","LB Value/");
5590 }
5591 if(strcmp(getParam(params, "action"), "kill") == 0)
5592 {
5593 char *cptr = getParam(params, "threadid");
5594 struct s_client *cl = NULL;
5595 if(cs_strlen(cptr) > 1)
5596 { sscanf(cptr, "%p", (void **)(void *)&cl); }
5597
5598 if(cl && is_valid_client(cl))
5599 {
5600 if(is_dvbapi_usr(cl->account->usr))
5601 {
5602 cs_log("WebIF from %s requests to kill dvbapi client %s -> ignoring!", cs_inet_ntoa(GET_IP()), cl->account->usr);
5603 }
5604 else
5605 {
5606 kill_thread(cl);
5607 cs_log("Client %s killed by WebIF from %s", cl->account->usr, cs_inet_ntoa(GET_IP()));
5608 }
5609 }
5610 }
5611
5612 if(strcmp(getParam(params, "action"), "resetuserstats") == 0)
5613 {
5614 clear_info_clients_stats();
5615 }
5616 if(strcmp(getParam(params, "action"), "resetreaderstats") == 0)
5617 {
5618 clear_info_readers_stats();
5619 }
5620 if(strcmp(getParam(params, "action"), "restart") == 0)
5621 {
5622 struct s_reader *rdr = get_reader_by_label(getParam(params, "label"));
5623 if(rdr)
5624 {
5625 if(rdr->typ != R_GBOX)
5626 {
5627 add_job(rdr->client, ACTION_READER_RESTART, NULL, 0);
5628 }
5629 #ifdef MODULE_GBOX
5630 else
5631 {
5632 restart_gbox_peer(rdr->label, 0, 0);
5633 }
5634 #endif
5635 cs_log("Reader %s restarted by WebIF from %s", rdr->label, cs_inet_ntoa(GET_IP()));
5636 }
5637 }
5638
5639 char *debuglvl = getParam(params, "debug");
5640 if(cs_strlen(debuglvl) > 0)
5641 {
5642 #ifndef WITH_DEBUG
5643 cs_log("*** Warning: Debug Support not compiled in ***");
5644 #else
5645 int32_t dblvl = atoi(debuglvl);
5646 if(dblvl >= 0 && dblvl <= 65535) { cs_dblevel = dblvl; }
5647 cs_log("%s debug_level=%d", "all", cs_dblevel);
5648 #endif
5649 }
5650
5651 char *hide = getParam(params, "hide");
5652 if(cs_strlen(hide) > 0)
5653 {
5654 struct s_client *hideidx = NULL;
5655 sscanf(hide, "%p", (void **)(void *)&hideidx);
5656
5657 if(hideidx && is_valid_client(hideidx))
5658 { hideidx->wihidden = 1; }
5659 }
5660
5661 char *hideidle = getParam(params, "hideidle");
5662 if(cs_strlen(hideidle) > 0)
5663 {
5664 if(atoi(hideidle) == 2)
5665 {
5666 struct s_client *cl;
5667 for(cl = first_client; cl ; cl = cl->next)
5668 {
5669 if(cl->typ == 's' || cl->typ == 'h' || cl->typ == 'm'){
5670 cl->wihidden = 0;
5671 }
5672 }
5673 }
5674 else if(atoi(hideidle) == 3)
5675 {
5676 struct s_client *cl;
5677 for(cl = first_client; cl ; cl = cl->next)
5678 {
5679 if(cl->typ == 'r'){
5680 cl->wihidden = 0;
5681 }
5682 }
5683 }
5684 else if(atoi(hideidle) == 4)
5685 {
5686 struct s_client *cl;
5687 for(cl = first_client; cl ; cl = cl->next)
5688 {
5689 if(cl->typ == 'p'){
5690 cl->wihidden = 0;
5691 }
5692 }
5693 }
5694 else if(atoi(hideidle) == 5)
5695 {
5696 struct s_client *cl;
5697 for(cl = first_client; cl ; cl = cl->next)
5698 {
5699 if(cl->typ == 'c'){
5700 cl->wihidden = 0;
5701 }
5702 }
5703 }
5704 else
5705 {
5706 int32_t oldval = cfg.http_hide_idle_clients;
5707 config_set("webif", "httphideidleclients", hideidle);
5708 if(oldval != cfg.http_hide_idle_clients)
5709 {
5710 refresh_oscam(REFR_SERVER);
5711 }
5712 }
5713 }
5714
5715 if(cfg.http_hide_idle_clients > 0) { tpl_addVar(vars, TPLADD, "HIDEIDLECLIENTSSELECTED1", "selected"); }
5716 else { tpl_addVar(vars, TPLADD, "HIDEIDLECLIENTSSELECTED0", "selected"); }
5717
5718 tpl_addVar(vars, TPLADD, "SRVIDFILE", use_srvid2 ? "oscam.srvid2" : "oscam.srvid");
5719
5720 int32_t user_count_all = 0, user_count_shown = 0, user_count_active = 0;
5721 int32_t reader_count_all = 0, reader_count_conn = 0, reader_count_off = 0;
5722 int32_t proxy_count_all = 0, proxy_count_conn = 0, proxy_count_off = 0;
5723 int32_t server_count_all = 0, server_count_shown = 0, server_count_hidden = 0;
5724 int32_t monitor_count_all = 0, monitor_count_shown = 0;
5725 int32_t shown;
5726
5727 int32_t total_readers = 0;
5728 int32_t active_readers = 0;
5729 int32_t disabled_readers = 0;
5730 int32_t connected_readers = 0;
5731
5732 struct s_client *cl;
5733 int8_t filtered;
5734
5735 cs_readlock(__func__, &readerlist_lock);
5736 cs_readlock(__func__, &clientlist_lock);
5737 for(i = 0, cl = first_client; cl ; cl = cl->next, i++)
5738 {
5739 #ifdef CS_CACHEEX_AIO
5740 #if defined(MODULE_CCCAM) && defined(CS_CACHEEX)
5741 struct cc_data *cc = cl->cc;
5742 #endif
5743 #endif
5744 if(cl->kill) { continue; }
5745 #ifdef CS_CACHEEX
5746 if(get_module(cl)->listenertype != LIS_CSPUDP)
5747 {
5748 #endif
5749
5750 // Reset template variables
5751 tpl_addVar(vars, TPLADD, "LBLRPSTRVALUE", "");
5752 tpl_addVar(vars, TPLADD, "CLIENTLBVALUE", "");
5753 tpl_addVar(vars, TPLADD, "LASTREADER", "");
5754 tpl_addVar(vars, TPLADD, "CLIENTPROTO", "");
5755 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
5756 tpl_addVar(vars, TPLADD, "CLIENTLASTRESPONSETIME", "");
5757 tpl_addVar(vars, TPLADD, "CLIENTLASTRESPONSETIMEHIST", "");
5758 tpl_addVar(vars, TPLADD, "UPICMISSING" , "");
5759 tpl_addVar(vars, TPLADD, "ENTITLEMENTS", "");
5760
5761 if(cl->typ == 'c')
5762 { user_count_all++; }
5763 else if(cl->typ == 'p')
5764 {
5765 proxy_count_all++;
5766 if((cl->reader->typ == R_GBOX && cl->reader->card_status != CARD_INSERTED && cl->reader->card_status != NO_CARD) ||
5767 (cl->reader->typ != R_GBOX && cl->reader->card_status != CARD_INSERTED))
5768 { proxy_count_off++; }
5769 }
5770 else if(cl->typ == 'r')
5771 { reader_count_all++; if(cl->reader->card_status != CARD_INSERTED) { reader_count_off++; } }
5772 else if(cl->typ == 's' || cl->typ == 'h')
5773 { server_count_all++; if(cl->wihidden) {server_count_hidden++;} }
5774 else if(cl->typ == 'm')
5775 { monitor_count_all++; }
5776
5777 shown = 0;
5778 if(cl->wihidden != 1)
5779 {
5780 filtered = !(cfg.http_hide_idle_clients != 1 || cl->typ != 'c' || (now - cl->lastecm) <= cfg.hideclient_to);
5781 if(!filtered && cfg.http_hide_type)
5782 {
5783 char *p = cfg.http_hide_type;
5784 while(*p && !filtered)
5785 {
5786 char type = *p++;
5787 #ifdef CS_CACHEEX
5788 filtered = (type == cl->typ) || (type == 'x' && (cl->typ == 'p' || cl->typ == 'r') && (cl->reader && cl->reader->cacheex.mode));
5789 #else
5790 filtered = (type == cl->typ);
5791 #endif
5792 #ifdef WITH_EMU
5793 if(type == 'e' && cl->typ == 'r' && cl->reader->typ == R_EMU) filtered = 1;
5794 #endif
5795 }
5796 }
5797
5798 if(!filtered)
5799 {
5800 if(cl->typ == 'c')
5801 {
5802 user_count_shown++;
5803 if(cfg.http_hide_idle_clients != 1 && cfg.hideclient_to > 0 && (now - cl->lastecm) <= cfg.hideclient_to)
5804 {
5805 user_count_active++;
5806 }
5807 }
5808 else if(cl->typ == 's' || cl->typ == 'h')
5809 {
5810 server_count_shown++;
5811 }
5812 else if(cl->typ == 'm')
5813 {
5814 monitor_count_shown++;
5815 }
5816 else if(cl->typ == 'r')
5817 {
5818 reader_count_conn++;
5819 }
5820 else if(cl->typ == 'p')
5821 {
5822 proxy_count_conn++;
5823 }
5824
5825 if(cl->typ == 'c' || cl->typ == 'r' || cl->typ == 'p')
5826 {
5827 if(cl->lastecm >= cl->login && cl->lastecm >= cl->logout) { isec = now - cl->lastecm; }
5828 else if(cl->logout >= cl->login) { isec = now - cl->logout; }
5829 else { isec = now - cl->login; }
5830 }
5831 else { isec = now - cl->last; }
5832
5833 shown = 1;
5834 lsec = now - cl->login;
5835 chsec = now - cl->lastswitch;
5836 usr = username(cl);
5837
5838 if((cl->typ == 'r') || (cl->typ == 'p')) { usr = cl->reader->label; }
5839
5840 if(cl->dup) { con = 2; }
5841 else if((cl->tosleep) && (now - cl->lastswitch > cl->tosleep)) { con = 1; }
5842 else { con = 0; }
5843
5844 // no AU reader == 0 / AU ok == 1 / Last EMM > aulow == -1
5845 if(cl->typ == 'c' || cl->typ == 'p' || cl->typ == 'r')
5846 {
5847 if((cl->typ == 'c' && ll_count(cl->aureader_list) == 0) || ((cl->typ == 'p' || cl->typ == 'r') && cl->reader->audisabled)) { cau = 0; }
5848 else if((now - cl->lastemm) / 60 > cfg.aulow) { cau = -1; }
5849 else { cau = 1; }
5850
5851 if(cau == 0)
5852 {
5853 tpl_addVar(vars, TPLADD, "CLIENTCAUHTTP", "OFF");
5854 }
5855 else
5856 {
5857 if(cau == -1)
5858 { tpl_addVar(vars, TPLADD, "CLIENTCAUHTTP", !apicall?"<A HREF=\"#\" CLASS=\"tooltip\">ON":""); }
5859 else
5860 { tpl_addVar(vars, TPLADD, "CLIENTCAUHTTP", !apicall?"<A HREF=\"#\" CLASS=\"tooltip\">ACTIVE":""); }
5861 tpl_addVar(vars, TPLAPPEND, "CLIENTCAUHTTP", !apicall?"<SPAN>":"");
5862 if(cl->typ == 'c')
5863 {
5864 struct s_reader *rdr;
5865 LL_ITER itr = ll_iter_create(cl->aureader_list);
5866 while((rdr = ll_iter_next(&itr)))
5867 {
5868 if(rdr->audisabled)
5869 { tpl_printf(vars, TPLAPPEND, "CLIENTCAUHTTP", "(%s)<BR>", xml_encode(vars, rdr->label)); }
5870 else
5871 { tpl_printf(vars, TPLAPPEND, "CLIENTCAUHTTP", "%s<BR>", xml_encode(vars, rdr->label)); }
5872 }
5873 }
5874 else { tpl_addVar(vars, TPLAPPEND, "CLIENTCAUHTTP", xml_encode(vars, cl->reader->label)); }
5875 tpl_addVar(vars, TPLAPPEND, "CLIENTCAUHTTP", !apicall?"</SPAN></A>":"");
5876 }
5877 }
5878 else
5879 {
5880 cau = 0;
5881 tpl_addVar(vars, TPLADD, "CLIENTCAUHTTP", "");
5882 }
5883 localtime_r(&cl->login, &lt);
5884
5885 if(cl->typ == 'c' || cl->typ == 'm')
5886 {
5887 if(cl->account && cl->account->description)
5888 tpl_printf(vars, TPLADD, "CLIENTDESCRIPTION","%s(%s)",!apicall?"&#13;":"",xml_encode(vars, cl->account->description));
5889 else
5890 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
5891 }
5892 else if(cl->typ == 'p' || cl->typ == 'r')
5893 {
5894 if(cl->reader && cl->reader->description)
5895 tpl_printf(vars, TPLADD, "CLIENTDESCRIPTION","%s(%s)",!apicall?"&#13;":"",xml_encode(vars, cl->reader->description));
5896 else
5897 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
5898 }
5899 if(!apicall)
5900 {
5901 tpl_addVar(vars, TPLADD, "LBL", xml_encode(vars, usr));
5902 tpl_printf(vars, TPLADD, "CID", "%p", cl);
5903 if(cl->typ == 'c' || cl->typ == 'm')
5904 {
5905 tpl_addVar(vars, TPLADD, "TARGET", "User");
5906 tpl_addVar(vars, TPLADD, "CSIDX", tpl_getTpl(vars, "STATUSKBUTTON"));
5907 }
5908 else if(cl->typ == 'p')
5909 {
5910 tpl_addVar(vars, TPLADD, "TARGET", "Proxy");
5911 tpl_addVar(vars, TPLADD, "LBLENC", urlencode(vars, usr));
5912 tpl_addVar(vars, TPLADD, "CSIDX", tpl_getTpl(vars, "STATUSRBUTTON"));
5913 }
5914 else if(cl->typ == 'r')
5915 {
5916 tpl_addVar(vars, TPLADD, "TARGET", "Reader");
5917 tpl_addVar(vars, TPLADD, "LBLENC", urlencode(vars, usr));
5918 tpl_addVar(vars, TPLADD, "CSIDX", tpl_getTpl(vars, "STATUSRBUTTON"));
5919 }
5920 else if (cl->typ == 'h' || cl->typ == 's')
5921 {
5922 tpl_addVar(vars, TPLADD, "TARGET", "Server");
5923 tpl_addVar(vars, TPLADD, "CSIDX", "");
5924 }
5925 tpl_addVar(vars, TPLADD, "HIDEIDX", tpl_getTpl(vars, "STATUSHBUTTON"));
5926 tpl_printf(vars, TPLADD, "CSIDXPLAIN", "id_%p", cl);
5927 }
5928 else
5929 {
5930 tpl_printf(vars, TPLADD, "HIDEIDX", "%p", cl);
5931 tpl_printf(vars, TPLADD, "CSIDX", "id_%p", cl);
5932 }
5933 tpl_printf(vars, TPLADD, "CLIENTTYPE", "%c", cl->typ);
5934 tpl_printf(vars, TPLADD, "CLIENTCNR", "%d", get_threadnum(cl));
5935 tpl_addVar(vars, TPLADD, "CLIENTUSER", xml_encode(vars, usr));
5936
5937 tpl_addVar(vars, TPLADD, "STATUSUSERICON", xml_encode(vars, usr));
5938 if (cl->typ == 'c' || cl->typ == 'm')
5939 {
5940 tpl_addVar(vars, TPLADD, "USERNAME", xml_encode(vars, usr));
5941 tpl_addVar(vars, TPLADD, "USERENC", urlencode(vars, usr));
5942 }
5943 else if (cl->typ == 'p' || cl->typ == 'r')
5944 {
5945 tpl_addVar(vars, TPLADD, "READERNAME", xml_encode(vars, usr));
5946 tpl_addVar(vars, TPLADD, "READERNAMEENC", urlencode(vars, usr));
5947 }
5948
5949 bool picon_shown = false;
5950 const char *status_user_icon_tpl = NULL;
5951
5952 char picon_name[32];
5953 if(cfg.http_showpicons)
5954 {
5955 if(picon_exists(xml_encode(vars, usr)))
5956 {
5957 switch (cl->typ)
5958 {
5959 case 'm': // Fall through
5960 case 'c': status_user_icon_tpl = "SUSERICON"; picon_shown = true; break;
5961 case 'p': // Fall through
5962 case 'r': status_user_icon_tpl = "SREADERICON"; picon_shown = true; break;
5963 }
5964 }
5965 else
5966 tpl_printf(vars, TPLADD, "UPICMISSING", "%smissing icon: IC_%s.tpl",!apicall?"&#13;":"",xml_encode(vars, usr));
5967 }
5968
5969 if (!picon_shown)
5970 {
5971 switch (cl->typ)
5972 {
5973 case 'm': // Fall through
5974 case 'c': status_user_icon_tpl = "SUSER"; break;
5975 case 'p': // Fall through
5976 case 'r': status_user_icon_tpl = "SREADER"; break;
5977 }
5978 }
5979
5980 if (status_user_icon_tpl)
5981 tpl_addVar(vars, TPLADD, "STATUSUSERICON", tpl_getTpl(vars, status_user_icon_tpl));
5982
5983 tpl_printf(vars, TPLADD, "CLIENTCAU", "%d", cau);
5984 if(!apicall)
5985 {
5986 if(cl->typ == 'c' || cl->typ == 'p' || cl->typ == 'r')
5987 {
5988 if(cl->crypted) { tpl_addVar(vars, TPLADD, "CLIENTCRYPTED", "ON"); }
5989 else { tpl_addVar(vars, TPLADD, "CLIENTCRYPTED", "OFF"); }
5990 }
5991 else { tpl_addVar(vars, TPLADD, "CLIENTCRYPTED", ""); }
5992 }
5993 else { tpl_printf(vars, TPLADD, "CLIENTCRYPTED", "%d", cl->crypted); }
5994 tpl_addVar(vars, TPLADD, "CLIENTIP", cs_inet_ntoa(cl->ip));
5995 tpl_printf(vars, TPLADD, "CLIENTPORT", "%d", cl->port);
5996 const char *proto = client_get_proto(cl);
5997 #ifdef CS_CACHEEX_AIO
5998 if(cl &&
5999 ( (cl->typ == 'c' && cl->account && cl->account->cacheex.feature_bitfield)
6000 #if defined(MODULE_CAMD35) || defined (MODULE_CAMD35_TCP)
6001 || (cl->c35_extmode > 1)
6002 #endif
6003 #ifdef MODULE_CCCAM
6004 || (cc && cc->extended_lg_flagged_cws)
6005 #endif
6006 || (cl->typ == 'p' && cl->reader && cl->reader->cacheex.feature_bitfield))
6007 )
6008 {
6009 const char *aio_suffix = " (cx-aio)";
6010 char *new_proto;
6011 if(cs_malloc(&new_proto, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
6012 new_proto[0] = '\0';
6013 if (!cs_strncat(new_proto, (char *)proto, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
6014 cs_log("FIXME!");
6015 }
6016 if (cs_strncat(new_proto, (char *)aio_suffix, cs_strlen(proto)+cs_strlen(aio_suffix)+1)) {
6017 webif_add_client_proto(vars, cl, (const char*)new_proto, apicall);
6018 } else {
6019 cs_log("FIXME!");
6020 }
6021 free(new_proto);
6022 }
6023 } else {
6024 #endif
6025 webif_add_client_proto(vars, cl, proto, apicall);
6026 #ifdef CS_CACHEEX_AIO
6027 }
6028 #endif
6029 if(!apicall)
6030 {
6031 if((cl->typ != 'p' && cl->typ != 'r') || cl->reader->card_status == CARD_INSERTED)
6032 {
6033 tpl_printf(vars, TPLADD, "CLIENTLOGINDATE", "%02d.%02d.%02d<BR>%02d:%02d:%02d", lt.tm_mday, lt.tm_mon + 1, lt.tm_year % 100, lt.tm_hour, lt.tm_min, lt.tm_sec);
6034 tpl_addVar(vars, TPLADD, "CLIENTLOGINSECS", sec2timeformat(vars, lsec));
6035 }
6036 else
6037 {
6038 tpl_addVar(vars, TPLADD, "CLIENTLOGINDATE", "");
6039 tpl_addVar(vars, TPLADD, "CLIENTLOGINSECS", "");
6040 }
6041 }
6042 else
6043 {
6044 tpl_printf(vars, TPLADD, "CLIENTLOGINDATEFMT", "%02d.%02d.%02d %02d:%02d:%02d", lt.tm_mday, lt.tm_mon + 1, lt.tm_year % 100, lt.tm_hour, lt.tm_min, lt.tm_sec);
6045 char tbuffer [30];
6046 strftime(tbuffer, 30, "%Y-%m-%dT%H:%M:%S%z", &lt);
6047 tpl_addVar(vars, TPLADD, "CLIENTLOGINDATE", tbuffer);
6048 tpl_printf(vars, TPLADD, "CLIENTLOGINSECS", "%d", lsec);
6049 }
6050
6051 //load historical values from ringbuffer
6052 char *value = get_ecm_historystring(cl);
6053 tpl_addVar(vars, TPLADD, "CLIENTLASTRESPONSETIMEHIST", value);
6054 free_mk_t(value);
6055
6056 if((isec < cfg.hideclient_to || cfg.hideclient_to == 0 || is_dvbapi_usr(cl->account->usr)) && (cl->typ == 'c' || cl->typ == 'p' || cl->typ == 'r'))
6057 {
6058 if(((cl->typ == 'c')) && (cl->lastreader[0]))
6059 {
6060 tpl_printf(vars, TPLADD, "MSVALUE", PRINTF_LOCAL_D, cl->cwlastresptime);
6061 if(apicall)
6062 {
6063 tpl_addVar(vars, TPLADD, "LASTREADER", (cl->last_caid == NO_CAID_VALUE || isec > cfg.hideclient_to ) ? "" : cl->lastreader);
6064 tpl_addVar(vars, TPLADD, "READERNAMEENC", urlencode(vars, cl->lastreader));
6065 }
6066 else
6067 {
6068 #ifdef WITH_LB
6069 tpl_addVar(vars, TPLADD, "LBLVALUE", xml_encode(vars, cl->lastreader));
6070 if(strstr(cl->lastreader, " (cache)"))
6071 {
6072 char lastreader_tmp[cs_strlen(cl->lastreader) - 8];
6073 tpl_addVar(vars, TPLADD, "CLIENTLBVALUE", tpl_getVar(vars, "LBLRPSTRVALUE"));
6074 cs_strncpy(lastreader_tmp, cl->lastreader, sizeof(lastreader_tmp));
6075 tpl_addVar(vars, TPLADD, "LBLVALUEENC", urlencode(vars, lastreader_tmp));
6076 tpl_addVar(vars, TPLADD, "LBLVALUETITLE", xml_encode(vars, lastreader_tmp));
6077 }
6078 else
6079 {
6080 tpl_addVar(vars, TPLADD, "LBLVALUEENC", urlencode(vars, cl->lastreader));
6081 tpl_addVar(vars, TPLADD, "LBLVALUETITLE", xml_encode(vars, cl->lastreader));
6082 }
6083 tpl_addVar(vars, TPLAPPEND, "CLIENTLBVALUE", tpl_getTpl(vars, "CLIENTLBLVALUEBIT"));
6084 #else
6085 tpl_printf(vars, TPLAPPEND, "CLIENTLBVALUE", "%s (%'d ms)", xml_encode(vars, cl->lastreader), cl->cwlastresptime);
6086 #endif
6087 }
6088 if(cl->last_caid == NO_CAID_VALUE || isec > cfg.hideclient_to) tpl_addVar(vars, TPLADD, "CLIENTLBVALUE", "");
6089 }
6090 if(cl->last_caid != NO_CAID_VALUE || cl->last_srvid != NO_SRVID_VALUE)
6091 {
6092 char channame[CS_SERVICENAME_SIZE];
6093 const char *lastprovidername;
6094
6095 get_servicename_or_null(cl, cl->last_srvid, cl->last_provid, cl->last_caid, channame, sizeof(channame));
6096 if(channame[0] == '\0')
6097 {
6098 cs_strncpy(channame, "unknown", sizeof(channame));
6099 }
6100
6101 lastprovidername = get_cl_lastprovidername(cl);
6102
6103 tpl_printf(vars, TPLADD, "CLIENTCAID", "%04X", cl->last_caid);
6104 tpl_printf(vars, TPLADD, "CLIENTPROVID", "%06X", cl->last_provid);
6105 tpl_printf(vars, TPLADD, "CLIENTSRVID", "%04X", cl->last_srvid);
6106 tpl_printf(vars, TPLADD, "CLIENTSRVPROVIDER", "%s%s%s", (lastprovidername[0] != '\0' && strcmp(lastprovidername, " ")) ? " [" : "", xml_encode(vars, lastprovidername), (lastprovidername[0] != '\0' && strcmp(lastprovidername, " ")) ? "]" : "");
6107 tpl_addVar(vars, TPLADD, "CLIENTSRVNAME", xml_encode(vars, channame));
6108 tpl_printf(vars, TPLADD, "CLIENTLASTRESPONSETIME", "%d", cl->cwlastresptime ? cl->cwlastresptime : 1);
6109 tpl_addVar(vars, TPLADD, "CLIENTSRVTYPE", cl->last_srvidptr && cl->last_srvidptr->type ? xml_encode(vars, cl->last_srvidptr->type) : "");
6110 tpl_addVar(vars, TPLADD, "CLIENTSRVDESCRIPTION", cl->last_srvidptr && cl->last_srvidptr->desc ? xml_encode(vars, cl->last_srvidptr->desc) : "");
6111 tpl_addVar(vars, TPLADD, "CLIENTTIMEONCHANNEL", sec2timeformat(vars, chsec));
6112 if(cfg.http_showpicons && cl->last_srvid)
6113 {
6114 char picon_channame[30];
6115 int8_t picon_ok = 0;
6116
6117 get_picon_servicename_or_null(cl, cl->last_srvid, cl->last_provid, cl->last_caid, picon_channame, sizeof(picon_channame));
6118 if(picon_channame[0])
6119 {
6120 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", picon_channame);
6121 picon_ok = picon_exists(picon_name);
6122 if(picon_ok) tpl_addVar(vars, TPLADD, "PICONNAME", picon_name);
6123
6124 if(!picon_ok && picon_servicename_remve_hd(picon_channame, sizeof(picon_channame)))
6125 {
6126 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%s", picon_channame);
6127 picon_ok = picon_exists(picon_name);
6128 if(picon_ok) tpl_addVar(vars, TPLADD, "PICONNAME", picon_name);
6129 }
6130 }
6131 if(!picon_ok)
6132 {
6133 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%04X_%06X_%04X", cl->last_caid, cl->last_provid, cl->last_srvid);
6134 tpl_addVar(vars, TPLADD, "PICONNAME", picon_name);
6135 picon_ok = picon_exists(picon_name);
6136 }
6137 if(!picon_ok)
6138 {
6139 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "%04X_%04X", cl->last_caid, cl->last_srvid);
6140 picon_ok = picon_exists(picon_name);
6141 if(picon_ok) tpl_addVar(vars, TPLADD, "PICONNAME", picon_name);
6142 }
6143 if(!picon_ok)
6144 {
6145 snprintf(picon_name, sizeof(picon_name) / sizeof(char) - 1, "0000_%04X", cl->last_srvid);
6146 picon_ok = picon_exists(picon_name);
6147 if(picon_ok) tpl_addVar(vars, TPLADD, "PICONNAME", picon_name);
6148 }
6149 if(picon_ok)
6150 {
6151 tpl_addVar(vars, TPLADDONCE, "CURRENTPICON", tpl_getTpl(vars, "CLIENTCURRENTCHANNELPIC"));
6152 }
6153 else
6154 {
6155 tpl_addVar(vars, TPLADDONCE, "CURRENTPICON", tpl_getTpl(vars, "CLIENTCURRENTCHANNEL"));
6156 tpl_addVar(vars, TPLADD, "PICONNAME", "");
6157 }
6158 }
6159 else
6160 {
6161 tpl_addVar(vars, TPLADDONCE, "CURRENTPICON", tpl_getTpl(vars, "CLIENTCURRENTCHANNELBIT"));
6162 tpl_addVar(vars, TPLADD, "PICONNAME", "0000_0000");
6163 }
6164 }
6165 else
6166 {
6167 tpl_addVar(vars, TPLADD, "CLIENTCAID", "0000");
6168 tpl_addVar(vars, TPLADD, "CLIENTPROVID", "000000");
6169 tpl_printf(vars, TPLADD, "CLIENTSRVID", "0000");
6170 }
6171 }
6172 else
6173 {
6174 tpl_addVar(vars, TPLADD, "CLIENTCAID", "0000");
6175 tpl_addVar(vars, TPLADD, "CLIENTPROVID", "000000");
6176 tpl_addVar(vars, TPLADD, "CLIENTSRVID", "0000");
6177 tpl_addVar(vars, TPLADD, "CURRENTPICON", "");
6178 tpl_addVar(vars, TPLADD, "CLIENTSRVPROVIDER", "");
6179 tpl_addVar(vars, TPLADD, "CLIENTSRVNAME", "");
6180 tpl_addVar(vars, TPLADD, "CLIENTSRVTYPE", "");
6181 tpl_addVar(vars, TPLADD, "CLIENTSRVDESCRIPTION", "");
6182 tpl_addVar(vars, TPLADD, "CLIENTLBVALUE", "");
6183 tpl_addVar(vars, TPLADD, "CLIENTTIMEONCHANNEL", "");
6184 }
6185
6186 if(!apicall)
6187 {
6188 tpl_addVar(vars, TPLADD, "CLIENTIDLESECS", sec2timeformat(vars, isec));
6189
6190 if((cl->typ != 'p' && cl->typ != 'r') || cl->reader->card_status == CARD_INSERTED)
6191 { tpl_addVar(vars, TPLADD, "CLIENTIDLESECSCLASS", "idlesec_normal"); }
6192 else
6193 { tpl_addVar(vars, TPLADD, "CLIENTIDLESECSCLASS", "idlesec_alert"); }
6194 }
6195 else
6196 {
6197 tpl_printf(vars, TPLADD, "CLIENTIDLESECS", "%d", isec);
6198 }
6199
6200 if(con == 2) { tpl_addVar(vars, TPLADD, "CLIENTCON", "Duplicate"); }
6201 else if(con == 1) { tpl_addVar(vars, TPLADD, "CLIENTCON", "Sleep"); }
6202 else
6203 {
6204 struct s_reader *rdr = cl->reader;
6205 char *txt = "OK";
6206 if(!rdr && (cl->typ == 'r' || cl->typ == 'p')) { txt = "UNKNOWN"; }
6207
6208 else if(cl->typ == 'r' || cl->typ == 'p') //reader or proxy
6209 {
6210 #ifdef WITH_LB
6211 if(rdr->lbvalue)
6212 {
6213 tpl_printf(vars, TPLADD, "LBLRPSTRVALUE", "%d", rdr->lbvalue);
6214 }
6215 else
6216 {
6217 tpl_addVar(vars, TPLADD, "LBLRPSTRVALUE", "no data");
6218 }
6219 tpl_addVar(vars, TPLADD, "LBLRPVALUE", rdr->label);
6220 tpl_addVar(vars, TPLADD, "LBLRPVALUEENC", urlencode(vars, rdr->label));
6221 tpl_addVar(vars, TPLADD, "CLIENTLBVALUE", tpl_getTpl(vars, "CLIENTLBLVALUERP"));
6222 #else
6223 tpl_addVar(vars, TPLADD, "CLIENTLBVALUE", tpl_getVar(vars, "LBLRPSTRVALUE"));
6224 #endif
6225 switch(rdr->card_status)
6226 {
6227 case NO_CARD:
6228 if(rdr->typ == R_GBOX)
6229 { txt = "ONL"; }
6230 else
6231 { txt = "OFF"; }
6232 break;
6233 case UNKNOWN:
6234 txt = "UNKNOWN";
6235 break;
6236 case READER_DEVICE_ERROR:
6237 txt = "READER DEVICE ERROR";
6238 break;
6239 case CARD_NEED_INIT:
6240 if(rdr->typ == R_GBOX)
6241 { txt = "OFFLINE"; }
6242 #ifdef CS_CACHEEX
6243 else if (cl->reader->cacheex.mode > 0)
6244 { txt = "CCcam CacheEX"; }
6245 #endif
6246 else
6247 { txt = "NEEDINIT"; }
6248 break;
6249 case CARD_INSERTED:
6250 if(cl->typ == 'p')
6251 {
6252 if(rdr->typ == R_GBOX)
6253 { txt = "ONL"; }
6254 else
6255 { txt = "CONNECTED"; }
6256 }
6257 else
6258 { txt = "CARDOK"; }
6259 break;
6260 case CARD_FAILURE:
6261 txt = "ERROR";
6262 break;
6263 default:
6264 txt = "UNDEF";
6265 }
6266 #ifdef MODULE_GBOX
6267 if(rdr->typ == R_GBOX)
6268 {
6269 struct gbox_peer *peer = cl->gbox;
6270 char gbx_txt[45];
6271 memset(gbx_txt, 0, sizeof(gbx_txt));
6272 if(!strcmp(txt, "OFFLINE"))
6273 {
6274 snprintf(gbx_txt, sizeof(gbx_txt), "%s | ID: %04X", txt, peer->gbox.id);
6275 }
6276 else
6277 {
6278 snprintf(gbx_txt, sizeof(gbx_txt), "%s | crd: %d | ID: %04X", txt, gbox_count_peer_cards(peer->gbox.id), peer->gbox.id);
6279 }
6280 txt = gbx_txt;
6281 }
6282 #endif
6283 }
6284
6285 tpl_addVar(vars, TPLADD, "CLIENTCON", txt);
6286
6287 if(rdr && (cl->typ == 'r')) //reader
6288 {
6289 if(rdr->ll_entitlements)
6290 {
6291 LL_ITER itr = ll_iter_create(rdr->ll_entitlements);
6292 S_ENTITLEMENT *ent;
6293 uint16_t total_ent = 0;
6294 uint16_t active_ent = 0;
6295 struct tm end_t;
6296 tpl_addVar(vars, TPLADD, "TMPSPAN", "<SPAN>");
6297 while((ent = ll_iter_next(&itr)))
6298 {
6299 total_ent++;
6300 if((ent->end > now) && (ent->type != 7))
6301 {
6302 if(active_ent) {tpl_addVar(vars, TPLAPPEND, "TMPSPAN", "<BR><BR>");}
6303 active_ent++;
6304 localtime_r(&ent->end, &end_t);
6305 tpl_printf(vars, TPLAPPEND, "TMPSPAN", "%04X@%06X<BR>exp:%04d/%02d/%02d",
6306 ent->caid, ent->provid,
6307 end_t.tm_year + 1900, end_t.tm_mon + 1, end_t.tm_mday);
6308 tpl_printf(vars, TPLAPPEND, "ENTITLEMENTS", "%s{\"caid\":\"%04X\",\"provid\":\"%06X\",\"exp\":\"%04d/%02d/%02d\"}",
6309 active_ent > 1 ? ",": "",
6310 ent->caid, ent->provid,
6311 end_t.tm_year + 1900, end_t.tm_mon + 1, end_t.tm_mday);
6312 }
6313 }
6314 tpl_printf(vars, TPLADD, "TOTENTITLEMENTS", "%d", total_ent);
6315 if(((total_ent) && (active_ent == 0)) || (total_ent == 0))
6316 {
6317 tpl_addVar(vars, TPLAPPEND, "TMPSPAN", "No active entitlements found");
6318 }
6319 tpl_addVar(vars, TPLAPPEND, "TMPSPAN", "</SPAN>");
6320 if(active_ent)
6321 {
6322 tpl_printf(vars, TPLADD, "TMP", "(%d entitlement%s)", active_ent, (active_ent != 1) ? "s" : "");
6323 }
6324 else
6325 {
6326 tpl_addVar(vars, TPLADD, "TMP", "(no entitlements)");
6327 }
6328 tpl_addVar(vars, TPLADD, "ENTLABEL", urlencode(vars, cl->reader->label));
6329 tpl_addVar(vars, TPLADD, "ENTVALUE", active_ent > 0 ? "" : "1");
6330 if (!apicall) tpl_addVar(vars, TPLAPPEND, "CLIENTCON", tpl_getTpl(vars, "FOUNDENTITLEMENTS"));
6331 }
6332 else
6333 {
6334 tpl_addVar(vars, TPLADD, "ENTLABEL", urlencode(vars, cl->reader->label));
6335 if (!apicall) tpl_addVar(vars, TPLAPPEND, "CLIENTCON", tpl_getTpl(vars, "NOENTITLEMENTS"));
6336 }
6337 }
6338 #ifdef MODULE_CCCAM
6339 if(!apicall || apicall == 2)
6340 {
6341 if(rdr && (cl->typ == 'r' || cl->typ == 'p') && strncmp(proto, "cccam", 5) == 0 && rdr->tcp_connected && rdr->card_status != CARD_FAILURE)
6342 {
6343 struct cc_data *rcc = cl->cc;
6344 if(rcc)
6345 {
6346 LLIST *cards = rcc->cards;
6347 if(cards)
6348 {
6349 int32_t cnt = ll_count(cards);
6350 int32_t locals = rcc->num_hop1;
6351 if(!apicall)
6352 {
6353 tpl_printf(vars, TPLADD, "TMP", "(%d of %d card%s)", locals, cnt, (cnt > 1) ? "s" : "");
6354 tpl_printf(vars, TPLADD, "CCCOUNT", "%d", cnt);
6355 tpl_printf(vars, TPLADD, "CCCHOP1", "%d", rcc->num_hop1);
6356 tpl_printf(vars, TPLADD, "CCCHOP2", "%d", rcc->num_hop2);
6357 tpl_printf(vars, TPLADD, "CCCHOPX", "%d", rcc->num_hopx);
6358 tpl_printf(vars, TPLADD, "CCCCURR", "%d", cl->reader->currenthops);
6359 tpl_printf(vars, TPLADD, "CCCRES0", "%d", rcc->num_reshare0);
6360 tpl_printf(vars, TPLADD, "CCCRES1", "%d", rcc->num_reshare1);
6361 tpl_printf(vars, TPLADD, "CCCRES2", "%d", rcc->num_reshare2);
6362 tpl_printf(vars, TPLADD, "CCCRESX", "%d", rcc->num_resharex);
6363 tpl_addVar(vars, TPLADD, "TMPSPAN", tpl_getTpl(vars, "CCENTITLEMENTS"));
6364 tpl_addVar(vars, TPLADD, "CCCLABEL", urlencode(vars, cl->reader->label));
6365 tpl_addVar(vars, TPLADD, "CCCRESHARE", rcc->num_reshare0 > 0 ? "1" : "");
6366 tpl_addVar(vars, TPLADD, "CCCTMP", tpl_getVar(vars, "TMP"));
6367 tpl_addVar(vars, TPLADD, "CCCTMPSPAN", tpl_getVar(vars, "TMPSPAN"));
6368 tpl_addVar(vars, TPLAPPEND, "CLIENTCON", tpl_getTpl(vars, "CCENTITLETOOLTIP"));
6369 }
6370 if (apicall == 2)
6371 {
6372 tpl_addVar(vars, TPLADD, "READERNAMEENC", urlencode(vars, cl->reader->label));
6373 tpl_printf(vars, TPLADD, "ENTITLEMENTS", "{\"locals\":\"%d\",\"cccount\":\"%d\",\"ccchop1\":\"%d\",\"ccchop2\":\"%d\",\"ccchopx\":\"%d\",\"ccccurr\":\"%d\",\"cccres0\":\"%d\",\"cccres1\":\"%d\",\"cccres2\":\"%d\",\"cccresx\":\"%d\",\"cccreshare\":\"%s\"}",
6374 locals, cnt, rcc->num_hop1, rcc->num_hop2, rcc->num_hopx, cl->reader->currenthops,
6375 rcc->num_reshare0, rcc->num_reshare1, rcc->num_reshare2, rcc->num_resharex,
6376 rcc->num_reshare0 > 0 ? "1" : "");
6377 }
6378 cs_log_dbg(D_TRACE, "Reader %s has total %d local%s hop1 %d hopx %d from total of %d card%s", cl->reader->label, locals, (locals > 1) ? "s" : "", rcc->num_hop2, rcc->num_hopx, cnt, (cnt > 1) ? "s" : "");
6379 }
6380 }
6381 }
6382 }
6383 #endif
6384 }
6385 }
6386 }
6387 if(!apicall)
6388 {
6389 // select right suborder
6390 if(cl->typ == 'c')
6391 {
6392 if(shown) { tpl_addVar(vars, TPLAPPEND, "CLIENTSTATUS", tpl_getTpl(vars, "CLIENTSTATUSBIT")); }
6393 if(cfg.http_hide_idle_clients != 1 && cfg.hideclient_to > 0)
6394 {
6395 tpl_printf(vars, TPLADD, "UCAC", "%d", user_count_active);
6396 tpl_printf(vars, TPLADD, "CFGH", "%d", cfg.hideclient_to);
6397 tpl_addVar(vars, TPLADD, "CHEADADD", tpl_getTpl(vars, "CLIENTHEADLINEADD"));
6398 }
6399
6400 tpl_printf(vars, TPLADD, "UCS", "%d", user_count_shown);
6401 tpl_printf(vars, TPLADD, "UCA", "%d", user_count_all);
6402 tpl_addVar(vars, TPLADD, "HIDEIDLE", "5");
6403 tpl_addVar(vars, TPLADD, "SHOWHIDDEN", "User");
6404 tpl_addVar(vars, TPLADD, "XHEAD", tpl_getTpl(vars, "CLIENTHEADLINE"));
6405 tpl_addVar(vars, TPLADD, "CLIENTOPTIONADD", tpl_getTpl(vars, "CLIENTHEADLINEBIT"));
6406 tpl_addVar(vars, TPLADD, "CLIENTHEADLINE", tpl_getTpl(vars, "STATUSHEADLINE"));
6407 tpl_addVar(vars, TPLADD, "CLIENTOPTIONADD", "");
6408 }
6409 else if(cl->typ == 'r')
6410 {
6411 if(shown)
6412 {
6413 tpl_addVar(vars, TPLAPPEND, "READERSTATUS", tpl_getTpl(vars, "CLIENTSTATUSBIT"));
6414 }
6415
6416 tpl_printf(vars, TPLADD, "RCC", "%d", reader_count_conn);
6417 tpl_printf(vars, TPLADD, "RCA", "%d", reader_count_all);
6418
6419 if(reader_count_off)
6420 {
6421 tpl_printf(vars, TPLADD, "RCO", "%d", reader_count_all-reader_count_off);
6422 tpl_addVar(vars, TPLADD, "RHEADADD", tpl_getTpl(vars, "CLIENTRHEADLINEADD"));
6423 }
6424
6425 tpl_addVar(vars, TPLADD, "HIDEIDLE", "3");
6426 tpl_addVar(vars, TPLADD, "SHOWHIDDEN", "Reader");
6427 tpl_addVar(vars, TPLADD, "XHEAD", tpl_getTpl(vars, "CLIENTRHEADLINE"));
6428 tpl_addVar(vars, TPLADD, "READERHEADLINE", tpl_getTpl(vars, "STATUSHEADLINE"));
6429 }
6430 else if(cl->typ == 'p')
6431 {
6432 if(shown)
6433 {
6434 tpl_addVar(vars, TPLAPPEND, "PROXYSTATUS", tpl_getTpl(vars, "CLIENTSTATUSBIT"));
6435 }
6436
6437 tpl_printf(vars, TPLADD, "PCC", "%d", proxy_count_conn);
6438 tpl_printf(vars, TPLADD, "PCA", "%d", proxy_count_all);
6439
6440 if(proxy_count_off)
6441 {
6442 tpl_printf(vars, TPLADD, "PCO", "%d", proxy_count_all-proxy_count_off);
6443 tpl_addVar(vars, TPLADD, "PHEADADD", tpl_getTpl(vars, "CLIENTPHEADLINEADD"));
6444 }
6445
6446 tpl_addVar(vars, TPLADD, "HIDEIDLE", "4");
6447 tpl_addVar(vars, TPLADD, "SHOWHIDDEN", "Proxy");
6448 tpl_addVar(vars, TPLADD, "XHEAD", tpl_getTpl(vars, "CLIENTPHEADLINE"));
6449 tpl_addVar(vars, TPLADD, "PROXYHEADLINE", tpl_getTpl(vars, "STATUSHEADLINE"));
6450 }
6451 else if(cl->typ == 'm' || cl->typ == 's' || cl->typ == 'h')
6452 {
6453 if(shown)
6454 {
6455 tpl_addVar(vars, TPLAPPEND, "SERVERSTATUS", tpl_getTpl(vars, "CLIENTSTATUSBIT"));
6456 }
6457
6458 tpl_addVar(vars, TPLADD, "HIDEIDLE", "2");
6459 tpl_addVar(vars, TPLADD, "SHOWHIDDEN", "Server");
6460
6461 if(cl->typ == 's' || cl->typ == 'h')
6462 {
6463 tpl_printf(vars, TPLADD, "SCS", "%d", server_count_shown);
6464 tpl_printf(vars, TPLADD, "SCA", "%d", server_count_all);
6465 tpl_addVar(vars, TPLADD, "XHEAD", tpl_getTpl(vars, "CLIENTSHEADLINE"));
6466
6467 if(shown || cl->wihidden)
6468 {
6469 tpl_addVar(vars, TPLADD, "SERVERHEADLINE", tpl_getTpl(vars, "STATUSHEADLINE"));
6470 }
6471 }
6472 else
6473 {
6474 tpl_addVar(vars, TPLADD, "SHOWHIDDENADD", " & Monitors");
6475 tpl_printf(vars, TPLADD, "MCS", "%d", monitor_count_shown);
6476 tpl_printf(vars, TPLADD, "MCA", "%d", monitor_count_all);
6477 tpl_addVar(vars, TPLADD, "MHEADADD", tpl_getTpl(vars, "CLIENTMHEADLINE"));
6478 tpl_addVar(vars, TPLADD, "XHEAD", tpl_getTpl(vars, "CLIENTSHEADLINE"));
6479 tpl_addVar(vars, TPLADD, "SERVERHEADLINE", tpl_getTpl(vars, "STATUSHEADLINE"));
6480 tpl_addVar(vars, TPLADD, "SHOWHIDDENADD", "");
6481 }
6482 }
6483 }
6484 else
6485 {
6486 if(shown)
6487 {
6488 if(apicall == 1)
6489 {
6490 tpl_addVar(vars, TPLAPPEND, "APISTATUSBITS", tpl_getTpl(vars, "APISTATUSBIT"));
6491 }
6492
6493 if(apicall == 2)
6494 {
6495 tpl_addVar(vars, TPLADD, "JSONARRAYDELIMITER", delimiter?",":"");
6496 tpl_addVar(vars, TPLAPPEND, "JSONSTATUSBITS", tpl_getTpl(vars, "JSONSTATUSBIT"));
6497 delimiter++;
6498 }
6499 }
6500 }
6501
6502 #ifdef CS_CACHEEX
6503 }
6504 #endif
6505
6506 }
6507
6508 LL_ITER itr = ll_iter_create(configured_readers);
6509 struct s_reader *rdrr;
6510 while((rdrr = ll_iter_next(&itr)))
6511 {
6512 if(rdrr->label[0] && rdrr->typ)
6513 {
6514 total_readers += 1;
6515
6516 if(rdrr->enable) { active_readers += 1; }
6517 else { disabled_readers += 1; }
6518
6519 if(rdrr->tcp_connected) { connected_readers += 1; }
6520 }
6521 }
6522
6523 cs_readunlock(__func__, &clientlist_lock);
6524 cs_readunlock(__func__, &readerlist_lock);
6525
6526 if(cfg.http_status_log || (apicall == 1 && strcmp(getParam(params, "appendlog"), "1") == 0))
6527 {
6528 if(cfg.loghistorylines && log_history)
6529 {
6530 LL_ITER it = ll_iter_create(log_history);
6531 struct s_log_history *hist;
6532
6533 while((hist = (struct s_log_history*)ll_iter_next(&it)))
6534 {
6535 char p_usr[32];
6536 size_t pos1 = strcspn(hist->txt, "\t") + 1;
6537 cs_strncpy(p_usr, hist->txt , pos1 > sizeof(p_usr) ? sizeof(p_usr) : pos1);
6538
6539 char *p_txt = hist->txt + pos1;
6540
6541 if(!apicall)
6542 {
6543 if(p_txt[0]) tpl_printf(vars, TPLAPPEND, "LOGHISTORY","\t\t<SPAN CLASS=\"%s\">%s\t\t</SPAN><BR>\n", xml_encode(vars, p_usr), xml_encode(vars, p_txt));
6544 }
6545 else
6546 {
6547 tpl_addVar(vars, TPLAPPEND, "LOGHISTORY", p_txt);
6548 }
6549 }
6550 }
6551 else
6552 {
6553 tpl_addVar(vars, TPLADD, "LOGHISTORY", "loghistorylines is set to 0 in your configuration");
6554 }
6555 }
6556
6557 #ifdef CS_CACHEEX
6558 char *getting = "<IMG SRC=\"image?i=ICARRL\" ALT=\"Getting\">";
6559 char *pushing = "<IMG SRC=\"image?i=ICARRR\" ALT=\"Pushing\">";
6560
6561 float cachesum = first_client ? first_client->cwcacheexgot : 1;
6562 if(cachesum < 1)
6563 {
6564 cachesum = 1;
6565 }
6566 tpl_printf(vars, TPLADD, "TOTAL_CACHEXPUSH", "%d", first_client ? first_client->cwcacheexpush : 0);
6567 tpl_addVar(vars, TPLADD, "TOTAL_CACHEXPUSH_IMG", pushing);
6568 tpl_printf(vars, TPLADD, "TOTAL_CACHEXGOT", "%d", first_client ? first_client->cwcacheexgot : 0);
6569 tpl_addVar(vars, TPLADD, "TOTAL_CACHEXGOT_IMG", getting);
6570 tpl_printf(vars, TPLADD, "TOTAL_CACHEXHIT", "%d", first_client ? first_client->cwcacheexhit : 0);
6571 tpl_printf(vars, TPLADD, "TOTAL_CACHESIZE", "%d", cache_size());
6572 #ifdef CS_CACHEEX_AIO
6573 tpl_printf(vars, TPLADD, "TOTAL_CACHESIZE_LG", "%d", cache_size_lg());
6574 #endif
6575 tpl_printf(vars, TPLADD, "REL_CACHEXHIT", "%.2f", (first_client ? first_client->cwcacheexhit : 0) * 100 / cachesum);
6576 tpl_addVar(vars, TPLADD, "CACHEEXSTATS", tpl_getTpl(vars, "STATUSCACHEX"));
6577 #endif
6578 //User info
6579 struct s_auth *account;
6580 int32_t total_users = 0;
6581 int32_t disabled_users = 0;
6582 int32_t expired_users = 0;
6583 int32_t expired_or_disabled_users = 0;
6584 int32_t connected_users = 0;
6585 int32_t online_users = 0;
6586
6587 for(account = cfg.account; (account); account = account->next)
6588 {
6589 total_users++;
6590 if(account->expirationdate && account->expirationdate < now)
6591 {
6592 expired_users++;
6593 }
6594 if(account->disabled != 0)
6595 {
6596 disabled_users++;
6597 }
6598 if((account->expirationdate && account->expirationdate < now)||account->disabled != 0)
6599 {
6600 expired_or_disabled_users++;
6601 }
6602 int32_t latestactivity = 0;
6603 struct s_client *latestclient = NULL;
6604 for(cl = first_client->next; cl ; cl = cl->next)
6605 {
6606 if(cl->account && !strcmp(cl->account->usr, account->usr))
6607 {
6608 if(cl->lastecm > latestactivity || cl->login > latestactivity)
6609 {
6610 if(cl->lastecm > cl->login) { latestactivity = cl->lastecm; }
6611 else { latestactivity = cl->login; }
6612 latestclient = cl;
6613 }
6614 }
6615 }
6616
6617 if(latestclient != NULL)
6618 {
6619 connected_users++;
6620
6621 if(latestactivity > 0)
6622 {
6623 if((now - latestactivity) < cfg.hideclient_to)
6624 {
6625 if(latestclient->cwfound + latestclient->cwnot + latestclient->cwcache > 0)
6626 {
6627 online_users++;
6628 }
6629 }
6630 }
6631 }
6632 }
6633 tpl_printf(vars, TPLADD, "TOTAL_USERS", "%d", total_users);
6634 tpl_printf(vars, TPLADD, "TOTAL_ACTIVE", "%d", total_users - expired_or_disabled_users);
6635 tpl_printf(vars, TPLADD, "TOTAL_EXPIRED", "%d", expired_users);
6636 tpl_printf(vars, TPLADD, "TOTAL_DISABLED", "%d", disabled_users);
6637 tpl_printf(vars, TPLADD, "TOTAL_ONLINE", "%d", online_users);
6638 tpl_printf(vars, TPLADD, "TOTAL_CONNECTED", "%d", connected_users);
6639
6640 tpl_printf(vars, TPLADD, "TOTAL_READERS", "%d", total_readers);
6641 tpl_printf(vars, TPLADD, "TOTAL_DISABLED_READERS", "%d", disabled_readers);
6642 tpl_printf(vars, TPLADD, "TOTAL_ACTIVE_READERS", "%d", active_readers);
6643 tpl_printf(vars, TPLADD, "TOTAL_CONNECTED_READERS", "%d", connected_readers);
6644
6645 //CM info
6646 set_ecm_info(vars);
6647
6648 //copy struct to p_stat_old for cpu_usage calculation
6649 p_stat_old = p_stat_cur;
6650
6651 /*
6652 * check_available Bit mapping
6653 * mem 0 total, 1 used & free, 2 buff, cached & free incl. buff, 3 share
6654 * swap 4 total, 5 used & free,
6655 * proc 6 count
6656 * cpu 7 load
6657 * oscam 8 vsize & rssize, 9 cpu user, 10 cpu sys, 11 cpu sum, 12 cpu refreshtime
6658 * unused 13 - 15
6659 */
6660 //Memory-CPU Info for linux based systems
6661 #if defined(__linux__)
6662 //get actual stats
6663 if(!get_stats_linux(getpid(),&p_stat_cur)){
6664 if(p_stat_old.cpu_total_time != 0){
6665 calc_cpu_usage_pct(&p_stat_cur, &p_stat_old);
6666 }
6667 }
6668 else{
6669 //something went wrong, so fill with "N/A"
6670 p_stat_cur.check_available = 65535;
6671 }
6672 #else // if not linux, fill with "N/A" but probably in future gets filled also for other platforms
6673 p_stat_cur.check_available = 65535;
6674 #endif
6675 set_status_info(vars, p_stat_cur);
6676
6677 if(cfg.http_showmeminfo || cfg.http_showuserinfo || cfg.http_showreaderinfo || cfg.http_showloadinfo || cfg.http_showecminfo || (cfg.http_showcacheexinfo && config_enabled(CS_CACHEEX)) || (cfg.http_showcacheexinfo && config_enabled(CS_CACHEEX_AIO))){
6678 tpl_addVar(vars, TPLADD, "DISPLAYINFO", "visible");
6679 }
6680 else{
6681 tpl_addVar(vars, TPLADD, "DISPLAYINFO", "hidden");
6682 }
6683
6684 tpl_addVar(vars, TPLADD, "DISPLAYSYSINFO", cfg.http_showmeminfo ? "visible" : "hidden");
6685 tpl_addVar(vars, TPLADD, "DISPLAYUSERINFO", cfg.http_showuserinfo ? "visible" : "hidden");
6686 tpl_addVar(vars, TPLADD, "DISPLAYREADERINFO", cfg.http_showreaderinfo ? "visible" : "hidden");
6687 tpl_addVar(vars, TPLADD, "DISPLAYLOADINFO", cfg.http_showloadinfo ?"visible" : "hidden");
6688 tpl_addVar(vars, TPLADD, "DISPLAYECMINFO", cfg.http_showecminfo ? "visible" : "hidden");
6689 tpl_addVar(vars, TPLADD, "DISPLAYECMINFO_READERS", cfg.http_showecminfo ? "visible" : "hidden");
6690
6691 if(cfg.http_showcacheexinfo == 1 && config_enabled(CS_CACHEEX))
6692 {
6693 if (config_enabled(CS_CACHEEX_AIO))
6694 {
6695 tpl_addVar(vars, TPLADD, "DISPLAYCACHEEXINFO", "hidden");
6696 tpl_addVar(vars, TPLADD, "DISPLAYCACHEEXAIOINFO", "visible");
6697 }
6698 else
6699 {
6700 tpl_addVar(vars, TPLADD, "DISPLAYCACHEEXINFO", "visible");
6701 tpl_addVar(vars, TPLADD, "DISPLAYCACHEEXAIOINFO", "hidden");
6702 }
6703 }
6704 else{
6705 tpl_addVar(vars, TPLADD, "DISPLAYCACHEEXINFO", "hidden");
6706 tpl_addVar(vars, TPLADD, "DISPLAYCACHEEXAIOINFO", "hidden");
6707 }
6708
6709 #ifdef WITH_DEBUG
6710 if(cfg.http_status_log)
6711 {
6712 // Debuglevel Selector
6713 int32_t lvl;
6714 for(i = 0; i < MAX_DEBUG_LEVELS; i++)
6715 {
6716 lvl = 1 << i;
6717 tpl_printf(vars, TPLADD, "TMPC", "DCLASS%d", lvl);
6718 tpl_printf(vars, TPLADD, "TMPV", "DEBUGVAL%d", lvl);
6719 if(cs_dblevel & lvl)
6720 {
6721 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMPC"), "debugls");
6722 tpl_printf(vars, TPLADD, tpl_getVar(vars, "TMPV"), "%d", cs_dblevel - lvl);
6723 }
6724 else
6725 {
6726 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMPC"), "debugl");
6727 tpl_printf(vars, TPLADD, tpl_getVar(vars, "TMPV"), "%d", cs_dblevel + lvl);
6728 }
6729 }
6730
6731 if(cs_dblevel == D_ALL_DUMP)
6732 { tpl_addVar(vars, TPLADD, "DCLASS65535", "debugls"); }
6733 else
6734 { tpl_addVar(vars, TPLADD, "DCLASS65535", "debugl"); }
6735
6736 tpl_addVar(vars, TPLADD, "NEXTPAGE", "status.html");
6737 tpl_addVar(vars, TPLADD, "DCLASS", "debugl"); //default
6738 tpl_printf(vars, TPLADD, "ACTDEBUG", "%d", cs_dblevel);
6739 #ifdef CS_CACHEEX_AIO
6740 tpl_addVar(vars, TPLADD, "SDEBUG", tpl_getTpl(vars, "DEBUGSELECTAIO"));
6741 #else
6742 tpl_addVar(vars, TPLADD, "SDEBUG", tpl_getTpl(vars, "DEBUGSELECT"));
6743 #endif
6744 }
6745 #endif
6746
6747 if(cfg.http_status_log)
6748 tpl_addVar(vars, TPLADDONCE, "LOG_HISTORY", tpl_getTpl(vars, "LOGHISTORYBIT"));
6749
6750 if(apicall)
6751 {
6752 if(apicall == 1)
6753 { return tpl_getTpl(vars, "APISTATUS"); }
6754 if(apicall == 2)
6755 {
6756 tpl_printf(vars, TPLADD, "UCS", "%d", user_count_shown);
6757 tpl_printf(vars, TPLADD, "UCA", "%d", user_count_all);
6758 if(cfg.http_hide_idle_clients != 1 && cfg.hideclient_to > 0){
6759 tpl_printf(vars, TPLADD, "UCAC", "%d", user_count_active);
6760 }
6761 tpl_printf(vars, TPLADD, "CFGH", "%d", cfg.hideclient_to);
6762 tpl_printf(vars, TPLADD, "MCS", "%d", monitor_count_shown);
6763 tpl_printf(vars, TPLADD, "MCA", "%d", monitor_count_all);
6764 tpl_printf(vars, TPLADD, "SCS", "%d", server_count_shown);
6765 tpl_printf(vars, TPLADD, "SCH", "%d", server_count_hidden);
6766 tpl_printf(vars, TPLADD, "SCA", "%d", server_count_all);
6767 tpl_printf(vars, TPLADD, "RCC", "%d", reader_count_conn);
6768 tpl_printf(vars, TPLADD, "RCO", "%d", reader_count_off);
6769 tpl_printf(vars, TPLADD, "RCA", "%d", reader_count_all);
6770 tpl_printf(vars, TPLADD, "PCC", "%d", proxy_count_conn);
6771 tpl_printf(vars, TPLADD, "PCO", "%d", proxy_count_off);
6772 tpl_printf(vars, TPLADD, "PCA", "%d", proxy_count_all);
6773 tpl_printf(vars, TPLADD, "PICONENABLED", "%d", cfg.http_showpicons?1:0);
6774 tpl_printf(vars, TPLADD, "SRVIDFILE", "%s", use_srvid2 ? "oscam.srvid2" : "oscam.srvid");
6775 return tpl_getTpl(vars, "JSONSTATUS");
6776 }
6777 }
6778
6779 return tpl_getTpl(vars, "STATUS");
6780 }
6781
6782 static char *send_oscam_services_edit(struct templatevars * vars, struct uriparams * params)
6783 {
6784 struct s_sidtab *sidtab, *ptr;
6785 char label[sizeof(cfg.sidtab->label)];
6786 int32_t i;
6787
6788 setActiveMenu(vars, MNU_SERVICES);
6789
6790 cs_strncpy(label, strtolower(getParam(params, "service")), sizeof(label));
6791 ++cfg_sidtab_generation;
6792 for(sidtab = cfg.sidtab; sidtab != NULL && strcmp(label, sidtab->label) != 0; sidtab = sidtab->next) { ; }
6793
6794 if(sidtab == NULL)
6795 {
6796 i = 1;
6797 while(cs_strlen(label) < 1)
6798 {
6799 snprintf(label, sizeof(label) / sizeof(char) - 1, "newservice%d", i);
6800 for(sidtab = cfg.sidtab; sidtab != NULL && strcmp(label, sidtab->label) != 0; sidtab = sidtab->next) { ; }
6801 if(sidtab != NULL) { label[0] = '\0'; }
6802 ++i;
6803 }
6804 if(!cs_malloc(&sidtab, sizeof(struct s_sidtab))) { return "0"; }
6805
6806 if(cfg.sidtab == NULL) { cfg.sidtab = sidtab; }
6807 else
6808 {
6809 for(ptr = cfg.sidtab; ptr != NULL && ptr->next != NULL; ptr = ptr->next) { ; }
6810 ptr->next = sidtab;
6811 }
6812 cs_strncpy((char *)sidtab->label, label, sizeof(sidtab->label));
6813 ++cfg_sidtab_generation;
6814 tpl_addMsg(vars, "New service has been added");
6815 // Adding is uncritical as the new service is appended to sidtabs.ok/sidtabs.no and accounts/clients/readers have zeros there
6816 if(write_services() != 0) { tpl_addMsg(vars, "Writing services to disk failed!"); }
6817 }
6818
6819 if(strcmp(getParam(params, "action"), "Save") == 0)
6820 {
6821 for(i = 0; i < (*params).paramcount; i++)
6822 {
6823 if((strcmp((*params).params[i], "action")) && (strcmp((*params).params[i], "service")))
6824 {
6825 chk_sidtab((*params).params[i], (*params).values[i], sidtab);
6826 }
6827 }
6828 ++cfg_sidtab_generation;
6829 tpl_addMsg(vars, "Services updated");
6830 // We don't need any refresh here as accounts/clients/readers sidtabs.ok/sidtabs.no are unaffected!
6831 if(write_services() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
6832
6833 for(sidtab = cfg.sidtab; sidtab != NULL && strcmp(label, sidtab->label) != 0; sidtab = sidtab->next) { ; }
6834 }
6835
6836 tpl_addVar(vars, TPLADD, "LABEL", xml_encode(vars, sidtab->label));
6837 tpl_addVar(vars, TPLADD, "LABELENC", urlencode(vars, sidtab->label));
6838
6839 if(sidtab)
6840 {
6841 #ifdef CS_CACHEEX_AIO
6842 tpl_addVar(vars, TPLADD, "DCRCCHECKED", (sidtab->disablecrccws_only_for_exception == 1) ? "checked" : "" );
6843 tpl_addVar(vars, TPLADD, "NWCHECKED", (sidtab->no_wait_time == 1) ? "checked" : "" );
6844 tpl_addVar(vars, TPLADD, "LGOECHECKED", (sidtab->lg_only_exception == 1) ? "checked" : "" );
6845 #endif
6846 for(i = 0; i < sidtab->num_caid; i++)
6847 {
6848 if(i == 0) { tpl_printf(vars, TPLADD, "CAIDS", "%04X", sidtab->caid[i]); }
6849 else { tpl_printf(vars, TPLAPPEND, "CAIDS", ",%04X", sidtab->caid[i]); }
6850 }
6851 for(i = 0; i < sidtab->num_provid; i++)
6852 {
6853 if(i == 0) { tpl_printf(vars, TPLADD, "PROVIDS", "%06X", sidtab->provid[i]); }
6854 else { tpl_printf(vars, TPLAPPEND, "PROVIDS", ",%06X", sidtab->provid[i]); }
6855 }
6856 for(i = 0; i < sidtab->num_srvid; i++)
6857 {
6858 if(i == 0) { tpl_printf(vars, TPLADD, "SRVIDS", "%04X", sidtab->srvid[i]); }
6859 else { tpl_printf(vars, TPLAPPEND, "SRVIDS", ",%04X", sidtab->srvid[i]); }
6860 }
6861 }
6862 #ifdef CS_CACHEEX_AIO
6863 return tpl_getTpl(vars, "SERVICEEDITAIO");
6864 #else
6865 return tpl_getTpl(vars, "SERVICEEDIT");
6866 #endif
6867 }
6868
6869 static void delete_from_SIDTABBITS(SIDTABBITS * orgsidtab, int32_t position, int32_t sidtablength)
6870 {
6871 if(*orgsidtab)
6872 {
6873 int32_t i;
6874 SIDTABBITS newsidtab = 0;
6875 for(i = 0; i < position; ++i)
6876 {
6877 if(*orgsidtab & ((SIDTABBITS)1 << i))
6878 { newsidtab |= ((SIDTABBITS)1 << i); }
6879 }
6880 for(; i < sidtablength; ++i)
6881 {
6882 if(*orgsidtab & ((SIDTABBITS)1 << (i + 1)))
6883 { newsidtab |= ((SIDTABBITS)1 << i); }
6884 }
6885 *orgsidtab = newsidtab;
6886 }
6887 }
6888
6889 static char *send_oscam_services(struct templatevars * vars, struct uriparams * params)
6890 {
6891 struct s_sidtab *sidtab;
6892 char *service = getParam(params, "service");
6893 char channame[CS_SERVICENAME_SIZE];
6894 int32_t i, counter = 0;
6895
6896 setActiveMenu(vars, MNU_SERVICES);
6897
6898 if(strcmp(getParam(params, "action"), "delete") == 0)
6899 {
6900 if(cfg.http_readonly)
6901 {
6902 tpl_addMsg(vars, "Sorry, Webif is in readonly mode. No deletion will be made!");
6903 }
6904 else
6905 {
6906 struct s_sidtab *sidtab_prev = NULL;
6907 int32_t sidtablength = -1;
6908 int32_t position = 0;
6909
6910 // Calculate sidtablength before deletion so that updating sidtabs is faster
6911 for(sidtab = cfg.sidtab; sidtab; sidtab = sidtab->next)
6912 { ++sidtablength; }
6913
6914 for(sidtab = cfg.sidtab; sidtab; sidtab = sidtab->next)
6915 {
6916 if(strcmp(sidtab->label, service) == 0)
6917 {
6918 struct s_auth *account;
6919 struct s_client *cl;
6920 struct s_reader *rdr;
6921
6922 if(!sidtab_prev)
6923 { cfg.sidtab = sidtab->next; }
6924 else
6925 { sidtab_prev->next = sidtab->next; }
6926
6927 for(account = cfg.account; (account); account = account->next)
6928 {
6929 delete_from_SIDTABBITS(&account->sidtabs.ok, position, sidtablength);
6930 delete_from_SIDTABBITS(&account->sidtabs.no, position, sidtablength);
6931
6932 for(cl = first_client->next; cl ; cl = cl->next)
6933 {
6934 if(account == cl->account)
6935 {
6936 cl->sidtabs.ok = account->sidtabs.ok;
6937 cl->sidtabs.no = account->sidtabs.no;
6938 }
6939 }
6940 }
6941
6942 LL_ITER itr = ll_iter_create(configured_readers);
6943 while((rdr = ll_iter_next(&itr)))
6944 {
6945 delete_from_SIDTABBITS(&rdr->sidtabs.ok, position, sidtablength);
6946 delete_from_SIDTABBITS(&rdr->sidtabs.no, position, sidtablength);
6947 delete_from_SIDTABBITS(&rdr->lb_sidtabs.ok, position, sidtablength);
6948 }
6949 free_sidtab(sidtab);
6950 ++counter;
6951 break;
6952 }
6953 sidtab_prev = sidtab;
6954 position++;
6955 }
6956 if(counter > 0)
6957 {
6958 ++cfg_sidtab_generation;
6959 tpl_addMsg(vars, "Service has been deleted!");
6960 if(write_services() != 0) { tpl_addMsg(vars, "Writing services to disk failed!"); }
6961 }
6962 else { tpl_addMsg(vars, "Sorry but the specified service doesn't exist. No deletion will be made!"); }
6963 }
6964 }
6965
6966 sidtab = cfg.sidtab;
6967 // Show List
6968 counter = 0;
6969 while(sidtab != NULL)
6970 {
6971 tpl_addVar(vars, TPLADD, "SID", "");
6972 if((strcmp(getParam(params, "service"), sidtab->label) == 0) && (strcmp(getParam(params, "action"), "list") == 0))
6973 {
6974 tpl_addVar(vars, TPLADD, "SIDCLASS", "sidlist");
6975 tpl_addVar(vars, TPLAPPEND, "SID", "<DIV CLASS=\"sidlistclose\"><A HREF=\"services.html\">X</A></DIV>");
6976 for(i = 0; i < sidtab->num_srvid; i++)
6977 {
6978 tpl_printf(vars, TPLAPPEND, "SID", "%04X : %s<BR>", sidtab->srvid[i],
6979 xml_encode(vars, get_servicename(cur_client(), sidtab->srvid[i], sidtab->num_provid ? sidtab->provid[0] : 0,
6980 sidtab->num_caid ? sidtab->caid[0] : 0, channame, sizeof(channame))));
6981 }
6982 }
6983 else
6984 {
6985 tpl_addVar(vars, TPLADD, "SIDCLASS", "");
6986 tpl_printf(vars, TPLADD, "SID", "<A HREF=\"services.html?service=%s&amp;action=list\">Show Services</A>", urlencode(vars, sidtab->label));
6987 }
6988 tpl_addVar(vars, TPLADD, "LABELENC", urlencode(vars, sidtab->label));
6989 tpl_addVar(vars, TPLADD, "LABEL", xml_encode(vars, sidtab->label));
6990 tpl_addVar(vars, TPLADD, "SIDLIST", tpl_getTpl(vars, "SERVICECONFIGSIDBIT"));
6991
6992 tpl_addVar(vars, TPLAPPEND, "SERVICETABS", tpl_getTpl(vars, "SERVICECONFIGLISTBIT"));
6993 sidtab = sidtab->next;
6994 counter++;
6995 }
6996 if(counter >= MAX_SIDBITS)
6997 {
6998 tpl_addVar(vars, TPLADD, "BTNDISABLED", "DISABLED");
6999 tpl_addMsg(vars, "Maximum Number of Services is reached");
7000 }
7001 return tpl_getTpl(vars, "SERVICECONFIGLIST");
7002 }
7003
7004 static char *send_oscam_savetpls(struct templatevars * vars)
7005 {
7006 if(cfg.http_tpl)
7007 {
7008 tpl_printf(vars, TPLADD, "CNT", "%d", tpl_saveIncludedTpls(cfg.http_tpl));
7009 tpl_addVar(vars, TPLADD, "PATH", cfg.http_tpl);
7010 }
7011 else { tpl_addVar(vars, TPLADD, "CNT", "0"); }
7012 return tpl_getTpl(vars, "SAVETEMPLATES");
7013 }
7014
7015 static char *send_oscam_shutdown(struct templatevars * vars, FILE * f, struct uriparams * params, int8_t apicall, int8_t *keepalive, char *extraheader)
7016 {
7017 if(!apicall) { setActiveMenu(vars, MNU_SHUTDOWN); }
7018 if(strcmp(strtolower(getParam(params, "action")), "shutdown") == 0)
7019 {
7020 *keepalive = 0;
7021 if(!apicall)
7022 {
7023 char *CSS = tpl_getUnparsedTpl("CSS", 1, "");
7024 tpl_addVar(vars, TPLADD, "STYLESHEET", CSS);
7025 NULLFREE(CSS);
7026 tpl_printf(vars, TPLADD, "REFRESHTIME", "%d", SHUTDOWNREFRESH);
7027 tpl_addVar(vars, TPLADD, "REFRESH", tpl_getTpl(vars, "REFRESH"));
7028 tpl_printf(vars, TPLADD, "SECONDS", "%d", SHUTDOWNREFRESH);
7029 char *result = tpl_getTpl(vars, "SHUTDOWN");
7030 send_headers(f, 200, "OK", extraheader, "text/html", 0, cs_strlen(result), NULL, 0);
7031 webif_write(result, f);
7032 cs_log("Shutdown requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
7033 }
7034 else
7035 {
7036 tpl_addVar(vars, TPLADD, "APICONFIRMMESSAGE", "shutdown");
7037 cs_log("Shutdown requested by XMLApi from %s", cs_inet_ntoa(GET_IP()));
7038 }
7039 cs_exit_oscam();
7040
7041 if(!apicall)
7042 { return "1"; }
7043 else
7044 { return tpl_getTpl(vars, "APICONFIRMATION"); }
7045
7046 }
7047 else if(strcmp(strtolower(getParam(params, "action")), "restart") == 0)
7048 {
7049 *keepalive = 0;
7050 if(!apicall)
7051 {
7052 char *CSS = tpl_getUnparsedTpl("CSS", 1, "");
7053 tpl_addVar(vars, TPLADD, "STYLESHEET", CSS);
7054 NULLFREE(CSS);
7055 tpl_addVar(vars, TPLADD, "REFRESHTIME", "5");
7056 tpl_addVar(vars, TPLADD, "REFRESH", tpl_getTpl(vars, "REFRESH"));
7057 tpl_addVar(vars, TPLADD, "SECONDS", "5");
7058 char *result = tpl_getTpl(vars, "SHUTDOWN");
7059 send_headers(f, 200, "OK", extraheader, "text/html", 0, cs_strlen(result), NULL, 0);
7060 webif_write(result, f);
7061 cs_log("Restart requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
7062 }
7063 else
7064 {
7065 tpl_addVar(vars, TPLADD, "APICONFIRMMESSAGE", "restart");
7066 cs_log("Restart requested by XMLApi from %s", cs_inet_ntoa(GET_IP()));
7067 }
7068 cs_restart_oscam();
7069
7070 if(!apicall)
7071 { return "1"; }
7072 else
7073 { return tpl_getTpl(vars, "APICONFIRMATION"); }
7074
7075 }
7076 else
7077 {
7078 return tpl_getTpl(vars, "PRESHUTDOWN");
7079 }
7080 }
7081
7082 static char *send_oscam_script(struct templatevars * vars, struct uriparams * params)
7083 {
7084 setActiveMenu(vars, MNU_SCRIPT);
7085 tpl_printf(vars, TPLADD, "SCRIPTOPTIONS", "<option value=\"\">----select script----</option>\n");
7086
7087 if(!cfg.http_readonly && cfg.http_script)
7088 {
7089 struct dirent **namelist;
7090 int count, i;
7091 count = scandir(cfg.http_script, &namelist, 0, alphasort );
7092 if( count >= 0 )
7093 {
7094 for( i = 0 ; i < count; i++ )
7095 {
7096 if(is_ext(namelist[i]->d_name, ".script") || is_ext(namelist[i]->d_name, ".sh"))
7097 {
7098 tpl_printf(vars, TPLAPPEND, "SCRIPTOPTIONS", "<option value=\"script.html?scriptname=%s\">%s</option>\n",namelist[i]->d_name,namelist[i]->d_name);
7099 }
7100 free( namelist[i] );
7101 }
7102 free(namelist);
7103 }
7104
7105 char *scriptname = getParam(params, "scriptname");
7106 char *scriptparam = getParam(params, "scriptparam");
7107 char system_str[256];
7108 struct stat s;
7109 snprintf(system_str, sizeof(system_str), "%s/%s", cfg.http_script, scriptname);
7110
7111 if(!stat(system_str,&s))
7112 {
7113 if(s.st_mode & S_IFREG)
7114 {
7115 if(s.st_mode & S_IXUSR)
7116 {
7117 int32_t rc;
7118 FILE *fp;
7119 char buf[256];
7120
7121 if((scriptparam != NULL) && (sizeof(scriptparam) > 0))
7122 {
7123 cs_strncat(system_str, " ", sizeof(system_str));
7124 cs_strncat(system_str, scriptparam, sizeof(system_str));
7125 }
7126
7127 fp = popen(system_str, "r");
7128
7129 while (fgets(buf, sizeof(buf), fp) != NULL)
7130 {
7131 tpl_addVar(vars, TPLAPPEND, "SCRIPTRESULTOUT", buf);
7132 }
7133
7134 rc = pclose(fp)/256;
7135
7136 tpl_printf(vars, TPLAPPEND, "CODE", "returncode: %d", rc);
7137 tpl_printf(vars, TPLADD, "SCRIPTNAME", "scriptname: %s", scriptname);
7138 }
7139 else
7140 {
7141 tpl_printf(vars, TPLADD, "SCRIPTRESULTOUT", "[Error]: Script \"%s\" not executable!", scriptname);
7142 }
7143 }
7144 }
7145 else
7146 {
7147 tpl_printf(vars, TPLADD, "SCRIPTRESULTOUT", "[Error]: Script \"%s\" not found!", scriptname);
7148 }
7149
7150 }
7151 return tpl_getTpl(vars, "SCRIPT");
7152 }
7153
7154 static char *send_oscam_scanusb(struct templatevars * vars)
7155 {
7156 setActiveMenu(vars, MNU_READERS);
7157 #if !defined(__CYGWIN__)
7158 FILE *fp;
7159 char path[1035];
7160
7161 fp = popen("lsusb -v | egrep '^Bus|^ *iSerial|^ *iProduct'", "r");
7162 if(!fgets(path, sizeof(path) - 1, fp) || !fp)
7163 {
7164 tpl_addVar(vars, TPLADD, "USBENTRY", "<b>lsusb:</b> Failed to run or not installed!");
7165 tpl_addVar(vars, TPLADD, "USBBIT", tpl_getTpl(vars, "SCANUSBBIT"));
7166 }
7167 else
7168 {
7169 do{
7170 tpl_addVar(vars, TPLADD, "USBENTRYCLASS", "");
7171 if(strstr(path, "Bus "))
7172 {
7173 tpl_addVar(vars, TPLADD, "USBENTRY", path);
7174 tpl_addVar(vars, TPLADD, "USBENTRYCLASS", "CLASS=\"scanusbsubhead\"");
7175 }
7176 else
7177 {
7178 tpl_printf(vars, TPLADD, "USBENTRY", "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;%s", path);
7179 }
7180 tpl_addVar(vars, TPLAPPEND, "USBBIT", tpl_getTpl(vars, "SCANUSBBIT"));
7181 }
7182 while(fgets(path, sizeof(path) - 1, fp) != NULL);
7183 }
7184 pclose(fp);
7185 #else
7186 tpl_addMsg(vars, "Function not supported in CYGWIN environment");
7187 #endif
7188 return tpl_getTpl(vars, "SCANUSB");
7189 }
7190
7191 static void webif_process_logfile(struct templatevars * vars, struct uriparams * params, char *targetfile, size_t targetfile_len)
7192 {
7193 snprintf(targetfile, targetfile_len, "%s", cfg.logfile);
7194 if(strcmp(getParam(params, "clear"), "logfile") == 0)
7195 {
7196 if(cs_strlen(targetfile) > 0)
7197 {
7198 FILE *file = fopen(targetfile, "w");
7199 fclose(file);
7200 }
7201 }
7202 #ifdef WITH_DEBUG
7203 // Debuglevel Selector
7204 int32_t i, lvl;
7205 for(i = 0; i < MAX_DEBUG_LEVELS; i++)
7206 {
7207 lvl = 1 << i;
7208 tpl_printf(vars, TPLADD, "TMPC", "DCLASS%d", lvl);
7209 tpl_printf(vars, TPLADD, "TMPV", "DEBUGVAL%d", lvl);
7210 if(cs_dblevel & lvl)
7211 {
7212 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMPC"), "debugls");
7213 tpl_printf(vars, TPLADD, tpl_getVar(vars, "TMPV"), "%d", cs_dblevel - lvl);
7214 }
7215 else
7216 {
7217 tpl_addVar(vars, TPLADD, tpl_getVar(vars, "TMPC"), "debugl");
7218 tpl_printf(vars, TPLADD, tpl_getVar(vars, "TMPV"), "%d", cs_dblevel + lvl);
7219 }
7220 }
7221 if(cs_dblevel == D_ALL_DUMP)
7222 { tpl_addVar(vars, TPLADD, "DCLASS65535", "debugls"); }
7223 else
7224 { tpl_addVar(vars, TPLADD, "DCLASS65535", "debugl"); }
7225 tpl_addVar(vars, TPLADD, "CUSTOMPARAM", "&file=logfile");
7226 tpl_printf(vars, TPLADD, "ACTDEBUG", "%d", cs_dblevel);
7227 #ifdef CS_CACHEEX_AIO
7228 tpl_addVar(vars, TPLADD, "SDEBUG", tpl_getTpl(vars, "DEBUGSELECTAIO"));
7229 #else
7230 tpl_addVar(vars, TPLADD, "SDEBUG", tpl_getTpl(vars, "DEBUGSELECT"));
7231 #endif
7232 tpl_addVar(vars, TPLADD, "NEXTPAGE", "files.html");
7233 #endif
7234 if(!cfg.disablelog)
7235 {
7236 tpl_printf(vars, TPLADD, "SWITCH", "%d", 1);
7237 tpl_addVar(vars, TPLADD, "TEXT", "Stop Log");
7238 tpl_addVar(vars, TPLADD, "LOGMENU", tpl_getTpl(vars, "LOGMENUDISABLELOG"));
7239
7240 }
7241 else
7242 {
7243 tpl_printf(vars, TPLADD, "SWITCH", "%d", 0);
7244 tpl_addVar(vars, TPLADD, "TEXT", "Start Log");
7245 tpl_addVar(vars, TPLADD, "LOGMENU", tpl_getTpl(vars, "LOGMENUDISABLELOG"));
7246 }
7247 tpl_addVar(vars, TPLAPPEND, "LOGMENU", tpl_getTpl(vars, "CLEARLOG"));
7248 return;
7249 }
7250
7251 static void webif_process_userfile(struct templatevars * vars, struct uriparams * params, char *targetfile, size_t targetfile_len)
7252 {
7253 snprintf(targetfile, targetfile_len, "%s", cfg.usrfile);
7254 if(strcmp(getParam(params, "clear"), "usrfile") == 0)
7255 {
7256 if(cs_strlen(targetfile) > 0)
7257 {
7258 FILE *file = fopen(targetfile, "w");
7259 fclose(file);
7260 }
7261 }
7262 if(!cfg.disableuserfile)
7263 {
7264 tpl_printf(vars, TPLADD, "SWITCH", "%d", 1);
7265 tpl_addVar(vars, TPLADD, "TEXT", "Stop Log");
7266 tpl_addVar(vars, TPLADD, "LOGMENU", tpl_getTpl(vars, "LOGMENUONOFF"));
7267 }
7268 else
7269 {
7270 tpl_printf(vars, TPLADD, "SWITCH", "%d", 0);
7271 tpl_addVar(vars, TPLADD, "TEXT", "Start Log");
7272 tpl_addVar(vars, TPLADD, "LOGMENU", tpl_getTpl(vars, "LOGMENUONOFF"));
7273 }
7274 tpl_addVar(vars, TPLAPPEND, "LOGMENU", tpl_getTpl(vars, "CLEARUSERLOG"));
7275 tpl_addVar(vars, TPLADD, "FFVAL", "all");
7276 tpl_addVar(vars, TPLADD, "FILTERFORMOPTIONS", tpl_getTpl(vars, "LOGMENUFILTERFORM"));
7277 struct s_auth *account;
7278 for(account = cfg.account; account; account = account->next)
7279 {
7280 tpl_addVar(vars, TPLADD, "FFVAL", xml_encode(vars, account->usr));
7281 tpl_addVar(vars, TPLADD, "FFSEL", strcmp(getParam(params, "filter"), account->usr) ? "" : "selected");
7282 tpl_addVar(vars, TPLAPPEND, "FILTERFORMOPTIONS", tpl_getTpl(vars, "LOGMENUFILTERFORM"));
7283 }
7284 tpl_addVar(vars, TPLADD, "FILTERFORM", tpl_getTpl(vars, "FILTERFORM"));
7285 }
7286
7287 enum file_types { FTYPE_CONFIG, FTYPE_VERSION, FTYPE_ANTICASC, FTYPE_LOGFILE, FTYPE_USERFILE , FTYPE_GBOX };
7288
7289 struct files
7290 {
7291 char *file;
7292 int menu_id;
7293 enum file_types type;
7294 };
7295
7296 static char *send_oscam_files(struct templatevars * vars, struct uriparams * params, int8_t apicall)
7297 {
7298 bool writable = false;
7299 const struct files *entry;
7300 static struct files config_files[] =
7301 {
7302 // id are used
7303 // new entry after last entry before first ifdef entry
7304 // ifdef must be add to end
7305 { "oscam.version", MNU_CFG_FVERSION, FTYPE_VERSION }, // id 0
7306 { "oscam.conf", MNU_CFG_FCONF, FTYPE_CONFIG }, // id 1
7307 { "oscam.user", MNU_CFG_FUSER, FTYPE_CONFIG }, // id 2
7308 { "oscam.server", MNU_CFG_FSERVER, FTYPE_CONFIG }, // id 3
7309 { "oscam.srvid", MNU_CFG_FSRVID, FTYPE_CONFIG }, // id 4
7310 { "oscam.srvid2", MNU_CFG_FSRVID2, FTYPE_CONFIG }, // id 5
7311 { "logfile", MNU_CFG_FLOGFILE, FTYPE_LOGFILE }, // id 6
7312 { "userfile", MNU_CFG_FUSERFILE, FTYPE_USERFILE }, // id 7
7313 { "css_file_name", MNU_CFG_FCSS, FTYPE_CONFIG }, // id 8
7314 { "oscam.services", MNU_CFG_FSERVICES, FTYPE_CONFIG }, // id 9
7315 { "oscam.provid", MNU_CFG_FPROVID, FTYPE_CONFIG }, // id 10
7316 { "oscam.tiers", MNU_CFG_FTIERS, FTYPE_CONFIG }, // id 11
7317 { "oscam.ratelimit", MNU_CFG_FRATELIMIT,FTYPE_CONFIG }, // id 12
7318 { "oscam.whitelist", MNU_CFG_FWHITELIST,FTYPE_CONFIG }, // id 13
7319 #ifdef HAVE_DVBAPI
7320 { "oscam.dvbapi", MNU_CFG_FDVBAPI, FTYPE_CONFIG }, // id 14
7321 #endif
7322 #ifdef CS_CACHEEX
7323 { "oscam.fakecws", MNU_CFG_FFAKECWS, FTYPE_CONFIG }, // id 15
7324 #endif
7325 #ifdef CS_ANTICASC
7326 { "anticasc", MNU_CFG_FACLOG, FTYPE_ANTICASC }, // id 16
7327 #endif
7328 #ifdef MODULE_SERIAL
7329 { "oscam.twin", MNU_CFG_FTWIN, FTYPE_CONFIG }, // id 17
7330 #endif
7331 #ifdef MODULE_CONSTCW
7332 { "constant.cw", MNU_CFG_FKEYCW, FTYPE_CONFIG }, // id 18
7333 #endif
7334 #ifdef MODULE_GBOX
7335 { "sc.info", MNU_GBX_FSCINF, FTYPE_GBOX }, // id 19
7336 { "share.info", MNU_GBX_FSHRINF, FTYPE_GBOX }, // id 20
7337 { "share.onl", MNU_GBX_FSHRONL, FTYPE_GBOX }, // id 21
7338 { "gbox.ver", MNU_GBX_FVERS, FTYPE_GBOX }, // id 22
7339 { "attack.txt", MNU_GBX_FATTACK, FTYPE_GBOX }, // id 23
7340 { "gsms.log", MNU_GBX_FSMSLOG, FTYPE_GBOX }, // id 24
7341 { "gsms.ack", MNU_GBX_FSMSACK, FTYPE_GBOX }, // id 25
7342 { "gsms.nack", MNU_GBX_FSMSNACK, FTYPE_GBOX }, // id 26
7343 { "stats.info", MNU_GBX_FSTAINF, FTYPE_GBOX }, // id 27
7344 { "expired.info", MNU_GBX_FEXPINF, FTYPE_GBOX }, // id 28
7345 { "info.log", MNU_GBX_INFOLOG, FTYPE_GBOX }, // id 29
7346 #endif
7347 #ifdef WITH_EMU
7348 { "SoftCam.Key", MNU_CFG_FSOFTCAMKEY,FTYPE_CONFIG }, // id 30
7349 #endif
7350 { NULL, 0, 0 },
7351 };
7352
7353 if(use_srvid2)
7354 {
7355 config_files[4].menu_id = MNU_CFG_FSRVID2;
7356 config_files[5].menu_id = MNU_CFG_FSRVID;
7357 }
7358
7359 if(cfg.http_css)
7360 {
7361 if(strchr(cfg.http_css,'/'))
7362 config_files[8].file = strrchr(cfg.http_css, '/')+1;
7363 else if(strchr(cfg.http_css,'\\'))
7364 config_files[8].file = strrchr(cfg.http_css, '\\')+1;
7365 else
7366 config_files[8].file = cfg.http_css;
7367 tpl_addVar(vars, TPLADD, "FILE_USER_CSS", xml_encode(vars, config_files[8].file));
7368 }
7369
7370 if(!apicall) { setActiveMenu(vars, MNU_FILES); }
7371
7372 tpl_addVar(vars, TPLADD, "APIFILENAME", "null");
7373 tpl_addVar(vars, TPLADD, "APIWRITABLE", "0");
7374
7375 if(use_srvid2)
7376 {
7377 tpl_printf(vars, TPLADD, "SRVID", "%s", "oscam.srvid2");
7378 tpl_printf(vars, TPLADD, "SRVIDSUB", "%s", "oscam.srvid");
7379 }
7380 else
7381 {
7382 tpl_printf(vars, TPLADD, "SRVID", "%s", "oscam.srvid");
7383 tpl_printf(vars, TPLADD, "SRVIDSUB", "%s", "oscam.srvid2");
7384 }
7385
7386 char *stoplog = getParam(params, "stoplog");
7387 if(cs_strlen(stoplog) > 0)
7388 { cs_disable_log(atoi(stoplog)); }
7389
7390 char *stopusrlog = getParam(params, "stopusrlog");
7391 if(cs_strlen(stopusrlog) > 0)
7392 { cfg.disableuserfile = atoi(stopusrlog); }
7393
7394 char *debuglvl = getParam(params, "debug");
7395 if(cs_strlen(debuglvl) > 0)
7396 {
7397 #ifndef WITH_DEBUG
7398 cs_log("*** Warning: Debug Support not compiled in ***");
7399 #else
7400 int32_t dblvl = atoi(debuglvl);
7401 if(dblvl >= 0 && dblvl <= 65535) { cs_dblevel = dblvl; }
7402 cs_log("%s debug_level=%d", "all", cs_dblevel);
7403 #endif
7404 }
7405 // Process config files
7406 char *file = getParam(params, "file");
7407 char targetfile[256] = { 0 };
7408 int menu_id = 0;
7409 for(entry = config_files; entry->file; entry++)
7410 {
7411 if(streq(file, entry->file))
7412 {
7413 if(!apicall) { setActiveSubMenu(vars, entry->menu_id); }
7414 menu_id = entry->menu_id;
7415 tpl_addVar(vars, TPLADD, "APIWRITABLE", writable ? "1" : "0");
7416 switch(entry->type)
7417 {
7418 case FTYPE_CONFIG:
7419 writable = 1;
7420 get_config_filename(targetfile, sizeof(targetfile), entry->file);
7421 break;
7422 case FTYPE_VERSION:
7423 get_tmp_dir_filename(targetfile, sizeof(targetfile), entry->file);
7424 break;
7425 case FTYPE_ANTICASC:
7426 #ifdef CS_ANTICASC
7427 if(!apicall) { snprintf(targetfile, sizeof(targetfile), "%s", ESTR(cfg.ac_logfile)); }
7428 #endif
7429 break;
7430 case FTYPE_LOGFILE:
7431 if(!apicall) { webif_process_logfile(vars, params, targetfile, sizeof(targetfile)); }
7432 break;
7433 case FTYPE_USERFILE:
7434 if(!apicall) { webif_process_userfile(vars, params, targetfile, sizeof(targetfile)); }
7435 break;
7436 case FTYPE_GBOX:
7437 #ifdef MODULE_GBOX
7438 get_gbox_filename(targetfile, sizeof(targetfile), entry->file);
7439 #endif
7440 break;
7441 }
7442 tpl_addVar(vars, TPLADD, "APIFILENAME", entry->file);
7443 break;
7444 }
7445 }
7446
7447 if(cfg.http_css)
7448 {
7449 tpl_addVar(vars, TPLADD, "VIEW_FILEMENUCSS", tpl_getTpl(vars, "FILEMENUCSS"));
7450 }
7451
7452 if(!strstr(targetfile, "/dev/"))
7453 {
7454 if(strcmp(getParam(params, "action"), "Save") == 0)
7455 {
7456 if((cs_strlen(targetfile) > 0) /*&& (file_exists(targetfile) == 1)*/)
7457 {
7458 FILE *fpsave;
7459 char *fcontent = getParam(params, "filecontent");
7460 if((fpsave = fopen(targetfile, "w")))
7461 {
7462 int32_t i, lastpos = 0, len = cs_strlen(fcontent) + 1;
7463 //write submitted file line by line to disk and remove windows linebreaks
7464 for(i = 0; i < len; ++i)
7465 {
7466 char tmp = fcontent[i];
7467 if(tmp == '\r' || tmp == '\n' || tmp == 0)
7468 {
7469 fcontent[i] = 0;
7470 fprintf(fpsave, "%s%s", fcontent + lastpos, tmp == 0 ? "" : "\n");
7471 if(tmp == '\r' && fcontent[i + 1] == '\n') { ++i; }
7472 lastpos = i + 1;
7473 }
7474 }
7475 fclose(fpsave);
7476 tpl_addVar(vars, TPLAPPEND, "APIFILENAME", " saved!");
7477 // Reinit on save
7478 switch(menu_id)
7479 {
7480 case MNU_CFG_FSRVID:
7481 case MNU_CFG_FSRVID2:
7482 init_srvid();
7483 break;
7484 case MNU_CFG_FPROVID:
7485 init_provid();
7486 break;
7487 case MNU_CFG_FUSER:
7488 cs_accounts_chk();
7489 break;
7490 case MNU_CFG_FDVBAPI:
7491 dvbapi_read_priority();
7492 break;
7493 case MNU_CFG_FWHITELIST:
7494 global_whitelist_read();
7495 break;
7496 case MNU_CFG_FFAKECWS:
7497 init_fakecws();
7498 break;
7499 default:
7500 break;
7501 }
7502 }
7503 }
7504 }
7505
7506 if((cs_strlen(targetfile) > 0) && (file_exists(targetfile) == 1))
7507 {
7508 FILE *fp;
7509 char buffer[256];
7510
7511 if((fp = fopen(targetfile, "r")) == NULL) { return "0"; }
7512 while(fgets(buffer, sizeof(buffer), fp) != NULL)
7513 if(!strcmp(getParam(params, "filter"), "all"))
7514 { tpl_addVar(vars, TPLAPPEND, "FILECONTENT", buffer); }
7515 else if(strstr(buffer, getParam(params, "filter")))
7516 { tpl_addVar(vars, TPLAPPEND, "FILECONTENT", buffer); }
7517 fclose(fp);
7518 }
7519 else
7520 {
7521 tpl_addVar(vars, TPLAPPEND, "FILECONTENT", "File does not exist or no file selected!");
7522 }
7523 }
7524 else
7525 {
7526 tpl_addVar(vars, TPLAPPEND, "FILECONTENT", "File not valid!");
7527 }
7528
7529 tpl_addVar(vars, TPLADD, "PART", file);
7530
7531 if(!writable)
7532 {
7533 tpl_addVar(vars, TPLADD, "WRITEPROTECTION", tpl_getTpl(vars, "WRITEPROTECTION"));
7534 tpl_addVar(vars, TPLADD, "BTNDISABLED", "DISABLED");
7535 }
7536
7537 if(!apicall)
7538 { return tpl_getTpl(vars, "FILE"); }
7539 else
7540 { return tpl_getTpl(vars, "APIFILE"); }
7541 }
7542
7543 static char *send_oscam_failban(struct templatevars * vars, struct uriparams * params, int8_t apicall)
7544 {
7545 IN_ADDR_T ip2delete;
7546 set_null_ip(&ip2delete);
7547 LL_ITER itr = ll_iter_create(cfg.v_list);
7548 V_BAN *v_ban_entry;
7549 //int8_t apicall = 0; //remove before flight
7550
7551 if(!apicall) { setActiveMenu(vars, MNU_FAILBAN); }
7552
7553 if(strcmp(getParam(params, "action"), "delete") == 0)
7554 {
7555 if(strcmp(getParam(params, "intip"), "all") == 0)
7556 {
7557 // clear whole list
7558 while(ll_iter_next(&itr))
7559 {
7560 ll_iter_remove_data(&itr);
7561 }
7562 }
7563 else
7564 {
7565 //we have a single IP
7566 cs_inet_addr(getParam(params, "intip"), &ip2delete);
7567 while((v_ban_entry = ll_iter_next(&itr)))
7568 {
7569 if(IP_EQUAL(v_ban_entry->v_ip, ip2delete))
7570 {
7571 ll_iter_remove_data(&itr);
7572 break;
7573 }
7574 }
7575 }
7576 }
7577 ll_iter_reset(&itr);
7578
7579 struct timeb now;
7580 cs_ftime(&now);
7581
7582 while((v_ban_entry = ll_iter_next(&itr)))
7583 {
7584 tpl_printf(vars, TPLADD, "IPADDRESS", "%s@%d", cs_inet_ntoa(v_ban_entry->v_ip), v_ban_entry->v_port);
7585 tpl_addVar(vars, TPLADD, "VIOLATIONUSER", v_ban_entry->info ? v_ban_entry->info : "unknown");
7586 struct tm st ;
7587 localtime_r(&v_ban_entry->v_time.time, &st); // fix me, we need walltime!
7588 if(!apicall)
7589 {
7590 tpl_printf(vars, TPLADD, "VIOLATIONDATE", "%02d.%02d.%02d %02d:%02d:%02d",
7591 st.tm_mday, st.tm_mon + 1,
7592 st.tm_year % 100, st.tm_hour,
7593 st.tm_min, st.tm_sec);
7594 }
7595 else
7596 {
7597 char tbuffer [30];
7598 strftime(tbuffer, 30, "%Y-%m-%dT%H:%M:%S%z", &st);
7599 tpl_addVar(vars, TPLADD, "VIOLATIONDATE", tbuffer);
7600 }
7601
7602 tpl_printf(vars, TPLADD, "VIOLATIONCOUNT", "%d", v_ban_entry->v_count);
7603
7604 int64_t gone = comp_timeb(&now, &v_ban_entry->v_time);
7605 if(!apicall)
7606 {
7607 if(!v_ban_entry->acosc_entry)
7608 { tpl_addVar(vars, TPLADD, "LEFTTIME", sec2timeformat(vars, (cfg.failbantime * 60) - (gone / 1000))); }
7609 else
7610 { tpl_addVar(vars, TPLADD, "LEFTTIME", sec2timeformat(vars, v_ban_entry->acosc_penalty_dur - (gone / 1000))); }
7611 }
7612 else
7613 {
7614 if(!v_ban_entry->acosc_entry)
7615 { tpl_printf(vars, TPLADD, "LEFTTIME", "%"PRId64"", (cfg.failbantime * 60) - (gone / 1000)); }
7616 else
7617 { tpl_printf(vars, TPLADD, "LEFTTIME", "%"PRId64"", v_ban_entry->acosc_penalty_dur - (gone / 1000)); }
7618 }
7619
7620 tpl_addVar(vars, TPLADD, "INTIP", cs_inet_ntoa(v_ban_entry->v_ip));
7621
7622 if(!apicall)
7623 { tpl_addVar(vars, TPLAPPEND, "FAILBANROW", tpl_getTpl(vars, "FAILBANBIT")); }
7624 else
7625 { tpl_addVar(vars, TPLAPPEND, "APIFAILBANROW", tpl_getTpl(vars, "APIFAILBANBIT")); }
7626 }
7627 if(!apicall)
7628 { return tpl_getTpl(vars, "FAILBAN"); }
7629 else
7630 { return tpl_getTpl(vars, "APIFAILBAN"); }
7631 }
7632
7633 static bool send_EMM(struct s_reader * rdr, uint16_t caid, const struct s_cardsystem *csystem, const uint8_t *emmhex, uint32_t len)
7634 {
7635 if(NULL != rdr && NULL != emmhex && 0 != len)
7636 {
7637 EMM_PACKET *emm_pack = NULL;
7638
7639 if(cs_malloc(&emm_pack, sizeof(EMM_PACKET)))
7640 {
7641 struct s_client *webif_client = cur_client();
7642 webif_client->grp = 0xFF; /* to access to all readers */
7643
7644 memset(emm_pack, '\0', sizeof(EMM_PACKET));
7645 emm_pack->client = webif_client;
7646 emm_pack->emmlen = len;
7647 memcpy(emm_pack->emm, emmhex, len);
7648
7649 emm_pack->caid[0] = (caid >> 8) & 0xFF;
7650 emm_pack->caid[1] = caid & 0xFF;
7651
7652 if(csystem && csystem->get_emm_type)
7653 {
7654 if(!csystem->get_emm_type(emm_pack, rdr))
7655 {
7656 rdr_log_dbg(rdr, D_EMM, "get_emm_type() returns error");
7657 }
7658 }
7659
7660 cs_log_dbg(D_EMM, "emm is being sent to reader %s.", rdr->label);
7661 add_job(rdr->client, ACTION_READER_EMM, emm_pack, sizeof(EMM_PACKET));
7662 return true;
7663 }
7664 }
7665
7666 return false;
7667 }
7668
7669 static bool process_single_emm(struct templatevars * vars, struct s_reader * rdr, uint16_t caid, const struct s_cardsystem *csystem, const char *ep)
7670 {
7671
7672 if(NULL != vars && NULL != rdr && NULL != ep)
7673 {
7674 char emmdata[1025] = {'\0'}; /*1024 + '\0'*/
7675 uint8_t emmhex[513] = {'\0'};
7676 char buff[7] = {'\0'};
7677 uint16_t len = 0;
7678 cs_strncpy(emmdata, ep, sizeof(emmdata));
7679 remove_white_chars(emmdata);
7680
7681 if('\0' != emmdata[0])
7682 {
7683 len = cs_strlen(emmdata);
7684 tpl_addVar(vars, TPLADD, "EP", strtoupper(emmdata));
7685 if(key_atob_l(emmdata, emmhex, len))
7686 {
7687 tpl_addMsg(vars, "Single EMM has not been sent due to wrong value!");
7688 }
7689 else
7690 {
7691 len /= 2;
7692 snprintf(buff, sizeof(buff), "0x%02X", len);
7693 tpl_addVar(vars, TPLADD, "EP", strtoupper(emmdata));
7694 tpl_addVar(vars, TPLADD, "SIZE", buff);
7695
7696 if(send_EMM(rdr, caid, csystem, emmhex, len))
7697 {
7698 tpl_addMsg(vars, "Single EMM has been sent.");
7699 return true;
7700 }
7701 }
7702 }
7703 }
7704 tpl_addVar(vars, TPLADD, "SIZE", "0x00");
7705 return false;
7706 }
7707
7708 static bool process_emm_file(struct templatevars * vars, struct s_reader * rdr, uint16_t caid, const struct s_cardsystem *csystem, const char *sFilePath)
7709 {
7710
7711 bool bret = false;
7712 uint32_t fsize = 0;
7713 uint32_t rlines = 0;
7714 uint32_t wemms = 0;
7715 uint32_t errsize = 0;
7716 char numerrl[256] = {'\0'};
7717 char buff[20] = {'\0'};
7718
7719 if(NULL != rdr && NULL != sFilePath && '\0' != sFilePath[0])
7720 {
7721 char sMessage[128] = {0};
7722 if(true == file_exists(sFilePath))
7723 {
7724 FILE *fp;
7725 if((fp = fopen(sFilePath, "r")))
7726 {
7727 char line[2048] = {'\0'};
7728 uint8_t emmhex[513] = {'\0'};
7729 uint32_t len = 0;
7730
7731 tpl_addMsg(vars, "EMM file has been processed.");
7732 while(fgets(line, sizeof(line), fp))
7733 {
7734 ++rlines;
7735 len = cs_strlen(remove_white_chars(line));
7736
7737 // wrong emm
7738 if(len > (sizeof(emmhex) * 2) ||
7739 key_atob_l(line, emmhex, len))
7740 {
7741 errsize += snprintf(numerrl + errsize, sizeof(numerrl) - errsize, "%d, ", rlines);
7742 continue;
7743 }
7744 len /= 2;
7745 if(send_EMM(rdr, caid, csystem, emmhex, len))
7746 {
7747 ++wemms;
7748 int32_t jcount = ll_count(rdr->client->joblist);
7749 if (jcount > 200)
7750 {
7751 /* Give more time to process EMMs */
7752 cs_sleepms(1000);
7753 }
7754 rdr_log_dbg(rdr, D_READER, "pending emm jobs: %i, processed emms: %i", jcount, wemms);
7755 }
7756 }
7757 fsize = ftell(fp);
7758 fclose(fp);
7759 }
7760 else
7761 {
7762 snprintf(sMessage, sizeof(sMessage), "Cannot open file '%s' (errno=%d: %s)\n", sFilePath, errno, strerror(errno));
7763 tpl_addMsg(vars, sMessage);
7764 }
7765 }
7766 else
7767 {
7768 snprintf(sMessage, sizeof(sMessage), "FILE \"%s\" not found!", sFilePath);
7769 tpl_addMsg(vars, sMessage);
7770 }
7771 bret = true;
7772 }
7773
7774 snprintf(buff, sizeof(buff), "%d bytes", fsize);
7775 tpl_addVar(vars, TPLADD, "FSIZE", buff);
7776 snprintf(buff, sizeof(buff), "%d", rlines);
7777 tpl_addVar(vars, TPLADD, "NUMRLINE", buff);
7778 snprintf(buff, sizeof(buff), "%d", wemms);
7779 tpl_addVar(vars, TPLADD, "NUMWEMM", buff);
7780 tpl_addVar(vars, TPLADD, "ERRLINE", numerrl);
7781
7782 return bret;
7783 }
7784
7785 static char *send_oscam_EMM_running(struct templatevars * vars, struct uriparams * params)
7786 {
7787
7788 struct s_reader *rdr = NULL;
7789
7790 setActiveMenu(vars, MNU_READERS);
7791 tpl_addVar(vars, TPLADD, "READER", getParam(params, "label"));
7792 tpl_addVar(vars, TPLADD, "FNAME", getParam(params, "emmfile"));
7793
7794 rdr = get_reader_by_label(getParam(params, "label"));
7795 if(rdr)
7796 {
7797 int32_t tcaid = dyn_word_atob(getParam(params, "emmcaid"));
7798 uint16_t caid = (-1 != tcaid) ? (uint16_t)tcaid : 0;
7799 char buff[7] = "";
7800 const struct s_cardsystem *csystem = NULL;
7801 int32_t proxy = is_cascading_reader(rdr);
7802
7803 if((proxy || !rdr->csystem_active) && caid) // network reader (R_CAMD35 R_NEWCAMD R_CS378X R_CCCAM)
7804 {
7805 if(proxy && !rdr->ph.c_send_emm)
7806 {
7807 tpl_addMsg(vars, "The reader does not support EMM's!");
7808 return tpl_getTpl(vars, "EMM_RUNNING");
7809 }
7810
7811 csystem = get_cardsystem_by_caid(caid);
7812 if(!csystem)
7813 {
7814 rdr_log_dbg(rdr, D_EMM, "unable to find cardsystem for caid %04X", caid);
7815 caid = 0;
7816 }
7817 }
7818 else if(!proxy && rdr->csystem_active) // local active reader
7819 {
7820 csystem = rdr->csystem;
7821
7822 if(rdr->typ != R_EMU)
7823 {
7824 caid = rdr->caid;
7825 }
7826 }
7827
7828 if(csystem)
7829 {
7830 tpl_addVar(vars, TPLADD, "SYSTEM", csystem->desc);
7831 }
7832 else
7833 {
7834 tpl_addVar(vars, TPLADD, "SYSTEM", "unknown");
7835 }
7836 if(caid)
7837 {
7838 snprintf(buff, sizeof(buff), "0x%04X", caid);
7839 tpl_addVar(vars, TPLADD, "CAID", buff);
7840 }
7841 else
7842 {
7843 tpl_addVar(vars, TPLADD, "CAID", "unknown");
7844 }
7845
7846 process_single_emm(vars, rdr, caid, csystem, getParam(params, "ep"));
7847 process_emm_file(vars, rdr, caid, csystem, getParam(params, "emmfile"));
7848 }
7849 else
7850 {
7851 char sMessage[128] = {0};
7852 snprintf(sMessage, sizeof(sMessage), "READER \"%s\" not found!", getParam(params, "label"));
7853 tpl_addMsg(vars, sMessage);
7854 tpl_addVar(vars, TPLADD, "READER", "reader not found");
7855 }
7856
7857 return tpl_getTpl(vars, "EMM_RUNNING");
7858 }
7859
7860 static char *send_oscam_EMM(struct templatevars * vars, struct uriparams * params)
7861 {
7862
7863 setActiveMenu(vars, MNU_READERS);
7864 tpl_addVar(vars, TPLADD, "READER", getParam(params, "label"));
7865
7866 struct s_reader *rdr = NULL;
7867 rdr = get_reader_by_label(getParam(params, "label"));
7868 if(rdr && rdr->caid)
7869 {
7870 char buff[5] = "";
7871 snprintf(buff, sizeof(buff), "%04X", rdr->caid);
7872 tpl_addVar(vars, TPLADD, "CAID", buff);
7873 if(!is_cascading_reader(rdr))
7874 {
7875 tpl_addVar(vars, TPLADD, "READONLY", "readonly=\"readonly\"");
7876 }
7877 }
7878
7879 FILE *fp;
7880 struct stat sb;
7881 char buffer[1024];
7882 char emm_hex[1024];
7883 char filename[128];
7884 char targetfile[256];
7885 char tmpstr[20];
7886 char emm_txt[32];
7887 char emm_title[32];
7888 char *emm_path;
7889 char *emm_types[] = { "unique_emm", "shared_emm", "global_emm" };
7890 char *emm_names[] = { "RDREMMUNIQUE", "RDREMMSHARED", "RDREMMGLOBAL" };
7891 char *emm_cfg_names[] = { "httpemmuclean", "httpemmsclean", "httpemmgclean" };
7892 int32_t emm_max_size[] = { cfg.http_emmu_clean, cfg.http_emms_clean, cfg.http_emmg_clean };
7893 int num_emm_types = 3;
7894 int i;
7895
7896 emm_path = cfg.emmlogdir ? cfg.emmlogdir : cs_confdir;
7897
7898 for( i = 0 ; i < num_emm_types; i++ )
7899 {
7900 snprintf(filename, sizeof(filename), "%s%s%s%s", getParam(params, "label"), "_", emm_types[i], ".log");
7901 snprintf(targetfile, sizeof(targetfile), "%s%s%s", emm_path, emm_path[cs_strlen(emm_path) - 1] == '/' ? "" : "/", filename);
7902 snprintf(emm_txt, sizeof(emm_txt), "%s_TXT", emm_names[i]);
7903 tpl_addVar(vars, TPLADD, emm_txt, filename);
7904
7905 if((fp = fopen(targetfile, "r")) != NULL)
7906 {
7907 stat(targetfile, &sb);
7908 tpl_printf(vars, TPLAPPEND, emm_txt, " (Size: %'.2f kB)", (double)sb.st_size/1024);
7909
7910 if(emm_max_size[i]>=0)
7911 {
7912 snprintf(emm_title, sizeof(emm_title), "%s_TITLE", emm_names[i]);
7913 tpl_addVar(vars, TPLADD, emm_title, "title=\"Click Line to Copy EMM in Single EMM Write Field\"");
7914 }
7915
7916 if(emm_max_size[i]>0)
7917 {
7918 uint32_t emms=0, emm_d, emmrs=0;
7919 char *ptr, *saveptr1 = NULL;
7920
7921 while(fgets(buffer, sizeof(buffer), fp) != NULL)
7922 {
7923 emms++;
7924 snprintf(tmpstr, sizeof(tmpstr), "LINE_%d", emms);
7925 tpl_addVar(vars, TPLADD, tmpstr, buffer);
7926 }
7927
7928 for(emm_d=emms;emm_d>0;--emm_d)
7929 {
7930 snprintf(tmpstr, sizeof(tmpstr), "LINE_%d", emm_d);
7931 if(sscanf(tpl_getVar(vars, tmpstr), "%*s %*s %*s %s", &emm_hex[0])==1)
7932 {
7933 if(strstr(tpl_getVar(vars, "EMM_TMP"),emm_hex)==0)
7934 { tpl_addVar(vars, TPLAPPEND, "EMM_TMP", tpl_getVar(vars, tmpstr)); }
7935 tpl_addVar(vars, TPLADD, tmpstr, "");
7936 }
7937 }
7938
7939 for(ptr = strtok_r(tpl_getVar(vars, "EMM_TMP"),"\n", &saveptr1); ptr; ptr = strtok_r(NULL,"\n", &saveptr1))
7940 {
7941 emmrs++;
7942 snprintf(tmpstr, sizeof(tmpstr), "LINE_%d", emmrs);
7943 tpl_addVar(vars, TPLADD, tmpstr, ptr);
7944 }
7945 tpl_addVar(vars, TPLADD, "EMM_TMP", "");
7946
7947 tpl_printf(vars, TPLAPPEND, emm_txt, ": %'d different EMM's from a total off %'d Entrys", emmrs,emms);
7948 for(emm_d=emmrs;emm_d>0;--emm_d)
7949 {
7950 snprintf(tmpstr, sizeof(tmpstr), "LINE_%d", emm_d);
7951 tpl_printf(vars, TPLAPPEND, emm_names[i], "<a class=\"tosingleemm\" href=\"#\">%s</a>\n", tpl_getVar(vars, tmpstr));
7952 if(sb.st_size>emm_max_size[i]*1024) { tpl_printf(vars, TPLAPPEND, "EMM_TMP", "%s\n", tpl_getVar(vars, tmpstr)); }
7953 tpl_addVar(vars, TPLADD, tmpstr, "");
7954 }
7955
7956 if(sb.st_size>emm_max_size[i]*1024)
7957 {
7958 char orgfile[268];
7959 int f=0;
7960 do {
7961 snprintf(orgfile, sizeof(orgfile), "%s.%d", targetfile, f);
7962 f++;
7963 } while(access(orgfile, 0|F_OK) != -1);
7964
7965 if(rename(targetfile, orgfile) == 0)
7966 {
7967 FILE *fs = fopen(targetfile, "w");
7968 fprintf(fs, "%s", tpl_getVar(vars, "EMM_TMP"));
7969 fclose(fs);
7970 tpl_printf(vars, TPLAPPEND, emm_txt, "<br><b>New reduced File created!</b> Size of Original File is higher as %d kB, saved to %s", emm_max_size[i], orgfile);
7971 }
7972 }
7973 tpl_addVar(vars, TPLADD, "EMM_TMP", "");
7974 }
7975 else if (emm_max_size[i]==0)
7976 {
7977 while(fgets(buffer, sizeof(buffer), fp) != NULL)
7978 {
7979 tpl_printf(vars, TPLAPPEND, emm_names[i], "<a class=\"tosingleemm\" href=\"#\">%s</a>", buffer);
7980 }
7981 }
7982 else
7983 {
7984 tpl_printf(vars, TPLADD, emm_names[i],"Viewing of EMM File deactivated.<br>Set %s in Config Webif to 0 or higher for viewing or filtering EMM File.", emm_cfg_names[i]);
7985 }
7986 fclose(fp);
7987 }
7988 if(strcmp(tpl_getVar(vars, emm_names[i]),"")==0) { tpl_addVar(vars, TPLADD, emm_names[i],"no saved EMM's"); }
7989 }
7990
7991 return tpl_getTpl(vars, "ASKEMM");
7992 }
7993
7994 #ifdef CS_CACHEEX
7995 static uint64_t get_cacheex_node(struct s_client * cl)
7996 {
7997 uint64_t node = 0x00;
7998 #if defined(MODULE_CCCAM) || defined(MODULE_CAMD35) || defined(MODULE_CAMD35_TCP)
7999 struct s_module *module = (cl->reader ? &cl->reader->ph : get_module(cl));
8000 #endif
8001 #ifdef MODULE_CCCAM
8002 if(module->num == R_CCCAM && cl->cc)
8003 {
8004 struct cc_data *cc = cl->cc;
8005 memcpy(&node, cc->peer_node_id, 8);
8006 }
8007 else
8008 #endif
8009 #ifdef MODULE_CAMD35
8010 if(module->num == R_CAMD35)
8011 {
8012 memcpy(&node, cl->ncd_skey, 8);
8013 }
8014 else
8015 #endif
8016 #ifdef MODULE_CAMD35_TCP
8017 if(module->num == R_CS378X)
8018 {
8019 memcpy(&node, cl->ncd_skey, 8);
8020 }
8021 else
8022 #endif
8023 {}
8024 return node;
8025 }
8026
8027
8028 static char *send_oscam_cacheex(struct templatevars * vars, struct uriparams * params, int8_t apicall)
8029 {
8030
8031 if(!apicall) { setActiveMenu(vars, MNU_CACHEEX); }
8032
8033 if(strcmp(getParam(params, "x"), "x") == 0)
8034 {
8035 // avoid compilerwarning unused vars
8036 }
8037 char *level[] = {"NONE", "CACHE PULL", "CACHE PUSH", "REVERSE CACHE PUSH"};
8038 char *getting = "<IMG SRC=\"image?i=ICARRL\" ALT=\"Getting\">";
8039 char *pushing = "<IMG SRC=\"image?i=ICARRR\" ALT=\"Pushing\">";
8040 char *rowvariable = "";
8041
8042 int16_t i, written = 0;
8043 struct s_client *cl;
8044 time_t now = time((time_t *)0);
8045 int delimiter=0;
8046
8047 if(!apicall)
8048 {
8049 if(strcmp(getParam(params, "action"), "resetallcacheexstats") == 0)
8050 {
8051 cacheex_clear_all_stats();
8052 }
8053 }
8054
8055 tpl_printf(vars, TPLADD, "OWN_CACHEEX_NODEID", "%" PRIu64 "X", cacheex_node_id(cacheex_peer_id));
8056
8057 const char *cacheex_name_link_tpl = NULL;
8058 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
8059
8060 for(i = 0, cl = first_client; cl ; cl = cl->next, i++)
8061 {
8062 #ifdef CS_CACHEEX_AIO
8063 char classname[9];
8064 snprintf(classname, 8, "class%02d", i) < 0 ? abort() : (void)0;
8065 classname[8] = '\0';
8066 tpl_addVar(vars, TPLADD, "CLASSNAME", classname);
8067 #endif
8068
8069 if(cl->typ == 'c' && cl->account && cl->account->cacheex.mode)
8070 {
8071 cacheex_name_link_tpl = "SUSER";
8072 tpl_addVar(vars, TPLADD, "TYPE", "Client");
8073 if(!apicall)
8074 {
8075 tpl_addVar(vars, TPLADD, "USERNAME", xml_encode(vars, cl->account->usr));
8076 tpl_addVar(vars, TPLADD, "USERENC", urlencode(vars, cl->account->usr));
8077
8078 if(cl->account->description)
8079 {
8080 tpl_printf(vars, TPLADD, "CLIENTDESCRIPTION","%s(%s)",!apicall?"&#13;":"",xml_encode(vars, cl->account->description));
8081 }
8082 else
8083 {
8084 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
8085 }
8086 }
8087 else
8088 {
8089 tpl_addVar(vars, TPLADD, "NAME", cl->account->usr);
8090
8091 if(cl->account->description)
8092 {
8093 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", cl->account->description);
8094 }
8095 else
8096 {
8097 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
8098 }
8099 }
8100
8101 tpl_addVar(vars, TPLADD, "IP", cs_inet_ntoa(cl->ip));
8102 tpl_printf(vars, TPLADD, "NODE", "%" PRIu64 "X", get_cacheex_node(cl));
8103 tpl_addVar(vars, TPLADD, "LEVEL", level[cl->account->cacheex.mode]);
8104 tpl_printf(vars, TPLADD, "PUSH", "%d", cl->account->cwcacheexpush);
8105 tpl_printf(vars, TPLADD, "GOT", "%d", cl->account->cwcacheexgot);
8106 tpl_printf(vars, TPLADD, "CWCINFO", "%d", cl->account->cwc_info);
8107 tpl_printf(vars, TPLADD, "HIT", "%d", cl->account->cwcacheexhit);
8108 tpl_printf(vars, TPLADD, "ERR", "%d", cl->account->cwcacheexerr);
8109 tpl_printf(vars, TPLADD, "ERRCW", "%d", cl->account->cwcacheexerrcw);
8110 #ifdef CS_CACHEEX_AIO
8111 tpl_printf(vars, TPLADD, "GOTLG", "%d", cl->account->cwcacheexgotlg);
8112 tpl_printf(vars, TPLADD, "PUSHLG", "%d", cl->account->cwcacheexpushlg);
8113 tpl_printf(vars, TPLADD, "REL_CACHEXHITGOT", "%.2f", (double)(cl->account->cwcacheexhit ? (double)cl->account->cwcacheexhit : 0) * 100 / (double)(cl->account->cwcacheexgot ? cl->account->cwcacheexgot : 1));
8114 #endif
8115 tpl_addVar(vars, TPLADD, "DIRECTIONIMG", (cl->account->cacheex.mode == 3) ? getting : pushing);
8116 rowvariable = "TABLECLIENTROWS";
8117 written = 1;
8118 }
8119 else if((cl->typ == 'p' || cl->typ == 'r') && (cl->reader && cl->reader->cacheex.mode))
8120 {
8121 cacheex_name_link_tpl = "SREADER";
8122 tpl_addVar(vars, TPLADD, "TYPE", "Reader");
8123
8124 if(!apicall)
8125 {
8126 tpl_addVar(vars, TPLADD, "READERNAME", xml_encode(vars, cl->reader->label));
8127 tpl_addVar(vars, TPLADD, "READERNAMEENC", urlencode(vars, cl->reader->label));
8128
8129 if(cl->reader->description)
8130 {
8131 tpl_printf(vars, TPLADD, "CLIENTDESCRIPTION","%s(%s)",!apicall?"&#13;":"",xml_encode(vars, cl->reader->description));
8132 }
8133 else
8134 {
8135 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
8136 }
8137 }
8138 else
8139 {
8140 tpl_addVar(vars, TPLADD, "NAME", cl->reader->label);
8141
8142 if(cl->reader->description)
8143 {
8144 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", cl->reader->description);
8145 }
8146 else
8147 {
8148 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", "");
8149 }
8150 }
8151
8152 tpl_addVar(vars, TPLADD, "IP", cs_inet_ntoa(cl->ip));
8153 tpl_printf(vars, TPLADD, "NODE", "%" PRIu64 "X", get_cacheex_node(cl));
8154 tpl_addVar(vars, TPLADD, "LEVEL", level[cl->reader->cacheex.mode]);
8155 tpl_printf(vars, TPLADD, "PUSH", "%d", cl->cwcacheexpush);
8156 tpl_printf(vars, TPLADD, "CWCINFO", "%d", cl->cwc_info);
8157 tpl_printf(vars, TPLADD, "GOT", "%d", cl->cwcacheexgot);
8158 tpl_printf(vars, TPLADD, "CWCINFO", "%d", cl->cwc_info);
8159 tpl_printf(vars, TPLADD, "HIT", "%d", cl->cwcacheexhit);
8160 tpl_printf(vars, TPLADD, "ERR", "%d", cl->cwcacheexerr);
8161 tpl_printf(vars, TPLADD, "ERRCW", "%d", cl->cwcacheexerrcw);
8162 #ifdef CS_CACHEEX_AIO
8163 tpl_printf(vars, TPLADD, "GOTLG", "%d", cl->cwcacheexgotlg);
8164 tpl_printf(vars, TPLADD, "PUSHLG", "%d", cl->cwcacheexpushlg);
8165 tpl_printf(vars, TPLADD, "REL_CACHEXHITGOT", "%.2f", (double)(cl->cwcacheexhit ? (double)cl->cwcacheexhit : 0) * 100 / (double)(cl->cwcacheexgot ? cl->cwcacheexgot : 1));
8166 #endif
8167 tpl_addVar(vars, TPLADD, "DIRECTIONIMG", (cl->reader->cacheex.mode == 3) ? pushing : getting);
8168
8169 rowvariable = "TABLEREADERROWS";
8170 written = 1;
8171 }
8172 else if(get_module(cl)->listenertype == LIS_CSPUDP)
8173 {
8174 cacheex_name_link_tpl = "SREADER";
8175 tpl_addVar(vars, TPLADD, "TYPE", "csp");
8176
8177 if(!apicall)
8178 {
8179 tpl_addVar(vars, TPLADD, "READERNAME", "csp");
8180 tpl_addVar(vars, TPLADD, "READERNAMEENC", "csp");
8181 }
8182 else
8183 {
8184 tpl_addVar(vars, TPLADD, "NAME", "csp");
8185 }
8186
8187 tpl_addVar(vars, TPLADD, "IP", cs_inet_ntoa(cl->ip));
8188 tpl_addVar(vars, TPLADD, "NODE", "csp");
8189
8190 if(cl->cwcacheexping)
8191 {
8192 tpl_printf(vars, TPLADD, "LEVEL", "csp (%d ms)", cl->cwcacheexping);
8193 }
8194 else
8195 {
8196 tpl_addVar(vars, TPLADD, "LEVEL", "csp");
8197 }
8198
8199 tpl_printf(vars, TPLADD, "PUSH", "%d", cl->cwcacheexpush);
8200 tpl_printf(vars, TPLADD, "GOT", "%d", cl->cwcacheexgot);
8201 tpl_printf(vars, TPLADD, "HIT", "%d", cl->cwcacheexhit);
8202 tpl_printf(vars, TPLADD, "ERR", "%d", cl->cwcacheexerr);
8203 tpl_printf(vars, TPLADD, "ERRCW", "%d", cl->cwcacheexerrcw);
8204 #ifdef CS_CACHEEX_AIO
8205 tpl_printf(vars, TPLADD, "GOTLG", "%d", cl->cwcacheexgotlg);
8206 tpl_printf(vars, TPLADD, "PUSHLG", "%d", cl->cwcacheexpushlg);
8207 tpl_printf(vars, TPLADD, "REL_CACHEXHITGOT", "%.2f", (double)(cl->cwcacheexhit ? (double)cl->cwcacheexhit : 0) * 100 / (double)(cl->cwcacheexgot ? cl->cwcacheexgot : 1));
8208 #endif
8209 tpl_addVar(vars, TPLADD, "DIRECTIONIMG", getting);
8210 rowvariable = "TABLECLIENTROWS";
8211 written = 1;
8212 }
8213
8214 if(written)
8215 {
8216 if(!apicall)
8217 {
8218 tpl_addVar(vars, TPLADD, "NAME", tpl_getTpl(vars, cacheex_name_link_tpl));
8219 }
8220 #ifdef CS_CACHEEX_AIO
8221 tpl_addVar(vars, TPLAPPEND, rowvariable, tpl_getTpl(vars, "CACHEEXAIOTABLEROW"));
8222 #else
8223 tpl_addVar(vars, TPLAPPEND, rowvariable, tpl_getTpl(vars, "CACHEEXTABLEROW"));
8224 #endif
8225
8226 if(cl->ll_cacheex_stats)
8227 {
8228 LL_ITER itr = ll_iter_create(cl->ll_cacheex_stats);
8229 S_CACHEEX_STAT_ENTRY *cacheex_stats_entry;
8230
8231 while((cacheex_stats_entry = ll_iter_next(&itr)))
8232 {
8233 tpl_addVar(vars, TPLADD, "DIRECTIONIMG", "");
8234 if(now - cacheex_stats_entry->cache_last < 20)
8235 { tpl_addVar(vars, TPLADD, "TYPE", cacheex_stats_entry->cache_direction == 0 ? pushing : getting); }
8236 else
8237 { tpl_addVar(vars, TPLADD, "TYPE", ""); }
8238 tpl_printf(vars, TPLADD, "NAME", "%04X@%06X:%04X", cacheex_stats_entry->cache_caid,
8239 cacheex_stats_entry->cache_prid,
8240 cacheex_stats_entry->cache_srvid);
8241 if(cacheex_stats_entry->cache_direction == 0)
8242 {
8243 tpl_printf(vars, TPLADD, "PUSH", "%d", cacheex_stats_entry->cache_count);
8244 #ifdef CS_CACHEEX_AIO
8245 tpl_printf(vars, TPLADD, "PUSHLG", "%d", cacheex_stats_entry->cache_count_lg);
8246 #endif
8247 tpl_addVar(vars, TPLADD, "GOT", "");
8248 }
8249 else
8250 {
8251 tpl_printf(vars, TPLADD, "GOT", "%d", cacheex_stats_entry->cache_count);
8252 #ifdef CS_CACHEEX_AIO
8253 tpl_printf(vars, TPLADD, "GOTLG", "%d", cacheex_stats_entry->cache_count_lg);
8254 #endif
8255 tpl_addVar(vars, TPLADD, "PUSH", "");
8256 }
8257 tpl_addVar(vars, TPLADD, "HIT", "");
8258 char channame[CS_SERVICENAME_SIZE];
8259 char *lastchan = xml_encode(vars, get_servicename(cl, cacheex_stats_entry->cache_srvid, cacheex_stats_entry->cache_prid, cacheex_stats_entry->cache_caid, channame, sizeof(channame)));
8260 tpl_addVar(vars, TPLADD, "LEVEL", lastchan);
8261 if (apicall == 2)
8262 {
8263 tpl_printf(vars, TPLADD, "JSONDELIMITER", "%s", (delimiter > 1)?",":"");
8264 #ifdef CS_CACHEEX_AIO
8265 tpl_addVar(vars, TPLAPPEND, "JSONCACHEEXBITS", tpl_getTpl(vars, "JSONCACHEEXAIOBIT"));
8266 #else
8267 tpl_addVar(vars, TPLAPPEND, "JSONCACHEEXBITS", tpl_getTpl(vars, "JSONCACHEEXBIT"));
8268 #endif
8269 delimiter++;
8270 }
8271 else
8272 {
8273 #ifdef CS_CACHEEX_AIO
8274 tpl_addVar(vars, TPLAPPEND, rowvariable, tpl_getTpl(vars, "CACHEEXAIOTABLEROWSTATS"));
8275 #else
8276 tpl_addVar(vars, TPLAPPEND, rowvariable, tpl_getTpl(vars, "CACHEEXTABLEROW"));
8277 #endif
8278 }
8279 }
8280 }
8281 written = 0;
8282 }
8283 }
8284
8285 float cachesum = first_client ? first_client->cwcacheexgot : 1;
8286 if(cachesum < 1)
8287 {
8288 cachesum = 1;
8289 }
8290 tpl_printf(vars, TPLADD, "TOTAL_CACHEXPUSH", PRINTF_LOCAL_D, first_client ? first_client->cwcacheexpush : 0);
8291 tpl_addVar(vars, TPLADD, "TOTAL_CACHEXPUSH_IMG", pushing);
8292 tpl_printf(vars, TPLADD, "TOTAL_CACHEXGOT", PRINTF_LOCAL_D, first_client ? first_client->cwcacheexgot : 0);
8293 tpl_addVar(vars, TPLADD, "TOTAL_CACHEXGOT_IMG", getting);
8294 tpl_printf(vars, TPLADD, "TOTAL_CACHEXHIT", PRINTF_LOCAL_D, first_client ? first_client->cwcacheexhit : 0);
8295 tpl_printf(vars, TPLADD, "TOTAL_CACHESIZE", "%d", cache_size());
8296 #ifdef CS_CACHEEX_AIO
8297 tpl_printf(vars, TPLADD, "TOTAL_CACHESIZE_LG", "%d", cache_size_lg());
8298 #endif
8299
8300 tpl_printf(vars, TPLADD, "REL_CACHEXHIT", "%.2f", (first_client ? first_client->cwcacheexhit : 0) * 100 / cachesum);
8301
8302 if(!apicall)
8303 {
8304 #ifdef CS_CACHEEX_AIO
8305 return tpl_getTpl(vars, "CACHEEXAIOPAGE");
8306 #else
8307 return tpl_getTpl(vars, "CACHEEXPAGE");
8308 #endif
8309 }
8310 else
8311 {
8312 return tpl_getTpl(vars, "JSONCACHEEX");
8313 }
8314 }
8315 #endif
8316
8317 static char *send_oscam_api(struct templatevars * vars, FILE * f, struct uriparams * params, int8_t *keepalive, int8_t apicall, char *extraheader)
8318 {
8319 if(strcmp(getParam(params, "part"), "status") == 0)
8320 {
8321 return send_oscam_status(vars, params, apicall);
8322 }
8323 else if(strcmp(getParam(params, "part"), "userstats") == 0)
8324 {
8325 return send_oscam_user_config(vars, params, apicall);
8326 }
8327 else if(strcmp(getParam(params, "part"), "failban") == 0)
8328 {
8329 return send_oscam_failban(vars, params, apicall);
8330 }
8331 #ifdef CS_CACHEEX
8332 else if(strcmp(getParam(params, "part"), "cacheex") == 0)
8333 {
8334 return send_oscam_cacheex(vars, params, apicall);
8335 }
8336 #endif
8337 else if(strcmp(getParam(params, "part"), "files") == 0)
8338 {
8339 return send_oscam_files(vars, params, apicall);
8340 }
8341 else if(strcmp(getParam(params, "part"), "readerlist") == 0)
8342 {
8343 return send_oscam_reader(vars, params, apicall);
8344 }
8345 else if(strcmp(getParam(params, "part"), "serverconfig") == 0)
8346 {
8347 //Send Errormessage
8348 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "serverconfig not yet avail");
8349 return tpl_getTpl(vars, "APIERROR");
8350 }
8351 else if(strcmp(getParam(params, "part"), "userconfig") == 0)
8352 {
8353 if(((strcmp(getParam(params, "action"), "Save") == 0) ||
8354 (strcmp(getParam(params, "action"), "Save As") == 0)) && cfg.http_readonly == 1)
8355 {
8356 //Send Errormessage
8357 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "API is in readonly mode");
8358 return tpl_getTpl(vars, "APIERROR");
8359 }
8360 else
8361 {
8362 struct s_auth *account = get_account_by_name(getParam(params, "user"));
8363 if(!account && strcmp(getParam(params, "action"), "Save"))
8364 {
8365 //Send Errormessage
8366 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "user not exist");
8367 return tpl_getTpl(vars, "APIERROR");
8368 }
8369 else
8370 {
8371 return send_oscam_user_config_edit(vars, params, apicall);
8372 }
8373 }
8374 }
8375 else if(strcmp(getParam(params, "part"), "entitlement") == 0)
8376 {
8377
8378 if(strcmp(getParam(params, "label"), ""))
8379 {
8380 struct s_reader *rdr = get_reader_by_label(getParam(params, "label"));
8381 if(rdr)
8382 {
8383 if(rdr->enable == 1)
8384 {
8385 return send_oscam_entitlement(vars, params, apicall);
8386 }
8387 else
8388 {
8389 //Send Errormessage
8390 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "no cccam reader or disabled");
8391 return tpl_getTpl(vars, "APIERROR");
8392 }
8393 }
8394 else
8395 {
8396 //Send Errormessage
8397 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "reader not exist");
8398 return tpl_getTpl(vars, "APIERROR");
8399 }
8400 }
8401 else
8402 {
8403 //Send Errormessage
8404 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "no reader selected");
8405 return tpl_getTpl(vars, "APIERROR");
8406 }
8407 }
8408 else if(strcmp(getParam(params, "part"), "ecmhistory") == 0)
8409 {
8410 int32_t i;
8411 int32_t isec;
8412 int32_t shown;
8413 time_t now = time((time_t *)0);
8414 const char *usr;
8415 struct s_client *cl;
8416 for(i = 0, cl = first_client; cl ; cl = cl->next, i++)
8417 {
8418 if(cl->wihidden != 1)
8419 {
8420 isec = now - cl->lastecm;
8421 usr = username(cl);
8422 shown = 0;
8423 if(strcmp(getParam(params, "label"), "") == 0)
8424 {
8425 if(strcmp(getParam(params, "type"), "servers") == 0)
8426 {
8427 if(cl->typ == 'p' || cl->typ == 'r')
8428 { shown = 1; }
8429 }
8430 else if(strcmp(getParam(params, "type"), "users") == 0)
8431 {
8432 if(cl->typ == 'c')
8433 { shown = 1; }
8434 }
8435 else
8436 {
8437 shown = 1;
8438 }
8439 }
8440 else if(strcmp(getParam(params, "label"), usr) == 0)
8441 {
8442 shown = 1;
8443 }
8444 if(shown == 1)
8445 {
8446 tpl_printf(vars, TPLADD, "CLIENTTYPE", "%c", cl->typ);
8447 tpl_addVar(vars, TPLADD, "CLIENTUSER", xml_encode(vars, usr));
8448 if(cl->typ == 'c' || cl->typ == 'm')
8449 {
8450 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", xml_encode(vars, cl->account->description ? cl->account->description : ""));
8451 }
8452 else if(cl->typ == 'p' || cl->typ == 'r')
8453 {
8454 tpl_addVar(vars, TPLADD, "CLIENTDESCRIPTION", xml_encode(vars, cl->reader->description ? cl->reader->description : ""));
8455 }
8456 tpl_printf(vars, TPLADD, "CLIENTLASTRESPONSETIME", "%d", cl->cwlastresptime ? cl->cwlastresptime : -1);
8457 tpl_printf(vars, TPLADD, "CLIENTIDLESECS", "%d", isec);
8458
8459 //load historical values from ringbuffer
8460 char *value = get_ecm_fullhistorystring(cl);
8461 tpl_addVar(vars, TPLADD, "CLIENTLASTRESPONSETIMEHIST", value);
8462 free_mk_t(value);
8463
8464 tpl_addVar(vars, TPLAPPEND, "APISTATUSBITS", tpl_getTpl(vars, "APISTATUSBIT"));
8465 }
8466 }
8467 }
8468 return tpl_getTpl(vars, "APISTATUS");
8469 }
8470 else if(strcmp(getParam(params, "part"), "readerstats") == 0)
8471 {
8472 if(strcmp(getParam(params, "label"), ""))
8473 {
8474 struct s_reader *rdr = get_reader_by_label(getParam(params, "label"));
8475 if(rdr)
8476 {
8477 return send_oscam_reader_stats(vars, params, apicall);
8478 }
8479 else
8480 {
8481 //Send Errormessage
8482 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "reader not exist");
8483 return tpl_getTpl(vars, "APIERROR");
8484 }
8485 }
8486 else
8487 {
8488 //Send Errormessage
8489 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "no reader selected");
8490 return tpl_getTpl(vars, "APIERROR");
8491 }
8492 }
8493 else if(strcmp(getParam(params, "part"), "sendcmd") == 0)
8494 {
8495 if(strcmp(getParam(params, "label"), ""))
8496 {
8497 struct s_reader *rdr = get_reader_by_label(getParam(params, "label"));
8498 if(rdr)
8499 {
8500 char api_msg[150];
8501 CMD_PACKET *cmd_pack = NULL;
8502 if(!cs_malloc(&cmd_pack, sizeof(CMD_PACKET)))
8503 {
8504 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "cs_malloc failed!");
8505 return tpl_getTpl(vars, "APIERROR");
8506 }
8507 struct s_client *webif_client = cur_client();
8508 webif_client->grp = 0xFF; // access all readers
8509
8510 memset(cmd_pack, '0', sizeof(CMD_PACKET));
8511 cmd_pack->client = webif_client;
8512 cmd_pack->cmdlen = strlen(getParam(params, "cmd")) / 2;
8513
8514 if(cmd_pack->cmdlen > 0 && (unsigned long)abs(cmd_pack->cmdlen) <= sizeof(cmd_pack->cmd))
8515 {
8516 if(key_atob_l(getParam(params, "cmd"), cmd_pack->cmd, cmd_pack->cmdlen*2))
8517 {
8518 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "'cmd' has not been sent due to wrong value!");
8519 return tpl_getTpl(vars, "APIERROR");
8520 }
8521 }
8522 else
8523 {
8524 if(cmd_pack->cmdlen)
8525 {
8526 snprintf(api_msg, sizeof(api_msg), "Command would exceed %lu bytes!", (long unsigned int)sizeof(cmd_pack->cmd));
8527 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", api_msg);
8528 }
8529 else
8530 {
8531 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "Missing parameter 'cmd'!");
8532 }
8533 return tpl_getTpl(vars, "APIERROR");
8534 }
8535
8536 struct s_client *cl = rdr->client;
8537 if(rdr->enable == 1 && cl && cl->typ == 'r')
8538 {
8539 add_job(cl, ACTION_READER_SENDCMD, cmd_pack, sizeof(CMD_PACKET));
8540 tpl_addVar(vars, TPLADD, "APICONFIRMMESSAGE", "command sent");
8541 return tpl_getTpl(vars, "APICONFIRMATION");
8542 }
8543 else
8544 {
8545 snprintf(api_msg, sizeof(api_msg), "Reader '%s' is not suitable!", xml_encode(vars, rdr->label));
8546 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", api_msg);
8547 return tpl_getTpl(vars, "APIERROR");
8548 }
8549 }
8550 else
8551 {
8552 //Send Errormessage
8553 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "no such reader");
8554 return tpl_getTpl(vars, "APIERROR");
8555 }
8556 }
8557 else
8558 {
8559 //Send Errormessage
8560 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "no reader selected");
8561 return tpl_getTpl(vars, "APIERROR");
8562 }
8563 }
8564 else if(strcmp(getParam(params, "part"), "shutdown") == 0)
8565 {
8566 if((strcmp(strtolower(getParam(params, "action")), "restart") == 0) ||
8567 (strcmp(strtolower(getParam(params, "action")), "shutdown") == 0))
8568 {
8569 if(!cfg.http_readonly)
8570 {
8571 return send_oscam_shutdown(vars, f, params, apicall, keepalive, extraheader);
8572 }
8573 else
8574 {
8575 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "webif readonly mode");
8576 return tpl_getTpl(vars, "APIERROR");
8577 }
8578 }
8579 else
8580 {
8581 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "missing parameter action");
8582 return tpl_getTpl(vars, "APIERROR");
8583 }
8584
8585 }
8586 else
8587 {
8588 tpl_addVar(vars, TPLADD, "APIERRORMESSAGE", "part not found");
8589 return tpl_getTpl(vars, "APIERROR");
8590 }
8591 }
8592
8593 static char *send_oscam_image(struct templatevars * vars, FILE * f, struct uriparams * params, char *image, time_t modifiedheader, uint32_t etagheader, char *extraheader)
8594 {
8595 char *wanted;
8596 if(image == NULL) { wanted = getParam(params, "i"); }
8597 else { wanted = image; }
8598 if(cs_strlen(wanted) > 3 && wanted[0] == 'I' && wanted[1] == 'C')
8599 {
8600 if(etagheader == 0)
8601 {
8602 int8_t disktpl = 0;
8603 char *tpl_path;
8604 tpl_path = cfg.http_piconpath? cfg.http_piconpath : cfg.http_tpl;
8605
8606 if(tpl_path)
8607 {
8608 char path[255];
8609 if(cs_strlen(tpl_getTplPath(wanted, tpl_path, path, 255)) > 0 && file_exists(path))
8610 {
8611 struct stat st;
8612 disktpl = 1;
8613 stat(path, &st);
8614 if((time_t)st.st_mtime < modifiedheader)
8615 {
8616 send_header304(f, extraheader);
8617 return "1";
8618 }
8619 }
8620 }
8621 if(disktpl == 0 && first_client->login < modifiedheader)
8622 {
8623 send_header304(f, extraheader);
8624 return "1";
8625 }
8626 }
8627 char *header = strstr(tpl_getTpl(vars, wanted), "data:");
8628 if(header != NULL)
8629 {
8630 char *ptr = header + 5;
8631 while(ptr[0] != ';' && ptr[0] != '\0') { ++ptr; }
8632 if(ptr[0] != '\0' && ptr[1] != '\0') { ptr[0] = '\0'; }
8633 else { return "0"; }
8634 ptr = strstr(ptr + 1, "base64,");
8635 if(ptr != NULL)
8636 {
8637 int32_t len = b64decode((uint8_t *)ptr + 7);
8638 if(len > 0)
8639 {
8640 if((uint32_t)crc32(0L, (uint8_t *)ptr + 7, len) == etagheader)
8641 {
8642 send_header304(f, extraheader);
8643 }
8644 else
8645 {
8646 send_headers(f, 200, "OK", extraheader, header + 5, 1, len, ptr + 7, 0);
8647 webif_write_raw(ptr + 7, f, len);
8648 }
8649 return "1";
8650 }
8651 }
8652 }
8653 }
8654 // Return file not found
8655 const char *not_found = "File not found.\n";
8656 send_headers(f, 404, "Not Found", extraheader, "text/plain", 0, cs_strlen(not_found), (char *)not_found, 0);
8657 webif_write_raw((char *)not_found, f, cs_strlen(not_found));
8658 return "1";
8659 }
8660
8661 static char *send_oscam_robots_txt(FILE * f)
8662 {
8663 const char *content = "User-agent: *\nDisallow: /\n";
8664 send_headers(f, 200, "OK", NULL, "text/plain", 0, cs_strlen(content), (char *)content, 0);
8665 webif_write_raw((char *)content, f, cs_strlen(content));
8666 return "1";
8667 }
8668
8669 static char *send_oscam_graph(struct templatevars * vars)
8670 {
8671 return tpl_getTpl(vars, "GRAPH");
8672 }
8673
8674 #ifdef MODULE_GHTTP
8675 static bool ghttp_autoconf(struct templatevars * vars, struct uriparams * params)
8676 {
8677 int8_t i = 0;
8678 struct s_reader *rdr;
8679 char *name = getParam(params, "gacname");
8680 if(cs_strlen(name) < 3)
8681 {
8682 tpl_addMsg(vars, "Invalid host name!");
8683 return false;
8684 }
8685
8686 LL_ITER itr = ll_iter_create(configured_readers);
8687 while((rdr = ll_iter_next(&itr)))
8688 if(rdr->ph.num == R_GHTTP) { i++; } // count existing ghttp readers
8689
8690 while(i < 3) // if less than 3, add more
8691 {
8692 char lbl[128];
8693 snprintf(lbl, sizeof(lbl), "%s%d", "ghttp", i + 1);
8694 cs_log("GHttp autoconf: adding reader %s", lbl);
8695 struct s_reader *newrdr;
8696 if(!cs_malloc(&newrdr, sizeof(struct s_reader)))
8697 {
8698 tpl_addMsg(vars, "Create reader failed!");
8699 return false;
8700 };
8701 newrdr->typ = R_GHTTP;
8702 cs_strncpy(newrdr->label, lbl, sizeof(newrdr->label));
8703 module_reader_set(newrdr);
8704 reader_set_defaults(newrdr);
8705 newrdr->enable = 0;
8706 newrdr->grp = 1;
8707 ll_append(configured_readers, newrdr);
8708 i++;
8709 }
8710
8711 uint16_t port = 0;
8712 char *str = strstr(name, ":");
8713 if(str)
8714 {
8715 port = atoi(str + 1);
8716 str[0] = '\0';
8717 }
8718
8719 i = 0;
8720 itr = ll_iter_create(configured_readers);
8721 while((rdr = ll_iter_next(&itr)))
8722 {
8723 if(rdr->ph.num == R_GHTTP)
8724 {
8725 if(i > 2) // remove superflous
8726 {
8727 cs_log("GHttp autoconf: removing reader %s", rdr->label);
8728 inactivate_reader(rdr);
8729 ll_iter_remove(&itr);
8730 free_reader(rdr);
8731 }
8732 else // reconfigure the 3 first ghttp readers
8733 {
8734 cs_log("GHttp autoconf: reconfiguring reader %s", rdr->label);
8735 snprintf(rdr->label, sizeof(rdr->label), "%s%d", "ghttp", i + 1);
8736 rdr->r_port = port;
8737 rdr->enable = 1;
8738 rdr->ghttp_use_ssl = 0;
8739 #ifdef WITH_SSL
8740 rdr->ghttp_use_ssl = 1;
8741 #endif
8742 if(rdr->grp < 1) { rdr->grp = 1; }
8743 cs_strncpy(rdr->r_usr, getParam(params, "gacuser"), sizeof(rdr->r_usr));
8744 cs_strncpy(rdr->r_pwd, getParam(params, "gacpasswd"), sizeof(rdr->r_pwd));
8745 if(i == 0) { cs_strncpy(rdr->device, name, sizeof(rdr->device)); }
8746 else
8747 {
8748 if(!strstr(name, "."))
8749 { snprintf(rdr->device, sizeof(rdr->device), "%s%d", name, i); } // name, name1, name2
8750 else { cs_strncpy(rdr->device, name, sizeof(rdr->device)); }
8751 // . in the name = assume full hostname = use same for all 3 readers
8752 }
8753 if(i == 2) { rdr->fallback = 1; }
8754 else { rdr->fallback = 0; }
8755 i++;
8756 }
8757 }
8758 }
8759 cs_log("GHttp autoconf: Saving %d readers", i);
8760 if(write_server() != 0) { tpl_addMsg(vars, "Write Config failed!"); }
8761 itr = ll_iter_create(configured_readers);
8762 while((rdr = ll_iter_next(&itr)))
8763 {
8764 if(rdr->ph.num == R_GHTTP)
8765 { restart_cardreader(rdr, 1); }
8766 }
8767 return true;
8768 }
8769
8770 static char *send_oscam_ghttp(struct templatevars * vars, struct uriparams * params, int8_t apicall)
8771 {
8772 if(strcmp(strtolower(getParam(params, "action")), "autoconf") == 0)
8773 {
8774 if(!apicall)
8775 {
8776 bool missing = false;
8777 if(cs_strlen(getParam(params, "gacuser")) == 0)
8778 {
8779 tpl_addVar(vars, TPLADD, "USERREQ", "<FONT COLOR='red'>(Required)</FONT>");
8780 missing = true;
8781 }
8782 else { tpl_addVar(vars, TPLADD, "GACUSER", getParam(params, "gacuser")); }
8783 if(cs_strlen(getParam(params, "gacpasswd")) == 0)
8784 {
8785 tpl_addVar(vars, TPLADD, "PWDREQ", "<FONT COLOR='red'>(Required)</FONT>");
8786 missing = true;
8787 }
8788 else { tpl_addVar(vars, TPLADD, "GACPASSWD", getParam(params, "gacpasswd")); }
8789 if(cs_strlen(getParam(params, "gacname")) == 0)
8790 {
8791 tpl_addVar(vars, TPLADD, "NAMEREQ", "<FONT COLOR='red'>(Required)</FONT>");
8792 missing = true;
8793 }
8794 else { tpl_addVar(vars, TPLADD, "GACNAME", getParam(params, "gacname")); }
8795 if(missing) { return tpl_getTpl(vars, "PREAUTOCONF"); }
8796 cs_log("GHttp autoconf requested by WebIF from %s", cs_inet_ntoa(GET_IP()));
8797 }
8798 else
8799 {
8800 tpl_addVar(vars, TPLADD, "APICONFIRMMESSAGE", "autoconf");
8801 cs_log("GHttp autoconf requested by XMLApi from %s", cs_inet_ntoa(GET_IP()));
8802 }
8803
8804 if(ghttp_autoconf(vars, params))
8805 {
8806 tpl_printf(vars, TPLADD, "REFRESHTIME", "%d", 3);
8807 tpl_addVar(vars, TPLADD, "REFRESH", tpl_getTpl(vars, "REFRESH"));
8808 tpl_printf(vars, TPLADD, "SECONDS", "%d", 3);
8809 if(apicall) { return tpl_getTpl(vars, "APICONFIRMATION"); }
8810 else { return tpl_getTpl(vars, "AUTOCONF"); }
8811 }
8812 else { return tpl_getTpl(vars, "PREAUTOCONF"); } // something failed
8813
8814 }
8815 else
8816 {
8817 if(cs_strlen(getParam(params, "token")) > 0) // parse autoconf token
8818 {
8819 char *token = getParam(params, "token");
8820 int32_t len = b64decode((uint8_t *)token);
8821 if(len > 0)
8822 {
8823 struct uriparams tokenprms;
8824 tokenprms.paramcount = 0;
8825 parseParams(&tokenprms, token);
8826 if(cs_strlen(getParam(&tokenprms, "u")) > 0)
8827 {
8828 tpl_addVar(vars, TPLADD, "GACUSER", getParam(&tokenprms, "u"));
8829 tpl_addVar(vars, TPLADD, "USERRDONLY", "readonly");
8830 }
8831 if(cs_strlen(getParam(&tokenprms, "p")) > 0)
8832 {
8833 tpl_addVar(vars, TPLADD, "GACPASSWD", getParam(&tokenprms, "p"));
8834 tpl_addVar(vars, TPLADD, "PWDRDONLY", "readonly");
8835 }
8836 if(cs_strlen(getParam(&tokenprms, "n")) > 0)
8837 {
8838 tpl_addVar(vars, TPLADD, "GACNAME", getParam(&tokenprms, "n"));
8839 tpl_addVar(vars, TPLADD, "NAMERDONLY", "readonly");
8840 }
8841 }
8842 }
8843 return tpl_getTpl(vars, "PREAUTOCONF");
8844 }
8845 }
8846 #endif
8847
8848 static int8_t check_httpip(IN_ADDR_T addr)
8849 {
8850 int8_t i = 0;
8851 // check all previously dyndns resolved addresses
8852 for(i = 0; i < MAX_HTTP_DYNDNS; i++)
8853 {
8854 if(IP_ISSET(cfg.http_dynip[i]) && IP_EQUAL(cfg.http_dynip[i], addr))
8855 { return 1; }
8856 }
8857 return 0;
8858 }
8859
8860 static int8_t check_httpdyndns(IN_ADDR_T addr)
8861 {
8862
8863 // check all previously dyndns resolved addresses
8864 if(check_httpip(addr))
8865 { return 1; }
8866
8867 // we are not ok, so resolve all dyndns entries into IP's - maybe outdated IP's
8868
8869 if(cfg.http_dyndns[0][0])
8870 {
8871 int8_t i = 0;
8872 for(i = 0; i < MAX_HTTP_DYNDNS; i++)
8873 {
8874 if(cfg.http_dyndns[i][0])
8875 {
8876 cs_resolve((const char *)cfg.http_dyndns[i], &cfg.http_dynip[i], NULL, NULL);
8877 cs_log_dbg(D_TRACE, "WebIf: httpdyndns [%d] resolved %s to %s ", i, (char *)cfg.http_dyndns[i], cs_inet_ntoa(cfg.http_dynip[i]));
8878 }
8879 }
8880 }
8881 else
8882 {
8883 cs_log_dbg(D_TRACE, "WebIf: No dyndns addresses found");
8884 return 0;
8885 }
8886
8887 // again check all dyndns resolved addresses
8888 if(check_httpip(addr))
8889 { return 1; }
8890
8891 return 0;
8892 }
8893
8894 static int8_t check_valid_origin(IN_ADDR_T addr)
8895 {
8896
8897 // check whether requesting IP is in allowed IP ranges
8898 if(check_ip(cfg.http_allowed, addr))
8899 { return 1; }
8900
8901 // we havn't found the requesting IP in allowed range. So we check for allowed httpdyndns as last chance
8902 if(cfg.http_dyndns[0][0])
8903 {
8904 int8_t ok;
8905 ok = check_httpdyndns(addr);
8906 return ok;
8907 }
8908 return 0;
8909 }
8910
8911 static int8_t check_request(char *result, int32_t readen)
8912 {
8913 if(readen < 50) { return 0; }
8914 result[readen] = '\0';
8915 int8_t method;
8916 if(strncmp(result, "POST", 4) == 0) { method = 1; }
8917 else { method = 0; }
8918 char *headerEnd = strstr(result, "\r\n\r\n");
8919 if(headerEnd == NULL) { return 0; }
8920 else if(method == 0) { return 1; }
8921 else
8922 {
8923 char *ptr = strstr(result, "Content-Length: ");
8924 if(ptr != NULL)
8925 {
8926 ptr += 16;
8927 if(ptr < result + readen)
8928 {
8929 uint32_t length = atoi(ptr);
8930 if(cs_strlen(headerEnd + 4) >= length) { return 1; }
8931 }
8932 }
8933 }
8934 return 0;
8935 }
8936
8937 static int32_t readRequest(FILE * f, IN_ADDR_T in, char **result, int8_t forcePlain)
8938 {
8939 int32_t n, bufsize = 0, errcount = 0;
8940 char buf2[1024];
8941 struct pollfd pfd2[1];
8942 #ifdef WITH_SSL
8943 int8_t is_ssl = 0;
8944 if(ssl_active && !forcePlain)
8945 { is_ssl = 1; }
8946 #endif
8947
8948 while(1)
8949 {
8950 errno = 0;
8951 if(forcePlain)
8952 { n = read(fileno(f), buf2, sizeof(buf2)); }
8953 else
8954 { n = webif_read(buf2, sizeof(buf2), f); }
8955 if(n <= 0)
8956 {
8957 if((errno == 0 || errno == EINTR))
8958 {
8959 if(errcount++ < 10)
8960 {
8961 cs_sleepms(5);
8962 continue;
8963 }
8964 else { return -1; }
8965 }
8966 #ifdef WITH_SSL
8967 if(is_ssl)
8968 {
8969 if(errno != ECONNRESET)
8970 {
8971 int32_t errcode = ERR_peek_error();
8972 char errstring[128];
8973 ERR_error_string_n(errcode, errstring, sizeof(errstring) - 1);
8974 cs_log_dbg(D_TRACE, "WebIf: read error ret=%d (%d%s%s)", n, SSL_get_error(cur_ssl(), n), errcode ? " " : "", errcode ? errstring : "");
8975 }
8976 return -1;
8977 }
8978 #else
8979 if(errno != ECONNRESET)
8980 { cs_log_dbg(D_TRACE, "WebIf: read error ret=%d (errno=%d %s)", n, errno, strerror(errno)); }
8981 #endif
8982 return -1;
8983 }
8984 if(!cs_realloc(result, bufsize + n + 1))
8985 {
8986 send_error500(f);
8987 NULLFREE(*result);
8988 return -1;
8989 }
8990
8991 memcpy(*result + bufsize, buf2, n);
8992 bufsize += n;
8993
8994 #ifdef WITH_EMU
8995 if(bufsize > 204800) // max request size 200kb
8996 #else
8997 if(bufsize > 102400) // max request size 100kb
8998 #endif
8999 {
9000 cs_log("error: too much data received from %s", cs_inet_ntoa(in));
9001 NULLFREE(*result);
9002 *result = NULL;
9003 return -1;
9004 }
9005
9006 #ifdef WITH_SSL
9007 if(ssl_active && !forcePlain)
9008 {
9009 int32_t len = 0;
9010 len = SSL_pending((SSL *)f);
9011
9012 if(len > 0)
9013 { continue; }
9014
9015 pfd2[0].fd = SSL_get_fd((SSL *)f);
9016
9017 }
9018 else
9019 #endif
9020 pfd2[0].fd = fileno(f);
9021
9022 pfd2[0].events = (POLLIN | POLLPRI);
9023
9024 int32_t rc = poll(pfd2, 1, 100);
9025 if(rc > 0 || !check_request(*result, bufsize))
9026 { continue; }
9027 else
9028 { break; }
9029 }
9030 return bufsize;
9031 }
9032 static int32_t process_request(FILE * f, IN_ADDR_T in)
9033 {
9034 int32_t ok = 0;
9035 int8_t *keepalive = (int8_t *)pthread_getspecific(getkeepalive);
9036 IN_ADDR_T addr = GET_IP();
9037
9038 do
9039 {
9040 #ifdef WITH_SSL
9041 if(!ssl_active && *keepalive) { fflush(f); }
9042 #else
9043 if(*keepalive) { fflush(f); }
9044 #endif
9045
9046 // at this point we do all checks related origin IP, ranges and dyndns stuff
9047 ok = check_valid_origin(addr);
9048 cs_log_dbg(D_TRACE, "WebIf: Origin checked. Result: access from %s => %s", cs_inet_ntoa(addr), (!ok) ? "forbidden" : "allowed");
9049
9050 // based on the failed origin checks we send a 403 to calling browser
9051 if(!ok)
9052 {
9053 send_error(f, 403, "Forbidden", NULL, "Access denied.", 0);
9054 cs_log("unauthorized access from %s - invalid ip or dyndns", cs_inet_ntoa(addr));
9055 return 0;
9056 }
9057 int32_t authok = 0;
9058 char expectednonce[(MD5_DIGEST_LENGTH * 2) + 1], opaque[(MD5_DIGEST_LENGTH * 2) + 1];
9059 char authheadertmp[sizeof(AUTHREALM) + sizeof(expectednonce) + sizeof(opaque) + 100];
9060
9061 char *method, *path, *protocol, *str1, *saveptr1 = NULL, *authheader = NULL, *extraheader = NULL, *filebuf = NULL;
9062 char *pch, *tmp, *buf, *nameInUrl, subdir[32];
9063 /* List of possible pages */
9064 char *pages[] =
9065 {
9066 "/config.html",
9067 "/readers.html",
9068 "/entitlements.html",
9069 "/status.html",
9070 "/userconfig.html",
9071 "/readerconfig.html",
9072 "/services.html",
9073 "/user_edit.html",
9074 "/site.css",
9075 "/services_edit.html",
9076 "/savetemplates.html",
9077 "/shutdown.html",
9078 "/script.html",
9079 "/scanusb.html",
9080 "/files.html",
9081 "/readerstats.html",
9082 "/failban.html",
9083 "/oscam.js",
9084 "/oscamapi.html",
9085 "/image",
9086 "/favicon.ico",
9087 "/graph.svg",
9088 "/oscamapi.xml",
9089 "/cacheex.html",
9090 "/oscamapi.json",
9091 "/emm.html",
9092 "/emm_running.html",
9093 "/robots.txt",
9094 "/ghttp.html",
9095 "/logpoll.html",
9096 "/jquery.js",
9097 };
9098
9099 int32_t pagescnt = sizeof(pages) / sizeof(char *); // Calculate the amount of items in array
9100 int32_t i, bufsize, len, pgidx = -1;
9101 uint32_t etagheader = 0;
9102 struct uriparams params;
9103 params.paramcount = 0;
9104 time_t modifiedheader = 0;
9105
9106 bufsize = readRequest(f, in, &filebuf, 0);
9107
9108 if(!filebuf || bufsize < 1)
9109 {
9110 if(!*keepalive) { cs_log_dbg(D_CLIENT, "WebIf: No data received from client %s. Closing connection.", cs_inet_ntoa(addr)); }
9111 return -1;
9112 }
9113
9114 buf = filebuf;
9115
9116 if((method = strtok_r(buf, " ", &saveptr1)) != NULL)
9117 {
9118 if((path = strtok_r(NULL, " ", &saveptr1)) != NULL)
9119 {
9120 if((protocol = strtok_r(NULL, "\r", &saveptr1)) == NULL)
9121 {
9122 NULLFREE(filebuf);
9123 return -1;
9124 }
9125 }
9126 else
9127 {
9128 NULLFREE(filebuf);
9129 return -1;
9130 }
9131 }
9132 else
9133 {
9134 NULLFREE(filebuf);
9135 return -1;
9136 }
9137 tmp = protocol + cs_strlen(protocol) + 2;
9138
9139 pch = path;
9140 /* advance pointer to beginning of query string */
9141 while(pch[0] != '?' && pch[0] != '\0') { ++pch; }
9142 if(pch[0] == '?')
9143 {
9144 pch[0] = '\0';
9145 ++pch;
9146 }
9147
9148 nameInUrl = pch - 1;
9149 while(nameInUrl != path && nameInUrl[0] != '/') { --nameInUrl; }
9150
9151 /* allow only alphanumeric sub-folders */
9152 int32_t subdirLen = nameInUrl - path;
9153 subdir[0] = '\0';
9154 if(subdirLen > 0 && subdirLen < 32)
9155 {
9156 cs_strncpy(subdir, path + 1, subdirLen);
9157
9158 int32_t invalidSubdir = 0;
9159 for(i = 0; i < subdirLen - 1; i++)
9160 {
9161 if(!((subdir[i] >= '0' && subdir[i] <= '9')
9162 || (subdir[i] >= 'a' && subdir[i] <= 'z')
9163 || (subdir[i] >= 'A' && subdir[i] <= 'Z')))
9164 {
9165
9166 invalidSubdir = 1;
9167 subdir[0] = '\0';
9168 break;
9169 }
9170 }
9171
9172 if(!invalidSubdir)
9173 {
9174 subdir[subdirLen] = '\0';
9175 #ifdef WIN32
9176 subdir[subdirLen - 1] = '\\';
9177 #else
9178 subdir[subdirLen - 1] = '/';
9179 #endif
9180 }
9181 }
9182
9183 /* Map page to our static page definitions */
9184 for(i = 0; i < pagescnt; i++)
9185 {
9186 if(!strcmp(nameInUrl, pages[i])) { pgidx = i; }
9187 }
9188
9189 parseParams(&params, pch);
9190
9191 if(!cfg.http_user || !cfg.http_pwd)
9192 { authok = 1; }
9193
9194 for(str1 = strtok_r(tmp, "\n", &saveptr1); str1; str1 = strtok_r(NULL, "\n", &saveptr1))
9195 {
9196 len = cs_strlen(str1);
9197 if(str1[len - 1] == '\r')
9198 {
9199 str1[len - 1] = '\0';
9200 --len;
9201 }
9202 if(len == 0)
9203 {
9204 if(strcmp(method, "POST") == 0)
9205 {
9206 parseParams(&params, str1 + 2);
9207 }
9208 break;
9209 }
9210 if(!authok && len > 50 && strncasecmp(str1, "Authorization:", 14) == 0 && strstr(str1, "Digest") != NULL)
9211 {
9212 if(cs_dblevel & D_CLIENT)
9213 {
9214 if(cs_realloc(&authheader, len + 1))
9215 { cs_strncpy(authheader, str1, len); }
9216 }
9217 authok = check_auth(str1, method, path, addr, expectednonce, opaque);
9218 }
9219 else if(len > 40 && strncasecmp(str1, "If-Modified-Since:", 18) == 0)
9220 {
9221 modifiedheader = parse_modifiedsince(str1);
9222 }
9223 else if(len > 20 && strncasecmp(str1, "If-None-Match:", 14) == 0)
9224 {
9225 for(pch = str1 + 14; pch[0] != '"' && pch[0] != '\0'; ++pch) { ; }
9226 if(cs_strlen(pch) > 5) { etagheader = (uint32_t)strtoul(++pch, NULL, 10); }
9227 }
9228 else if(len > 12 && strncasecmp(str1, "Connection: Keep-Alive", 22) == 0 && strcmp(method, "POST"))
9229 {
9230 *keepalive = 1;
9231 }
9232 }
9233
9234 if(cfg.http_user && cfg.http_pwd)
9235 {
9236 if (!authok || cs_strlen(opaque) != MD5_DIGEST_LENGTH * 2)
9237 {
9238 calculate_opaque(addr, opaque);
9239 }
9240
9241 if (authok != 2)
9242 {
9243 if(!authok)
9244 {
9245 if(authheader)
9246 {
9247 cs_log_dbg(D_CLIENT, "WebIf: Received wrong auth header from %s:", cs_inet_ntoa(addr));
9248 cs_log_dbg(D_CLIENT, "%s", authheader);
9249 }
9250 else
9251 { cs_log_dbg(D_CLIENT, "WebIf: Received no auth header from %s.", cs_inet_ntoa(addr)); }
9252 }
9253 calculate_nonce(NULL, expectednonce, opaque);
9254 }
9255
9256 if (authok != 1)
9257 {
9258 snprintf(authheadertmp, sizeof(authheadertmp), "WWW-Authenticate: Digest algorithm=\"MD5\", realm=\"%s\", qop=\"auth\", opaque=\"%s\", nonce=\"%s\"", AUTHREALM, opaque, expectednonce);
9259 if (authok == 2)
9260 {
9261 if (!cs_strncat(authheadertmp, ", stale=true", sizeof(authheadertmp))) {
9262 cs_log("WARNING, bug here!");
9263 }
9264 }
9265 }
9266 else
9267 {
9268 snprintf(authheadertmp, sizeof(authheadertmp), "Authentication-Info: nextnonce=\"%s\"", expectednonce);
9269 }
9270
9271 extraheader = authheadertmp;
9272
9273 if (authok != 1)
9274 {
9275 char *msg = "Access denied.\n";
9276 send_headers(f, 401, "Unauthorized", extraheader, "text/html", 0, cs_strlen(msg), msg, 0);
9277 webif_write(msg, f);
9278 NULLFREE(authheader);
9279 NULLFREE(filebuf);
9280 if (*keepalive) {
9281 continue;
9282 } else {
9283 return 0;
9284 }
9285 }
9286 }
9287 else
9288 {
9289 NULLFREE(authheader);
9290 }
9291
9292 /*build page*/
9293 if(pgidx == 8)
9294 {
9295 send_file(f, "CSS", subdir, modifiedheader, etagheader, extraheader);
9296 }
9297 else if(pgidx == 17)
9298 {
9299 send_file(f, "JS", subdir, modifiedheader, etagheader, extraheader);
9300 }
9301 else if(pgidx == 30)
9302 {
9303 send_file(f, "JQ", subdir, modifiedheader, etagheader, extraheader);
9304 }
9305 else
9306 {
9307 time_t t;
9308 struct templatevars *vars = tpl_create();
9309 if(vars == NULL)
9310 {
9311 send_error500(f);
9312 NULLFREE(filebuf);
9313 return 0;
9314 }
9315
9316 tpl_addVar(vars, TPLADD, "SUBDIR", subdir);
9317
9318 struct tm lt, st;
9319 time(&t);
9320
9321 localtime_r(&t, &lt);
9322
9323 tpl_addVar(vars, TPLADD, "CS_VERSION", CS_VERSION);
9324 tpl_addVar(vars, TPLADD, "CS_SVN_VERSION", CS_SVN_VERSION);
9325 tpl_addVar(vars, TPLADD, "CS_TARGET", CS_TARGET);
9326 tpl_addVar(vars, TPLADD, "HTTPOSCAMLABEL", xml_encode(vars,cfg.http_oscam_label));
9327 if (!boxtype_is("generic"))
9328 {
9329 if (!boxname_is("generic"))
9330 tpl_printf(vars, TPLADD, "DETECTED_BOXTYPE", "%s (%s)", boxtype_get(), boxname_get());
9331 else
9332 tpl_addVar(vars, TPLADD, "DETECTED_BOXTYPE", boxtype_get());
9333 }
9334
9335 if(cfg.http_locale){
9336 float decimal_point = 0.0;
9337 setlocale(LC_ALL, cfg.http_locale);
9338 tpl_printf(vars, TPLADD, "TMP_DECPOINT", "%.1f", decimal_point);
9339 tpl_addVar(vars, TPLADD, "LOCALE_DECPOINT", strstr(tpl_getVar(vars, "TMP_DECPOINT"), ",") ? ",": ".");
9340 }
9341
9342 tpl_addVar(vars, TPLADD, "HTTP_CHARSET", "UTF-8");
9343 if(cfg.http_picon_size > 0)
9344 {
9345 tpl_printf(vars, TPLADD, "HTTPPICONSIZEINS", "img.statususericon, img.protoicon, img.usericon, img.readericon {height:%dpx !important;max-height:%dpx !important;}", cfg.http_picon_size, cfg.http_picon_size);
9346 }
9347 if(cfg.poll_refresh > 0)
9348 {
9349 tpl_printf(vars, TPLADD, "POLLREFRESHTIME", "%d", cfg.poll_refresh);
9350 }
9351 if ( cfg.http_refresh > 0 &&
9352 ((( pgidx == 1 || pgidx == 4 ) && !cfg.poll_refresh ) ||
9353 ( pgidx == 3 && ( cfg.http_status_log || !cfg.poll_refresh )) ||
9354 pgidx == 15 || pgidx == 23 || pgidx == -1 )) // wenn polling bei cachex.html eingeführt wird muss die 23 => 2 zeilen höher
9355 {
9356 tpl_printf(vars, TPLADD, "REFRESHTIME", "%d", cfg.http_refresh);
9357 tpl_addVar(vars, TPLADD, "WITHQUERY", pgidx == 15 ? "1" : "0");
9358 tpl_addVar(vars, TPLADD, "REFRESH", tpl_getTpl(vars, "REFRESH"));
9359 }
9360 #ifdef WEBIF_JQUERY
9361 tpl_printf(vars, TPLADD, "SRCJQUERY", "jquery.js?v=%s", CS_SVN_VERSION);
9362 #else
9363 tpl_addVar(vars, TPLADD, "SRCJQUERY", cfg.http_extern_jquery);
9364 #endif
9365
9366 if(picon_exists("LOGO")||cs_strlen(tpl_getTpl(vars, "IC_LOGO"))>3)
9367 {
9368 tpl_addVar(vars, TPLADD, "LOGO_INS", tpl_getTpl(vars, "LOGOBITIMG"));
9369 }
9370 else
9371 {
9372 tpl_addVar(vars, TPLADD, "LOGO_INS", tpl_getTpl(vars, "LOGOBITSVG"));
9373 }
9374 tpl_addVar(vars, TPLADD, "LOGO", tpl_getTpl(vars, "LOGOBIT"));
9375 tpl_printf(vars, TPLADD, "CURDATE", "%02d.%02d.%02d", lt.tm_mday, lt.tm_mon + 1, lt.tm_year % 100);
9376 tpl_printf(vars, TPLADD, "CURTIME", "%02d:%02d:%02d", lt.tm_hour, lt.tm_min, lt.tm_sec);
9377 localtime_r(&first_client->login, &st);
9378 tpl_printf(vars, TPLADD, "STARTDATE", "%02d.%02d.%02d", st.tm_mday, st.tm_mon + 1, st.tm_year % 100);
9379 tpl_printf(vars, TPLADD, "STARTTIME", "%02d:%02d:%02d", st.tm_hour, st.tm_min, st.tm_sec);
9380 tpl_printf(vars, TPLADD, "PROCESSID", "%d", getppid());
9381 tpl_addVar(vars, TPLADD, "RUNAS", urlencode(vars, username(first_client)));
9382
9383 time_t now = time((time_t *)0);
9384 // XMLAPI
9385 if(pgidx == 18 || pgidx == 22 || pgidx == 24)
9386 {
9387 char tbuffer [30];
9388 strftime(tbuffer, 30, "%Y-%m-%dT%H:%M:%S%z", &st);
9389 tpl_addVar(vars, TPLADD, "APISTARTTIME", tbuffer);
9390 tpl_printf(vars, TPLADD, "APIRUNTIME", "%ld", now - first_client->login);
9391 tpl_printf(vars, TPLADD, "APIREADONLY", "%d", cfg.http_readonly);
9392 if(strcmp(getParam(&params, "callback"), ""))
9393 {
9394 tpl_printf(vars, TPLADD, "CALLBACK", "%s%s", getParam(&params, "callback"), "(");
9395 tpl_addVar(vars, TPLADD, "ENDBRACKET", ")");
9396 }
9397
9398 }
9399
9400 if (config_enabled(WITH_LB))
9401 tpl_addVar(vars, TPLADD, "LBISDEFINED", "1");
9402
9403 // language code in helplink
9404 tpl_addVar(vars, TPLADD, "LANGUAGE", cfg.http_help_lang);
9405 tpl_addVar(vars, TPLADD, "RUNTIME", sec2timeformat(vars, (now - first_client->login)));
9406 time_t uptime = oscam_get_uptime();
9407 if(uptime > 0){
9408 tpl_printf(vars, TPLADD, "UPTIMETXT", "%s Up Time: ", strcmp(tpl_getVar(vars, "DETECTED_BOXTYPE"),"")==0 ? "System" : tpl_getVar(vars, "DETECTED_BOXTYPE"));
9409 tpl_addVar(vars, TPLADD, "UPTIME", sec2timeformat(vars, uptime));
9410 }
9411 tpl_addVar(vars, TPLADD, "CURIP", cs_inet_ntoa(addr));
9412 if(cfg.http_readonly)
9413 { tpl_addVar(vars, TPLAPPEND, "BTNDISABLED", "DISABLED"); }
9414
9415 i = ll_count(cfg.v_list);
9416 if(i > 0) { tpl_printf(vars, TPLADD, "FAILBANNOTIFIER", "<SPAN CLASS=\"span_notifier\">%d</SPAN>", i); }
9417 tpl_printf(vars, TPLADD, "FAILBANNOTIFIERPOLL", "%d", i);
9418
9419 char *result = NULL;
9420
9421 // WebIf allows modifying many things. Thus, all pages except images/css/static are expected to be non-threadsafe!
9422 if(pgidx != 19 && pgidx != 20 && pgidx != 21 && pgidx != 27) { cs_writelock(__func__, &http_lock); }
9423 switch(pgidx)
9424 {
9425 case 0:
9426 tpl_addVar(vars, TPLADD, "CONFIG_CONTENT", send_oscam_config(vars, &params));
9427 result = tpl_getTpl(vars, "CONFIGCONTENT");
9428 break;
9429 case 1:
9430 result = send_oscam_reader(vars, &params, 0);
9431 break;
9432 case 2:
9433 result = send_oscam_entitlement(vars, &params, 0);
9434 break;
9435 case 3:
9436 result = send_oscam_status(vars, &params, 0);
9437 break;
9438 case 4:
9439 result = send_oscam_user_config(vars, &params, 0);
9440 break;
9441 case 5:
9442 result = send_oscam_reader_config(vars, &params);
9443 break;
9444 case 6:
9445 result = send_oscam_services(vars, &params);
9446 break;
9447 case 7:
9448 result = send_oscam_user_config_edit(vars, &params, 0);
9449 break;
9450 //case 8: css file
9451 case 9:
9452 result = send_oscam_services_edit(vars, &params);
9453 break;
9454 case 10:
9455 result = send_oscam_savetpls(vars);
9456 break;
9457 case 11:
9458 result = send_oscam_shutdown(vars, f, &params, 0, keepalive, extraheader);
9459 break;
9460 case 12:
9461 result = send_oscam_script(vars, &params);
9462 break;
9463 case 13:
9464 result = send_oscam_scanusb(vars);
9465 break;
9466 case 14:
9467 result = send_oscam_files(vars, &params, 0);
9468 break;
9469 case 15:
9470 result = send_oscam_reader_stats(vars, &params, 0);
9471 break;
9472 case 16:
9473 result = send_oscam_failban(vars, &params, 0);
9474 break;
9475 //case 17: js file
9476 case 18:
9477 result = send_oscam_api(vars, f, &params, keepalive, 1, extraheader);
9478 break; //oscamapi.html
9479 case 19:
9480 result = send_oscam_image(vars, f, &params, NULL, modifiedheader, etagheader, extraheader);
9481 break;
9482 case 20:
9483 result = send_oscam_image(vars, f, &params, "ICMAI", modifiedheader, etagheader, extraheader);
9484 break;
9485 case 21:
9486 result = send_oscam_graph(vars);
9487 break;
9488 case 22:
9489 result = send_oscam_api(vars, f, &params, keepalive, 1, extraheader);
9490 break; //oscamapi.xml
9491 #ifdef CS_CACHEEX
9492 case 23:
9493 result = send_oscam_cacheex(vars, &params, 0);
9494 break;
9495 #endif
9496 case 24:
9497 result = send_oscam_api(vars, f, &params, keepalive, 2, extraheader);
9498 break; //oscamapi.json
9499 case 25:
9500 result = send_oscam_EMM(vars, &params);
9501 break; //emm.html
9502 case 26:
9503 result = send_oscam_EMM_running(vars, &params);
9504 break; //emm_running.html
9505 case 27:
9506 result = send_oscam_robots_txt(f);
9507 break; //robots.txt
9508 #ifdef MODULE_GHTTP
9509 case 28:
9510 result = send_oscam_ghttp(vars, &params, 0);
9511 break;
9512 #endif
9513 #ifdef WEBIF_LIVELOG
9514 case 29:
9515 result = send_oscam_logpoll(vars, &params);
9516 break;
9517 //case 30: jquery.js
9518 #endif
9519 default:
9520 result = send_oscam_status(vars, &params, 0);
9521 break;
9522 }
9523 if(pgidx != 19 && pgidx != 20 && pgidx != 21 && pgidx != 27) { cs_writeunlock(__func__, &http_lock); }
9524
9525 if(result == NULL || !strcmp(result, "0") || cs_strlen(result) == 0) { send_error500(f); }
9526 else if(strcmp(result, "1"))
9527 {
9528 //it doesn't make sense to check for modified etagheader here as standard template has timestamp in output and so site changes on every request
9529 if(pgidx == 18)
9530 { send_headers(f, 200, "OK", extraheader, "text/xml", 0, cs_strlen(result), NULL, 0); }
9531 else if(pgidx == 21)
9532 { send_headers(f, 200, "OK", extraheader, "image/svg+xml", 0, cs_strlen(result), NULL, 0); }
9533 else if(pgidx == 24)
9534 { send_headers(f, 200, "OK", extraheader, "text/javascript", 0, cs_strlen(result), NULL, 0); }
9535 else
9536 { send_headers(f, 200, "OK", extraheader, "text/html", 0, cs_strlen(result), NULL, 0); }
9537 webif_write(result, f);
9538 }
9539 tpl_clear(vars);
9540 }
9541 NULLFREE(filebuf);
9542 }
9543 while(*keepalive == 1 && !exit_oscam);
9544 return 0;
9545 }
9546
9547 static void *serve_process(void *conn)
9548 {
9549 struct s_connection *myconn = (struct s_connection *)conn;
9550 int32_t s = myconn->socket;
9551 struct s_client *cl = myconn->cl;
9552 IN_ADDR_T in;
9553 IP_ASSIGN(in, myconn->remote);
9554
9555 set_thread_name(__func__);
9556
9557 #ifdef WITH_SSL
9558 SSL *ssl = myconn->ssl;
9559 SAFE_SETSPECIFIC(getssl, ssl);
9560 #endif
9561 NULLFREE(myconn);
9562
9563 SAFE_SETSPECIFIC(getip, &in);
9564 SAFE_SETSPECIFIC(getclient, cl);
9565
9566 int8_t keepalive = 0;
9567 SAFE_SETSPECIFIC(getkeepalive, &keepalive);
9568
9569 #ifdef WITH_SSL
9570 if(ssl_active)
9571 {
9572 if(SSL_set_fd(ssl, s))
9573 {
9574 int32_t ok = (SSL_accept(ssl) != -1);
9575 if(!ok)
9576 {
9577 int8_t tries = 100;
9578 while(!ok && tries--)
9579 {
9580 int32_t err = SSL_get_error(ssl, -1);
9581 if(err != SSL_ERROR_WANT_READ && err != SSL_ERROR_WANT_WRITE)
9582 { break; }
9583 else
9584 {
9585 struct pollfd pfd;
9586 pfd.fd = s;
9587 pfd.events = POLLIN | POLLPRI;
9588 int32_t rc = poll(&pfd, 1, -1);
9589 if(rc < 0)
9590 {
9591 if(errno == EINTR || errno == EAGAIN) { continue; }
9592 break;
9593 }
9594 if(rc == 1)
9595 { ok = (SSL_accept(ssl) != -1); }
9596 }
9597 }
9598 }
9599 if(ok)
9600 {
9601 process_request((FILE *)ssl, in);
9602 }
9603 else
9604 {
9605 FILE *f;
9606 f = fdopen(s, "r+");
9607 if(f != NULL)
9608 {
9609 char *ptr, *filebuf = NULL, *host = NULL;
9610 int32_t bufsize = readRequest(f, in, &filebuf, 1);
9611
9612 if(filebuf)
9613 {
9614 filebuf[bufsize] = '\0';
9615 host = strstr(filebuf, "Host: ");
9616 if(host)
9617 {
9618 host += 6;
9619 ptr = strchr(host, '\r');
9620 if(ptr) { ptr[0] = '\0'; }
9621 }
9622 }
9623 if(host)
9624 {
9625 char extra[cs_strlen(host) + 20];
9626 snprintf(extra, sizeof(extra), "Location: https://%s", host);
9627 send_error(f, 301, "Moved Permanently", extra, "This web server is running in SSL mode.", 1);
9628 }
9629 else
9630 { send_error(f, 200, "Bad Request", NULL, "This web server is running in SSL mode.", 1); }
9631 fflush(f);
9632 fclose(f);
9633 NULLFREE(filebuf);
9634 }
9635 else
9636 {
9637 cs_log_dbg(D_TRACE, "WebIf: fdopen(%d) failed. (errno=%d %s)", s, errno, strerror(errno));
9638 }
9639 }
9640 }
9641 else { cs_log("WebIf: Error calling SSL_set_fd()."); }
9642 SSL_shutdown(ssl);
9643 close(s);
9644 SSL_free(ssl);
9645 }
9646 else
9647 #endif
9648 {
9649 FILE *f;
9650 f = fdopen(s, "r+");
9651 if(f != NULL)
9652 {
9653 process_request(f, in);
9654 fflush(f);
9655 fclose(f);
9656 }
9657 else
9658 {
9659 cs_log_dbg(D_TRACE, "WebIf: fdopen(%d) failed. (errno=%d %s)", s, errno, strerror(errno));
9660 }
9661 shutdown(s, SHUT_WR);
9662 close(s);
9663 }
9664
9665 return NULL;
9666 }
9667
9668 /* Creates a random string with specified length. Note that dst must be one larger than size to hold the trailing \0*/
9669 static void create_rand_str(char *dst, int32_t size)
9670 {
9671 int32_t i;
9672 for(i = 0; i < size; ++i)
9673 {
9674 dst[i] = (rand() % 94) + 32;
9675 }
9676 dst[i] = '\0';
9677 }
9678
9679 static void *http_server(void *UNUSED(d))
9680 {
9681 struct s_client *cl = create_client(first_client->ip);
9682 if(cl == NULL) { return NULL; }
9683 SAFE_SETSPECIFIC(getclient, cl);
9684 cl->typ = 'h';
9685 int32_t s, reuse = 1;
9686 struct s_connection *conn;
9687
9688 set_thread_name(__func__);
9689
9690 /* Create random string for nonce value generation */
9691 create_rand_str(noncekey, 32);
9692
9693 /* Prepare base64 decoding array */
9694 b64prepare();
9695 webif_tpls_prepare();
9696
9697 tpl_checkDiskRevisions();
9698
9699 cs_lock_create(__func__, &http_lock, "http_lock", 10000);
9700 init_noncelocks();
9701
9702 memset(&p_stat_cur, 0x0, sizeof(p_stat_cur));
9703
9704 if(pthread_key_create(&getip, NULL))
9705 {
9706 cs_log("Could not create getip");
9707 return NULL;
9708 }
9709 if(pthread_key_create(&getkeepalive, NULL))
9710 {
9711 cs_log("Could not create getkeepalive");
9712 return NULL;
9713 }
9714
9715 struct SOCKADDR sin;
9716 socklen_t len = 0;
9717 memset(&sin, 0, sizeof(sin));
9718
9719 bool do_ipv6 = config_enabled(IPV6SUPPORT);
9720 #ifdef IPV6SUPPORT
9721 if(do_ipv6)
9722 {
9723 len = sizeof(struct sockaddr_in6);
9724 if((sock = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP)) < 0)
9725 {
9726 cs_log("HTTP Server: ERROR: Creating IPv6 socket failed! (errno=%d %s)", errno, strerror(errno));
9727 cs_log("HTTP Server: Falling back to IPv4.");
9728 do_ipv6 = false;
9729 }
9730 else
9731 {
9732 struct sockaddr_in6 *ia = (struct sockaddr_in6 *)&sin;
9733 ia->sin6_family = AF_INET6;
9734 ia->sin6_addr = in6addr_any;
9735 ia->sin6_port = htons(cfg.http_port);
9736 }
9737 }
9738 #endif
9739 if(!do_ipv6)
9740 {
9741 len = sizeof(struct sockaddr_in);
9742 if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
9743 {
9744 cs_log("HTTP Server: ERROR: Creating socket failed! (errno=%d %s)", errno, strerror(errno));
9745 return NULL;
9746 }
9747 SIN_GET_FAMILY(sin) = AF_INET;
9748 if(IP_ISSET(cfg.http_srvip))
9749 { IP_ASSIGN(SIN_GET_ADDR(sin), cfg.http_srvip); }
9750 else if(IP_ISSET(cfg.srvip))
9751 { IP_ASSIGN(SIN_GET_ADDR(sin), cfg.srvip); }
9752 // The default is INADDR_ANY (0)
9753 SIN_GET_PORT(sin) = htons(cfg.http_port);
9754 }
9755
9756 if(setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) < 0)
9757 {
9758 cs_log("HTTP Server: Setting SO_REUSEADDR via setsockopt failed! (errno=%d %s)", errno, strerror(errno));
9759 }
9760
9761 if(bind(sock, (struct sockaddr *)&sin, len) < 0)
9762 {
9763 cs_log("HTTP Server couldn't bind on port %d (errno=%d %s). Not starting HTTP!", cfg.http_port, errno, strerror(errno));
9764 close(sock);
9765 return NULL;
9766 }
9767
9768 if(listen(sock, SOMAXCONN) < 0)
9769 {
9770 cs_log("HTTP Server: Call to listen() failed! (errno=%d %s)", errno, strerror(errno));
9771 close(sock);
9772 return NULL;
9773 }
9774
9775 #ifdef WITH_SSL
9776 if(pthread_key_create(&getssl, NULL))
9777 {
9778 cs_log("Could not create getssl");
9779 }
9780
9781 SSL_CTX *ctx = NULL;
9782 if(cfg.http_use_ssl)
9783 {
9784 ctx = SSL_Webif_Init();
9785 if(ctx == NULL)
9786 { cs_log("SSL could not be initialized. Starting WebIf in plain mode."); }
9787 else { ssl_active = 1; }
9788 }
9789 else { ssl_active = 0; }
9790 cs_log("HTTP Server running. ip=%s port=%d%s", cs_inet_ntoa(SIN_GET_ADDR(sin)), cfg.http_port, ssl_active ? " (SSL)" : "");
9791 #else
9792 cs_log("HTTP Server running. ip=%s port=%d", cs_inet_ntoa(SIN_GET_ADDR(sin)), cfg.http_port);
9793 #endif
9794
9795 struct SOCKADDR remote;
9796 memset(&remote, 0, sizeof(remote));
9797
9798 while(!exit_oscam)
9799 {
9800 if((s = accept(sock, (struct sockaddr *) &remote, &len)) < 0)
9801 {
9802 if(exit_oscam)
9803 { break; }
9804 if(errno != EAGAIN && errno != EINTR)
9805 {
9806 cs_log("HTTP Server: Error calling accept() (errno=%d %s)", errno, strerror(errno));
9807 cs_sleepms(100);
9808 }
9809 else { cs_sleepms(5); }
9810 continue;
9811 }
9812 else
9813 {
9814 getpeername(s, (struct sockaddr *) &remote, &len);
9815 if(!cs_malloc(&conn, sizeof(struct s_connection)))
9816 {
9817 close(s);
9818 continue;
9819 }
9820 setTCPTimeouts(s);
9821 cur_client()->last = time((time_t *)0); //reset last busy time
9822 conn->cl = cur_client();
9823 #ifdef IPV6SUPPORT
9824 if(do_ipv6)
9825 {
9826 struct sockaddr_in6 *ra = (struct sockaddr_in6 *)&remote;
9827 memcpy(&conn->remote, &ra->sin6_addr, sizeof(struct in6_addr));
9828 }
9829 else
9830 {
9831 struct sockaddr_in *fba = (struct sockaddr_in *)&remote;
9832 struct in6_addr taddr;
9833 memset(&taddr, 0, sizeof(taddr));
9834 taddr.s6_addr32[3] = fba->sin_addr.s_addr;
9835 memcpy(&conn->remote, &taddr, sizeof(struct in6_addr));
9836 }
9837 #else
9838 memcpy(&conn->remote, &remote.sin_addr, sizeof(struct in_addr));
9839 #endif
9840 conn->socket = s;
9841 #ifdef WITH_SSL
9842 conn->ssl = NULL;
9843 if(ssl_active)
9844 {
9845 conn->ssl = SSL_new(ctx);
9846 if(conn->ssl == NULL)
9847 {
9848 close(s);
9849 cs_log("WebIf: Error calling SSL_new().");
9850 continue;
9851 }
9852 }
9853 #endif
9854
9855 int32_t ret = start_thread("webif workthread", serve_process, (void *)conn, NULL, 1, 1);
9856 if(ret)
9857 {
9858 NULLFREE(conn);
9859 }
9860 }
9861 }
9862 // Wait a bit so that we don't close ressources while http threads are active
9863 cs_sleepms(300);
9864 #ifdef WITH_SSL
9865 SSL_CTX_free(ctx);
9866 CRYPTO_set_dynlock_create_callback(NULL);
9867 CRYPTO_set_dynlock_lock_callback(NULL);
9868 CRYPTO_set_dynlock_destroy_callback(NULL);
9869 CRYPTO_set_locking_callback(NULL);
9870 CRYPTO_set_id_callback(NULL);
9871 OPENSSL_free(lock_cs);
9872 lock_cs = NULL;
9873 #endif
9874 cs_log("HTTP Server stopped");
9875 free_client(cl);
9876 close(sock);
9877 return NULL;
9878 }
9879
9880 void webif_client_reset_lastresponsetime(struct s_client * cl)
9881 {
9882 int32_t i;
9883 for(i = 0; i < CS_ECM_RINGBUFFER_MAX; i++)
9884 {
9885 cl->cwlastresptimes[i].duration = 0;
9886 cl->cwlastresptimes[i].timestamp = time((time_t *)0);
9887 cl->cwlastresptimes[i].rc = 0;
9888 }
9889 cl->cwlastresptimes_last = 0;
9890 }
9891
9892 void webif_client_add_lastresponsetime(struct s_client * cl, int32_t ltime, time_t timestamp, int32_t rc)
9893 {
9894 int32_t last = cl->cwlastresptimes_last = (cl->cwlastresptimes_last + 1) & (CS_ECM_RINGBUFFER_MAX - 1);
9895 cl->cwlastresptimes[last].duration = ltime > 9999 ? 9999 : ltime;
9896 cl->cwlastresptimes[last].timestamp = timestamp;
9897 cl->cwlastresptimes[last].rc = rc;
9898 }
9899
9900 void webif_client_init_lastreader(struct s_client * client, ECM_REQUEST * er, struct s_reader * er_reader, const char *stxt[])
9901 {
9902 if(er_reader)
9903 {
9904 if(er->rc == E_FOUND)
9905 { cs_strncpy(client->lastreader, er_reader->label, sizeof(client->lastreader)); }
9906 else if(er->rc == E_CACHEEX)
9907 { cs_strncpy(client->lastreader, "cache3", sizeof(client->lastreader)); }
9908 else if(er->rc < E_NOTFOUND)
9909 { snprintf(client->lastreader, sizeof(client->lastreader) - 1, "%.54s (cache)", er_reader->label); }
9910 else
9911 { cs_strncpy(client->lastreader, stxt[er->rc], sizeof(client->lastreader)); }
9912 }
9913 else
9914 {
9915 cs_strncpy(client->lastreader, stxt[er->rc], sizeof(client->lastreader));
9916 }
9917 }
9918
9919 void webif_init(void)
9920 {
9921 char buf[8], fname[256];
9922 snprintf(buf, 8, "%'d", 7);
9923 if(strcmp(buf, "7"))
9924 {
9925 useLocal = 0;
9926 }
9927
9928 if(cfg.http_port == 0)
9929 {
9930 cs_log("http disabled");
9931 return;
9932 }
9933
9934 get_config_filename(fname, sizeof(fname), "oscam.srvid2");
9935 use_srvid2 = file_exists(fname);
9936
9937 if(start_thread("http", http_server, NULL, &httpthread, 0, 1) == 0)
9938 {
9939 httpthread_running = 1;
9940 }
9941 }
9942
9943 void webif_close(void)
9944 {
9945 if(!sock)
9946 { return; }
9947
9948 shutdown(sock, 2);
9949 close(sock);
9950
9951 if(httpthread_running)
9952 { SAFE_THREAD_JOIN(httpthread, NULL); }
9953 }
9954
9955 #endif
Open Source Conditional Access Modul