source: trunk/oscam.c @ 5375

Last change on this file since 5375 was 5373, checked in by _network, 8 years ago

correct some declarations

File size: 96.8 KB
Line 
1  //FIXME Not checked on threadsafety yet; after checking please remove this line
2#define CS_CORE
3#include "globals.h"
4#include "csctapi/icc_async.h"
5#ifdef MODULE_CCCAM
6#include "module-cccam.h"
7#endif
8#if defined(AZBOX) && defined(HAVE_DVBAPI)
9#  include "openxcas/openxcas_api.h"
10#endif
11#define CS_VERSION_X  CS_VERSION
12#ifdef COOL
13void coolapi_close_all();
14void coolapi_open_all();
15#endif
16
17static void cs_fake_client(struct s_client *client, char *usr, int32_t uniq, in_addr_t ip);
18
19/*****************************************************************************
20        Globals
21*****************************************************************************/
22int32_t exit_oscam=0;
23struct s_module     ph[CS_MAX_MOD]; // Protocols
24struct s_cardsystem cardsystem[CS_MAX_MOD];
25struct s_cardreader cardreader[CS_MAX_MOD];
26
27struct s_client * first_client = NULL; //Pointer to clients list, first client is master
28struct s_reader * first_active_reader = NULL; //list of active readers (enable=1 deleted = 0)
29LLIST * configured_readers = NULL; //list of all (configured) readers
30
31uint16_t  len4caid[256];    // table for guessing caid (by len)
32char  cs_confdir[128]=CS_CONFDIR;
33int32_t cs_dblevel=0;   // Debug Level
34#ifdef WEBIF
35int8_t cs_restart_mode=1; //Restartmode: 0=off, no restart fork, 1=(default)restart fork, restart by webif, 2=like=1, but also restart on segfaults
36#endif
37int8_t cs_capture_SEGV=0;
38char  cs_tmpdir[200]={0x00};
39pid_t server_pid=0;
40pthread_mutex_t gethostbyname_lock;
41pthread_mutex_t get_cw_lock;
42pthread_mutex_t system_lock;
43pthread_mutex_t clientlist_lock;
44pthread_mutex_t readerlist_lock;
45pthread_mutex_t fakeuser_lock;
46pthread_key_t getclient;
47
48//Cache for  ecms, cws and rcs:
49LLIST *ecmcache;
50
51struct  s_config  cfg;
52
53char    *processUsername = NULL;
54char    *loghist = NULL;     // ptr of log-history
55char    *loghistptr = NULL;
56
57int32_t cs_check_v(uint32_t ip, int32_t add) {
58        int32_t result = 0;
59    if (cfg.failbantime) {
60
61        if (!cfg.v_list)
62            cfg.v_list = ll_create();
63
64        time_t now = time((time_t)0);
65        LL_ITER itr = ll_iter_create(cfg.v_list);
66        V_BAN *v_ban_entry;
67        int32_t ftime = cfg.failbantime*60;
68
69        //run over all banned entries to do housekeeping:
70        while ((v_ban_entry=ll_iter_next(&itr))) {
71
72            // housekeeping:
73            if ((now - v_ban_entry->v_time) >= ftime) { // entry out of time->remove
74                ll_iter_remove_data(&itr);
75                continue;
76                        }
77
78            if (ip == v_ban_entry->v_ip) {
79                    result=1;
80                    if (!add) {
81                        if (v_ban_entry->v_count >= cfg.failbancount) {
82                            cs_debug_mask(D_TRACE, "failban: banned ip %s - %ld seconds left",
83                                    cs_inet_ntoa(v_ban_entry->v_ip),ftime - (now - v_ban_entry->v_time));
84                        } else {
85                            cs_debug_mask(D_TRACE, "failban: ip %s chance %d of %d",
86                                    cs_inet_ntoa(v_ban_entry->v_ip), v_ban_entry->v_count, cfg.failbancount);
87                            v_ban_entry->v_count++;
88                        }
89                                }
90                                else {
91                        cs_debug_mask(D_TRACE, "failban: banned ip %s - already exist in list", cs_inet_ntoa(v_ban_entry->v_ip));
92                                }
93
94            }
95        }
96        if (add && !result) {
97        if(cs_malloc(&v_ban_entry,sizeof(V_BAN), -1)){
98                v_ban_entry->v_time = time((time_t *)0);
99                v_ban_entry->v_ip = ip;
100
101                ll_iter_insert(&itr, v_ban_entry);
102
103                cs_debug_mask(D_TRACE, "failban: ban ip %s with timestamp %d", cs_inet_ntoa(v_ban_entry->v_ip), v_ban_entry->v_time);
104        }
105     }
106    }
107    return result;
108}
109
110int32_t cs_check_violation(uint32_t ip) {
111        return cs_check_v(ip, 0);
112}
113void cs_add_violation(uint32_t ip) {
114        cs_check_v(ip, 1);
115}
116
117void cs_add_lastresponsetime(struct s_client *cl, int32_t ltime){
118
119    if(cl->cwlastresptimes_last == CS_ECM_RINGBUFFER_MAX - 1){
120        cl->cwlastresptimes_last = 0;
121    } else {
122        cl->cwlastresptimes_last++;
123    }
124    cl->cwlastresptimes[cl->cwlastresptimes_last] = ltime;
125}
126
127/*****************************************************************************
128        Statics
129*****************************************************************************/
130static const char *logo = "  ___  ____   ___                \n / _ \\/ ___| / __|__ _ _ __ ___  \n| | | \\___ \\| |  / _` | '_ ` _ \\ \n| |_| |___) | |_| (_| | | | | | |\n \\___/|____/ \\___\\__,_|_| |_| |_|\n";
131
132/* Prints usage information and information about the built-in modules. */
133static void usage()
134{
135  fprintf(stderr, "%s\n\n", logo);
136  fprintf(stderr, "OSCam cardserver v%s, build #%s (%s) - (w) 2009-2011 Streamboard SVN\n", CS_VERSION_X, CS_SVN_VERSION, CS_OSTYPE);
137  fprintf(stderr, "\tsee http://streamboard.gmc.to/oscam/ for more details\n");
138  fprintf(stderr, "\tbased on Streamboard mp-cardserver v0.9d - (w) 2004-2007 by dukat\n");
139  fprintf(stderr, "\tThis program is distributed under GPL.\n");
140  fprintf(stderr, "\tinbuilt add-ons: ");
141#ifdef WEBIF
142  fprintf(stderr, "webif ");
143#endif
144#ifdef MODULE_MONITOR
145  fprintf(stderr, "monitor ");
146#endif
147#ifdef WITH_SSL
148  fprintf(stderr, "ssl ");
149#endif
150#ifdef HAVE_DVBAPI
151#ifdef WITH_STAPI
152  fprintf(stderr, "dvbapi_stapi ");
153#else
154  fprintf(stderr, "dvbapi ");
155#endif
156#endif
157#ifdef IRDETO_GUESSING
158  fprintf(stderr, "irdeto-guessing ");
159#endif
160#ifdef CS_ANTICASC
161  fprintf(stderr, "anticascading ");
162#endif
163#ifdef WITH_DEBUG
164  fprintf(stderr, "debug ");
165#endif
166#ifdef CS_LED
167  fprintf(stderr, "led ");
168#endif
169#ifdef CS_WITH_DOUBLECHECK
170  fprintf(stderr, "doublecheck ");
171#endif
172#ifdef QBOXHD_LED
173  fprintf(stderr, "qboxhd-led ");
174#endif
175#ifdef CS_LOGHISTORY
176  fprintf(stderr, "loghistory ");
177#endif
178#ifdef LIBUSB
179  fprintf(stderr, "smartreader ");
180#endif
181#ifdef HAVE_PCSC
182  fprintf(stderr, "pcsc ");
183#endif
184#ifdef WITH_LB
185  fprintf(stderr, "loadbalancing ");
186#endif
187#ifdef LCDSUPPORT
188  fprintf(stderr, "lcd ");
189#endif
190  fprintf(stderr, "\n\tinbuilt protocols: ");
191#ifdef MODULE_CAMD33
192  fprintf(stderr, "camd33 ");
193#endif
194#ifdef MODULE_CAMD35
195  fprintf(stderr, "camd35_udp ");
196#endif
197#ifdef MODULE_CAMD35_TCP
198  fprintf(stderr, "camd35_tcp ");
199#endif
200#ifdef MODULE_NEWCAMD
201  fprintf(stderr, "newcamd ");
202#endif
203#ifdef MODULE_CCCAM
204  fprintf(stderr, "cccam ");
205#endif
206#ifdef MODULE_GBOX
207  fprintf(stderr, "gbox ");
208#endif
209#ifdef MODULE_RADEGAST
210  fprintf(stderr, "radegast ");
211#endif
212#ifdef MODULE_SERIAL
213  fprintf(stderr, "serial ");
214#endif
215#ifdef MODULE_CONSTCW
216  fprintf(stderr, "constcw ");
217#endif
218  fprintf(stderr, "\n\tinbuilt cardreaders: ");
219#ifdef READER_NAGRA
220  fprintf(stderr, "nagra ");
221#endif
222#ifdef READER_IRDETO
223  fprintf(stderr, "irdeto ");
224#endif
225#ifdef READER_CONAX
226  fprintf(stderr, "conax ");
227#endif
228#ifdef READER_CRYPTOWORKS
229  fprintf(stderr, "cryptoworks ");
230#endif
231#ifdef READER_SECA
232  fprintf(stderr, "seca ");
233#endif
234#ifdef READER_VIACCESS
235  fprintf(stderr, "viaccess ");
236#endif
237#ifdef READER_VIDEOGUARD
238  fprintf(stderr, "videoguard ");
239#endif
240#ifdef READER_DRE
241  fprintf(stderr, "dre ");
242#endif
243#ifdef READER_TONGFANG
244  fprintf(stderr, "tongfang ");
245#endif
246  fprintf(stderr, "\n\n");
247  fprintf(stderr, "oscam [-b] [-s] [-c <config dir>] [-t <tmp dir>] [-d <level>] [-r <level>] [-h]");
248  fprintf(stderr, "\n\n\t-b         : start in background\n");
249  fprintf(stderr, "\t-s         : capture segmentation faults\n");
250  fprintf(stderr, "\t-c <dir>   : read configuration from <dir>\n");
251  fprintf(stderr, "\t             default = %s\n", CS_CONFDIR);
252  fprintf(stderr, "\t-t <dir>   : tmp dir <dir>\n");
253#ifdef CS_CYGWIN32
254  fprintf(stderr, "\t             default = (OS-TMP)\n");
255#else
256  fprintf(stderr, "\t             default = /tmp/.oscam\n");
257#endif
258  fprintf(stderr, "\t-d <level> : debug level mask\n");
259  fprintf(stderr, "\t               0 = no debugging (default)\n");
260  fprintf(stderr, "\t               1 = detailed error messages\n");
261  fprintf(stderr, "\t               2 = ATR parsing info, ECM, EMM and CW dumps\n");
262  fprintf(stderr, "\t               4 = traffic from/to the reader\n");
263  fprintf(stderr, "\t               8 = traffic from/to the clients\n");
264  fprintf(stderr, "\t              16 = traffic to the reader-device on IFD layer\n");
265  fprintf(stderr, "\t              32 = traffic to the reader-device on I/O layer\n");
266  fprintf(stderr, "\t              64 = EMM logging\n");
267  fprintf(stderr, "\t             128 = DVBAPI logging\n");
268  fprintf(stderr, "\t             255 = debug all\n");
269#ifdef WEBIF
270  fprintf(stderr, "\t-r <level> : restart level\n");
271  fprintf(stderr, "\t               0 = disabled, restart request sets exit status 99\n");
272  fprintf(stderr, "\t               1 = restart activated, web interface can restart oscam (default)\n");
273  fprintf(stderr, "\t               2 = like 1, but also restart on segmentation faults\n");
274#endif
275  fprintf(stderr, "\t-h         : show this help\n");
276  fprintf(stderr, "\n");
277  exit(1);
278}
279
280#ifdef NEED_DAEMON
281#ifdef OS_MACOSX
282// this is done because daemon is being deprecated starting with 10.5 and -Werror will always trigger an error
283static int32_t daemon_compat(int32_t nochdir, int32_t noclose)
284#else
285static int32_t daemon(int32_t nochdir, int32_t noclose)
286#endif
287{
288  int32_t fd;
289
290  switch (fork())
291  {
292    case -1: return (-1);
293    case 0:  break;
294    default: _exit(0);
295  }
296
297  if (setsid()==(-1))
298    return(-1);
299
300  if (!nochdir)
301    (void)chdir("/");
302
303  if (!noclose && (fd=open("/dev/null", O_RDWR, 0)) != -1)
304  {
305    (void)dup2(fd, STDIN_FILENO);
306    (void)dup2(fd, STDOUT_FILENO);
307    (void)dup2(fd, STDERR_FILENO);
308    if (fd>2)
309      (void)close(fd);
310  }
311  return(0);
312}
313#endif
314
315int32_t recv_from_udpipe(uchar *buf)
316{
317  uint16_t n;
318  if (buf[0]!='U')
319  {
320    cs_log("INTERNAL PIPE-ERROR");
321    cs_exit(1);
322  }
323  memcpy(&n, buf+1, 2);
324
325  memmove(buf, buf+3, n);
326
327  return n;
328}
329
330/* Returns the username from the client. You will always get a char reference back (no NULLs but it may be string containting "NULL")
331   which you should never modify and not free()! */
332char *username(struct s_client * client)
333{
334    if (!client)
335        return "NULL";
336
337    if (client->typ == 's' || client->typ == 'h' || client->typ == 'a')
338    {
339        return processUsername?processUsername:"NULL";
340    }
341
342    if (client->typ == 'c' || client->typ == 'm') {
343        struct s_auth *acc = client->account;
344        if(acc)
345        {
346            if (acc->usr[0])
347                return acc->usr;
348            else
349                return "anonymous";
350        }
351        else
352        {
353            return "NULL";
354        }
355    } else if (client->typ == 'r' || client->typ == 'p'){
356        struct s_reader *rdr = client->reader;
357        if(rdr)
358            return rdr->label;
359    }
360    return "NULL";
361}
362
363static struct s_client * idx_from_ip(in_addr_t ip, in_port_t port)
364{
365  struct s_client *cl;
366  for (cl=first_client; cl ; cl=cl->next)
367    if ((cl->ip==ip) && (cl->port==port) && ((cl->typ=='c') || (cl->typ=='m')))
368      return cl;
369  return NULL;
370}
371
372struct s_client * get_client_by_tid(uint32_t tid) //FIXME untested!! no longer pid in output...
373{
374  struct s_client *cl;
375  for (cl=first_client; cl ; cl=cl->next)
376    if ((uint32_t)(cl->thread)==tid)
377      return cl;
378  return NULL;
379}
380
381static int32_t chk_caid(uint16_t caid, CAIDTAB *ctab)
382{
383  int32_t n;
384  int32_t rc;
385  for (rc=(-1), n=0; (n<CS_MAXCAIDTAB) && (rc<0); n++)
386    if ((caid & ctab->mask[n]) == ctab->caid[n])
387      rc=ctab->cmap[n] ? ctab->cmap[n] : caid;
388  return(rc);
389}
390
391int32_t chk_bcaid(ECM_REQUEST *er, CAIDTAB *ctab)
392{
393  int32_t caid;
394  if ((caid=chk_caid(er->caid, ctab))<0)
395    return(0);
396  er->caid=caid;
397  return(1);
398}
399
400#ifdef WEBIF
401void clear_account_stats(struct s_auth *account)
402{
403  account->cwfound = 0;
404  account->cwcache = 0;
405  account->cwnot = 0;
406  account->cwtun = 0;
407  account->cwignored  = 0;
408  account->cwtout = 0;
409  account->emmok = 0;
410  account->emmnok = 0;
411}
412
413void clear_all_account_stats()
414{
415  struct s_auth *account = cfg.account;
416  while (account) {
417    clear_account_stats(account);
418    account = account->next;
419  }
420}
421
422void clear_system_stats()
423{
424  first_client->cwfound = 0;
425  first_client->cwcache = 0;
426  first_client->cwnot = 0;
427  first_client->cwtun = 0;
428  first_client->cwignored  = 0;
429  first_client->cwtout = 0;
430  first_client->emmok = 0;
431  first_client->emmnok = 0;
432}
433#endif
434
435void cs_accounts_chk()
436{
437  struct s_auth *old_accounts = cfg.account;
438  struct s_auth *new_accounts = init_userdb();
439  struct s_auth *account1,*account2;
440  for (account1=cfg.account; account1; account1=account1->next) {
441    for (account2=new_accounts; account2; account2=account2->next) {
442      if (!strcmp(account1->usr, account2->usr)) {
443        account2->cwfound = account1->cwfound;
444        account2->cwcache = account1->cwcache;
445        account2->cwnot = account1->cwnot;
446        account2->cwtun = account1->cwtun;
447        account2->cwignored  = account1->cwignored;
448        account2->cwtout = account1->cwtout;
449        account2->emmok = account1->emmok;
450        account2->emmnok = account1->emmnok;
451        account2->firstlogin = account1->firstlogin;
452#ifdef CS_ANTICASC
453        account2->ac_users = account1->ac_users;
454        account2->ac_penalty = account1->ac_penalty;
455        account2->ac_stat = account1->ac_stat;
456#endif
457      }
458    }
459  }
460  cs_reinit_clients(new_accounts);
461  cfg.account = new_accounts;
462  init_free_userdb(old_accounts);
463
464#ifdef CS_ANTICASC
465  ac_clear();
466#endif
467}
468
469void nullclose(int32_t *fd)
470{
471    //if closing an already closed pipe, we get a sigpipe signal, and this causes a cs_exit
472    //and this causes a close and this causes a sigpipe...and so on
473    int32_t f = *fd;
474    *fd = 0; //so first null client-fd
475    close(f); //then close fd
476}
477
478static void cleanup_ecmtasks(struct s_client *cl)
479{
480        if (!cl->ecmtask)
481                return;
482
483        int32_t i, n=(ph[cl->ctyp].multi)?CS_MAXPENDING:1;
484        ECM_REQUEST *ecm;
485        for (i=0; i<n; i++) {
486                ecm = &cl->ecmtask[i];
487                ll_destroy(ecm->matching_rdr); //no need to garbage this
488                ecm->matching_rdr=NULL;
489        }
490        add_garbage(cl->ecmtask);
491}
492
493void cleanup_thread(void *var)
494{
495    struct s_client *cl = var;
496    if(cl && !cl->cleaned){ //cleaned=0
497        cl->cleaned++; //cleaned=1
498       
499#ifdef MODULE_CCCAM
500        if(cl->typ == 'c'){
501            struct cc_data *cc = cl->cc;
502            if (cc) cc->mode = CCCAM_MODE_SHUTDOWN;
503        }
504#endif
505
506        //kill_thread also removes this client, so here just to get sure client is removed:
507        struct s_client *prev, *cl2;
508        cs_lock(&clientlist_lock);
509        for (prev=first_client, cl2=first_client->next; prev->next != NULL; prev=prev->next, cl2=cl2->next)
510            if (cl == cl2)
511                break;
512        if (cl == cl2)
513            prev->next = cl2->next; //remove client from list
514        cs_unlock(&clientlist_lock);
515
516        cs_sleepms(500); //just wait a bit that really really nobody is accessing client data
517
518        if(cl->typ == 'c' && ph[cl->ctyp].cleanup)
519            ph[cl->ctyp].cleanup(cl);
520        else if (cl->reader && cl->reader->ph.cleanup)
521            cl->reader->ph.cleanup(cl);
522      if(cl->typ == 'c'){
523        cs_statistics(cl);
524        cl->last_caid = 0xFFFF;
525        cl->last_srvid = 0xFFFF;
526        cs_statistics(cl);
527      }
528
529        if(cl->pfd) nullclose(&cl->pfd); //Closing Network socket
530        int32_t rc, fd_m2c = cl->fd_m2c, fd_m2c_c = cl->fd_m2c_c;
531        if(fd_m2c_c){
532            cl->fd_m2c_c = 0;
533            cl->fd_m2c = 0;
534            cs_sleepms(5);      // make sure no other thread is currently writing...
535            struct pollfd pfd2[1];
536            pfd2[0].fd = fd_m2c_c;
537            pfd2[0].events = (POLLIN | POLLPRI);
538            uchar *ptr;
539            while ((rc = poll(pfd2, 1, 5)) != 0){
540                if(rc == -1){
541                    if(errno == EINTR)
542                        continue;
543                    else
544                        break;
545                }
546                int32_t pipeCmd = read_from_pipe(fd_m2c_c, &ptr);
547                if (ptr) free(ptr);
548                if (pipeCmd==PIP_ID_ERR || pipeCmd==PIP_ID_NUL)
549                    break;
550            }
551        }
552        if(fd_m2c) close(fd_m2c);   //Closing master write fd
553        if(fd_m2c_c) close(fd_m2c_c);   //Closing client read fd
554
555        if(cl->typ == 'r' && cl->reader){
556            // Maybe we also need a "nullclose" mechanism here...
557            ICC_Async_Close(cl->reader);
558        }
559        if (cl->reader) {
560            cl->reader->client = NULL;
561            cl->reader = NULL;
562        }
563        cleanup_ecmtasks(cl);
564        add_garbage(cl->emmcache);
565        add_garbage(cl->req);
566#ifdef MODULE_CCCAM
567        add_garbage(cl->cc);
568#endif
569        add_garbage(cl->serialdata);
570        cl->cleaned++;//cleaned=2
571        add_garbage(cl);
572        cs_cleanlocks();
573    }
574}
575
576static void cs_cleanup()
577{
578#ifdef WITH_LB
579    if (cfg.lb_mode && cfg.lb_save) {
580        save_stat_to_file(0);
581        cfg.lb_save = 0; //this is for avoiding duplicate saves
582    }
583#endif
584
585#ifdef MODULE_CCCAM
586    done_share();
587#endif
588
589    //cleanup clients:
590    struct s_client *cl;
591    for (cl=first_client->next; cl; cl=cl->next) {
592        if (cl->typ=='c'){
593            if(cl->account && cl->account->usr)
594                cs_log("killing client %s", cl->account->usr);
595            kill_thread(cl);
596        }
597    }
598
599    //cleanup readers:
600    struct s_reader *rdr;
601    for (rdr=first_active_reader; rdr ; rdr=rdr->next) {
602        cs_log("killing reader %s", rdr->label);
603        kill_thread(rdr->client);
604    }
605    first_active_reader = NULL;
606
607    init_free_userdb(cfg.account);
608    cfg.account = NULL;
609    init_free_sidtab();
610}
611
612/*
613 * flags: 1 = restart, 2 = don't modify if SIG_IGN, may be combined
614 */
615void set_signal_handler(int32_t sig, int32_t flags, void (*sighandler))
616{
617#ifdef CS_SIGBSD
618  if ((signal(sig, sighandler)==SIG_IGN) && (flags & 2))
619  {
620    signal(sig, SIG_IGN);
621    siginterrupt(sig, 0);
622  }
623  else
624    siginterrupt(sig, (flags & 1) ? 0 : 1);
625#else
626  struct sigaction sa;
627  sigaction(sig, (struct sigaction *) 0, &sa);
628  if (!((flags & 2) && (sa.sa_handler==SIG_IGN)))
629  {
630    sigemptyset(&sa.sa_mask);
631    sa.sa_flags=(flags & 1) ? SA_RESTART : 0;
632    sa.sa_handler=sighandler;
633    sigaction(sig, &sa, (struct sigaction *) 0);
634  }
635#endif
636}
637
638static void cs_master_alarm()
639{
640  cs_log("PANIC: master deadlock!");
641  fprintf(stderr, "PANIC: master deadlock!");
642  fflush(stderr);
643}
644
645static void cs_sigpipe()
646{
647    if (cs_dblevel & D_ALL_DUMP)
648        cs_log("Got sigpipe signal -> captured");
649}
650
651/* Switch debuglevel forward one step (called when receiving SIGUSR1). */
652void cs_debug_level(){ 
653    switch (cs_dblevel) {
654        case 0:
655            cs_dblevel = 1;
656            break;
657        case 128:
658            cs_dblevel = 255;
659            break;
660        case 255:
661            cs_dblevel = 0;
662            break;
663        default:
664            cs_dblevel <<= 1;
665    }
666
667    cs_log("debug_level=%d", cs_dblevel);
668}
669
670void cs_card_info()
671{
672  uchar dummy[1]={0x00};
673    struct s_client *cl;
674    for (cl=first_client->next; cl ; cl=cl->next)
675    if( cl->typ=='r' && cl->fd_m2c )
676      write_to_pipe(cl->fd_m2c, PIP_ID_CIN, dummy, 1);
677      //kill(client[i].pid, SIGUSR2);
678}
679
680/**
681 * called by signal SIGHUP
682 *
683 * reloads configs:
684 *  - useraccounts (oscam.user)
685 *  - services ids (oscam.srvid)
686 *  - tier ids     (oscam.tiers)
687 *  Also clears anticascading stats.
688 **/
689void cs_reload_config()
690{
691        cs_accounts_chk();
692        init_srvid();
693        init_tierid();
694        #ifdef CS_ANTICASC
695        ac_init_stat();
696        #endif
697}
698
699/* Sets signal handlers to ignore for early startup of OSCam because for example log
700   could cause SIGPIPE errors and the normal signal handlers can't be used at this point. */
701static void init_signal_pre()
702{
703        set_signal_handler(SIGPIPE , 1, SIG_IGN);
704        set_signal_handler(SIGWINCH, 1, SIG_IGN);
705        set_signal_handler(SIGALRM , 1, SIG_IGN);
706        set_signal_handler(SIGHUP  , 1, SIG_IGN);
707}
708
709/* Sets the signal handlers.*/
710static void init_signal()
711{
712        set_signal_handler(SIGINT, 3, cs_exit);
713        //set_signal_handler(SIGKILL, 3, cs_exit);
714#ifdef OS_MACOSX
715        set_signal_handler(SIGEMT, 3, cs_exit);
716#else
717        //set_signal_handler(SIGPOLL, 3, cs_exit);
718#endif
719        //set_signal_handler(SIGPROF, 3, cs_exit);
720        set_signal_handler(SIGTERM, 3, cs_exit);
721        //set_signal_handler(SIGVTALRM, 3, cs_exit);
722
723        set_signal_handler(SIGWINCH, 1, SIG_IGN);
724        //  set_signal_handler(SIGPIPE , 0, SIG_IGN);
725        set_signal_handler(SIGPIPE , 0, cs_sigpipe);
726        //  set_signal_handler(SIGALRM , 0, cs_alarm);
727        set_signal_handler(SIGALRM , 0, cs_master_alarm);
728        // set_signal_handler(SIGCHLD , 1, cs_child_chk);
729        set_signal_handler(SIGHUP  , 1, cs_reload_config);
730        //set_signal_handler(SIGHUP , 1, cs_sighup);
731        set_signal_handler(SIGUSR1, 1, cs_debug_level);
732        set_signal_handler(SIGUSR2, 1, cs_card_info);
733        set_signal_handler(SIGCONT, 1, SIG_IGN);
734
735        if (cs_capture_SEGV)
736            set_signal_handler(SIGSEGV, 1, cs_exit);
737
738        cs_log("signal handling initialized (type=%s)",
739#ifdef CS_SIGBSD
740        "bsd"
741#else
742        "sysv"
743#endif
744        );
745    return;
746}
747
748void cs_exit(int32_t sig)
749{
750    char targetfile[256];
751
752    set_signal_handler(SIGCHLD, 1, SIG_IGN);
753    set_signal_handler(SIGHUP , 1, SIG_IGN);
754    set_signal_handler(SIGPIPE, 1, SIG_IGN);
755
756    if (sig==SIGALRM) {
757        cs_debug_mask(D_TRACE, "thread %8X: SIGALRM, skipping", pthread_self());
758        return;
759    }
760
761  if (sig && (sig!=SIGQUIT))
762    cs_log("thread %8X exit with signal %d", pthread_self(), sig);
763
764  struct s_client *cl = cur_client();
765  if (!cl)
766    return;
767
768  switch(cl->typ)
769  {
770    case 'c':
771        cs_statistics(cl);
772        cl->last_caid = 0xFFFF;
773        cl->last_srvid = 0xFFFF;
774        cs_statistics(cl);
775        break;
776
777    case 'm': break;
778    case 'r': break; //reader-cleanup now in cleanup_thread()
779
780    case 'h':
781    case 's':
782#ifdef CS_LED
783    cs_switch_led(LED1B, LED_OFF);
784    cs_switch_led(LED2, LED_OFF);
785    cs_switch_led(LED3, LED_OFF);
786    cs_switch_led(LED1A, LED_ON);
787#endif
788#ifdef QBOXHD_LED
789    qboxhd_led_blink(QBOXHD_LED_COLOR_YELLOW,QBOXHD_LED_BLINK_FAST);
790    qboxhd_led_blink(QBOXHD_LED_COLOR_RED,QBOXHD_LED_BLINK_FAST);
791    qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN,QBOXHD_LED_BLINK_FAST);
792    qboxhd_led_blink(QBOXHD_LED_COLOR_BLUE,QBOXHD_LED_BLINK_FAST);
793    qboxhd_led_blink(QBOXHD_LED_COLOR_MAGENTA,QBOXHD_LED_BLINK_FAST);
794#endif
795#ifdef LCDSUPPORT
796    end_lcd_thread();
797#endif
798
799#ifndef OS_CYGWIN32
800    snprintf(targetfile, 255, "%s%s", get_tmp_dir(), "/oscam.version");
801    if (unlink(targetfile) < 0)
802        cs_log("cannot remove oscam version file %s (errno=%d %s)", targetfile, errno, strerror(errno));
803#endif
804#ifdef COOL
805    coolapi_close_all();
806#endif
807    break;
808  }
809
810    // this is very important - do not remove
811    if (cl->typ != 's') {
812        cs_log("thread %8X ended!", pthread_self());
813        //Restore signals before exiting thread
814        set_signal_handler(SIGPIPE , 0, cs_sigpipe);
815        set_signal_handler(SIGHUP  , 1, cs_reload_config);
816
817        pthread_exit(NULL);
818        return;
819    }
820
821    cs_log("cardserver down");
822    cs_close_log();
823
824    if (sig == SIGINT)
825        exit(sig);
826
827    cs_cleanup();
828
829    if (!exit_oscam)
830      exit_oscam = sig?sig:1;
831}
832
833void cs_reinit_clients(struct s_auth *new_accounts)
834{
835    struct s_auth *account;
836    unsigned char md5tmp[MD5_DIGEST_LENGTH];
837
838    struct s_client *cl;
839    for (cl=first_client->next; cl ; cl=cl->next)
840        if( (cl->typ == 'c' || cl->typ == 'm') && cl->account ) {
841            for (account = new_accounts; (account) ; account = account->next)
842                if (!strcmp(cl->account->usr, account->usr))
843                    break;
844
845            if (account && !account->disabled && cl->pcrc == crc32(0L, MD5((uchar *)account->pwd, strlen(account->pwd), md5tmp), MD5_DIGEST_LENGTH)) {
846                cl->account = account;
847                if(cl->typ == 'c'){
848                    cl->grp = account->grp;
849                    cl->aureader_list   = account->aureader_list;
850                    cl->autoau = account->autoau;
851                    cl->expirationdate = account->expirationdate;
852                    cl->allowedtimeframe[0] = account->allowedtimeframe[0];
853                    cl->allowedtimeframe[1] = account->allowedtimeframe[1];
854                    cl->ncd_keepalive = account->ncd_keepalive;
855                    cl->c35_suppresscmd08 = account->c35_suppresscmd08;
856                    cl->tosleep = (60*account->tosleep);
857                    cl->c35_sleepsend = account->c35_sleepsend;
858                    cl->monlvl = account->monlvl;
859                    cl->disabled    = account->disabled;
860                    cl->fchid   = account->fchid;  // CHID filters
861                    cl->cltab   = account->cltab;  // Class
862                    // newcamd module doesn't like ident reloading
863                    if(!cl->ncd_server)
864                        cl->ftab = account->ftab;   // Ident
865
866                    cl->sidtabok = account->sidtabok;   // services
867                    cl->sidtabno = account->sidtabno;   // services
868                    cl->failban = account->failban;
869
870                    memcpy(&cl->ctab, &account->ctab, sizeof(cl->ctab));
871                    memcpy(&cl->ttab, &account->ttab, sizeof(cl->ttab));
872
873                    int32_t i;
874                    for(i = 0; i < CS_ECM_RINGBUFFER_MAX; i++)
875                        cl->cwlastresptimes[i] = 0;
876                    cl->cwlastresptimes_last = 0;
877                    if (account->uniq)
878                        cs_fake_client(cl, account->usr, (account->uniq == 1 || account->uniq == 2)?account->uniq+2:account->uniq, cl->ip);
879#ifdef CS_ANTICASC
880                    cl->ac_limit    = (account->ac_users * 100 + 80) * cfg.ac_stime;
881#endif
882                }
883            } else {
884                if (ph[cl->ctyp].type & MOD_CONN_NET) {
885                    cs_debug_mask(D_TRACE, "client '%s', thread=%8X not found in db (or password changed)", cl->account->usr, cl->thread);
886                    kill_thread(cl);
887                } else {
888                    cl->account = first_client->account;
889                }
890            }
891        } else {
892            cl->account = NULL;
893        }
894}
895
896
897struct s_client * create_client(in_addr_t ip) {
898    struct s_client *cl;
899
900    if(cs_malloc(&cl, sizeof(struct s_client), -1)){
901        int32_t fdp[2];
902        if (pipe(fdp)) {
903            cs_log("Cannot create pipe (errno=%d: %s)", errno, strerror(errno));
904            free(cl);
905            return NULL;
906        }
907        //client part
908
909        //make_non_blocking(fdp[0]);
910        //make_non_blocking(fdp[1]);
911        cl->fd_m2c_c = fdp[0]; //store client read fd
912        cl->fd_m2c = fdp[1]; //store master write fd
913        cl->ip=ip;
914        cl->account = first_client->account;
915
916        //master part
917        cl->stat=1;
918        cl->mutexstore = NULL;
919        cl->mutexstore_alloc = 0;
920    cl->mutexstore_used = 0;
921
922        cl->login=cl->last=time((time_t *)0);
923
924        //Now add new client to the list:
925        struct s_client *last;
926        cs_lock(&clientlist_lock);
927        for (last=first_client; last->next != NULL; last=last->next); //ends with cl on last client
928        last->next = cl;
929        cs_unlock(&clientlist_lock);
930    } else {
931        cs_log("max connections reached (out of memory) -> reject client %s", cs_inet_ntoa(ip));
932        return NULL;
933    }
934    return(cl);
935}
936
937
938/* Creates the master client of OSCam and inits some global variables/mutexes. */
939static void init_first_client()
940{
941    // get username OScam is running under
942    struct passwd pwd;
943    char buf[256];
944    struct passwd *pwdbuf;
945    if ((getpwuid_r(getuid(), &pwd, buf, sizeof(buf), &pwdbuf)) == 0){
946        if(cs_malloc(&processUsername, strlen(pwd.pw_name) + 1, -1))
947            cs_strncpy(processUsername, pwd.pw_name, strlen(pwd.pw_name) + 1);
948        else
949            processUsername = "root";
950    } else
951        processUsername = "root";
952
953  //Generate 5 ECM cache entries:
954  ecmcache = ll_create();
955
956  if(!cs_malloc(&first_client, sizeof(struct s_client), -1)){
957    fprintf(stderr, "Could not allocate memory for master client, exiting...");
958    exit(1);
959  }
960  memset(first_client, 0, sizeof(struct s_auth));
961  first_client->next = NULL; //terminate clients list with NULL
962  first_client->login=time((time_t *)0);
963  first_client->ip=cs_inet_addr("127.0.0.1");
964  first_client->typ='s';
965  first_client->thread=pthread_self();
966  struct s_auth *null_account;
967  if(!cs_malloc(&null_account, sizeof(struct s_auth), -1)){
968    fprintf(stderr, "Could not allocate memory for master account, exiting...");
969    exit(1);
970  }
971  first_client->account = null_account;
972  if (pthread_setspecific(getclient, first_client)) {
973    fprintf(stderr, "Could not setspecific getclient in master process, exiting...");
974    exit(1);
975  }
976
977    int8_t ok = 1;
978  if(pthread_mutex_init(&gethostbyname_lock, NULL)) ok = 0;
979  if(pthread_mutex_init(&get_cw_lock, NULL)) ok = 0;
980  if(pthread_mutex_init(&system_lock, NULL)) ok = 0;
981  if(pthread_mutex_init(&clientlist_lock, NULL)) ok = 0;
982  if(pthread_mutex_init(&readerlist_lock, NULL)) ok = 0;
983  if(pthread_mutex_init(&fakeuser_lock, NULL)) ok = 0;
984  if(pthread_mutex_init(&sc8in1_lock, NULL)) ok = 0;
985  if(!ok){
986    fprintf(stderr, "Could not init locks, exiting...");
987    exit(1);
988  }
989
990#ifdef COOL
991  coolapi_open_all();
992#endif
993}
994
995/* Checks if the date of the system is correct and waits if necessary. */
996static void init_check(){
997    char *ptr = __DATE__;
998    int32_t month, year = atoi(ptr + strlen(ptr) - 4), day = atoi(ptr + 4);
999    if(day > 0 && day < 32 && year > 2010 && year < 9999){
1000        struct tm timeinfo;
1001        char months[12][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
1002        for(month = 0; month < 12; ++month){
1003            if(!strncmp(ptr, months[month], 3)) break;
1004        }
1005        if(month > 11) month = 0;
1006        memset(&timeinfo, 0, sizeof(timeinfo));
1007        timeinfo.tm_mday = day;
1008        timeinfo.tm_mon = month;
1009        timeinfo.tm_year = year - 1900;
1010        time_t builddate = mktime(&timeinfo) - 86400;
1011      int32_t i = 0;
1012      while(time((time_t)0) < builddate){
1013        cs_log("The current system time is smaller than the build date (%s). Waiting 5s for time to correct...", ptr);
1014        cs_sleepms(5000);
1015        ++i;
1016        if(i > 12){
1017            cs_log("Waiting was not successful. OSCam will be started but is UNSUPPORTED this way. Do not report any errors with this version.");
1018                break;
1019        }
1020      }
1021      // adjust login time of first client
1022      if(i > 0) first_client->login=time((time_t *)0);
1023    }
1024}
1025
1026static int32_t start_listener(struct s_module *ph, int32_t port_idx)
1027{
1028  int32_t ov=1, timeout, is_udp, i;
1029  char ptxt[2][32];
1030  struct   sockaddr_in sad;     /* structure to hold server's address */
1031
1032  ptxt[0][0]=ptxt[1][0]='\0';
1033  if (!ph->ptab->ports[port_idx].s_port)
1034  {
1035    cs_log("%s: disabled", ph->desc);
1036    return(0);
1037  }
1038  is_udp=(ph->type==MOD_CONN_UDP);
1039
1040  memset((char  *)&sad,0,sizeof(sad)); /* clear sockaddr structure   */
1041  sad.sin_family = AF_INET;            /* set family to Internet     */
1042  if (!ph->s_ip)
1043    ph->s_ip=cfg.srvip;
1044  if (ph->s_ip)
1045  {
1046    sad.sin_addr.s_addr=ph->s_ip;
1047    snprintf(ptxt[0], sizeof(ptxt[0]), ", ip=%s", inet_ntoa(sad.sin_addr));
1048  }
1049  else
1050    sad.sin_addr.s_addr=INADDR_ANY;
1051  timeout=cfg.bindwait;
1052  //ph->fd=0;
1053  ph->ptab->ports[port_idx].fd = 0;
1054
1055  if (ph->ptab->ports[port_idx].s_port > 0)   /* test for illegal value    */
1056    sad.sin_port = htons((uint16_t)ph->ptab->ports[port_idx].s_port);
1057  else
1058  {
1059    cs_log("%s: Bad port %d", ph->desc, ph->ptab->ports[port_idx].s_port);
1060    return(0);
1061  }
1062
1063  if ((ph->ptab->ports[port_idx].fd=socket(PF_INET,is_udp ? SOCK_DGRAM : SOCK_STREAM, is_udp ? IPPROTO_UDP : IPPROTO_TCP))<0)
1064  {
1065    cs_log("%s: Cannot create socket (errno=%d: %s)", ph->desc, errno, strerror(errno));
1066    return(0);
1067  }
1068
1069  ov=1;
1070  if (setsockopt(ph->ptab->ports[port_idx].fd, SOL_SOCKET, SO_REUSEADDR, (void *)&ov, sizeof(ov))<0)
1071  {
1072    cs_log("%s: setsockopt failed (errno=%d: %s)", ph->desc, errno, strerror(errno));
1073    close(ph->ptab->ports[port_idx].fd);
1074    return(ph->ptab->ports[port_idx].fd=0);
1075  }
1076
1077#ifdef SO_REUSEPORT
1078  setsockopt(ph->ptab->ports[port_idx].fd, SOL_SOCKET, SO_REUSEPORT, (void *)&ov, sizeof(ov));
1079#endif
1080
1081#ifdef SO_PRIORITY
1082  if (cfg.netprio)
1083    if (!setsockopt(ph->ptab->ports[port_idx].fd, SOL_SOCKET, SO_PRIORITY, (void *)&cfg.netprio, sizeof(uint32_t)))
1084      snprintf(ptxt[1], sizeof(ptxt[1]), ", prio=%d", cfg.netprio);
1085#endif
1086
1087  if( !is_udp )
1088  {
1089    int32_t keep_alive = 1;
1090    setsockopt(ph->ptab->ports[port_idx].fd, SOL_SOCKET, SO_KEEPALIVE,
1091               (void *)&keep_alive, sizeof(keep_alive));
1092  }
1093
1094  while (timeout--)
1095  {
1096    if (bind(ph->ptab->ports[port_idx].fd, (struct sockaddr *)&sad, sizeof (sad))<0)
1097    {
1098      if (timeout)
1099      {
1100        cs_log("%s: Bind request failed, waiting another %d seconds",
1101               ph->desc, timeout);
1102        cs_sleepms(1000);
1103      }
1104      else
1105      {
1106        cs_log("%s: Bind request failed, giving up", ph->desc);
1107        close(ph->ptab->ports[port_idx].fd);
1108        return(ph->ptab->ports[port_idx].fd=0);
1109      }
1110    }
1111    else timeout=0;
1112  }
1113
1114  if (!is_udp)
1115    if (listen(ph->ptab->ports[port_idx].fd, CS_QLEN)<0)
1116    {
1117      cs_log("%s: Cannot start listen mode (errno=%d: %s)", ph->desc, errno, strerror(errno));
1118      close(ph->ptab->ports[port_idx].fd);
1119      return(ph->ptab->ports[port_idx].fd=0);
1120    }
1121
1122  cs_log("%s: initialized (fd=%d, port=%d%s%s%s)",
1123         ph->desc, ph->ptab->ports[port_idx].fd,
1124         ph->ptab->ports[port_idx].s_port,
1125         ptxt[0], ptxt[1], ph->logtxt ? ph->logtxt : "");
1126
1127  for( i=0; i<ph->ptab->ports[port_idx].ftab.nfilts; i++ ) {
1128    int32_t j;
1129    cs_log("CAID: %04X", ph->ptab->ports[port_idx].ftab.filts[i].caid );
1130    for( j=0; j<ph->ptab->ports[port_idx].ftab.filts[i].nprids; j++ )
1131      cs_log("provid #%d: %06X", j, ph->ptab->ports[port_idx].ftab.filts[i].prids[j]);
1132  }
1133  return(ph->ptab->ports[port_idx].fd);
1134}
1135
1136/* Resolves the ip of the hostname of the specified account and saves it in account->dynip.
1137   If the hostname is not configured, the ip is set to 0. */
1138void cs_user_resolve(struct s_auth *account){
1139    if (account->dyndns[0]){
1140        in_addr_t lastip = account->dynip;
1141        account->dynip = cs_getIPfromHost((char*)account->dyndns);
1142       
1143        if (lastip != account->dynip)  {
1144            cs_log("%s: resolved ip=%s", (char*)account->dyndns, cs_inet_ntoa(account->dynip));
1145        }
1146    } else account->dynip=0;
1147}
1148
1149#pragma GCC diagnostic ignored "-Wempty-body"
1150void *clientthread_init(void * init){
1151    struct s_clientinit clientinit;
1152    memcpy(&clientinit, init, sizeof(struct s_clientinit)); //copy to stack to free init pointer
1153    free(init);
1154    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
1155    pthread_setspecific(getclient, clientinit.client);
1156    pthread_cleanup_push(cleanup_thread, (void *) clientinit.client);
1157    clientinit.handler(clientinit.client);
1158    pthread_cleanup_pop(1);
1159    return NULL;
1160}
1161#pragma GCC diagnostic warning "-Wempty-body"
1162
1163/* Starts a thread named nameroutine with the start function startroutine. */
1164void start_thread(void * startroutine, char * nameroutine) {
1165    pthread_t temp;
1166    pthread_attr_t attr;
1167    pthread_attr_init(&attr);
1168#ifndef TUXBOX
1169    pthread_attr_setstacksize(&attr, PTHREAD_STACK_SIZE);
1170#endif
1171    cs_lock(&system_lock);
1172    if (pthread_create(&temp, &attr, startroutine, NULL))
1173        cs_log("ERROR: can't create %s thread", nameroutine);
1174    else {
1175        cs_log("%s thread started", nameroutine);
1176        pthread_detach(temp);
1177    }
1178    pthread_attr_destroy(&attr);
1179    cs_unlock(&system_lock);
1180}
1181
1182/* Allows to kill another thread specified through the client cl without locking.
1183  If the own thread has to be cancelled, cs_exit or cs_disconnect_client has to be used. */
1184static void kill_thread_int(struct s_client *cl) {
1185
1186    if (!cl) return;
1187    pthread_t thread = cl->thread;
1188    if (pthread_equal(thread, pthread_self())) return; //cant kill yourself
1189
1190    struct s_client *prev, *cl2;
1191    cs_lock(&clientlist_lock);
1192    for (prev=first_client, cl2=first_client->next; prev->next != NULL; prev=prev->next, cl2=cl2->next)
1193        if (cl == cl2)
1194            break;
1195    if (cl != cl2)
1196        cs_log("FATAL ERROR: could not find client to remove from list.");
1197    else
1198        prev->next = cl2->next; //remove client from list
1199    cs_unlock(&clientlist_lock);
1200
1201    pthread_cancel(thread);
1202    pthread_join(thread, NULL);
1203    int32_t cnt = 0;
1204    while(cnt < 10 && cl && cl->cleaned < 2){
1205        cs_sleepms(50);
1206        ++cnt;
1207    }
1208    if(!exit_oscam && cl && !cl->cleaned){
1209        cs_log("A thread didn't cleanup itself for type %c (%s,%s)", cl->typ, cl->reader?cl->reader->label : cl->account?cl->account->usr?cl->account->usr: "" : "", cl->ip ? cs_inet_ntoa(cl->ip) : "");
1210        //Schlocke: Sometimes on high load a cleanup could take up to 10seconds! so if this took so long, double cleanups causes segfaults!
1211        //So only log it, but do NOT call cleanup_thread() !!
1212        //cleanup_thread(cl);
1213    }
1214
1215    cs_log("thread %8X killed!", thread);
1216    return;
1217}
1218
1219/* Allows to kill another thread specified through the client cl with locking.
1220  If the own thread has to be cancelled, cs_exit or cs_disconnect_client has to be used. */
1221void kill_thread(struct s_client *cl) {
1222    cs_lock(&system_lock);
1223    kill_thread_int(cl);
1224    cs_unlock(&system_lock);
1225}
1226
1227/* Removes a reader from the list of active readers so that no ecms can be requested anymore. */
1228void remove_reader_from_active(struct s_reader *rdr) {
1229    struct s_reader *rdr2, *prv = NULL;
1230    cs_lock(&readerlist_lock);
1231    for (rdr2=first_active_reader; rdr2 ; rdr2=rdr2->next) {
1232        if (rdr2==rdr) {
1233            if (prv) prv->next = rdr2->next;
1234            else first_active_reader = rdr2->next;
1235            break;
1236        }
1237        prv = rdr2;
1238    }
1239    cs_unlock(&readerlist_lock);
1240}
1241
1242/* Adds a reader to the list of active readers so that it can serve ecms. */
1243void add_reader_to_active(struct s_reader *rdr) {
1244    struct s_reader *rdr2;
1245    rdr->next = NULL;
1246    cs_lock(&readerlist_lock);
1247    if (first_active_reader) {
1248        for (rdr2=first_active_reader; rdr2->next ; rdr2=rdr2->next) ; //search last element
1249        rdr2->next = rdr;
1250    } else first_active_reader = rdr;
1251    cs_unlock(&readerlist_lock);
1252}
1253
1254/* Starts or restarts a cardreader without locking. If restart=1, the existing thread is killed before restarting,
1255   if restart=0 the cardreader is only started. */
1256static int32_t restart_cardreader_int(struct s_reader *rdr, int32_t restart) {
1257
1258    if (restart) {
1259        //remove from list:
1260        remove_reader_from_active(rdr);
1261    }
1262
1263    if (restart) //kill old thread
1264        if (rdr->client) {
1265            kill_thread_int(rdr->client);
1266            rdr->client = NULL;
1267        }
1268
1269    rdr->tcp_connected = 0;
1270    rdr->card_status = UNKNOWN;
1271    rdr->tcp_block_delay = 100;
1272    cs_ftime(&rdr->tcp_block_connect_till);
1273
1274    if (rdr->device[0] && (rdr->typ & R_IS_CASCADING)) {
1275        if (!rdr->ph.num) {
1276            cs_log("Protocol Support missing. (typ=%d)", rdr->typ);
1277            return 0;
1278        }
1279        cs_debug_mask(D_TRACE, "reader %s protocol: %s", rdr->label, rdr->ph.desc);
1280    }
1281
1282    if (rdr->enable == 0)
1283        return 0;
1284
1285    if (rdr->device[0]) {
1286        if (restart) {
1287            cs_log("restarting reader %s", rdr->label);
1288        }
1289
1290        struct s_client * cl = create_client(first_client->ip);
1291        if (cl == NULL) return 0;
1292
1293
1294        rdr->fd=cl->fd_m2c;
1295        cl->reader=rdr;
1296        cs_log("creating thread for device %s", rdr->device);
1297
1298        cl->sidtabok=rdr->sidtabok;
1299        cl->sidtabno=rdr->sidtabno;
1300
1301        rdr->client=cl;
1302
1303        cl->typ='r';
1304        //client[i].ctyp=99;
1305        pthread_attr_t attr;
1306        pthread_attr_init(&attr);
1307#if !defined(TUXBOX) && !defined(HAVE_PCSC)
1308        /* pcsc doesn't like this either; segfaults on x86, x86_64 */
1309        pthread_attr_setstacksize(&attr, PTHREAD_STACK_SIZE);
1310#endif
1311
1312        if (pthread_create(&cl->thread, &attr, start_cardreader, (void *)rdr)) {
1313            cs_log("ERROR: can't create thread for %s", rdr->label);
1314            cleanup_thread(cl);
1315            restart = 0;
1316        }
1317        else
1318            pthread_detach(cl->thread);
1319        pthread_attr_destroy(&attr);
1320
1321        if (restart) {
1322            //add to list
1323            add_reader_to_active(rdr);
1324        }
1325        return 1;
1326    }
1327    return 0;
1328}
1329
1330/* Starts or restarts a cardreader with locking. If restart=1, the existing thread is killed before restarting,
1331   if restart=0 the cardreader is only started. */
1332int32_t restart_cardreader(struct s_reader *rdr, int32_t restart) {
1333    cs_lock(&system_lock);
1334    int32_t result = restart_cardreader_int(rdr, restart);
1335    cs_unlock(&system_lock);
1336    return result;
1337}
1338
1339static void init_cardreader() {
1340
1341    cs_lock(&system_lock);
1342    struct s_reader *rdr;
1343    for (rdr=first_active_reader; rdr ; rdr=rdr->next) {
1344        if (!restart_cardreader_int(rdr, 0))
1345            remove_reader_from_active(rdr);
1346    }
1347#ifdef WITH_LB
1348    load_stat_from_file();
1349#endif
1350    cs_unlock(&system_lock);
1351}
1352
1353static void cs_fake_client(struct s_client *client, char *usr, int32_t uniq, in_addr_t ip)
1354{
1355    /* Uniq = 1: only one connection per user
1356     *
1357     * Uniq = 2: set (new connected) user only to fake if source
1358     *           ip is different (e.g. for newcamd clients with
1359     *           different CAID's -> Ports)
1360     *
1361     * Uniq = 3: only one connection per user, but only the last
1362     *           login will survive (old mpcs behavior)
1363     *
1364     * Uniq = 4: set user only to fake if source ip is
1365     *           different, but only the last login will survive
1366     */
1367
1368    struct s_client *cl;
1369    struct s_auth *account;
1370    cs_lock(&fakeuser_lock);
1371    for (cl=first_client->next; cl ; cl=cl->next)
1372    {
1373        account = cl->account;
1374        if (cl != client && (cl->typ == 'c') && !cl->dup && account && !strcmp(account->usr, usr)
1375           && (uniq < 5) && ((uniq % 2) || (cl->ip != ip)))
1376        {
1377                char buf[20];
1378            if (uniq  == 3 || uniq == 4)
1379            {
1380                cl->dup = 1;
1381                cl->aureader_list = NULL;
1382                cs_strncpy(buf, cs_inet_ntoa(cl->ip), sizeof(buf));
1383                cs_log("client(%8X) duplicate user '%s' from %s (prev %s) set to fake (uniq=%d)",
1384                    cl->thread, usr, cs_inet_ntoa(ip), buf, uniq);
1385                if (cl->failban & BAN_DUPLICATE) {
1386                    cs_add_violation(cl->ip);
1387                }
1388                if (cfg.dropdups)
1389                    kill_thread(cl);
1390            }
1391            else
1392            {
1393                client->dup = 1;
1394                client->aureader_list = NULL;
1395                cs_strncpy(buf, cs_inet_ntoa(ip), sizeof(buf));
1396                cs_log("client(%8X) duplicate user '%s' from %s (current %s) set to fake (uniq=%d)",
1397                    pthread_self(), usr, cs_inet_ntoa(cl->ip), buf, uniq);
1398                if (client->failban & BAN_DUPLICATE) {
1399                    cs_add_violation(ip);
1400                }
1401                if (cfg.dropdups){
1402                    cs_unlock(&fakeuser_lock);      // we need to unlock here as cs_disconnect_client kills the current thread!
1403                    cs_disconnect_client(client);
1404                }
1405                break;
1406            }
1407        }
1408    }
1409    cs_unlock(&fakeuser_lock);
1410}
1411
1412int32_t cs_auth_client(struct s_client * client, struct s_auth *account, const char *e_txt)
1413{
1414    int32_t rc=0;
1415    unsigned char md5tmp[MD5_DIGEST_LENGTH];
1416    char buf[32];
1417    char *t_crypt="encrypted";
1418    char *t_plain="plain";
1419    char *t_grant=" granted";
1420    char *t_reject=" rejected";
1421    char *t_msg[]= { buf, "invalid access", "invalid ip", "unknown reason" };
1422    memset(&client->grp, 0xff, sizeof(uint64_t));
1423    //client->grp=0xffffffffffffff;
1424    if ((intptr_t)account != 0 && (intptr_t)account != -1 && account->disabled){
1425        cs_add_violation((uint32_t)client->ip);
1426        cs_log("%s %s-client %s%s (%s%sdisabled account)",
1427                client->crypted ? t_crypt : t_plain,
1428                ph[client->ctyp].desc,
1429                client->ip ? cs_inet_ntoa(client->ip) : "",
1430                client->ip ? t_reject : t_reject+1,
1431                e_txt ? e_txt : "",
1432                e_txt ? " " : "");
1433        return(1);
1434    }
1435    client->account=first_client->account;
1436    switch((intptr_t)account)
1437    {
1438    case 0:           // reject access
1439        rc=1;
1440        cs_add_violation((uint32_t)client->ip);
1441        cs_log("%s %s-client %s%s (%s)",
1442                client->crypted ? t_crypt : t_plain,
1443                ph[client->ctyp].desc,
1444                client->ip ? cs_inet_ntoa(client->ip) : "",
1445                client->ip ? t_reject : t_reject+1,
1446                e_txt ? e_txt : t_msg[rc]);
1447        break;
1448    default:            // grant/check access
1449        if (client->ip && account->dyndns[0]) {
1450            if (client->ip != account->dynip)
1451                cs_user_resolve(account);
1452            if (client->ip != account->dynip) {
1453                cs_add_violation((uint32_t)client->ip);
1454                rc=2;
1455            }
1456        }
1457
1458        client->monlvl=account->monlvl;
1459        client->account = account;
1460        if (!rc)
1461        {
1462            client->dup=0;
1463            if (client->typ=='c' || client->typ=='m')
1464                client->pcrc = crc32(0L, MD5((uchar *)account->pwd, strlen(account->pwd), md5tmp), MD5_DIGEST_LENGTH);
1465            if (client->typ=='c')
1466            {
1467                client->last_caid = 0xFFFE;
1468                client->last_srvid = 0xFFFE;
1469                client->expirationdate = account->expirationdate;
1470                client->disabled = account->disabled;
1471                client->allowedtimeframe[0] = account->allowedtimeframe[0];
1472                client->allowedtimeframe[1] = account->allowedtimeframe[1];
1473                if(account->firstlogin == 0) account->firstlogin = time((time_t)0);
1474                client->failban = account->failban;
1475                client->c35_suppresscmd08 = account->c35_suppresscmd08;
1476                client->ncd_keepalive = account->ncd_keepalive;
1477                client->grp = account->grp;
1478                client->aureader_list = account->aureader_list;
1479                client->autoau = account->autoau;
1480                client->tosleep = (60*account->tosleep);
1481                client->c35_sleepsend = account->c35_sleepsend;
1482                memcpy(&client->ctab, &account->ctab, sizeof(client->ctab));
1483                if (account->uniq)
1484                    cs_fake_client(client, account->usr, account->uniq, client->ip);
1485                client->ftab  = account->ftab;   // IDENT filter
1486                client->cltab = account->cltab;  // CLASS filter
1487                client->fchid = account->fchid;  // CHID filter
1488                client->sidtabok= account->sidtabok;   // services
1489                client->sidtabno= account->sidtabno;   // services
1490                memcpy(&client->ttab, &account->ttab, sizeof(client->ttab));
1491#ifdef CS_ANTICASC
1492                ac_init_client(client, account);
1493#endif
1494            }
1495        }
1496    case -1:            // anonymous grant access
1497        if (rc)
1498            t_grant=t_reject;
1499        else {
1500            if (client->typ=='m')
1501                snprintf(t_msg[0], sizeof(buf), "lvl=%d", client->monlvl);
1502            else {
1503                int32_t rcount = ll_count(client->aureader_list);
1504                snprintf(buf, sizeof(buf), "au=");
1505                if (!rcount)
1506                    snprintf(buf+3, sizeof(buf)-3, "off");
1507                else {
1508                    if (client->autoau)
1509                        snprintf(buf+3, sizeof(buf)-3, "auto (%d reader)", rcount);
1510                    else
1511                        snprintf(buf+3, sizeof(buf)-3, "on (%d reader)", rcount);
1512                }
1513            }
1514        }
1515
1516        cs_log("%s %s-client %s%s (%s, %s)",
1517            client->crypted ? t_crypt : t_plain,
1518            e_txt ? e_txt : ph[client->ctyp].desc,
1519            client->ip ? cs_inet_ntoa(client->ip) : "",
1520            client->ip ? t_grant : t_grant+1,
1521            username(client), t_msg[rc]);
1522
1523        break;
1524    }
1525    return(rc);
1526}
1527
1528void cs_disconnect_client(struct s_client * client)
1529{
1530    char buf[32]={0};
1531    if (client->ip)
1532        snprintf(buf, sizeof(buf), " from %s", cs_inet_ntoa(client->ip));
1533    cs_log("%s disconnected %s", username(client), buf);
1534    cs_exit(0);
1535}
1536
1537/**
1538 * ecm cache
1539 **/
1540static int32_t check_and_store_ecmcache(ECM_REQUEST *er, uint64_t grp)
1541{
1542    time_t now = time(NULL);
1543    time_t timeout = now-(time_t)(cfg.ctimeout/1000)-CS_CACHE_TIMEOUT;
1544    struct s_ecm *ecmc;
1545    LL_ITER it = ll_iter_create(ecmcache);
1546    while ((ecmc=ll_iter_next(&it))) {
1547        if (ecmc->time < timeout) {
1548            ll_iter_remove_data(&it);
1549            continue;
1550        }
1551
1552        if (grp && !(grp & ecmc->grp))
1553            continue;
1554
1555        if (ecmc->caid!=er->caid)
1556            continue;
1557
1558        if (memcmp(ecmc->ecmd5, er->ecmd5, CS_ECMSTORESIZE))
1559            continue;
1560
1561        //cs_debug_mask(D_TRACE, "cachehit! (ecm)");
1562        memcpy(er->cw, ecmc->cw, 16);
1563        er->selected_reader = ecmc->reader;
1564        if (ecmc->rc == E_FOUND)
1565                return E_CACHE1;
1566        er->ecmcacheptr = ecmc;
1567        return ecmc->rc;
1568    }
1569
1570    //Add cache entry:
1571    ecmc = cs_malloc(&ecmc, sizeof(struct s_ecm), 0);
1572    memcpy(ecmc->ecmd5, er->ecmd5, CS_ECMSTORESIZE);
1573    ecmc->caid = er->caid;
1574    ecmc->grp = grp;
1575    ecmc->rc = E_99;
1576    ecmc->time = now;
1577    er->ecmcacheptr = ecmc;
1578    ll_prepend(ecmcache, ecmc);
1579
1580    return E_UNHANDLED;
1581}
1582
1583/**
1584 * cache 1: client-invoked
1585 * returns found ecm task index
1586 **/
1587static int32_t check_cwcache1(ECM_REQUEST *er, uint64_t grp)
1588{
1589    //cs_ddump(ecmd5, CS_ECMSTORESIZE, "ECM search");
1590    //cs_log("cache1 CHECK: grp=%lX", grp);
1591
1592    //cs_debug_mask(D_TRACE, "cachesize %d", ll_count(ecmcache));
1593    time_t now = time(NULL);
1594    time_t timeout = now-(time_t)(cfg.ctimeout/1000)-CS_CACHE_TIMEOUT;
1595    struct s_ecm *ecmc;
1596
1597    LL_ITER it = ll_iter_create(ecmcache);
1598    while ((ecmc=ll_iter_next(&it))) {
1599        if (ecmc->time < timeout) {
1600            ll_iter_remove_data(&it);
1601            continue;
1602        }
1603
1604        if (ecmc->rc != E_FOUND)
1605            continue;
1606
1607        if (ecmc->caid != er->caid)
1608            continue;
1609
1610        if (grp && !(grp & ecmc->grp))
1611            continue;
1612
1613        if (memcmp(ecmc->ecmd5, er->ecmd5, CS_ECMSTORESIZE))
1614            continue;
1615
1616        memcpy(er->cw, ecmc->cw, 16);
1617        er->selected_reader = ecmc->reader;
1618        //cs_debug_mask(D_TRACE, "cachehit!");
1619        return 1;
1620    }
1621    return 0;
1622}
1623
1624/**
1625 * cache 2: reader-invoked
1626 * returns 1 if found in cache. cw is copied to er
1627 **/
1628int32_t check_cwcache2(ECM_REQUEST *er, uint64_t grp)
1629{
1630    int32_t rc = check_cwcache1(er, grp);
1631    return rc;
1632}
1633
1634
1635static void store_cw_in_cache(ECM_REQUEST *er, uint64_t grp, int32_t rc)
1636{
1637#ifdef CS_WITH_DOUBLECHECK
1638    if (cfg.double_check && er->checked < 2)
1639        return;
1640#endif
1641    struct s_ecm *ecm = er->ecmcacheptr;
1642    if (!ecm || rc >= ecm->rc) return;
1643
1644    //cs_log("store ecm from reader %d", er->selected_reader);
1645    memcpy(ecm->ecmd5, er->ecmd5, CS_ECMSTORESIZE);
1646    memcpy(ecm->cw, er->cw, 16);
1647    ecm->caid = er->caid;
1648    ecm->grp = grp;
1649    ecm->reader = er->selected_reader;
1650    ecm->rc = rc;
1651    ecm->time = time(NULL);
1652
1653    //cs_ddump(cwcache[*cwidx].ecmd5, CS_ECMSTORESIZE, "ECM stored (idx=%d)", *cwidx);
1654}
1655
1656/*
1657// only for debug
1658static struct s_client * get_thread_by_pipefd(int32_t fd)
1659{
1660    struct s_client *cl;
1661    for (cl=first_client->next; cl ; cl=cl->next)
1662        if (fd==cl->fd_m2c || fd==cl->fd_m2c_c)
1663            return cl;
1664    return first_client; //master process
1665}
1666*/
1667
1668/*
1669 * write_to_pipe():
1670 * write all kind of data to pipe specified by fd
1671 */
1672int32_t write_to_pipe(int32_t fd, int32_t id, uchar *data, int32_t n)
1673{
1674    if (!fd) {
1675        cs_log("write_to_pipe: fd==0 id: %d", id);
1676        return -1;
1677    }
1678
1679    //cs_debug_mask(D_TRACE, "write to pipe %d (%s) thread: %8X to %8X", fd, PIP_ID_TXT[id], pthread_self(), get_thread_by_pipefd(fd)->thread);
1680
1681    uchar buf[3+sizeof(void*)];
1682
1683    // fixme
1684    // copy data to allocated memory
1685    // needed for compatibility
1686    // need to be freed after read_from_pipe
1687    void *d;
1688    if(!cs_malloc(&d, n, -1)) return -1;
1689    memcpy(d, data, n);
1690
1691    if ((id<0) || (id>PIP_ID_MAX))
1692        return(PIP_ID_ERR);
1693
1694    memcpy(buf, PIP_ID_TXT[id], 3);
1695    memcpy(buf+3, &d, sizeof(void*));
1696
1697    n=3+sizeof(void*);
1698
1699    return(write(fd, buf, n));
1700}
1701
1702
1703/*
1704 * read_from_pipe():
1705 * read all kind of data from pipe specified by fd
1706 * special-flag redir: if set AND data is ECM: this will redirected to appr. client
1707 */
1708int32_t read_from_pipe(int32_t fd, uchar **data)
1709{
1710    int32_t rc;
1711    intptr_t hdr=0;
1712    uchar buf[3+sizeof(void*)];
1713    memset(buf, 0, sizeof(buf));
1714
1715    *data=(uchar *)0;
1716    rc=PIP_ID_NUL;
1717
1718
1719    if (read(fd, buf, sizeof(buf))==sizeof(buf)) {
1720        memcpy(&hdr, buf+3, sizeof(void*));
1721    } else {
1722        cs_log("WARNING: pipe header to small !");
1723        return PIP_ID_ERR;
1724    }
1725
1726    //uchar id[4];
1727    //memcpy(id, buf, 3);
1728    //id[3]='\0';
1729
1730    //cs_debug_mask(D_TRACE, "read from pipe %d (%s) thread: %8X", fd, id, (uint32_t)pthread_self());
1731
1732    int32_t l;
1733    for (l=0; (rc<0) && (PIP_ID_TXT[l]); l++)
1734        if (!memcmp(buf, PIP_ID_TXT[l], 3))
1735            rc=l;
1736
1737    if (rc<0) {
1738        cs_log("WARNING: pipe garbage from pipe %i", fd);
1739        return PIP_ID_ERR;
1740    }
1741
1742    *data = (void*)hdr;
1743
1744    return(rc);
1745}
1746
1747/*
1748 * write_ecm_request():
1749 */
1750static int32_t write_ecm_request(int32_t fd, ECM_REQUEST *er)
1751{
1752  return(write_to_pipe(fd, PIP_ID_ECM, (uchar *) er, sizeof(ECM_REQUEST)));
1753}
1754
1755/**
1756 * distributes found ecm-request to all clients with rc=99
1757 **/
1758void distribute_ecm(ECM_REQUEST *er, uint64_t grp, int32_t rc)
1759{
1760  struct s_client *cl;
1761  ECM_REQUEST *ecm;
1762  int32_t n, i, pending;
1763
1764  er->rc = rc;
1765
1766  for (cl=first_client->next; cl ; cl=cl->next) {
1767    if (cl->fd_m2c && cl->typ=='c' && cl->ecmtask && (cl->grp&grp)) {
1768
1769      n=(ph[cl->ctyp].multi)?CS_MAXPENDING:1;
1770      pending=0;
1771      for (i=0; i<n; i++) {
1772        ecm = &cl->ecmtask[i];
1773        if (ecm->rc >= E_99) {
1774            pending++;
1775            if (ecm->ecmcacheptr == er->ecmcacheptr) {
1776                er->cpti = ecm->cpti;
1777                //cs_log("distribute %04X:%06X:%04X cpti %d to client %s", ecm->caid, ecm->prid, ecm->srvid, ecm->cpti, username(cl));
1778                write_ecm_request(cl->fd_m2c, er);
1779            }
1780        }
1781        //else if (ecm->rc == E_99)
1782        //  cs_log("NO-distribute %04X:%06X:%04X cpti %d to client %s", ecm->caid, ecm->prid, ecm->srvid, ecm->cpti, username(cl));
1783      }
1784      cl->pending=pending;
1785    }
1786  }
1787}
1788
1789
1790int32_t write_ecm_answer(struct s_reader * reader, ECM_REQUEST *er)
1791{
1792  int32_t i;
1793  uchar c;
1794  for (i=0; i<16; i+=4)
1795  {
1796    c=((er->cw[i]+er->cw[i+1]+er->cw[i+2]) & 0xff);
1797    if (er->cw[i+3]!=c)
1798    {
1799      cs_debug_mask(D_TRACE, "notice: changed dcw checksum byte cw[%i] from %02x to %02x", i+3, er->cw[i+3],c);
1800      er->cw[i+3]=c;
1801    }
1802  }
1803
1804  er->selected_reader=reader;
1805//cs_log("answer from reader %d (rc=%d)", er->selected_reader, er->rc);
1806  er->caid=er->ocaid;
1807
1808  if (er->rc==E_RDR_FOUND) {
1809
1810    store_cw_in_cache(er, reader->grp, E_FOUND);
1811
1812    /* CWL logging only if cwlogdir is set in config */
1813    if (cfg.cwlogdir != NULL)
1814      logCWtoFile(er);
1815  }
1816
1817  int32_t res=0;
1818  if( er->client && er->client->fd_m2c ) {
1819    //We got an ECM (or nok). Now we should check for another clients waiting for it:
1820    res = write_ecm_request(er->client->fd_m2c, er);
1821  }
1822
1823  return res;
1824}
1825
1826ECM_REQUEST *get_ecmtask()
1827{
1828    int32_t i, n, pending=0;
1829    ECM_REQUEST *er=0;
1830    struct s_client *cl = cur_client();
1831    if(!cl) return NULL;
1832    if (!cl->ecmtask)
1833    {
1834        n=(ph[cl->ctyp].multi)?CS_MAXPENDING:1;
1835        if(!cs_malloc(&cl->ecmtask,n*sizeof(ECM_REQUEST), -1)) return NULL;
1836    }
1837
1838    n=(-1);
1839    if (ph[cl->ctyp].multi)
1840    {
1841        for (i=0; (n<0) && (i<CS_MAXPENDING); i++)
1842            if (cl->ecmtask[i].rc<E_99)
1843                er=&cl->ecmtask[n=i];
1844            else
1845                pending++;
1846    }
1847    else
1848        er=&cl->ecmtask[n=0];
1849
1850    if (n<0)
1851        cs_log("WARNING: ecm pending table overflow !");
1852    else
1853    {
1854        LLIST *save = er->matching_rdr;
1855        memset(er, 0, sizeof(ECM_REQUEST));
1856        er->rc=E_UNHANDLED;
1857        er->cpti=n;
1858        er->client=cl;
1859        cs_ftime(&er->tps);
1860
1861        if (cl->typ=='c') { //for clients only! Not for readers!
1862          if (save) {
1863            ll_clear(save);
1864            er->matching_rdr = save;
1865                  }
1866                  else
1867                    er->matching_rdr = ll_create();
1868
1869                    //cs_log("client %s ECMTASK %d multi %d ctyp %d", username(cl), n, (ph[cl->ctyp].multi)?CS_MAXPENDING:1, cl->ctyp);
1870                }
1871    }
1872
1873    cl->pending=pending+1;
1874    return(er);
1875}
1876
1877#ifdef WITH_LB
1878void send_reader_stat(struct s_reader *rdr, ECM_REQUEST *er, int32_t rc)
1879{
1880    if (rc>=E_99)
1881        return;
1882    struct timeb tpe;
1883    cs_ftime(&tpe);
1884    int32_t time = 1000*(tpe.time-er->tps.time)+tpe.millitm-er->tps.millitm;
1885    if (time < 1)
1886            time = 1;
1887
1888    add_stat(rdr, er, time, rc);
1889}
1890#endif
1891
1892/**
1893 * Check for NULL CWs
1894 * Return them as "NOT FOUND"
1895 **/
1896static void checkCW(ECM_REQUEST *er)
1897{
1898    int8_t i;
1899    for (i=0;i<16;i++)
1900        if (er->cw[i]) return;
1901    er->rc = E_NOTFOUND;
1902}
1903
1904int32_t send_dcw(struct s_client * client, ECM_REQUEST *er)
1905{
1906    static const char *stxt[]={"found", "cache1", "cache2", "emu",
1907            "not found", "timeout", "sleeping",
1908            "fake", "invalid", "corrupt", "no card", "expdate", "disabled", "stopped"};
1909    static const char *stxtEx[]={"", "group", "caid", "ident", "class", "chid", "queue", "peer"};
1910    static const char *stxtWh[]={"", "user ", "reader ", "server ", "lserver "};
1911    char sby[32]="", sreason[32]="", schaninfo[32]="";
1912    char erEx[32]="";
1913    char uname[38]="";
1914    char channame[32];
1915    struct timeb tpe;
1916    uint16_t lc, *lp;
1917    for (lp=(uint16_t *)er->ecm+(er->l>>2), lc=0; lp>=(uint16_t *)er->ecm; lp--)
1918        lc^=*lp;
1919
1920        snprintf(uname,sizeof(uname)-1, "%s", username(client));
1921
1922    if (er->rc == E_FOUND||er->rc == E_CACHE1||er->rc == E_CACHE2)
1923        checkCW(er);
1924
1925    struct s_reader *er_reader = er->selected_reader; //responding reader
1926    if (!er_reader) er_reader = ll_has_elements(er->matching_rdr); //no reader? use first reader
1927
1928    if (er_reader)
1929    {
1930            // add marker to reader if ECM_REQUEST was betatunneled
1931            if(er->btun)
1932                snprintf(sby, sizeof(sby)-1, " by %s(btun)", er_reader->label);
1933            else
1934                snprintf(sby, sizeof(sby)-1, " by %s", er_reader->label);
1935    }
1936    if (er->rc < E_NOTFOUND) er->rcEx=0;
1937    if (er->rcEx)
1938        snprintf(erEx, sizeof(erEx)-1, "rejected %s%s", stxtWh[er->rcEx>>4],
1939                stxtEx[er->rcEx&0xf]);
1940
1941    if(cfg.mon_appendchaninfo)
1942        snprintf(schaninfo, sizeof(schaninfo)-1, " - %s", get_servicename(client, er->srvid, er->caid, channame));
1943
1944    if(er->msglog[0])
1945        snprintf(sreason, sizeof(sreason)-1, " (%s)", er->msglog);
1946
1947    cs_ftime(&tpe);
1948    client->cwlastresptime = 1000 * (tpe.time-er->tps.time) + tpe.millitm-er->tps.millitm;
1949    cs_add_lastresponsetime(client, client->cwlastresptime); // add to ringbuffer
1950
1951    if (er_reader){
1952        struct s_client *er_cl = er_reader->client;
1953        if(er_cl){
1954            er_cl->cwlastresptime = client->cwlastresptime;
1955            cs_add_lastresponsetime(er_cl, client->cwlastresptime);
1956            er_cl->last_srvidptr=client->last_srvidptr;
1957        }
1958    }
1959
1960#ifdef CS_LED
1961    if(!er->rc) cs_switch_led(LED2, LED_BLINK_OFF);
1962#endif
1963
1964#ifdef WITH_LB
1965    send_reader_stat(er->selected_reader, er, er->rc);
1966#endif
1967
1968#ifdef WEBIF
1969    if (er_reader) {
1970        if(er->rc == E_FOUND)
1971            snprintf(client->lastreader, sizeof(client->lastreader)-1, "%s", er_reader->label);
1972        else if ((er->rc == E_CACHE1) || (er->rc == E_CACHE2))
1973            snprintf(client->lastreader, sizeof(client->lastreader)-1, "%s (cache)", er_reader->label);
1974        else
1975            snprintf(client->lastreader, sizeof(client->lastreader)-1, "%s", stxt[er->rc]);
1976    }
1977#endif
1978
1979    er->caid = er->ocaid;
1980    switch(er->rc) {
1981        case E_FOUND:
1982        case E_EMU: //FIXME obsolete ?
1983                    client->cwfound++;
1984                            client->account->cwfound++;
1985                    first_client->cwfound++;
1986                    break;
1987
1988        case E_CACHE1:
1989        case E_CACHE2:
1990            client->cwcache++;
1991            client->account->cwcache++;
1992            first_client->cwcache++;
1993            break;
1994
1995        case E_NOTFOUND:
1996        case E_CORRUPT:
1997        case E_NOCARD:
1998            if (er->rcEx) {
1999                client->cwignored++;
2000                client->account->cwignored++;
2001                first_client->cwignored++;
2002            } else {
2003                client->cwnot++;
2004                client->account->cwnot++;
2005                first_client->cwnot++;
2006                        }
2007            break;
2008
2009        case E_TIMEOUT:
2010            client->cwtout++;
2011            client->account->cwtout++;
2012            first_client->cwtout++;
2013            break;
2014
2015        default:
2016            client->cwignored++;
2017            client->account->cwignored++;
2018            first_client->cwignored++;
2019    }
2020
2021#ifdef CS_ANTICASC
2022    ac_chk(client, er, 1);
2023#endif
2024
2025    int32_t is_fake = 0;
2026    if (er->rc==E_FAKE) {
2027        is_fake = 1;
2028        er->rc=E_FOUND;
2029    }
2030
2031#ifdef CS_WITH_DOUBLECHECK
2032    if (cfg.double_check && er->rc < E_NOTFOUND) {
2033      if (er->checked == 0) {//First CW, save it and wait for next one
2034        er->checked = 1;
2035        er->origin_reader = er->selected_reader;
2036        memcpy(er->cw_checked, er->cw, sizeof(er->cw));
2037        cs_log("DOUBLE CHECK FIRST CW by %s idx %d cpti %d", er->origin_reader->label, er->idx, er->cpti);
2038      }
2039      else if (er->origin_reader != er->selected_reader) { //Second (or third and so on) cw. We have to compare
2040        if (memcmp(er->cw_checked, er->cw, sizeof(er->cw)) == 0) {
2041            er->checked++;
2042            cs_log("DOUBLE CHECKED! %d. CW by %s idx %d cpti %d", er->checked, er->selected_reader->label, er->idx, er->cpti);
2043        }
2044        else {
2045            cs_log("DOUBLE CHECKED NONMATCHING! %d. CW by %s idx %d cpti %d", er->checked, er->selected_reader->label, er->idx, er->cpti);
2046        }
2047      }
2048
2049      if (er->checked < 2) { //less as two same cw? mark as pending!
2050        er->rc = E_UNHANDLED;
2051        return 0;
2052      }
2053
2054      store_cw_in_cache(er, er->selected_reader->grp, E_FOUND); //Store in cache!
2055
2056    }
2057#endif
2058
2059    ph[client->ctyp].send_dcw(client, er);
2060
2061    if (is_fake)
2062        er->rc = E_FAKE;
2063
2064    cs_log("%s (%04X&%06X/%04X/%02X:%04X): %s (%d ms)%s (of %d avail %d)%s%s",
2065            uname, er->caid, er->prid, er->srvid, er->l, lc,
2066            er->rcEx?erEx:stxt[er->rc], client->cwlastresptime, sby, er->reader_count, er->reader_avail, schaninfo, sreason);
2067
2068    cs_ddump_mask (D_ATR, er->cw, 16, "cw:");
2069
2070#ifdef QBOXHD_LED
2071    if (er->rc < E_NOTFOUND) {
2072        qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN, QBOXHD_LED_BLINK_MEDIUM);
2073    } else if (er->rc <= E_STOPPED) {
2074        qboxhd_led_blink(QBOXHD_LED_COLOR_RED, QBOXHD_LED_BLINK_MEDIUM);
2075    }
2076#endif
2077
2078    return 0;
2079}
2080
2081void chk_dcw(struct s_client *cl, ECM_REQUEST *er)
2082{
2083  if (!cl || !cl->ecmtask)
2084    return;
2085
2086  ECM_REQUEST *ert;
2087
2088  //cs_log("dcw check from reader %s for idx %d (rc=%d)", er->selected_reader->label, er->cpti, er->rc);
2089  ert=&cl->ecmtask[er->cpti];
2090  if (ert->rc<E_99) {
2091    //cs_debug_mask(D_TRACE, "chk_dcw: already done rc=%d %s", er->rc, er->selected_reader->label);
2092#ifdef WITH_LB
2093    send_reader_stat(er->selected_reader, er, (er->rc <= E_RDR_NOTFOUND)?E_NOTFOUND:E_FOUND);
2094#endif
2095    return; // already done
2096  }
2097  if( (er->caid!=ert->caid && er->ocaid!=ert->ocaid) || memcmp(er->ecmd5, ert->ecmd5, sizeof(er->ecmd5)) ) {
2098    //cs_debug_mask(D_TRACE, "OBSOLETE? %04X / %04X", er->caid, ert->caid);
2099    return; // obsolete
2100  }
2101
2102    ert->selected_reader=er->selected_reader;
2103
2104    if (er->rc>=E_RDR_FOUND)
2105    {
2106        if (er->rc == E_CACHE2 || er->rc == E_EMU)
2107                ert->rc=er->rc;
2108        else
2109                ert->rc=E_FOUND;
2110
2111        ert->rcEx=0;
2112        memcpy(ert->cw , er->cw , sizeof(er->cw));
2113  } else { // not found (from ONE of the readers !) er->rc==E_RDR_NOTFOUND
2114        ert->rcEx=er->rcEx;
2115        cs_strncpy(ert->msglog, er->msglog, sizeof(ert->msglog));
2116
2117        ll_remove(ert->matching_rdr, er->selected_reader);
2118
2119        if (ll_has_elements(ert->matching_rdr)) {//we have still another chance
2120                ert->selected_reader=NULL;
2121                ert=NULL;
2122        }
2123        //at this point, ert is only not NULL when it has no matching readers...
2124        if (ert) {
2125                ert->rc=E_NOTFOUND; //so we set the return code
2126                store_cw_in_cache(ert, er->selected_reader->grp, E_NOTFOUND);
2127        }
2128#ifdef WITH_LB
2129        else send_reader_stat(er->selected_reader, er, E_NOTFOUND);
2130#endif
2131    }
2132    if (ert) {
2133        send_dcw(cl, ert);
2134        distribute_ecm(er, ert->selected_reader->grp, (ert->rc<E_NOTFOUND)?E_CACHE2:ert->rc);
2135    }
2136    return;
2137}
2138
2139uint32_t chk_provid(uchar *ecm, uint16_t caid) {
2140    int32_t i, len, descriptor_length = 0;
2141    uint32_t provid = 0;
2142
2143    switch(caid >> 8) {
2144        case 0x01:
2145            // seca
2146            provid = b2i(2, ecm+3);
2147            break;
2148
2149        case 0x05:
2150            // viaccess
2151            i = (ecm[4] == 0xD2) ? ecm[5]+2 : 0;  // skip d2 nano
2152            if((ecm[5+i] == 3) && ((ecm[4+i] == 0x90) || (ecm[4+i] == 0x40)))
2153                provid = (b2i(3, ecm+6+i) & 0xFFFFF0);
2154
2155            i = (ecm[6] == 0xD2) ? ecm[7]+2 : 0;  // skip d2 nano long ecm
2156            if((ecm[7+i] == 7) && ((ecm[6+i] == 0x90) || (ecm[6+i] == 0x40)))
2157                provid = (b2i(3, ecm+8+i) & 0xFFFFF0);
2158
2159            break;
2160
2161        case 0x0D:
2162            // cryptoworks
2163            len = (((ecm[1] & 0xf) << 8) | ecm[2])+3;
2164            for(i=8; i<len; i+=descriptor_length+2) {
2165                descriptor_length = ecm[i+1];
2166                if (ecm[i] == 0x83) {
2167                    provid = (uint32_t)ecm[i+2] & 0xFE;
2168                    break;
2169                }
2170            }
2171            break;
2172
2173#ifdef WITH_LB
2174        default:
2175            for (i=0;i<CS_MAXCAIDTAB;i++) {
2176                            uint16_t tcaid = cfg.lb_noproviderforcaid.caid[i];
2177                            if (!tcaid) break;
2178                            if (tcaid == caid) {
2179                            provid = 0;
2180                            break;
2181                            }
2182                            if (tcaid < 0x0100 && (caid >> 8) == tcaid) {
2183                                provid = 0;
2184                                break;
2185                            }
2186            }
2187#endif
2188    }
2189    return(provid);
2190}
2191
2192#ifdef IRDETO_GUESSING
2193void guess_irdeto(ECM_REQUEST *er)
2194{
2195  uchar  b3;
2196  int32_t    b47;
2197  //uint16_t chid;
2198  struct s_irdeto_quess *ptr;
2199
2200  b3  = er->ecm[3];
2201  ptr = cfg.itab[b3];
2202  if( !ptr ) {
2203    cs_debug_mask(D_TRACE, "unknown irdeto byte 3: %02X", b3);
2204    return;
2205  }
2206  b47  = b2i(4, er->ecm+4);
2207  //chid = b2i(2, er->ecm+6);
2208  //cs_debug_mask(D_TRACE, "ecm: b47=%08X, ptr->b47=%08X, ptr->caid=%04X", b47, ptr->b47, ptr->caid);
2209  while( ptr )
2210  {
2211    if( b47==ptr->b47 )
2212    {
2213      if( er->srvid && (er->srvid!=ptr->sid) )
2214      {
2215        cs_debug_mask(D_TRACE, "sid mismatched (ecm: %04X, guess: %04X), wrong oscam.ird file?",
2216                  er->srvid, ptr->sid);
2217        return;
2218      }
2219      er->caid=ptr->caid;
2220      er->srvid=ptr->sid;
2221      er->chid=(uint16_t)ptr->b47;
2222//      cs_debug_mask(D_TRACE, "quess_irdeto() found caid=%04X, sid=%04X, chid=%04X",
2223//               er->caid, er->srvid, er->chid);
2224      return;
2225    }
2226    ptr=ptr->next;
2227  }
2228}
2229#endif
2230
2231void convert_to_beta(struct s_client *cl, ECM_REQUEST *er, uint16_t caidto)
2232{
2233    static uchar headerN3[10] = {0xc7, 0x00, 0x00, 0x00, 0x01, 0x10, 0x10, 0x00, 0x87, 0x12};
2234    static uchar headerN2[10] = {0xc9, 0x00, 0x00, 0x00, 0x01, 0x10, 0x10, 0x00, 0x48, 0x12};
2235
2236#ifdef WITH_DEBUG
2237    uint16_t caidfrom = er->caid;
2238#endif
2239    er->caid = caidto;
2240    er->prid = 0;
2241    er->l = er->ecm[2] + 3;
2242
2243    memmove(er->ecm + 13, er->ecm + 3, er->l - 3);
2244
2245    if (er->l > 0x88) {
2246        memcpy(er->ecm + 3, headerN3, 10);
2247
2248        if (er->ecm[0] == 0x81)
2249            er->ecm[12] += 1;
2250
2251        er->ecm[1]=0x70;
2252    }
2253    else
2254        memcpy(er->ecm + 3, headerN2, 10);
2255
2256    er->l += 10;
2257    er->ecm[2] = er->l - 3;
2258    er->btun = 1;
2259
2260    cl->cwtun++;
2261    cl->account->cwtun++;
2262    first_client->cwtun++;
2263
2264    cs_debug_mask(D_TRACE, "ECM converted from: 0x%X to BetaCrypt: 0x%X for service id:0x%X",
2265                    caidfrom, caidto, er->srvid);
2266}
2267
2268
2269void cs_betatunnel(ECM_REQUEST *er)
2270{
2271    int32_t n;
2272    struct s_client *cl = cur_client();
2273    uint32_t mask_all = 0xFFFF;
2274
2275    TUNTAB *ttab;
2276    ttab = &cl->ttab;
2277
2278    if (er->caid>>8 == 0x18)
2279        cs_ddump_mask(D_TRACE, er->ecm, 13, "betatunnel? ecmlen=%d", er->l);
2280
2281    for (n = 0; n<ttab->n; n++) {
2282        if ((er->caid==ttab->bt_caidfrom[n]) && ((er->srvid==ttab->bt_srvid[n]) || (ttab->bt_srvid[n])==mask_all)) {
2283
2284            convert_to_beta(cl, er, ttab->bt_caidto[n]);
2285
2286            return;
2287        }
2288    }
2289}
2290
2291static void guess_cardsystem(ECM_REQUEST *er)
2292{
2293  uint16_t last_hope=0;
2294
2295  // viaccess - check by provid-search
2296  if( (er->prid=chk_provid(er->ecm, 0x500)) )
2297    er->caid=0x500;
2298
2299  // nagra
2300  // is ecm[1] always 0x30 ?
2301  // is ecm[3] always 0x07 ?
2302  if ((er->ecm[6]==1) && (er->ecm[4]==er->ecm[2]-2))
2303    er->caid=0x1801;
2304
2305  // seca2 - very poor
2306  if ((er->ecm[8]==0x10) && ((er->ecm[9]&0xF1)==1))
2307    last_hope=0x100;
2308
2309  // is cryptoworks, but which caid ?
2310  if ((er->ecm[3]==0x81) && (er->ecm[4]==0xFF) &&
2311      (!er->ecm[5]) && (!er->ecm[6]) && (er->ecm[7]==er->ecm[2]-5))
2312    last_hope=0xd00;
2313
2314#ifdef IRDETO_GUESSING
2315  if (!er->caid && er->ecm[2]==0x31 && er->ecm[0x0b]==0x28)
2316    guess_irdeto(er);
2317#endif
2318
2319  if (!er->caid)    // guess by len ..
2320    er->caid=len4caid[er->ecm[2]+3];
2321
2322  if (!er->caid)
2323    er->caid=last_hope;
2324}
2325
2326/**
2327 * sends the ecm request to the readers
2328 * ECM_REQUEST er : the ecm
2329 * int32_t flag : 0=primary readers (no fallback)
2330 *            1=all readers (primary+fallback)
2331 * int32_t reader_types : 0=all readsers
2332 *                    1=Hardware/local readers
2333 *                    2=Proxy/network readers
2334 **/
2335void request_cw(ECM_REQUEST *er, int32_t flag, int32_t reader_types)
2336{
2337    if ((reader_types == 0) || (reader_types == 2))
2338        er->level=flag;
2339    struct s_reader *rdr;
2340
2341    uint16_t lc=0, *lp;
2342    if (cs_dblevel) {
2343        for (lp=(uint16_t *)er->ecm+(er->l>>2), lc=0; lp>=(uint16_t *)er->ecm; lp--)
2344            lc^=*lp;
2345    }
2346
2347    LL_NODE *ptr;
2348    for (ptr = er->matching_rdr->initial; ptr; ptr = ptr->nxt) {
2349            if (!flag && ptr == er->fallback)
2350              break;
2351
2352        rdr = (struct s_reader*)ptr->obj;
2353
2354        int32_t status = 0;
2355        //reader_types:
2356        //0 = network and local cards
2357        //1 = only local cards
2358        //2 = only network
2359        if ((reader_types == 0) || ((reader_types == 1) && (!(rdr->typ & R_IS_NETWORK))) || ((reader_types == 2) && (rdr->typ & R_IS_NETWORK))) {
2360            cs_debug_mask(D_TRACE, "request_cw%i to reader %s fd=%d ecm=%04X", reader_types+1, rdr->label, rdr->fd, lc);
2361            status = write_ecm_request(rdr->fd, er);
2362        }
2363        if (status == -1) {
2364            cs_log("request_cw() failed on reader %s errno=%d, %s", rdr->label, errno, strerror(errno));
2365            if (rdr->fd) {
2366                rdr->fd_error++;
2367                if (rdr->fd_error > 5) {
2368                    rdr->fd_error = 0;
2369                    cs_log("Restarting reader %s", rdr->label);
2370                    restart_cardreader(rdr, 1); //Schlocke: This restarts the reader!
2371                }
2372            }
2373        }
2374        else
2375            rdr->fd_error = 0;
2376  }
2377}
2378
2379void get_cw(struct s_client * client, ECM_REQUEST *er)
2380{
2381    int32_t i, j, m;
2382    time_t now = time((time_t)0);
2383
2384    client->lastecm = now;
2385
2386    if (!er->caid)
2387        guess_cardsystem(er);
2388
2389    /* Quickfix Area */
2390
2391    if( (er->caid & 0xFF00) == 0x600 && !er->chid )
2392        er->chid = (er->ecm[6]<<8)|er->ecm[7];
2393
2394    // quickfix for 0100:000065
2395    if (er->caid == 0x100 && er->prid == 0x65 && er->srvid == 0)
2396        er->srvid = 0x0642;
2397
2398    // Quickfixes for Opticum/Globo HD9500
2399    // Quickfix for 0500:030300
2400    if (er->caid == 0x500 && er->prid == 0x030300)
2401        er->prid = 0x030600;
2402
2403    // Quickfix for 0500:D20200
2404    if (er->caid == 0x500 && er->prid == 0xD20200)
2405        er->prid = 0x030600;
2406
2407    //betacrypt ecm with nagra header
2408    if (er->caid == 0x1702 && er->l == 0x89 && er->ecm[3] == 0x07 && er->ecm[4] == 0x84)
2409        er->caid = 0x1833;
2410
2411    //Ariva quickfix (invalid nagra provider)
2412    if (((er->caid & 0xFF00) == 0x1800) && er->prid > 0x00FFFF) er->prid=0;
2413
2414    if (!er->prid)
2415        er->prid = chk_provid(er->ecm, er->caid);
2416
2417    // Set providerid for newcamd clients if none is given
2418    if( (!er->prid) && client->ncd_server ) {
2419        int32_t pi = client->port_idx;
2420        if( pi >= 0 && cfg.ncd_ptab.nports && cfg.ncd_ptab.nports >= pi )
2421            er->prid = cfg.ncd_ptab.ports[pi].ftab.filts[0].prids[0];
2422    }
2423
2424    // CAID not supported or found
2425    if (!er->caid) {
2426        er->rc = E_INVALID;
2427        er->rcEx = E2_CAID;
2428        snprintf( er->msglog, MSGLOGSIZE, "CAID not supported or found" );
2429    }
2430
2431    // user expired
2432    if(client->expirationdate && client->expirationdate < client->lastecm)
2433        er->rc = E_EXPDATE;
2434
2435    // out of timeframe
2436    if(client->allowedtimeframe[0] && client->allowedtimeframe[1]) {
2437        struct tm acttm;
2438        localtime_r(&now, &acttm);
2439        int32_t curtime = (acttm.tm_hour * 60) + acttm.tm_min;
2440        int32_t mintime = client->allowedtimeframe[0];
2441        int32_t maxtime = client->allowedtimeframe[1];
2442        if(!((mintime <= maxtime && curtime > mintime && curtime < maxtime) || (mintime > maxtime && (curtime > mintime || curtime < maxtime)))) {
2443            er->rc = E_EXPDATE;
2444        }
2445        cs_debug_mask(D_TRACE, "Check Timeframe - result: %d, start: %d, current: %d, end: %d\n",er->rc, mintime, curtime, maxtime);
2446    }
2447
2448    // user disabled
2449    if(client->disabled != 0) {
2450        if (client->failban & BAN_DISABLED){
2451            cs_add_violation(client->ip);
2452            cs_exit(SIGQUIT); // don't know whether this is best way to kill the thread
2453        }
2454        er->rc = E_DISABLED;
2455    }
2456
2457
2458    // rc<100 -> ecm error
2459    if (er->rc >= E_UNHANDLED) {
2460
2461        m = er->caid;
2462        er->ocaid = er->caid;
2463        i = er->srvid;
2464
2465        if ((i != client->last_srvid) || (!client->lastswitch)) {
2466            if(cfg.usrfileflag)
2467                cs_statistics(client);
2468            client->lastswitch = now;
2469        }
2470
2471        // user sleeping
2472        if ((client->tosleep) && (now - client->lastswitch > client->tosleep)) {
2473
2474            if (client->failban & BAN_SLEEPING) {
2475                cs_add_violation(client->ip);
2476                cs_exit(SIGQUIT); // todo don't know whether this is best way to kill the thread
2477            }
2478
2479            if (client->c35_sleepsend != 0) {
2480                er->rc = E_STOPPED; // send stop command CMD08 {00 xx}
2481            } else {
2482                er->rc = E_SLEEPING;
2483            }
2484        }
2485
2486        client->last_srvid = i;
2487        client->last_caid = m;
2488
2489        int32_t ecm_len = (((er->ecm[1] & 0x0F) << 8) | er->ecm[2]) + 3;
2490
2491        for (j = 0; (j < 6) && (er->rc >= E_UNHANDLED); j++)
2492        {
2493            switch(j) {
2494
2495                case 0:
2496                    // fake (uniq)
2497                    if (client->dup)
2498                        er->rc = E_FAKE;
2499                    break;
2500
2501                case 1:
2502                    // invalid (caid)
2503                    if (!chk_bcaid(er, &client->ctab)) {
2504                        er->rc = E_INVALID;
2505                        er->rcEx = E2_CAID;
2506                        snprintf( er->msglog, MSGLOGSIZE, "invalid caid %x",er->caid );
2507                        }
2508                    break;
2509
2510                case 2:
2511                    // invalid (srvid)
2512                    if (!chk_srvid(client, er))
2513                    {
2514                        er->rc = E_INVALID;
2515                        snprintf( er->msglog, MSGLOGSIZE, "invalid SID" );
2516                    }
2517
2518                    break;
2519
2520                case 3:
2521                    // invalid (ufilters)
2522                    if (!chk_ufilters(er))
2523                        er->rc = E_INVALID;
2524                    break;
2525
2526                case 4:
2527                    // invalid (sfilter)
2528                    if (!chk_sfilter(er, ph[client->ctyp].ptab))
2529                        er->rc = E_INVALID;
2530                    break;
2531
2532                case 5:
2533                    // corrupt
2534                    if( (i = er->l - ecm_len) ) {
2535                        if (i > 0) {
2536                            cs_debug_mask(D_TRACE, "warning: ecm size adjusted from 0x%X to 0x%X", er->l, ecm_len);
2537                            er->l = ecm_len;
2538                        }
2539                        else
2540                            er->rc = E_CORRUPT;
2541                    }
2542                    break;
2543            }
2544        }
2545    }
2546
2547#ifdef WITH_LB
2548    //Use locking - now default=FALSE, activate on problems!
2549    int32_t locked;
2550    if (cfg.lb_mode && cfg.lb_use_locking) {
2551            cs_lock(&get_cw_lock);
2552            locked=1;
2553    }
2554    else
2555            locked=0;
2556#endif
2557
2558    //Schlocke: above checks could change er->rc so
2559    if (er->rc >= E_UNHANDLED) {
2560        /*BetaCrypt tunneling
2561         *moved behind the check routines,
2562         *because newcamd ECM will fail
2563         *if ECM is converted before
2564         */
2565        if (client->ttab.n)
2566            cs_betatunnel(er);
2567
2568        // ignore ecm ...
2569        int32_t offset = 3;
2570        // ... and betacrypt header for cache md5 calculation
2571        if ((er->caid >> 8) == 0x17)
2572            offset = 13;
2573        unsigned char md5tmp[MD5_DIGEST_LENGTH];
2574        // store ECM in cache
2575        memcpy(er->ecmd5, MD5(er->ecm+offset, er->l-offset, md5tmp), CS_ECMSTORESIZE);
2576
2577        // cache1
2578        //cache check now done by check_and_store_ecmcache() !!
2579        //if (check_cwcache1(er, client->grp))
2580        //      er->rc = E_CACHE1;
2581
2582#ifdef CS_ANTICASC
2583        ac_chk(client, er, 0);
2584#endif
2585    }
2586
2587    if(er->rc >= E_99) {
2588        er->reader_avail=0;
2589        struct s_reader *rdr;
2590        for (rdr=first_active_reader; rdr ; rdr=rdr->next) {
2591            if (matching_reader(er, rdr)) {
2592                if (rdr->fallback) {
2593                    if (er->fallback == NULL) //first fallbackreader to be added
2594                        er->fallback=ll_append(er->matching_rdr, rdr);
2595                    else
2596                        ll_append(er->matching_rdr, rdr);
2597
2598                }
2599                else {
2600                    ll_prepend(er->matching_rdr, rdr);
2601                }
2602#ifdef WITH_LB
2603                if (cfg.lb_mode || !rdr->fallback)
2604#else
2605                                if (!rdr->fallback)
2606#endif
2607                    er->reader_avail++;
2608            }
2609        }
2610
2611#ifdef WITH_LB
2612        if (cfg.lb_mode && er->reader_avail) {
2613            cs_debug_mask(D_TRACE, "requesting client %s best reader for %04X/%06X/%04X",
2614                username(client), er->caid, er->prid, er->srvid);
2615            get_best_reader(er);
2616        }
2617#endif
2618        LL_NODE *ptr;
2619        for (ptr = er->matching_rdr->initial; ptr && ptr != er->fallback; ptr = ptr->nxt)
2620            er->reader_count++;
2621
2622        if (!ll_has_elements(er->matching_rdr)) { //no reader -> not found
2623                er->rc = E_NOTFOUND;
2624                if (!er->rcEx)
2625                    er->rcEx = E2_GROUP;
2626                snprintf(er->msglog, MSGLOGSIZE, "no matching reader");
2627        }
2628        else
2629            if (er->matching_rdr->initial == er->fallback) { //fallbacks only
2630                    er->fallback = NULL; //switch them
2631                    er->reader_count = er->reader_avail;
2632            }
2633
2634        //we have to go through matching_reader() to check services!
2635        if (er->rc == E_UNHANDLED)
2636                er->rc = check_and_store_ecmcache(er, client->grp);
2637    }
2638
2639#ifdef WITH_LB
2640    if (locked)
2641        cs_unlock(&get_cw_lock);
2642#endif
2643
2644    if (er->rc == E_99)
2645            return; //ECM already requested / found in ECM cache
2646
2647    if (er->rc < E_UNHANDLED) {
2648        if (cfg.delay)
2649            cs_sleepms(cfg.delay);
2650
2651        send_dcw(client, er);
2652        return;
2653    }
2654
2655    er->rcEx = 0;
2656    request_cw(er, 0, cfg.preferlocalcards ? 1 : 0);
2657}
2658
2659void do_emm(struct s_client * client, EMM_PACKET *ep)
2660{
2661    char *typtext[]={"unknown", "unique", "shared", "global"};
2662
2663    struct s_reader *aureader = NULL;
2664    cs_ddump_mask(D_EMM, ep->emm, ep->l, "emm:");
2665
2666    LL_ITER itr = ll_iter_create(client->aureader_list);
2667    while ((aureader = ll_iter_next(&itr))) {
2668        if (!aureader->enable)
2669            continue;
2670
2671        uint16_t caid = b2i(2, ep->caid);
2672        uint32_t provid = b2i(4, ep->provid);
2673
2674        if (aureader->audisabled) {
2675            cs_debug_mask(D_EMM, "AU is disabled for reader %s", aureader->label);
2676            continue;
2677        }
2678
2679        if (!(aureader->grp & client->grp)) {
2680            cs_debug_mask(D_EMM, "skip emm reader %s group mismatch", aureader->label);
2681            continue;
2682        }
2683
2684        //TODO: provider possibly not set yet, this is done in get_emm_type()
2685        if (!emm_reader_match(aureader, caid, provid))
2686            continue;
2687
2688        struct s_cardsystem *cs = NULL;
2689
2690        if (aureader->typ & R_IS_CASCADING) { // network reader (R_CAMD35 R_NEWCAMD R_CS378X R_CCCAM)
2691            if (!aureader->ph.c_send_emm) // no emm support
2692                continue;
2693
2694            cs = get_cardsystem_by_caid(caid);
2695            if (!cs) {
2696                cs_debug_mask(D_EMM, "unable to find cardsystem for caid %04X, reader %s", caid, aureader->label);
2697                continue;
2698            }
2699        } else { // local reader
2700            if (aureader->csystem.active)
2701                cs=&aureader->csystem;
2702        }
2703
2704        if (cs && cs->get_emm_type) {
2705            if(!cs->get_emm_type(ep, aureader)) {
2706                cs_debug_mask(D_EMM, "emm skipped, get_emm_type() returns error, reader %s", aureader->label);
2707                client->emmnok++;
2708                if (client->account)
2709                    client->account->emmnok++;
2710                first_client->emmnok++;
2711                continue;
2712            }
2713        }
2714
2715        cs_debug_mask(D_EMM, "emmtype %s. Reader %s has serial %s.", typtext[ep->type], aureader->label, cs_hexdump(0, aureader->hexserial, 8));
2716        cs_ddump_mask(D_EMM, ep->hexserial, 8, "emm UA/SA:");
2717
2718        client->last=time((time_t)0);
2719        if ((1<<(ep->emm[0] % 0x80)) & aureader->s_nano) { //should this nano be saved?
2720            char token[256];
2721            FILE *fp;
2722            time_t rawtime;
2723            time (&rawtime);
2724            struct tm timeinfo;
2725            localtime_r (&rawtime, &timeinfo);  /* to access LOCAL date/time info */
2726            char buf[80];
2727            strftime (buf, 80, "%Y/%m/%d %H:%M:%S", &timeinfo);
2728            snprintf (token, sizeof(token), "%s%s_emm.log", cfg.emmlogdir?cfg.emmlogdir:cs_confdir, aureader->label);
2729            int32_t emm_length = ((ep->emm[1] & 0x0f) << 8) | ep->emm[2];
2730
2731            if (!(fp = fopen (token, "a"))) {
2732                cs_log ("ERROR: Cannot open file '%s' (errno=%d: %s)\n", token, errno, strerror(errno));
2733            } else {
2734                fprintf (fp, "%s   %s   ", buf, cs_hexdump(0, ep->hexserial, 8));
2735                fprintf (fp, "%s\n", cs_hexdump(0, ep->emm, emm_length + 3));
2736                fclose (fp);
2737                cs_log ("Succesfully added EMM to %s.", token);
2738            }
2739
2740            snprintf (token, sizeof(token), "%s%s_emm.bin", cfg.emmlogdir?cfg.emmlogdir:cs_confdir, aureader->label);
2741            if (!(fp = fopen (token, "ab"))) {
2742                cs_log ("ERROR: Cannot open file '%s' (errno=%d: %s)\n", token, errno, strerror(errno));
2743            } else {
2744                if ((int)fwrite(ep->emm, 1, emm_length+3, fp) == emm_length+3)  {
2745                    cs_log ("Succesfully added binary EMM to %s.", token);
2746                } else {
2747                    cs_log ("ERROR: Cannot write binary EMM to %s (errno=%d: %s)\n", token, errno, strerror(errno));
2748                }
2749                fclose (fp);
2750            }
2751        }
2752
2753        int32_t is_blocked = 0;
2754        switch (ep->type) {
2755            case UNKNOWN: is_blocked = (aureader->blockemm & EMM_UNKNOWN) ? 1 : 0;
2756                break;
2757            case UNIQUE: is_blocked = (aureader->blockemm & EMM_UNIQUE) ? 1 : 0;
2758                break;
2759            case SHARED: is_blocked = (aureader->blockemm & EMM_SHARED) ? 1 : 0;
2760                break;
2761            case GLOBAL: is_blocked = (aureader->blockemm & EMM_GLOBAL) ? 1 : 0;
2762                break;
2763        }
2764
2765        if (is_blocked != 0) {
2766#ifdef WEBIF
2767            aureader->emmblocked[ep->type]++;
2768            is_blocked = aureader->emmblocked[ep->type];
2769#endif
2770            /* we have to write the log for blocked EMM here because
2771             this EMM never reach the reader module where the rest
2772             of EMM log is done. */
2773            if (aureader->logemm & 0x08)  {
2774                cs_log("%s emmtype=%s, len=%d, idx=0, cnt=%d: blocked (0 ms) by %s",
2775                        client->account->usr,
2776                        typtext[ep->type],
2777                        ep->emm[2],
2778                        is_blocked,
2779                        aureader->label);
2780            }
2781            continue;
2782        }
2783
2784        client->lastemm = time((time_t)0);
2785
2786        client->emmok++;
2787        if (client->account)
2788            client->account->emmok++;
2789        first_client->emmok++;
2790
2791        ep->client = cur_client();
2792        cs_debug_mask(D_EMM, "emm is being sent to reader %s.", aureader->label);
2793        write_to_pipe(aureader->fd, PIP_ID_EMM, (uchar *) ep, sizeof(EMM_PACKET));
2794    }
2795}
2796
2797int32_t chk_pending(int32_t timeout)
2798{
2799    int32_t i, pending=0;
2800    uint32_t td;
2801    struct timeb tpn, tpe, tpc; // <n>ow, <e>nd, <c>heck
2802
2803    ECM_REQUEST *er;
2804    cs_ftime(&tpn);
2805
2806    tpe=tpn;
2807    tpe.time+=timeout;
2808
2809    struct s_client *cl = cur_client();
2810
2811    if (cl->ecmtask)
2812        i=(ph[cl->ctyp].multi)?CS_MAXPENDING:1;
2813    else
2814        i=0;
2815
2816    //cs_log("num pend=%d", i);
2817
2818    for (--i; i>=0; i--) {
2819
2820        if (cl->ecmtask[i].rc>=E_99) { // check all pending ecm-requests
2821            int32_t act=1;
2822            er=&cl->ecmtask[i];
2823            pending++;
2824
2825            //additional cache check:
2826            if (check_cwcache2(er, cl->grp)) {
2827                    //cs_log("found lost entry in cache! %s %04X&%06X/%04X", username(cl), er->caid, er->prid, er->srvid);
2828                    er->rc = E_CACHE2;
2829                    send_dcw(cl, er);
2830                    continue;
2831            }
2832
2833
2834            tpc=er->tps;
2835            uint32_t tt;
2836            tt = (er->stage) ? cfg.ctimeout : cfg.ftimeout;
2837            tpc.time +=tt / 1000;
2838            tpc.millitm += tt % 1000;
2839            if (!er->stage && er->rc >= E_UNHANDLED) {
2840
2841                LL_NODE *ptr;
2842                for (ptr = er->matching_rdr->initial; ptr && ptr != er->fallback; ptr = ptr->nxt)
2843                    if (!cfg.preferlocalcards ||
2844                                (cfg.preferlocalcards && !er->locals_done && (!(((struct s_reader*)ptr->obj)->typ & R_IS_NETWORK))) ||
2845                                (cfg.preferlocalcards && er->locals_done && (((struct s_reader*)ptr->obj)->typ & R_IS_NETWORK)))
2846                                act=0;
2847
2848                //cs_log("stage 0, act=%d r0=%d, r1=%d, r2=%d, r3=%d, r4=%d r5=%d", act,
2849                //    er->matching_rdr[0], er->matching_rdr[1], er->matching_rdr[2],
2850                //    er->matching_rdr[3], er->matching_rdr[4], er->matching_rdr[5]);
2851
2852                if (act) {
2853                    int32_t inc_stage = 1;
2854                    if (cfg.preferlocalcards && !er->locals_done) {
2855                        er->locals_done = 1;
2856                        struct s_reader *rdr;
2857                        for (rdr=first_active_reader; rdr ; rdr=rdr->next)
2858                            if (rdr->typ & R_IS_NETWORK)
2859                                inc_stage = 0;
2860                    }
2861                    uint32_t tt;
2862                    if (!inc_stage) {
2863                        request_cw(er, er->stage, 2);
2864                        tt = 1000 * (tpn.time - er->tps.time) + tpn.millitm - er->tps.millitm;
2865                    } else {
2866                        er->locals_done = 0;
2867                        er->stage++;
2868                        request_cw(er, er->stage, cfg.preferlocalcards ? 1 : 0);
2869
2870                        tt = (cfg.ctimeout-cfg.ftimeout);
2871                    }
2872                    tpc.time += tt / 1000;
2873                    tpc.millitm += tt % 1000;
2874                }
2875            }
2876            if (comp_timeb(&tpn, &tpc)>0) { // action needed
2877                //cs_log("Action now %d.%03d", tpn.time, tpn.millitm);
2878                //cs_log("           %d.%03d", tpc.time, tpc.millitm);
2879                if (er->stage) {
2880                    er->rc = E_TIMEOUT;
2881                    er->rcEx = 0;
2882#ifdef WITH_LB
2883                    if (cfg.lb_mode) {
2884                        LL_NODE *ptr;
2885                        for (ptr = er->matching_rdr->initial; ptr ; ptr = ptr->nxt)
2886                            send_reader_stat((struct s_reader *)ptr->obj, er, E_TIMEOUT);
2887                    }
2888#endif
2889                    store_cw_in_cache(er, cl->grp, E_TIMEOUT);
2890                    send_dcw(cl, er);
2891                    continue;
2892                } else {
2893                    er->stage++;
2894                    cs_debug_mask(D_TRACE, "fallback for %s %04X&%06X/%04X", username(cl), er->caid, er->prid, er->srvid);
2895                    if (er->rc >= E_UNHANDLED) //do not request rc=99
2896                            request_cw(er, er->stage, 0);
2897                    uint32_t tt;
2898                    tt = (cfg.ctimeout-cfg.ftimeout);
2899                    tpc.time += tt / 1000;
2900                    tpc.millitm += tt % 1000;
2901                }
2902            }
2903
2904            //build_delay(&tpe, &tpc);
2905            if (comp_timeb(&tpe, &tpc)>0) {
2906                tpe.time=tpc.time;
2907                tpe.millitm=tpc.millitm;
2908            }
2909        }
2910    }
2911
2912    td=(tpe.time-tpn.time)*1000+(tpe.millitm-tpn.millitm)+5;
2913    cl->pending=pending;
2914
2915    return td;
2916}
2917
2918int32_t process_input(uchar *buf, int32_t l, int32_t timeout)
2919{
2920    int32_t rc, i, pfdcount;
2921    struct pollfd pfd[2];
2922    struct s_client *cl = cur_client();
2923
2924    time_t starttime = time(NULL);
2925
2926    while (1) {
2927        pfdcount = 0;
2928        if (cl->pfd) {
2929            pfd[pfdcount].fd = cl->pfd;
2930            pfd[pfdcount++].events = POLLIN | POLLPRI;
2931        }
2932
2933        if (cl->fd_m2c_c) {
2934            pfd[pfdcount].fd = cl->fd_m2c_c;
2935            pfd[pfdcount++].events = POLLIN | POLLPRI;
2936        }
2937
2938        int32_t p_rc = poll(pfd, pfdcount, chk_pending(timeout));
2939
2940        if (p_rc < 0) {
2941            if (errno==EINTR) continue;
2942            else return(0);
2943        }
2944
2945        if (p_rc == 0 && (starttime+timeout) < time(NULL)) { // client maxidle reached
2946            rc=(-9);
2947            break;
2948        }
2949
2950        for (i=0;i<pfdcount && p_rc > 0;i++) {
2951            if (!(pfd[i].revents & (POLLIN | POLLPRI)))
2952                continue;
2953
2954            if (pfd[i].fd == cl->fd_m2c_c) {
2955                if (process_client_pipe(cl, buf, l)==PIP_ID_UDP)
2956                    return ph[cl->ctyp].recv(cl, buf, l);
2957            }
2958
2959            if (pfd[i].fd == cl->pfd)
2960                return ph[cl->ctyp].recv(cl, buf, l);
2961        }
2962    }
2963    return(rc);
2964}
2965
2966static void restart_clients()
2967{
2968    cs_log("restarting clients");
2969    struct s_client *cl;
2970    for (cl=first_client->next; cl ; cl=cl->next)
2971        if (cl->typ=='c' && ph[cl->ctyp].type & MOD_CONN_NET) {
2972            kill_thread(cl);
2973            cs_log("killing client c %8X", (uintptr_t)(cl->thread));
2974        }
2975}
2976
2977
2978static void process_master_pipe(int32_t mfdr)
2979{
2980  int32_t n;
2981  uchar *ptr;
2982
2983  switch(n=read_from_pipe(mfdr, &ptr))
2984  {
2985    case PIP_ID_KCL: //Kill all clients
2986        restart_clients();
2987        break;
2988    case PIP_ID_ERR:
2989        cs_exit(1); //better than reading from dead pipe!
2990        break;
2991    default:
2992       cs_log("unhandled pipe message %d (master pipe)", n);
2993       break;
2994  }
2995  if (ptr) free(ptr);
2996}
2997
2998
2999int32_t process_client_pipe(struct s_client *cl, uchar *buf, int32_t l) {
3000    uchar *ptr;
3001    uint16_t n;
3002    int32_t pipeCmd = read_from_pipe(cl->fd_m2c_c, &ptr);
3003
3004    switch(pipeCmd) {
3005        case PIP_ID_ECM:
3006            chk_dcw(cl, (ECM_REQUEST *)ptr);
3007            break;
3008        case PIP_ID_UDP:
3009            if (ptr[0]!='U') {
3010                cs_log("INTERNAL PIPE-ERROR");
3011            }
3012            memcpy(&n, ptr+1, 2);
3013            if (n+3<=l) {
3014                memcpy(buf, ptr, n+3);
3015            }
3016            break;
3017        case PIP_ID_ERR:
3018            cs_exit(1);
3019            break;
3020        default:
3021            cs_log("unhandled pipe message %d (client %s)", pipeCmd, cl->account->usr);
3022            break;
3023    }
3024    if (ptr) free(ptr);
3025    return pipeCmd;
3026}
3027
3028void cs_waitforcardinit()
3029{
3030    if (cfg.waitforcards)
3031    {
3032        cs_log("waiting for local card init");
3033        int32_t card_init_done;
3034        do {
3035            card_init_done = 1;
3036            struct s_reader *rdr;
3037            for (rdr=first_active_reader; rdr ; rdr=rdr->next)
3038                if (((rdr->typ & R_IS_CASCADING) == 0) && (rdr->card_status == CARD_NEED_INIT || rdr->card_status == UNKNOWN)) {
3039                    card_init_done = 0;
3040                    break;
3041                }
3042            if (!card_init_done)
3043                cs_sleepms(300); // wait a little bit
3044            //alarm(cfg.cmaxidle + cfg.ctimeout / 1000 + 1);
3045        } while (!card_init_done);
3046        if (cfg.waitforcards_extra_delay>0)
3047            cs_sleepms(cfg.waitforcards_extra_delay);
3048        cs_log("init for all local cards done");
3049    }
3050}
3051
3052int32_t accept_connection(int32_t i, int32_t j) {
3053    struct   sockaddr_in cad;
3054    int32_t scad,n;
3055    scad = sizeof(cad);
3056    uchar    buf[2048];
3057
3058    if (ph[i].type==MOD_CONN_UDP) {
3059
3060        if ((n=recvfrom(ph[i].ptab->ports[j].fd, buf+3, sizeof(buf)-3, 0, (struct sockaddr *)&cad, (socklen_t *)&scad))>0) {
3061            struct s_client *cl;
3062            cl=idx_from_ip(cad.sin_addr.s_addr, ntohs(cad.sin_port));
3063
3064            uint16_t rl;
3065            rl=n;
3066            buf[0]='U';
3067            memcpy(buf+1, &rl, 2);
3068
3069            if (!cl) {
3070                if (cs_check_violation((uint32_t)cad.sin_addr.s_addr))
3071                    return 0;
3072                //printf("IP: %s - %d\n", inet_ntoa(*(struct in_addr *)&cad.sin_addr.s_addr), cad.sin_addr.s_addr);
3073
3074                cl = create_client(cad.sin_addr.s_addr);
3075                if (!cl) return 0;
3076
3077                cl->ctyp=i;
3078                cl->port_idx=j;
3079                cl->udp_fd=ph[i].ptab->ports[j].fd;
3080                cl->udp_sa=cad;
3081
3082                cl->port=ntohs(cad.sin_port);
3083                cl->typ='c';
3084
3085                write_to_pipe(cl->fd_m2c, PIP_ID_UDP, (uchar*)&buf, n+3);
3086
3087                pthread_attr_t attr;
3088                pthread_attr_init(&attr);
3089#ifndef TUXBOX
3090                pthread_attr_setstacksize(&attr, PTHREAD_STACK_SIZE);
3091#endif
3092                //We need memory here, because when on stack and we leave the function, stack is overwritten,
3093                //but assigned to the thread
3094                //So alloc memory for the init data and free them in clientthread_init:
3095                struct s_clientinit *init = cs_malloc(&init, sizeof(struct s_clientinit), 0);
3096                init->handler = ph[i].s_handler;
3097                init->client = cl;
3098                if (pthread_create(&cl->thread, &attr, clientthread_init, (void*) init)) {
3099                    cs_log("ERROR: can't create thread for UDP client from %s", inet_ntoa(*(struct in_addr *)&cad.sin_addr.s_addr));
3100                    cleanup_thread(cl);
3101                    free(init);
3102                }
3103                else
3104                    pthread_detach(cl->thread);
3105                pthread_attr_destroy(&attr);
3106            } else {
3107                write_to_pipe(cl->fd_m2c, PIP_ID_UDP, (uchar*)&buf, n+3);
3108            }
3109        }
3110    } else { //TCP
3111
3112        int32_t pfd3;
3113        if ((pfd3=accept(ph[i].ptab->ports[j].fd, (struct sockaddr *)&cad, (socklen_t *)&scad))>0) {
3114
3115            if (cs_check_violation((uint32_t)cad.sin_addr.s_addr)) {
3116                close(pfd3);
3117                return 0;
3118            }
3119
3120            struct s_client * cl = create_client(cad.sin_addr.s_addr);
3121            if (cl == NULL) {
3122                close(pfd3);
3123                return 0;
3124            }
3125
3126            int32_t flag = 1;
3127            setsockopt(pfd3, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int));
3128
3129            cl->ctyp=i;
3130            cl->udp_fd=pfd3;
3131            cl->port_idx=j;
3132
3133            cl->pfd=pfd3;
3134            cl->port=ntohs(cad.sin_port);
3135            cl->typ='c';
3136
3137            pthread_attr_t attr;
3138            pthread_attr_init(&attr);
3139#ifndef TUXBOX
3140            pthread_attr_setstacksize(&attr, PTHREAD_STACK_SIZE);
3141#endif
3142
3143            //We need memory here, because when on stack and we leave the function, stack is overwritten,
3144            //but assigned to the thread
3145            //So alloc memory for the init data and free them in clientthread_init:
3146            struct s_clientinit *init = cs_malloc(&init, sizeof(struct s_clientinit), 0);
3147            init->handler = ph[i].s_handler;
3148            init->client = cl;
3149            if (pthread_create(&cl->thread, &attr, clientthread_init, (void*) init)) {
3150                cs_log("ERROR: can't create thread for TCP client from %s", inet_ntoa(*(struct in_addr *)&cad.sin_addr.s_addr));
3151                cleanup_thread(cl);
3152                free(init);
3153            }
3154            else
3155                pthread_detach(cl->thread);
3156            pthread_attr_destroy(&attr);
3157        }
3158    }
3159    return 0;
3160}
3161
3162#ifdef WEBIF
3163static void restart_daemon()
3164{
3165  while (1) {
3166
3167    //start client process:
3168    pid_t pid = fork();
3169    if (!pid)
3170      return; //client process=oscam process
3171    if (pid < 0)
3172      exit(1);
3173
3174    //restart control process:
3175    int32_t res=0;
3176    int32_t status=0;
3177    do {
3178      res = waitpid(pid, &status, 0);
3179      if (res==-1) {
3180        if (errno!=EINTR)
3181          exit(1);
3182      }
3183    } while (res!=pid);
3184
3185    if (cs_restart_mode==2 && WIFSIGNALED(status) && WTERMSIG(status)==SIGSEGV)
3186      status=99; //restart on segfault!
3187    else
3188      status = WEXITSTATUS(status);
3189
3190    //status=99 restart oscam, all other->terminate
3191    if (status!=99) {
3192      exit(status);
3193    }
3194  }
3195}
3196#endif
3197
3198int32_t main (int32_t argc, char *argv[])
3199{
3200
3201if (pthread_key_create(&getclient, NULL)) {
3202  fprintf(stderr, "Could not create getclient, exiting...");
3203  exit(1);
3204}
3205#ifdef CS_LED
3206  cs_switch_led(LED1A, LED_DEFAULT);
3207  cs_switch_led(LED1A, LED_ON);
3208#endif
3209
3210  //struct   sockaddr_in cad;     /* structure to hold client's address */
3211  //int32_t      scad;                /* length of address */
3212  //int32_t      fd;                  /* socket descriptors */
3213  int32_t      i, j;
3214  int32_t      bg=0;
3215  int32_t      gbdb=0;
3216  int32_t      gfd; //nph,
3217  int32_t      fdp[2];
3218  int32_t      mfdr=0;     // Master FD (read)
3219  int32_t      fd_c2m=0;
3220
3221  void (*mod_def[])(struct s_module *)=
3222  {
3223#ifdef MODULE_MONITOR
3224           module_monitor,
3225#endif
3226#ifdef MODULE_CAMD33
3227           module_camd33,
3228#endif
3229#ifdef MODULE_CAMD35
3230           module_camd35,
3231#endif
3232#ifdef MODULE_CAMD35_TCP
3233           module_camd35_tcp,
3234#endif
3235#ifdef MODULE_NEWCAMD
3236           module_newcamd,
3237#endif
3238#ifdef MODULE_CCCAM
3239           module_cccam,
3240#endif
3241#ifdef MODULE_GBOX
3242           module_gbox,
3243#endif
3244#ifdef MODULE_CONSTCW
3245           module_constcw,
3246#endif
3247#ifdef MODULE_RADEGAST
3248           module_radegast,
3249#endif
3250#ifdef MODULE_SERIAL
3251           module_oscam_ser,
3252#endif
3253#ifdef HAVE_DVBAPI
3254       module_dvbapi,
3255#endif
3256           0
3257  };
3258
3259  void (*cardsystem_def[])(struct s_cardsystem *)=
3260  {
3261#ifdef READER_NAGRA
3262    reader_nagra,
3263#endif
3264#ifdef READER_IRDETO
3265    reader_irdeto,
3266#endif
3267#ifdef READER_CONAX
3268    reader_conax,
3269#endif
3270#ifdef READER_CRYPTOWORKS
3271    reader_cryptoworks,
3272#endif
3273#ifdef READER_SECA
3274    reader_seca,
3275#endif
3276#ifdef READER_VIACCESS
3277    reader_viaccess,
3278#endif
3279#ifdef READER_VIDEOGUARD
3280    reader_videoguard1,
3281    reader_videoguard2,
3282    reader_videoguard12,
3283#endif
3284#ifdef READER_DRE
3285    reader_dre,
3286#endif
3287#ifdef READER_TONGFANG
3288    reader_tongfang,
3289#endif
3290    0
3291  };
3292
3293  void (*cardreader_def[])(struct s_cardreader *)=
3294  {
3295    cardreader_mouse,
3296    cardreader_smargo,
3297#ifdef WITH_STAPI
3298    cardreader_stapi,
3299#endif
3300    0
3301  };
3302
3303  while ((i=getopt(argc, argv, "gbsc:t:d:r:hm:x"))!=EOF)
3304  {
3305      switch(i) {
3306          case 'g':
3307              gbdb=1;
3308              break;
3309          case 'b':
3310              bg=1;
3311              break;
3312          case 's':
3313              cs_capture_SEGV=1;
3314              break;
3315          case 'c':
3316              cs_strncpy(cs_confdir, optarg, sizeof(cs_confdir));
3317              break;
3318          case 'd':
3319              cs_dblevel=atoi(optarg);
3320              break;
3321#ifdef WEBIF
3322                  case 'r':
3323                          cs_restart_mode=atoi(optarg);
3324                          break;
3325#endif
3326          case 't':
3327              mkdir(optarg, S_IRWXU);
3328              j = open(optarg, O_RDONLY);
3329              if (j >= 0) {
3330                close(j);
3331                cs_strncpy(cs_tmpdir, optarg, sizeof(cs_tmpdir));
3332              } else {
3333                printf("WARNING: tmpdir does not exist. using default value.\n");
3334              }
3335              break;
3336          case 'm':
3337                printf("WARNING: -m parameter is deprecated, ignoring it.\n");
3338                break;
3339          case 'h':
3340          default :
3341              usage();
3342      }
3343  }
3344
3345
3346#ifdef OS_MACOSX
3347  if (bg && daemon_compat(1,0))
3348#else
3349  if (bg && daemon(1,0))
3350#endif
3351  {
3352    printf("Error starting in background (errno=%d: %s)", errno, strerror(errno));
3353    cs_exit(1);
3354  }
3355
3356#ifdef WEBIF
3357  if (cs_restart_mode)
3358    restart_daemon();
3359#endif
3360
3361  memset(&cfg, 0, sizeof(struct s_config));
3362
3363  if (cs_confdir[strlen(cs_confdir)]!='/') strcat(cs_confdir, "/");
3364  init_signal_pre(); // because log could cause SIGPIPE errors, init a signal handler first
3365  init_first_client();
3366  init_config();
3367  init_check();
3368#ifdef WITH_LB
3369  init_stat();
3370#endif
3371
3372  for (i=0; mod_def[i]; i++)  // must be later BEFORE init_config()
3373  {
3374    memset(&ph[i], 0, sizeof(struct s_module));
3375    mod_def[i](&ph[i]);
3376  }
3377  for (i=0; cardsystem_def[i]; i++)  // must be later BEFORE init_config()
3378  {
3379    memset(&cardsystem[i], 0, sizeof(struct s_cardsystem));
3380    cardsystem_def[i](&cardsystem[i]);
3381  }
3382
3383  memset(&cardreader, 0, sizeof(struct s_cardsystem) * CS_MAX_MOD);
3384  for (i=0; cardreader_def[i]; i++)  // must be later BEFORE init_config()
3385  {
3386    cardreader_def[i](&cardreader[i]);
3387  }
3388
3389  init_rnd();
3390  init_sidtab();
3391  init_readerdb();
3392  cfg.account = init_userdb();
3393  init_signal();
3394  init_srvid();
3395  init_tierid();
3396  //Todo #ifdef CCCAM
3397  init_provid();
3398
3399  start_garbage_collector(gbdb);
3400
3401  init_len4caid();
3402#ifdef IRDETO_GUESSING
3403  init_irdeto_guess_tab();
3404#endif
3405
3406
3407  if (pipe(fdp))
3408  {
3409    cs_log("Cannot create pipe (errno=%d: %s)", errno, strerror(errno));
3410    cs_exit(1);
3411  }
3412  mfdr=fdp[0];
3413  fd_c2m=fdp[1];
3414  gfd=mfdr+1;
3415
3416  first_client->fd_m2c=fd_c2m;
3417  first_client->fd_m2c_c=mfdr;
3418
3419  write_versionfile();
3420  server_pid = getpid();
3421
3422#if defined(AZBOX) && defined(HAVE_DVBAPI)
3423  openxcas_debug_message_onoff(1);  // debug
3424
3425#ifdef WITH_CARDREADER
3426  if (openxcas_open_with_smartcard("oscamCAS") < 0) {
3427#else
3428  if (openxcas_open("oscamCAS") < 0) {
3429#endif
3430    cs_log("openxcas: could not init");
3431  }
3432#endif
3433
3434  for (i=0; i<CS_MAX_MOD; i++)
3435    if( (ph[i].type & MOD_CONN_NET) && ph[i].ptab )
3436      for(j=0; j<ph[i].ptab->nports; j++)
3437      {
3438        start_listener(&ph[i], j);
3439        if( ph[i].ptab->ports[j].fd+1>gfd )
3440          gfd=ph[i].ptab->ports[j].fd+1;
3441      }
3442
3443    //set time for server to now to avoid 0 in monitor/webif
3444    first_client->last=time((time_t *)0);
3445
3446#ifdef WEBIF
3447  if(cfg.http_port == 0)
3448    cs_log("http disabled");
3449  else
3450    start_thread((void *) &http_srv, "http");
3451#endif
3452
3453#ifdef LCDSUPPORT
3454  start_lcd_thread();
3455#endif
3456
3457    init_cardreader();
3458
3459    cs_waitforcardinit();
3460
3461#ifdef CS_LED
3462    cs_switch_led(LED1A, LED_OFF);
3463    cs_switch_led(LED1B, LED_ON);
3464#endif
3465
3466#ifdef QBOXHD_LED
3467    if(!cfg.disableqboxhdled)
3468        cs_log("QboxHD LED enabled");
3469    qboxhd_led_blink(QBOXHD_LED_COLOR_YELLOW,QBOXHD_LED_BLINK_FAST);
3470    qboxhd_led_blink(QBOXHD_LED_COLOR_RED,QBOXHD_LED_BLINK_FAST);
3471    qboxhd_led_blink(QBOXHD_LED_COLOR_GREEN,QBOXHD_LED_BLINK_FAST);
3472    qboxhd_led_blink(QBOXHD_LED_COLOR_BLUE,QBOXHD_LED_BLINK_FAST);
3473    qboxhd_led_blink(QBOXHD_LED_COLOR_MAGENTA,QBOXHD_LED_BLINK_FAST);
3474#endif
3475
3476#ifdef CS_ANTICASC
3477    if( !cfg.ac_enabled )
3478        cs_log("anti cascading disabled");
3479    else {
3480        init_ac();
3481        start_thread((void *) &start_anticascader, "anticascader"); // 96
3482
3483    }
3484#endif
3485
3486    for (i=0; i<CS_MAX_MOD; i++)
3487        if (ph[i].type & MOD_CONN_SERIAL)   // for now: oscam_ser only
3488            if (ph[i].s_handler)
3489                ph[i].s_handler(i);
3490
3491    //cs_close_log();
3492    while (!exit_oscam) {
3493        fd_set fds;
3494
3495        do {
3496                //timeout value for checking exit_oscam:
3497                        struct timeval timeout;
3498                        timeout.tv_sec = 1;
3499                        timeout.tv_usec = 0;
3500
3501                        //Wait for incoming data
3502            FD_ZERO(&fds);
3503            FD_SET(mfdr, &fds);
3504            for (i=0; i<CS_MAX_MOD; i++)
3505                if ( (ph[i].type & MOD_CONN_NET) && ph[i].ptab )
3506                    for (j=0; j<ph[i].ptab->nports; j++)
3507                        if (ph[i].ptab->ports[j].fd)
3508                            FD_SET(ph[i].ptab->ports[j].fd, &fds);
3509            errno=0;
3510            select(gfd, &fds, 0, 0, &timeout);
3511        } while (errno==EINTR && !exit_oscam); //if timeout accurs and exit_oscam is set, we break the loop
3512
3513        if (exit_oscam)
3514                break;
3515
3516        first_client->last=time((time_t *)0);
3517
3518        if (FD_ISSET(mfdr, &fds)) {
3519            process_master_pipe(mfdr);
3520        }
3521        for (i=0; i<CS_MAX_MOD; i++) {
3522            if( (ph[i].type & MOD_CONN_NET) && ph[i].ptab ) {
3523                for( j=0; j<ph[i].ptab->nports; j++ ) {
3524                    if( ph[i].ptab->ports[j].fd && FD_ISSET(ph[i].ptab->ports[j].fd, &fds) ) {
3525                        accept_connection(i,j);
3526                    }
3527                }
3528            } // if (ph[i].type & MOD_CONN_NET)
3529        }
3530    }
3531
3532#if defined(AZBOX) && defined(HAVE_DVBAPI)
3533  if (openxcas_close() < 0) {
3534    cs_log("openxcas: could not close");
3535  }
3536#endif
3537
3538        cs_cleanup();
3539
3540        stop_garbage_collector();
3541
3542    return exit_oscam;
3543}
3544
3545#ifdef WEBIF
3546void cs_exit_oscam()
3547{
3548  exit_oscam=1;
3549  cs_log("exit oscam requested");
3550}
3551
3552void cs_restart_oscam()
3553{
3554  exit_oscam=99;
3555  cs_log("restart oscam requested");
3556}
3557
3558int32_t cs_get_restartmode() {
3559    return cs_restart_mode;
3560}
3561
3562#endif
3563
3564#ifdef CS_LED
3565void cs_switch_led(int32_t led, int32_t action) {
3566
3567    if(action < 2) { // only LED_ON and LED_OFF
3568        char ledfile[256];
3569        FILE *f;
3570
3571        #ifdef DOCKSTAR
3572            switch(led){
3573            case LED1A:snprintf(ledfile, 255, "/sys/class/leds/dockstar:orange:misc/brightness");
3574            break;
3575            case LED1B:snprintf(ledfile, 255, "/sys/class/leds/dockstar:green:health/brightness");
3576            break;
3577            case LED2:snprintf(ledfile, 255, "/sys/class/leds/dockstar:green:health/brightness");
3578            break;
3579            case LED3:snprintf(ledfile, 255, "/sys/class/leds/dockstar:orange:misc/brightness");
3580            break;
3581            }
3582        #elif WRT350NV2
3583            switch(led){
3584            case LED1A:snprintf(ledfile, 255, "/sys/class/leds/wrt350nv2:orange:power/brightness");
3585            break;
3586            case LED1B:snprintf(ledfile, 255, "/sys/class/leds/wrt350nv2:green:power/brightness");
3587            break;
3588            case LED2:snprintf(ledfile, 255, "/sys/class/leds/wrt350nv2:green:wireless/brightness");
3589            break;
3590            case LED3:snprintf(ledfile, 255, "/sys/class/leds/wrt350nv2:green:security/brightness");
3591            break;
3592            }
3593        #else
3594            switch(led){
3595            case LED1A:snprintf(ledfile, 255, "/sys/class/leds/nslu2:red:status/brightness");
3596            break;
3597            case LED1B:snprintf(ledfile, 255, "/sys/class/leds/nslu2:green:ready/brightness");
3598            break;
3599            case LED2:snprintf(ledfile, 255, "/sys/class/leds/nslu2:green:disk-1/brightness");
3600            break;
3601            case LED3:snprintf(ledfile, 255, "/sys/class/leds/nslu2:green:disk-2/brightness");
3602            break;
3603            }
3604        #endif
3605
3606        if (!(f=fopen(ledfile, "w"))){
3607            // FIXME: sometimes cs_log was not available when calling cs_switch_led -> signal 11
3608            //cs_log("Cannot open file \"%s\" (errno=%d %s)", ledfile, errno, strerror(errno));
3609            return;
3610        }
3611        fprintf(f,"%d", action);
3612        fclose(f);
3613    } else { // LED Macros
3614        switch(action){
3615        case LED_DEFAULT:
3616            cs_switch_led(LED1A, LED_OFF);
3617            cs_switch_led(LED1B, LED_OFF);
3618            cs_switch_led(LED2, LED_ON);
3619            cs_switch_led(LED3, LED_OFF);
3620            break;
3621        case LED_BLINK_OFF:
3622            cs_switch_led(led, LED_OFF);
3623            cs_sleepms(100);
3624            cs_switch_led(led, LED_ON);
3625            break;
3626        case LED_BLINK_ON:
3627            cs_switch_led(led, LED_ON);
3628            cs_sleepms(300);
3629            cs_switch_led(led, LED_OFF);
3630            break;
3631        }
3632    }
3633}
3634#endif
3635
3636#ifdef QBOXHD_LED
3637void qboxhd_led_blink(int32_t color, int32_t duration) {
3638    int32_t f;
3639
3640    if (cfg.disableqboxhdled) {
3641        return;
3642    }
3643
3644    // try QboxHD-MINI first
3645    if ( (f = open ( QBOXHDMINI_LED_DEVICE,  O_RDWR |O_NONBLOCK )) > -1 ) {
3646        qboxhdmini_led_color_struct qbminiled;
3647        uint32_t qboxhdmini_color = 0x000000;
3648
3649        if (color != QBOXHD_LED_COLOR_OFF) {
3650            switch(color) {
3651                case QBOXHD_LED_COLOR_RED:
3652                    qboxhdmini_color = QBOXHDMINI_LED_COLOR_RED;
3653                    break;
3654                case QBOXHD_LED_COLOR_GREEN:
3655                    qboxhdmini_color = QBOXHDMINI_LED_COLOR_GREEN;
3656                    break;
3657                case QBOXHD_LED_COLOR_BLUE:
3658                    qboxhdmini_color = QBOXHDMINI_LED_COLOR_BLUE;
3659                    break;
3660                case QBOXHD_LED_COLOR_YELLOW:
3661                    qboxhdmini_color = QBOXHDMINI_LED_COLOR_YELLOW;
3662                    break;
3663                case QBOXHD_LED_COLOR_MAGENTA:
3664                    qboxhdmini_color = QBOXHDMINI_LED_COLOR_MAGENTA;
3665                    break;
3666            }
3667
3668            // set LED on with color
3669            qbminiled.red = (uchar)((qboxhdmini_color&0xFF0000)>>16);  // R
3670            qbminiled.green = (uchar)((qboxhdmini_color&0x00FF00)>>8); // G
3671            qbminiled.blue = (uchar)(qboxhdmini_color&0x0000FF);       // B
3672
3673            ioctl(f,QBOXHDMINI_IOSET_RGB,&qbminiled);
3674            cs_sleepms(duration);
3675        }
3676
3677        // set LED off
3678        qbminiled.red = 0;
3679        qbminiled.green = 0;
3680        qbminiled.blue = 0;
3681
3682        ioctl(f,QBOXHDMINI_IOSET_RGB,&qbminiled);
3683        close(f);
3684
3685    } else if ( (f = open ( QBOXHD_LED_DEVICE,  O_RDWR |O_NONBLOCK )) > -1 ) {
3686
3687        qboxhd_led_color_struct qbled;
3688
3689        if (color != QBOXHD_LED_COLOR_OFF) {
3690            // set LED on with color
3691            qbled.H = color;
3692            qbled.S = 99;
3693            qbled.V = 99;
3694            ioctl(f,QBOXHD_SET_LED_ALL_PANEL_COLOR, &qbled);
3695            cs_sleepms(duration);
3696        }
3697
3698        // set LED off
3699        qbled.H = 0;
3700        qbled.S = 0;
3701        qbled.V = 0;
3702        ioctl(f,QBOXHD_SET_LED_ALL_PANEL_COLOR, &qbled);
3703        close(f);
3704    }
3705
3706    return;
3707}
3708#endif
Note: See TracBrowser for help on using the repository browser.