module-webif.c

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