Changeset 1762


Ignore:
Timestamp:
Mar 3, 2010, 7:57:46 PM (10 years ago)
Author:
alno
Message:

New parameter in [monitor] "appendchaninfo=0|1" appends the channelname on logmessages. Unset = default = 0 = legacy behavior
Some code cleanup

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/globals.h

    r1759 r1762  
    639639    int     mon_hideclient_to;
    640640    int     mon_level;
     641    int     mon_appendchaninfo;
    641642#ifdef WEBIF
    642643    int         http_port;
  • trunk/module-monitor.c

    r1742 r1762  
    252252                    cs_strncpy(name, this->name, 32);
    253253
    254     if (!name[0]) sprintf(name, "[%04X:%04X]", caid, srvid);
     254    if (!name[0]) sprintf(name, "%04X:%04X unknown", caid, srvid);
    255255    if (!srvid) name[0] = '\0';
    256256    return(name);
  • trunk/oscam-config.c

    r1759 r1762  
    628628        } else {
    629629            cfg->mon_hideclient_to = atoi(value);
     630            return;
     631        }
     632    }
     633
     634    if (!strcmp(token, "appendchaninfo")) {
     635        if(strlen(value) == 0) {
     636            cfg->mon_appendchaninfo = 0;
     637            return;
     638        } else {
     639            cfg->mon_appendchaninfo = atoi(value);
    630640            return;
    631641        }
     
    15951605    fprintf_conf(f, CONFVARWIDTH, "hideclient_to", "%d\n", cfg->mon_hideclient_to);
    15961606    fprintf_conf(f, CONFVARWIDTH, "monlevel", "%d\n", cfg->mon_level);
     1607    fprintf_conf(f, CONFVARWIDTH, "appendchaninfo", "%d\n", cfg->mon_appendchaninfo);
    15971608    fputc((int)'\n', f);
    15981609
  • trunk/oscam-log.c

    r1725 r1762  
    1616static void switch_log(char* file, FILE **f, int (*pfinit)(char*))
    1717{
    18   if( cfg->max_log_size && mcl)
    19   {
    20     struct stat stlog;
    21     if( stat(file, &stlog)!=0 )
    22     {
    23       fprintf(stderr, "stat('%s',..) failed (errno=%d)\n", file, errno);
    24       return;
    25     }
    26 
    27     if( stlog.st_size >= cfg->max_log_size*1024 )
    28     {
    29       int rc;
    30       char prev_log[128];
    31       sprintf(prev_log, "%s-prev", file);
    32       fprintf(*f, "switch log file\n");
    33       fflush(*f);
    34       fclose(*f);
    35       *f=(FILE *)0;
    36       rc=rename(file, prev_log);
    37       if( rc!=0 ) {
    38         fprintf(stderr, "rename(%s, %s) failed (errno=%d)\n",
    39                 file, prev_log, errno);
    40       }
    41       else if( pfinit(file))
    42         cs_exit(0);
    43 
    44 
    45     }
    46   }
     18    if( cfg->max_log_size && mcl)
     19    {
     20        struct stat stlog;
     21        if( stat(file, &stlog)!=0 )
     22        {
     23            fprintf(stderr, "stat('%s',..) failed (errno=%d)\n", file, errno);
     24            return;
     25        }
     26
     27        if( stlog.st_size >= cfg->max_log_size*1024 ) {
     28            int rc;
     29            char prev_log[128];
     30            sprintf(prev_log, "%s-prev", file);
     31            fprintf(*f, "switch log file\n");
     32            fflush(*f);
     33            fclose(*f);
     34            *f=(FILE *)0;
     35            rc=rename(file, prev_log);
     36            if( rc!=0 ) {
     37                fprintf(stderr, "rename(%s, %s) failed (errno=%d)\n",
     38                        file, prev_log, errno);
     39            }
     40            else if( pfinit(file))
     41                cs_exit(0);
     42        }
     43    }
    4744}
    4845
     
    137134static void write_to_log(int flag, char *txt)
    138135{
    139 //flag = -1 is old behaviour, before implementation of debug_nolf (=debug no line feed)
    140 //
    141   int i;
    142   time_t t;
    143   struct tm *lt;
    144   char buf[512], sbuf[16];
    145 
    146 //  get_log_header(flag, sbuf);
    147 //  memcpy(txt, sbuf, 11);
    148 
    149 
    150   time(&t);
    151   lt=localtime(&t);
    152   sprintf(buf, "[LOG000]%4d/%02d/%02d %2d:%02d:%02d %s\n",
    153                 lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday,
    154                 lt->tm_hour, lt->tm_min, lt->tm_sec, txt);
    155 
    156   if (use_syslog && !use_ac_log)        // system-logfile
    157     syslog(LOG_INFO, "%s", txt);
    158   time(&t);
    159   lt=localtime(&t);
     136    //flag = -1 is old behaviour, before implementation of debug_nolf (=debug no line feed)
     137    //
     138    int i;
     139    time_t t;
     140    struct tm *lt;
     141    char buf[512], sbuf[16];
     142
     143    //  get_log_header(flag, sbuf);
     144    //  memcpy(txt, sbuf, 11);
     145
     146
     147    time(&t);
     148    lt=localtime(&t);
     149    sprintf(buf, "[LOG000]%4d/%02d/%02d %2d:%02d:%02d %s\n",
     150            lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday,
     151            lt->tm_hour, lt->tm_min, lt->tm_sec, txt);
     152
     153    if (use_syslog && !use_ac_log)      // system-logfile
     154        syslog(LOG_INFO, "%s", txt);
     155
     156    time(&t);
     157    lt=localtime(&t);
     158
    160159    switch(flag) {
    161160        case -1:
    162             sprintf(buf, "[LOG000]%4d/%02d/%02d %2d:%02d:%02d %s\n",
     161        sprintf(buf, "[LOG000]%4d/%02d/%02d %2d:%02d:%02d %s\n",
    163162                lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday,
    164163                lt->tm_hour, lt->tm_min, lt->tm_sec, txt);
    165             break;
     164        break;
    166165        case 1:
    167166            sprintf(buf, "[LOG000]%4d/%02d/%02d %2d:%02d:%02d            %s",
    168                 lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday,
    169                 lt->tm_hour, lt->tm_min, lt->tm_sec, txt);
     167                    lt->tm_year+1900, lt->tm_mon+1, lt->tm_mday,
     168                    lt->tm_hour, lt->tm_min, lt->tm_sec, txt);
    170169            break;
    171170        case 16:
    172171            number_of_chars_printed = 0;
    173         sprintf(buf, "[LOG000]%s\n", txt);
     172            sprintf(buf, "[LOG000]%s\n", txt);
    174173            break;
    175174        default:
    176         sprintf(buf, "[LOG000]%s", txt);
    177     }
    178 
    179   if ((*log_fd) && (client[cs_idx].typ!='l') && (client[cs_idx].typ!='a'))
    180     write_to_pipe(*log_fd, PIP_ID_LOG, (uchar *) buf+8, strlen(buf+8));
    181   else
    182     cs_write_log(buf+8);
    183   store_logentry(buf);
    184 
    185   for (i=0; i<CS_MAXPID; i++)   // monitor-clients
    186   {
    187     if ((client[i].pid) && (client[i].log))
    188     {
    189       if (client[i].monlvl<2)
    190       {
    191         if ((client[cs_idx].typ!='c') && (client[cs_idx].typ!='m'))
    192           continue;
    193         if (strcmp(client[cs_idx].usr, client[i].usr))
    194           continue;
    195       }
    196       sprintf(sbuf, "%03d", client[i].logcounter);
    197       client[i].logcounter=(client[i].logcounter+1) % 1000;
    198       memcpy(buf+4, sbuf, 3);
    199       monitor_send_idx(i, buf);
    200     }
    201   }
     175            sprintf(buf, "[LOG000]%s", txt);
     176    }
     177
     178    if ((*log_fd) && (client[cs_idx].typ != 'l') && (client[cs_idx].typ != 'a'))
     179        write_to_pipe(*log_fd, PIP_ID_LOG, (uchar *) buf+8, strlen(buf+8));
     180    else
     181        cs_write_log(buf + 8);
     182
     183    store_logentry(buf);
     184
     185    for (i = 0; i < CS_MAXPID; i++) // monitor-clients
     186    {
     187        if ((client[i].pid) && (client[i].log))
     188        {
     189            if (client[i].monlvl<2)
     190            {
     191                if ((client[cs_idx].typ != 'c') && (client[cs_idx].typ != 'm'))
     192                    continue;
     193                if (strcmp(client[cs_idx].usr, client[i].usr))
     194                    continue;
     195            }
     196            sprintf(sbuf, "%03d", client[i].logcounter);
     197            client[i].logcounter = (client[i].logcounter+1) % 1000;
     198            memcpy(buf + 4, sbuf, 3);
     199            monitor_send_idx(i, buf);
     200        }
     201    }
    202202}
    203203
    204204void cs_log(char *fmt,...)
    205205{
    206   char txt[256+11];
    207 
    208   get_log_header(1, txt);
    209   va_list params;
    210   va_start(params, fmt);
    211   vsprintf(txt+11, fmt, params);
    212   va_end(params);
    213   write_to_log(-1, txt);
    214 }
    215 
    216 void cs_close_log(void)
    217 {
    218   if (use_stdout || use_syslog || !fp) return;
    219   fclose(fp);
    220   fp=(FILE *)0;
    221 }
    222 
    223 void cs_debug(char *fmt,...)
    224 {
    225   char txt[256];
    226 
    227 //  cs_log("cs_debug called, cs_ptyp=%d, cs_dblevel=%d, %d", cs_ptyp, client[cs_idx].dbglvl ,cs_ptyp & client[cs_idx].dbglvl);
    228   if (client[cs_idx].dbglvl & cs_ptyp)
    229   {
    230     get_log_header(1, txt);
    231     va_list params;
    232     va_start(params, fmt);
    233     vsprintf(txt+11, fmt, params);
    234     va_end(params);
    235     write_to_log(-1, txt);
    236   }
    237 }
    238 
    239 void cs_debug_mask(unsigned short mask, char *fmt,...)
    240 {
    241     char txt[256];
    242   if (client[cs_idx].dbglvl & mask)
    243   {
    244     get_log_header(1, txt);
    245     va_list params;
    246     va_start(params, fmt);
    247     vsprintf(txt+11, fmt, params);
    248     va_end(params);
    249     write_to_log(-1, txt);
    250   }
    251 }
    252 
    253 void cs_debug_nolf(char *fmt,...)
    254 {
    255  char txt[256];
    256 
    257  if (client[cs_idx].dbglvl & cs_ptyp)
    258  {
     206    char txt[256+11];
     207
     208    get_log_header(1, txt);
    259209    va_list params;
    260210    va_start(params, fmt);
    261     vsprintf(txt, fmt, params);
     211    vsprintf(txt+11, fmt, params);
    262212    va_end(params);
    263     if(!memcmp(txt,"\n", 1)) {
    264         number_of_chars_printed = 0;
    265     }
    266     else
    267         number_of_chars_printed++;
    268     write_to_log(number_of_chars_printed, txt);
    269  }
     213    write_to_log(-1, txt);
     214}
     215
     216void cs_close_log(void)
     217{
     218    if (use_stdout || use_syslog || !fp) return;
     219    fclose(fp);
     220    fp=(FILE *)0;
     221}
     222
     223void cs_debug(char *fmt,...)
     224{
     225    char txt[256];
     226
     227    //  cs_log("cs_debug called, cs_ptyp=%d, cs_dblevel=%d, %d", cs_ptyp, client[cs_idx].dbglvl ,cs_ptyp & client[cs_idx].dbglvl);
     228    if (client[cs_idx].dbglvl & cs_ptyp)
     229    {
     230        get_log_header(1, txt);
     231        va_list params;
     232        va_start(params, fmt);
     233        vsprintf(txt+11, fmt, params);
     234        va_end(params);
     235        write_to_log(-1, txt);
     236    }
     237}
     238
     239void cs_debug_mask(unsigned short mask, char *fmt,...)
     240{
     241    char txt[256];
     242    if (client[cs_idx].dbglvl & mask)
     243    {
     244        get_log_header(1, txt);
     245        va_list params;
     246        va_start(params, fmt);
     247        vsprintf(txt+11, fmt, params);
     248        va_end(params);
     249        write_to_log(-1, txt);
     250    }
     251}
     252
     253void cs_debug_nolf(char *fmt,...)
     254{
     255    char txt[256];
     256
     257    if (client[cs_idx].dbglvl & cs_ptyp)
     258    {
     259        va_list params;
     260        va_start(params, fmt);
     261        vsprintf(txt, fmt, params);
     262        va_end(params);
     263        if(!memcmp(txt,"\n", 1)) {
     264            number_of_chars_printed = 0;
     265        }
     266        else
     267            number_of_chars_printed++;
     268        write_to_log(number_of_chars_printed, txt);
     269    }
    270270}
    271271
    272272void cs_dump(uchar *buf, int n, char *fmt, ...)
    273273{
    274   int i;
    275   char txt[512];
    276 
    277   if( fmt )
    278     cs_log(fmt);
    279 
    280   for( i=0; i<n; i+=16 )
    281   {
    282     get_log_header(0, txt);
    283     sprintf(txt+11, "%s", cs_hexdump(1, buf+i, (n-i>16) ? 16 : n-i));
    284     write_to_log(-1, txt);
    285   }
     274    int i;
     275    char txt[512];
     276
     277    if( fmt )
     278        cs_log(fmt);
     279
     280    for( i=0; i<n; i+=16 )
     281    {
     282        get_log_header(0, txt);
     283        sprintf(txt+11, "%s", cs_hexdump(1, buf+i, (n-i>16) ? 16 : n-i));
     284        write_to_log(-1, txt);
     285    }
    286286}
    287287
    288288void cs_ddump(uchar *buf, int n, char *fmt, ...)
    289289{
    290   int i;
    291   char txt[512];
    292 
    293   //if (((cs_ptyp & client[cs_idx].dbglvl)==cs_ptyp) && (fmt))
    294   if ((cs_ptyp & client[cs_idx].dbglvl) && (fmt))
    295   {
    296     get_log_header(1, txt);
    297     va_list params;
    298     va_start(params, fmt);
    299     vsprintf(txt+11, fmt, params);
    300     va_end(params);
    301     write_to_log(-1, txt);
    302 //printf("LOG: %s\n", txt); fflush(stdout);
    303   }
    304   //if (((cs_ptyp | D_DUMP) & client[cs_idx].dbglvl)==(cs_ptyp | D_DUMP))
    305   if (cs_ptyp & client[cs_idx].dbglvl)
    306   {
    307     for (i=0; i<n; i+=16)
    308     {
    309         get_log_header(0, txt);
    310       sprintf(txt+11, "%s", cs_hexdump(1, buf+i, (n-i>16) ? 16 : n-i));
    311       write_to_log(-1, txt);
    312     }
    313   }
     290    int i;
     291    char txt[512];
     292
     293    //if (((cs_ptyp & client[cs_idx].dbglvl)==cs_ptyp) && (fmt))
     294    if ((cs_ptyp & client[cs_idx].dbglvl) && (fmt))
     295    {
     296        get_log_header(1, txt);
     297        va_list params;
     298        va_start(params, fmt);
     299        vsprintf(txt+11, fmt, params);
     300        va_end(params);
     301        write_to_log(-1, txt);
     302        //printf("LOG: %s\n", txt); fflush(stdout);
     303    }
     304    //if (((cs_ptyp | D_DUMP) & client[cs_idx].dbglvl)==(cs_ptyp | D_DUMP))
     305    if (cs_ptyp & client[cs_idx].dbglvl)
     306    {
     307        for (i=0; i<n; i+=16)
     308        {
     309            get_log_header(0, txt);
     310            sprintf(txt+11, "%s", cs_hexdump(1, buf+i, (n-i>16) ? 16 : n-i));
     311            write_to_log(-1, txt);
     312        }
     313    }
    314314}
    315315
    316316void cs_ddump_mask(unsigned short mask, uchar *buf, int n, char *fmt, ...)
    317317{
    318   int i;
    319   char txt[512];
    320 
    321   //if (((cs_ptyp & client[cs_idx].dbglvl)==cs_ptyp) && (fmt))
    322   if ((mask & client[cs_idx].dbglvl) && (fmt))
    323   {
    324     get_log_header(1, txt);
    325     va_list params;
    326     va_start(params, fmt);
    327     vsprintf(txt+11, fmt, params);
    328     va_end(params);
    329     write_to_log(-1, txt);
    330 //printf("LOG: %s\n", txt); fflush(stdout);
    331   }
    332   //if (((cs_ptyp | D_DUMP) & client[cs_idx].dbglvl)==(cs_ptyp | D_DUMP))
    333   if (mask & client[cs_idx].dbglvl)
    334   {
    335     for (i=0; i<n; i+=16)
    336     {
    337         get_log_header(0, txt);
    338       sprintf(txt+11, "%s", cs_hexdump(1, buf+i, (n-i>16) ? 16 : n-i));
    339       write_to_log(-1, txt);
    340     }
    341   }
     318    int i;
     319    char txt[512];
     320
     321    //if (((cs_ptyp & client[cs_idx].dbglvl)==cs_ptyp) && (fmt))
     322    if ((mask & client[cs_idx].dbglvl) && (fmt))
     323    {
     324        get_log_header(1, txt);
     325        va_list params;
     326        va_start(params, fmt);
     327        vsprintf(txt+11, fmt, params);
     328        va_end(params);
     329        write_to_log(-1, txt);
     330        //printf("LOG: %s\n", txt); fflush(stdout);
     331    }
     332    //if (((cs_ptyp | D_DUMP) & client[cs_idx].dbglvl)==(cs_ptyp | D_DUMP))
     333    if (mask & client[cs_idx].dbglvl)
     334    {
     335        for (i=0; i<n; i+=16)
     336        {
     337            get_log_header(0, txt);
     338            sprintf(txt+11, "%s", cs_hexdump(1, buf+i, (n-i>16) ? 16 : n-i));
     339            write_to_log(-1, txt);
     340        }
     341    }
    342342}
    343343
    344344int cs_init_statistics(char *file)
    345345{
    346   if ((!fps) && (file != NULL))
    347   {
    348     if ((fps=fopen(file, "a"))<=(FILE *)0)
    349     {
    350       fps=(FILE *)0;
    351       cs_log("couldn't open statistics file: %s", file);
    352     }
    353   }
    354   return(fps<=(FILE *)0);
     346    if ((!fps) && (file != NULL))
     347    {
     348        if ((fps=fopen(file, "a"))<=(FILE *)0)
     349        {
     350            fps=(FILE *)0;
     351            cs_log("couldn't open statistics file: %s", file);
     352        }
     353    }
     354    return(fps<=(FILE *)0);
    355355}
    356356
  • trunk/oscam.c

    r1760 r1762  
    10611061static void init_service(int srv)
    10621062{
    1063   switch(cs_fork(0, srv))
    1064   {
    1065     case -1:
    1066       cs_exit(1);
    1067     case  0:
    1068       break;
    1069     default:
    1070       wait4master();
    1071       switch(srv)
    1072       {
     1063    switch(cs_fork(0, srv))
     1064    {
     1065    case -1:
     1066    cs_exit(1);
     1067    case  0:
     1068        break;
     1069    default:
     1070        wait4master();
     1071        switch(srv)
     1072        {
    10731073#ifdef CS_ANTICASC
    1074         case 96: start_anticascader();
    1075 #endif
    1076         case 97: cs_logger();
    1077         case 98: start_resolver();
     1074        case 96: start_anticascader();
     1075#endif
     1076        case 97: cs_logger();
     1077        case 98: start_resolver();
    10781078#ifdef WEBIF
    1079         case 95: cs_http();
    1080 #endif
    1081       }
    1082   }
     1079        case 95: cs_http();
     1080#endif
     1081        }
     1082    }
    10831083}
    10841084
     
    12601260void cs_disconnect_client(void)
    12611261{
    1262   char buf[32]={0};
    1263   if (client[cs_idx].ip)
    1264     sprintf(buf, " from %s", cs_inet_ntoa(client[cs_idx].ip));
    1265   cs_log("%s disconnected%s", username(cs_idx), buf);
    1266   cs_exit(0);
     1262    char buf[32]={0};
     1263    if (client[cs_idx].ip)
     1264        sprintf(buf, " from %s", cs_inet_ntoa(client[cs_idx].ip));
     1265    cs_log("%s disconnected%s", username(cs_idx), buf);
     1266    cs_exit(0);
    12671267}
    12681268
     
    12861286static void store_ecm(ECM_REQUEST *er)
    12871287{
    1288   int rc;
    1289   rc=*ecmidx;
    1290   *ecmidx=(*ecmidx+1) % CS_ECMCACHESIZE;
    1291   //cs_log("store ecm from reader %d", er->reader[0]);
    1292   memcpy(ecmcache[rc].ecmd5, er->ecmd5, CS_ECMSTORESIZE);
    1293   memcpy(ecmcache[rc].cw, er->cw, 16);
    1294   ecmcache[rc].caid=er->caid;
    1295   ecmcache[rc].grp=reader[er->reader[0]].grp;
    1296   //cs_ddump(ecmcache[*ecmidx].ecmd5, CS_ECMSTORESIZE, "ECM stored (idx=%d)", *ecmidx);
     1288    int rc;
     1289    rc=*ecmidx;
     1290    *ecmidx=(*ecmidx+1) % CS_ECMCACHESIZE;
     1291    //cs_log("store ecm from reader %d", er->reader[0]);
     1292    memcpy(ecmcache[rc].ecmd5, er->ecmd5, CS_ECMSTORESIZE);
     1293    memcpy(ecmcache[rc].cw, er->cw, 16);
     1294    ecmcache[rc].caid = er->caid;
     1295    ecmcache[rc].grp = reader[er->reader[0]].grp;
     1296    //cs_ddump(ecmcache[*ecmidx].ecmd5, CS_ECMSTORESIZE, "ECM stored (idx=%d)", *ecmidx);
    12971297}
    12981298
     
    13001300{
    13011301#ifdef CS_LOGHISTORY
    1302   char *ptr;
    1303   ptr=(char *)(loghist+(*loghistidx*CS_LOGHISTSIZE));
    1304   ptr[0]='\1';    // make username unusable
    1305   ptr[1]='\0';
    1306   if ((client[cs_idx].typ=='c') || (client[cs_idx].typ=='m'))
    1307     cs_strncpy(ptr, client[cs_idx].usr, 31);
    1308   cs_strncpy(ptr+32, txt, CS_LOGHISTSIZE-33);
    1309   *loghistidx=(*loghistidx+1) % CS_MAXLOGHIST;
     1302    char *ptr;
     1303    ptr=(char *)(loghist+(*loghistidx*CS_LOGHISTSIZE));
     1304    ptr[0]='\1';    // make username unusable
     1305    ptr[1]='\0';
     1306    if ((client[cs_idx].typ=='c') || (client[cs_idx].typ=='m'))
     1307        cs_strncpy(ptr, client[cs_idx].usr, 31);
     1308    cs_strncpy(ptr+32, txt, CS_LOGHISTSIZE-33);
     1309    *loghistidx=(*loghistidx+1) % CS_MAXLOGHIST;
    13101310#endif
    13111311}
     
    15231523  return(write_ecm_request(fd, er));
    15241524}
    1525 /*
     1525
     1526  /*
    15261527static int cs_read_timer(int fd, uchar *buf, int l, int msec)
    15271528{
     
    15481549ECM_REQUEST *get_ecmtask()
    15491550{
    1550   int i, n;
    1551   ECM_REQUEST *er=0;
    1552 
    1553   if (!ecmtask)
    1554   {
    1555     n=(ph[client[cs_idx].ctyp].multi)?CS_MAXPENDING:1;
    1556     if( (ecmtask=(ECM_REQUEST *)malloc(n*sizeof(ECM_REQUEST))) )
    1557       memset(ecmtask, 0, n*sizeof(ECM_REQUEST));
    1558   }
    1559 
    1560   n=(-1);
    1561   if (!ecmtask)
    1562   {
    1563     cs_log("Cannot allocate memory (errno=%d)", errno);
    1564     n=(-2);
    1565   }
    1566   else
    1567     if (ph[client[cs_idx].ctyp].multi)
    1568     {
    1569       for (i=0; (n<0) && (i<CS_MAXPENDING); i++)
    1570         if (ecmtask[i].rc<100)
    1571           er=&ecmtask[n=i];
    1572     }
    1573     else
    1574       er=&ecmtask[n=0];
    1575 
    1576   if (n<0)
    1577     cs_log("WARNING: ecm pending table overflow !");
    1578   else
    1579   {
    1580     memset(er, 0, sizeof(ECM_REQUEST));
    1581     er->rc=100;
    1582     er->cpti=n;
    1583     er->cidx=cs_idx;
    1584     cs_ftime(&er->tps);
    1585   }
    1586   return(er);
     1551    int i, n;
     1552    ECM_REQUEST *er=0;
     1553
     1554    if (!ecmtask)
     1555    {
     1556        n=(ph[client[cs_idx].ctyp].multi)?CS_MAXPENDING:1;
     1557        if( (ecmtask=(ECM_REQUEST *)malloc(n*sizeof(ECM_REQUEST))) )
     1558            memset(ecmtask, 0, n*sizeof(ECM_REQUEST));
     1559    }
     1560
     1561    n=(-1);
     1562    if (!ecmtask)
     1563    {
     1564        cs_log("Cannot allocate memory (errno=%d)", errno);
     1565        n=(-2);
     1566    }
     1567    else
     1568        if (ph[client[cs_idx].ctyp].multi)
     1569        {
     1570            for (i=0; (n<0) && (i<CS_MAXPENDING); i++)
     1571                if (ecmtask[i].rc<100)
     1572                    er=&ecmtask[n=i];
     1573        }
     1574        else
     1575            er=&ecmtask[n=0];
     1576
     1577    if (n<0)
     1578        cs_log("WARNING: ecm pending table overflow !");
     1579    else
     1580    {
     1581        memset(er, 0, sizeof(ECM_REQUEST));
     1582        er->rc=100;
     1583        er->cpti=n;
     1584        er->cidx=cs_idx;
     1585        cs_ftime(&er->tps);
     1586    }
     1587    return(er);
    15871588}
    15881589
    15891590int send_dcw(ECM_REQUEST *er)
    15901591{
    1591   static char *stxt[]={"found", "cache1", "cache2", "emu",
    1592                        "not found", "timeout", "sleeping",
    1593                        "fake", "invalid", "corrupt", "no card", "expdate", "disabled"};
    1594   static char *stxtEx[]={"", "group", "caid", "ident", "class", "chid", "queue", "peer"};
    1595   static char *stxtWh[]={"", "user ", "reader ", "server ", "lserver "};
    1596   char sby[32]="";
    1597   char erEx[32]="";
    1598   char uname[38]="";
    1599   struct timeb tpe;
    1600   ushort lc, *lp;
    1601   for (lp=(ushort *)er->ecm+(er->l>>2), lc=0; lp>=(ushort *)er->ecm; lp--)
    1602     lc^=*lp;
    1603   cs_ftime(&tpe);
     1592    static char *stxt[]={"found", "cache1", "cache2", "emu",
     1593            "not found", "timeout", "sleeping",
     1594            "fake", "invalid", "corrupt", "no card", "expdate", "disabled"};
     1595    static char *stxtEx[]={"", "group", "caid", "ident", "class", "chid", "queue", "peer"};
     1596    static char *stxtWh[]={"", "user ", "reader ", "server ", "lserver "};
     1597    char sby[32]="";
     1598    char erEx[32]="";
     1599    char uname[38]="";
     1600    struct timeb tpe;
     1601    ushort lc, *lp;
     1602    for (lp=(ushort *)er->ecm+(er->l>>2), lc=0; lp>=(ushort *)er->ecm; lp--)
     1603        lc^=*lp;
     1604    cs_ftime(&tpe);
    16041605
    16051606#ifdef CS_WITH_GBOX
    1606   if(er->gbxFrom)
    1607     snprintf(uname,sizeof(uname)-1, "%s(%04X)", username(cs_idx), er->gbxFrom);
    1608   else
    1609 #endif
    1610     snprintf(uname,sizeof(uname)-1, "%s", username(cs_idx));
    1611   if (er->rc==0)
    1612   {
     1607    if(er->gbxFrom)
     1608        snprintf(uname,sizeof(uname)-1, "%s(%04X)", username(cs_idx), er->gbxFrom);
     1609    else
     1610#endif
     1611        snprintf(uname,sizeof(uname)-1, "%s", username(cs_idx));
     1612    if (er->rc==0)
     1613    {
    16131614#ifdef CS_WITH_GBOX
    1614     if(reader[er->reader[0]].typ==R_GBOX)
    1615       snprintf(sby, sizeof(sby)-1, " by %s(%04X)", reader[er->reader[0]].label,er->gbxCWFrom);
    1616     else
    1617 #endif
    1618       // add marker to reader if ECM_REQUEST was betatunneled
    1619       if(er->btun)
    1620         snprintf(sby, sizeof(sby)-1, " by %s(btun)", reader[er->reader[0]].label);
    1621       else
    1622         snprintf(sby, sizeof(sby)-1, " by %s", reader[er->reader[0]].label);
    1623   }
    1624   if (er->rc<4) er->rcEx=0;
    1625   if (er->rcEx)
    1626     snprintf(erEx, sizeof(erEx)-1, "rejected %s%s", stxtWh[er->rcEx>>4],
    1627              stxtEx[er->rcEx&0xf]);
    1628 
    1629   client[cs_idx].cwlastresptime = 1000*(tpe.time-er->tps.time)+tpe.millitm-er->tps.millitm;
    1630 
    1631   cs_log("%s (%04X&%06X/%04X/%02X:%04X): %s (%d ms)%s",
    1632          uname, er->caid, er->prid, er->srvid, er->l, lc,
    1633          er->rcEx?erEx:stxt[er->rc], client[cs_idx].cwlastresptime, sby);
    1634 
    1635 
    1636   if(!client[cs_idx].ncd_server && client[cs_idx].autoau && er->rcEx==0)
    1637   {
    1638     if(client[cs_idx].au>=0 && er->caid!=reader[client[cs_idx].au].caid[0])
    1639     {
    1640       client[cs_idx].au=(-1);
    1641     }
    1642 
    1643     client[cs_idx].au=er->reader[0];
    1644     if(client[cs_idx].au<0)
    1645     {
    1646       int r=0;
    1647       for(r=0;r<CS_MAXREADER;r++)
    1648       {
    1649         if(er->caid==reader[r].caid[0])
    1650         {
    1651           client[cs_idx].au=r;
    1652           break;
    1653         }
    1654       }
    1655       if(r==CS_MAXREADER)
    1656       {
    1657         client[cs_idx].au=(-1);
    1658       }
    1659     }
    1660   }
    1661 
    1662   er->caid=er->ocaid;
    1663   switch(er->rc)
    1664   {
    1665     case 0:
    1666     case 3:
    1667         // 0 - found
    1668         // 3 - emu FIXME: obsolete ?
    1669         client[cs_idx].cwfound++;
    1670         break;
    1671 
    1672     case 1:
    1673     case 2:
    1674         // 1 - cache1
    1675         // 2 - cache2
    1676         client[cs_idx].cwcache++;
    1677         break;
    1678 
    1679     case 4:
    1680     case 9:
    1681     case 10:
    1682         // 4 - not found
    1683         // 9 - corrupt
    1684         // 10 - no card
    1685         if (er->rcEx)
     1615        if(reader[er->reader[0]].typ==R_GBOX)
     1616            snprintf(sby, sizeof(sby)-1, " by %s(%04X)", reader[er->reader[0]].label,er->gbxCWFrom);
     1617        else
     1618#endif
     1619            // add marker to reader if ECM_REQUEST was betatunneled
     1620            if(er->btun)
     1621                snprintf(sby, sizeof(sby)-1, " by %s(btun)", reader[er->reader[0]].label);
     1622            else
     1623                snprintf(sby, sizeof(sby)-1, " by %s", reader[er->reader[0]].label);
     1624    }
     1625    if (er->rc<4) er->rcEx=0;
     1626    if (er->rcEx)
     1627        snprintf(erEx, sizeof(erEx)-1, "rejected %s%s", stxtWh[er->rcEx>>4],
     1628                stxtEx[er->rcEx&0xf]);
     1629
     1630    client[cs_idx].cwlastresptime = 1000*(tpe.time-er->tps.time)+tpe.millitm-er->tps.millitm;
     1631
     1632    if(cfg->mon_appendchaninfo)
     1633        cs_log("%s (%04X&%06X/%04X/%02X:%04X): %s (%d ms)%s - %s",
     1634                uname, er->caid, er->prid, er->srvid, er->l, lc,
     1635                er->rcEx?erEx:stxt[er->rc], client[cs_idx].cwlastresptime, sby, monitor_get_srvname(er->srvid, er->caid));
     1636    else
     1637        cs_log("%s (%04X&%06X/%04X/%02X:%04X): %s (%d ms)%s",
     1638                uname, er->caid, er->prid, er->srvid, er->l, lc,
     1639                er->rcEx?erEx:stxt[er->rc], client[cs_idx].cwlastresptime, sby);
     1640
     1641    if(!client[cs_idx].ncd_server && client[cs_idx].autoau && er->rcEx==0)
     1642    {
     1643        if(client[cs_idx].au>=0 && er->caid!=reader[client[cs_idx].au].caid[0])
     1644        {
     1645            client[cs_idx].au=(-1);
     1646        }
     1647
     1648        client[cs_idx].au=er->reader[0];
     1649        if(client[cs_idx].au<0)
     1650        {
     1651            int r=0;
     1652            for(r=0;r<CS_MAXREADER;r++)
     1653            {
     1654                if(er->caid==reader[r].caid[0])
     1655                {
     1656                    client[cs_idx].au=r;
     1657                    break;
     1658                }
     1659            }
     1660            if(r==CS_MAXREADER)
     1661            {
     1662                client[cs_idx].au=(-1);
     1663            }
     1664        }
     1665    }
     1666
     1667    er->caid = er->ocaid;
     1668    switch(er->rc) {
     1669        case 0:
     1670        case 3:
     1671            // 0 - found
     1672            // 3 - emu FIXME: obsolete ?
     1673                    client[cs_idx].cwfound++;
     1674                    break;
     1675
     1676        case 1:
     1677        case 2:
     1678            // 1 - cache1
     1679            // 2 - cache2
     1680            client[cs_idx].cwcache++;
     1681            break;
     1682
     1683        case 4:
     1684        case 9:
     1685        case 10:
     1686            // 4 - not found
     1687            // 9 - corrupt
     1688            // 10 - no card
     1689            if (er->rcEx)
     1690                client[cs_idx].cwignored++;
     1691            else
     1692                client[cs_idx].cwnot++;
     1693            break;
     1694
     1695        case 5:
     1696            // 5 - timeout
     1697            client[cs_idx].cwtout++;
     1698            break;
     1699
     1700        default:
    16861701            client[cs_idx].cwignored++;
    1687         else
    1688             client[cs_idx].cwnot++;
    1689         break;
    1690 
    1691     case 5:
    1692         // 5 - timeout
    1693         client[cs_idx].cwtout++;
    1694         break;
    1695 
    1696         default:
    1697         client[cs_idx].cwignored++;
    1698   }
     1702    }
    16991703
    17001704#ifdef CS_ANTICASC
    1701   ac_chk(er, 1);
    1702 #endif
    1703 
    1704   cs_ddump_mask (D_ATR, er->cw, 16, "cw:");
    1705   if (er->rc==7) er->rc=0;
    1706   ph[client[cs_idx].ctyp].send_dcw(er);
    1707   return 0;
     1705    ac_chk(er, 1);
     1706#endif
     1707
     1708    cs_ddump_mask (D_ATR, er->cw, 16, "cw:");
     1709    if (er->rc==7) er->rc=0;
     1710    ph[client[cs_idx].ctyp].send_dcw(er);
     1711    return 0;
    17081712}
    17091713
Note: See TracChangeset for help on using the changeset viewer.