Ignore:
Timestamp:
Jun 2, 2019, 1:43:38 PM (6 months ago)
Author:
Gorgone Impertinence
Message:

small cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/module-newcamd.c

    r11518 r11519  
    22
    33#include "globals.h"
     4
    45#ifdef MODULE_NEWCAMD
     6
    57#include "cscrypt/des.h"
    68#include "cscrypt/md5.h"
     
    2123
    2224#define NCD_CLIENT_ID 0x8888
    23 
    24 #define CWS_FIRSTCMDNO 0xe0
     25#define CWS_FIRSTCMDNO 0xE0
     26
    2527typedef enum
    2628{
     
    4446    MSG_ADMIN_COMMAND_ACK,
    4547    MSG_ADMIN_COMMAND_NAK,
    46     MSG_KEEPALIVE = CWS_FIRSTCMDNO + 0x1d,
    47     MSG_SERVER_2_CLIENT_OSD = 0xd1,
    48     MSG_SERVER_2_CLIENT_ALLCARDS = 0xd2,
    49     MSG_SERVER_2_CLIENT_ADDCARD = 0xd3,
    50     MSG_SERVER_2_CLIENT_REMOVECARD = 0xd4,
    51     MSG_SERVER_2_CLIENT_CHANGE_KEY = 0xd5,
    52     MSG_SERVER_2_CLIENT_GET_VERSION = 0xd6,
    53     MSG_SERVER_2_CLIENT_ADDSID = 0xd7,
    54     MSG_CLIENT_2_SERVER_CARDDISCOVER = 0xd8
     48    MSG_KEEPALIVE = CWS_FIRSTCMDNO + 0x1D,
     49    MSG_SERVER_2_CLIENT_OSD = 0xD1,
     50    MSG_SERVER_2_CLIENT_ALLCARDS = 0xD2,
     51    MSG_SERVER_2_CLIENT_ADDCARD = 0xD3,
     52    MSG_SERVER_2_CLIENT_REMOVECARD = 0xD4,
     53    MSG_SERVER_2_CLIENT_CHANGE_KEY = 0xD5,
     54    MSG_SERVER_2_CLIENT_GET_VERSION = 0xD6,
     55    MSG_SERVER_2_CLIENT_ADDSID = 0xD7,
     56    MSG_CLIENT_2_SERVER_CARDDISCOVER = 0xD8
    5557} net_msg_type_t;
    5658
     
    6062    COMMTYPE_SERVER
    6163} comm_type_t;
    62 
    6364
    6465typedef struct custom_data
     
    7273#define REQ_SIZE 2
    7374
    74 
    75 static int32_t network_message_send(int32_t handle, uint16_t *netMsgId, uint8_t *buffer,
    76                                     int32_t len, uint8_t *deskey, comm_type_t commType,
    77                                     uint16_t sid, custom_data_t *cd)
     75static int32_t network_message_send(int32_t handle, uint16_t *netMsgId, uint8_t *buffer, int32_t len,
     76                                    uint8_t *deskey, comm_type_t commType, uint16_t sid, custom_data_t *cd)
    7877{
    7978    uint8_t netbuf[CWS_NETMSGSIZE];
     
    8483
    8584    if(len < 3 || len + head_size > CWS_NETMSGSIZE || handle < 0)
    86         { return -1; }
    87     buffer[1] = (buffer[1] & 0xf0) | (((len - 3) >> 8) & 0x0f);
    88     buffer[2] = (len - 3) & 0xff;
     85    {
     86        return -1;
     87    }
     88
     89    buffer[1] = (buffer[1] & 0xF0) | (((len - 3) >> 8) & 0x0F);
     90    buffer[2] = (len - 3) & 0xFF;
     91
    8992    memcpy(netbuf + head_size, buffer, len);
    9093    len += head_size;
     94
    9195    if(netMsgId)
    9296    {
    93         if(commType == COMMTYPE_CLIENT) { (*netMsgId)++; }
     97        if(commType == COMMTYPE_CLIENT)
     98        {
     99            (*netMsgId)++;
     100        }
     101
    94102        netbuf[2] = (*netMsgId) >> 8;
    95         netbuf[3] = (*netMsgId) & 0xff;
     103        netbuf[3] = (*netMsgId) & 0xFF;
    96104    }
    97105    else
    98         { netbuf[2] = netbuf[3] = 0; }
     106    {
     107        netbuf[2] = 0;
     108        netbuf[3] = 0;
     109    }
     110
    99111    memset(netbuf + 4, 0, (cl->ncd_proto == NCD_524) ? 4 : 8);
     112
    100113    if(sid)
    101114    {
    102         if(cl->reader && cl->reader->ncd_disable_server_filt &&
    103                 sid != NCD_CLIENT_ID && cl->ncd_proto != NCD_524) //mgclient send header
     115        if(cl->reader && cl->reader->ncd_disable_server_filt
     116            && sid != NCD_CLIENT_ID && cl->ncd_proto != NCD_524) // mgclient send header
    104117        {
    105118            memcpy(netbuf + 4, cl->ncd_header + 4, 7);
    106119        }
    107         netbuf[(cl->ncd_proto == NCD_524) ? 6 : 4] = (uint8_t)(sid >> 8); //sid
     120
     121        netbuf[(cl->ncd_proto == NCD_524) ? 6 : 4] = (uint8_t)(sid >> 8); // sid
    108122        netbuf[(cl->ncd_proto == NCD_524) ? 7 : 5] = (uint8_t)(sid);
    109123    }
    110     //if ((!ncd_proto==NCD_524) && (buffer[0] >= 0xd1) && (buffer[0]<= 0xd8)) { // extended proto for mg
    111     //cs_log_dbg(D_CLIENT, "newcamd: extended: msg");
     124
     125    //if((!ncd_proto == NCD_524) && (buffer[0] >= 0xD1) && (buffer[0] <= 0xD8)) // extended proto for mg
     126    //{
     127    //  cs_log_dbg(D_CLIENT, "newcamd: extended: msg");
     128
    112129    if(cd)
    113130    {
    114131        cs_log_dbg(D_CLIENT, "newcamd: has cd");
     132
    115133        netbuf[4] = cd->sid >> 8;
    116         netbuf[5] = cd->sid & 0xff;
     134        netbuf[5] = cd->sid & 0xFF;
    117135        netbuf[6] = cd->caid >> 8;
    118         netbuf[7] = cd->caid & 0xff;
     136        netbuf[7] = cd->caid & 0xFF;
    119137        netbuf[8] = (cd->provid >> 16) & 0xFF;
    120         netbuf[9] = (cd->provid >> 8) & 0xff;
    121         netbuf[10] = cd->provid & 0xff;
     138        netbuf[9] = (cd->provid >> 8) & 0xFF;
     139        netbuf[10] = cd->provid & 0xFF;
    122140    }
    123141    //}
    124     if(NCD_525 == cl->ncd_proto && cfg.ncd_mgclient &&
    125             MSG_CLIENT_2_SERVER_LOGIN_ACK == buffer[0])
    126     {
    127         netbuf[4] = 0x6E; //From ExtNewcamSession.java CSP line 65-66 getLoginOkMsg()
     142
     143    if(NCD_525 == cl->ncd_proto && cfg.ncd_mgclient && MSG_CLIENT_2_SERVER_LOGIN_ACK == buffer[0])
     144    {
     145        netbuf[4] = 0x6E; // From ExtNewcamSession.java CSP line 65-66 getLoginOkMsg()
    128146        netbuf[5] = 0x73;
    129147        netbuf[11] = 0x14;
    130148    }
    131     if(NCD_525 == cl->ncd_proto &&
    132             MSG_SERVER_2_CLIENT_ADDSID == buffer[0])
     149
     150    if(NCD_525 == cl->ncd_proto && MSG_SERVER_2_CLIENT_ADDSID == buffer[0])
    133151    {
    134152        netbuf[11] = 0x14;
    135153    }
    136     //  if (buffer[0]==MSG_CLIENT_2_SERVER_LOGIN && cur_client()->reader->ncd_disable_server_filt) {
    137     //        netbuf[11] = 0x11; //From ChameleonCwsConnector.java CSP line 59-61 run()
    138     //    }
     154
     155    //if(buffer[0] == MSG_CLIENT_2_SERVER_LOGIN && cur_client()->reader->ncd_disable_server_filt)
     156    //{
     157    //  netbuf[11] = 0x11; // From ChameleonCwsConnector.java CSP line 59-61 run()
     158    //}
    139159
    140160    netbuf[0] = (len - 2) >> 8;
    141     netbuf[1] = (len - 2) & 0xff;
     161    netbuf[1] = (len - 2) & 0xFF;
     162
    142163    cs_log_dump_dbg(D_CLIENT, netbuf, len, "send %d bytes to %s", len, remote_txt());
     164
    143165    if((len = nc_des_encrypt(netbuf, len, deskey)) < 0)
    144         { return -1; }
     166    {
     167        return -1;
     168    }
     169
    145170    netbuf[0] = (len - 2) >> 8;
    146     netbuf[1] = (len - 2) & 0xff;
     171    netbuf[1] = (len - 2) & 0xFF;
     172
    147173    return send(handle, netbuf, len, 0);
    148174}
     
    159185
    160186    uint8_t mbuf[CWS_NETMSGSIZE];
    161     int32_t n = 0, nr = 0, portion_sid_num = 0, i = 0, sid_num = 0,
    162             portion_num = 0;
     187    int32_t n = 0, nr = 0, portion_sid_num = 0, i = 0, sid_num = 0, portion_num = 0;
    163188    SIDTAB *sidtab = 0;
    164189    custom_data_t cd;
    165190
    166191    cs_log_dbg(D_TRACE, "Send SID list to mgcamd client.");
     192
    167193    memset(&cd, 0, sizeof(cd));
    168194    FILTER *pfilts = cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts;
    169195
    170     /*memset(mbuf, 0, sizeof(mbuf));*/ // not nessesery
     196    //memset(mbuf, 0, sizeof(mbuf)); // not nessesery
    171197
    172198    for(nr = 0, sidtab = cfg.sidtab; sidtab; sidtab = sidtab->next, nr++)
     199    {
    173200        if((cl->sidtabs.no & ((SIDTABBITS)1 << nr)) && (sidtab->num_caid | sidtab->num_provid | sidtab->num_srvid))
    174201        {
     
    183210                        {
    184211                            cd.sid = sidtab->srvid[i]; // first sid
    185                             cd.caid = cfg.ncd_ptab.ports[cl->port_idx].s_port;   //assigned port
     212                            cd.caid = cfg.ncd_ptab.ports[cl->port_idx].s_port; // assigned port
    186213                            cd.provid = 0x1; // mark as deny
    187214                        }
     215
    188216                        mbuf[portion_sid_num * 3] = (uint8_t)(sidtab->srvid[i] >> 8);
    189217                        mbuf[portion_sid_num * 3 + 1] = (uint8_t)(sidtab->srvid[i] & 0xFF);
     
    196224                        {
    197225                            ++portion_num;
    198                             cs_log_dump_dbg(0x0800, mbuf, (portion_sid_num) * 3, "Portion %d contains %d SIDs", portion_num, portion_sid_num);
     226
     227                            cs_log_dump_dbg(0x0800, mbuf, (portion_sid_num) * 3, "Portion %d contains %d SIDs",
     228                                            portion_num, portion_sid_num);
     229
    199230                            mbuf[0] = MSG_SERVER_2_CLIENT_ADDSID;
    200                             mbuf[1] = 0x0;
    201                             mbuf[2] = 0x0;
    202                             network_message_send(cl->udp_fd, &cl->ncd_msgid,
    203                                                  mbuf, portion_sid_num * 3, cl->ncd_skey, COMMTYPE_SERVER, 0, &cd);
     231                            mbuf[1] = 0x00;
     232                            mbuf[2] = 0x00;
     233
     234                            network_message_send(cl->udp_fd, &cl->ncd_msgid, mbuf, portion_sid_num * 3,
     235                                                    cl->ncd_skey, COMMTYPE_SERVER, 0, &cd);
    204236                            portion_sid_num = 0;
    205237                        }
     
    210242            }
    211243        }
     244    }
    212245
    213246    if(portion_sid_num)
    214247    {
    215248        ++portion_num;
    216         cs_log_dump_dbg(0x0800, mbuf, (portion_sid_num) * 3, "Portion %d contains %d SIDs", portion_num, portion_sid_num);
     249
     250        cs_log_dump_dbg(0x0800, mbuf, (portion_sid_num) * 3, "Portion %d contains %d SIDs",
     251                        portion_num, portion_sid_num);
     252
    217253        mbuf[0] = MSG_SERVER_2_CLIENT_ADDSID;
    218254        mbuf[1] = 0x0;
    219255        mbuf[2] = 0x0;
    220         network_message_send(cl->udp_fd, &cl->ncd_msgid, mbuf, portion_sid_num * 3, cl->ncd_skey, COMMTYPE_SERVER, 0, &cd);
     256
     257        network_message_send(cl->udp_fd, &cl->ncd_msgid, mbuf, portion_sid_num * 3,
     258                                cl->ncd_skey, COMMTYPE_SERVER, 0, &cd);
    221259        portion_sid_num = 0;
    222260    }
    223261
    224262    cs_log("%d deny SIDs in the %d messages were sent to the client.", sid_num, portion_num);
     263
    225264    return sid_num;
    226265}
     
    235274
    236275    if(!buffer || handle < 0)
    237         { return -1; }
     276    {
     277        return -1;
     278    }
     279
    238280    len = cs_recv(handle, netbuf, 2, 0);
     281
    239282    cs_log_dbg(D_CLIENT, "nmr(): len=%d, errno=%d", len, (len == -1) ? errno : 0);
     283
    240284    if(!len)
    241285    {
    242286        cs_log_dbg(D_CLIENT, "nmr: 1 return 0");
     287
    243288        if(commType == COMMTYPE_CLIENT)
    244             { network_tcp_connection_close(cl->reader, "receive error1"); }
     289        {
     290            network_tcp_connection_close(cl->reader, "receive error1");
     291        }
    245292        else
    246             { cs_disconnect_client(cl); }
     293        {
     294            cs_disconnect_client(cl);
     295        }
     296
    247297        return 0;
    248298    }
     299
    249300    if(len != 2)
    250301    {
    251302        cs_log_dbg(D_CLIENT, "nmr: len!=2");
     303
    252304        if(commType == COMMTYPE_CLIENT)
    253             { network_tcp_connection_close(cl->reader, "receive error2"); }
     305        {
     306            network_tcp_connection_close(cl->reader, "receive error2");
     307        }
    254308        else
    255             { cs_disconnect_client(cl); }
     309        {
     310            cs_disconnect_client(cl);
     311        }
     312
    256313        return -1;
    257314    }
     315
    258316    if(((netbuf[0] << 8) | netbuf[1]) > CWS_NETMSGSIZE - 2)
    259317    {
    260         cs_log_dbg(D_CLIENT, "nmr: received data len=%d longer than CWS_NETMSGSIZE=%d", ((netbuf[0] << 8) | netbuf[1]), CWS_NETMSGSIZE);
     318        cs_log_dbg(D_CLIENT, "nmr: received data len=%d longer than CWS_NETMSGSIZE=%d",
     319                    ((netbuf[0] << 8) | netbuf[1]), CWS_NETMSGSIZE);
    261320        cs_log_dbg(D_CLIENT, "nmr: 1 return -1");
    262321        return -1;
     
    269328        return 0;
    270329    }
     330
    271331    if(len != ((netbuf[0] << 8) | netbuf[1]))
    272332    {
     
    274334        return -1;
    275335    }
     336
    276337    len += 2;
     338
    277339    if((len = nc_des_decrypt(netbuf, len, deskey)) < 11) // 15(newcamd525) or 11 ???
    278340    {
     
    281343        return -1;
    282344    }
     345
    283346    //cs_log_dump_dbg(D_CLIENT, netbuf, len, "nmr: decrypted data, len=%d", len);
     347
    284348    msgid = (netbuf[2] << 8) | netbuf[3];
    285349
     
    287351    {
    288352        // auto detect
    289         int32_t l5 = (((netbuf[13] & 0x0f) << 8) | netbuf[14]) + 3;
    290         int32_t l4 = (((netbuf[9] & 0x0f) << 8) | netbuf[10]) + 3;
     353        int32_t l5 = (((netbuf[13] & 0x0F) << 8) | netbuf[14]) + 3;
     354        int32_t l4 = (((netbuf[9] & 0x0F) << 8) | netbuf[10]) + 3;
    291355
    292356        if((l5 <= len - 12) && ((netbuf[12] & 0xF0) == 0xE0 || (netbuf[12] & 0xF0) == 0x80))
    293             { cl->ncd_proto = NCD_525; }
     357        {
     358            cl->ncd_proto = NCD_525;
     359        }
    294360        else if((l4 <= len - 8) && ((netbuf[8] & 0xF0) == 0xE0 || (netbuf[9] & 0xF0) == 0x80))
    295             { cl->ncd_proto = NCD_524; }
     361        {
     362            cl->ncd_proto = NCD_524;
     363        }
    296364        else
    297365        {
     
    305373    ncd_off = (cl->ncd_proto == NCD_525) ? 4 : 0;
    306374
    307     returnLen = (((netbuf[9 + ncd_off] & 0x0f) << 8) | netbuf[10 + ncd_off]) + 3;
     375    returnLen = (((netbuf[9 + ncd_off] & 0x0F) << 8) | netbuf[10 + ncd_off]) + 3;
    308376    if(returnLen > (len - (8 + ncd_off)))
    309377    {
     
    313381
    314382    //cs_log_dump_dbg(D_CLIENT, netbuf, len, "nmr: decrypted data");
     383
    315384    if(netMsgId)
    316385    {
    317386        switch(commType)
    318387        {
     388            case COMMTYPE_SERVER:
     389                *netMsgId = msgid;
     390                break;
     391
     392            case COMMTYPE_CLIENT:
     393                //if(*netMsgId != ((netbuf[2] << 8) | netbuf[3]))
     394                //{
     395                cs_log_dbg(D_CLIENT, "nmr: netMsgId=%d, from server=%d, ", *netMsgId, msgid);
     396                //return -2;
     397                //}
     398                break;
     399
     400            default:
     401                cs_log_dbg(D_CLIENT, "nmr: 5 return -1");
     402                return -1;
     403                break;
     404        }
     405    }
     406
     407    switch(commType)
     408    {
    319409        case COMMTYPE_SERVER:
    320             *netMsgId = msgid;
     410            memcpy(cl->ncd_header, netbuf, (8 + ncd_off));
     411            buffer[0] = (cl->ncd_proto == NCD_525) ? netbuf[4] : netbuf[6]; // sid
     412            buffer[1] = (cl->ncd_proto == NCD_525) ? netbuf[5] : netbuf[7];
    321413            break;
    322414
    323415        case COMMTYPE_CLIENT:
    324             //if (*netMsgId != ((netbuf[2] << 8) | netbuf[3])) {
    325             cs_log_dbg(D_CLIENT, "nmr: netMsgId=%d, from server=%d, ", *netMsgId, msgid);
    326             //return -2;
    327             //}
     416            memcpy(cl->ncd_header, netbuf, (8 + ncd_off));
     417            buffer[0] = netbuf[2]; // msgid
     418            buffer[1] = netbuf[3];
    328419            break;
    329 
    330         default:
    331             cs_log_dbg(D_CLIENT, "nmr: 5 return -1");
    332             return -1;
    333             break;
    334         }
    335     }
    336     switch(commType)
    337     {
    338     case COMMTYPE_SERVER:
    339         memcpy(cl->ncd_header, netbuf, (8 + ncd_off));
    340         buffer[0] = (cl->ncd_proto == NCD_525) ? netbuf[4] : netbuf[6]; // sid
    341         buffer[1] = (cl->ncd_proto == NCD_525) ? netbuf[5] : netbuf[7];
    342         break;
    343     case COMMTYPE_CLIENT:
    344         memcpy(cl->ncd_header, netbuf, (8 + ncd_off));
    345         buffer[0] = netbuf[2]; // msgid
    346         buffer[1] = netbuf[3];
    347         break;
    348420    }
    349421
     
    352424}
    353425
    354 static void network_cmd_no_data_send(int32_t handle, uint16_t *netMsgId,
    355                                      net_msg_type_t cmd, uint8_t *deskey,
    356                                      comm_type_t commType)
     426static void network_cmd_no_data_send(int32_t handle, uint16_t *netMsgId, net_msg_type_t cmd,
     427                                    uint8_t *deskey, comm_type_t commType)
    357428{
    358429    uint8_t buffer[3];
     
    361432    buffer[1] = 0;
    362433    buffer[2] = 0;
     434
    363435    network_message_send(handle, netMsgId, buffer, 3, deskey, commType, 0, NULL);
    364436}
    365437
    366 static int32_t network_cmd_no_data_receive(int32_t handle, uint16_t *netMsgId,
    367         uint8_t *deskey, comm_type_t commType)
     438static int32_t network_cmd_no_data_receive(int32_t handle, uint16_t *netMsgId, uint8_t *deskey,
     439                                            comm_type_t commType)
    368440{
    369441    uint8_t buffer[CWS_NETMSGSIZE];
    370442
    371443    if(network_message_receive(handle, netMsgId, buffer, deskey, commType) != 3 + 2)
    372         { return -1; }
     444    {
     445        return -1;
     446    }
     447
    373448    return buffer[2];
    374449}
     
    378453    struct s_client *cl = cur_client();
    379454
    380     if(!cl) { return; }
     455    if(!cl)
     456    {
     457        return;
     458    }
    381459
    382460    if(!cl->udp_fd)
     
    389467
    390468    if(cl->reader)
    391         { cl->reader->last_s = time((time_t *)0); }
     469    {
     470        cl->reader->last_s = time((time_t *)0);
     471    }
    392472
    393473    network_cmd_no_data_send(cl->udp_fd, &cl->ncd_msgid, MSG_KEEPALIVE, cl->ncd_skey, COMMTYPE_SERVER);
     
    408488    struct s_client *cl = cur_client();
    409489
    410     if(cl->reader->device[0] == 0 || cl->reader->r_pwd[0] == 0 ||
    411             cl->reader->r_usr[0] == 0 || cl->reader->r_port == 0)
    412         { return -5; }
     490    if(cl->reader->device[0] == 0 || cl->reader->r_pwd[0] == 0
     491        || cl->reader->r_usr[0] == 0 || cl->reader->r_port == 0)
     492    {
     493        return -5;
     494    }
    413495
    414496    // 1. Connect
    415497    handle = network_tcp_connection_open(cl->reader);
    416     if(handle < 0) { return -1; }
     498    if(handle < 0)
     499    {
     500        return -1;
     501    }
    417502
    418503    // 2. Get init sequence
     
    424509        return -2;
    425510    }
     511
    426512    cs_log_dump_dbg(D_CLIENT, keymod, sizeof(cl->reader->ncd_key), "server init sequence:");
    427513    nc_des_login_key_get(keymod, cl->reader->ncd_key, sizeof(cl->reader->ncd_key), key);
     
    431517    buf[0] = MSG_CLIENT_2_SERVER_LOGIN;
    432518    buf[1] = 0;
     519
    433520    cs_strncpy((char *)buf + idx, cl->reader->r_usr, sizeof(buf) - idx);
    434521    __md5_crypt(cl->reader->r_pwd, "$1$abcdefgh$", (char *)passwdcrypt);
     
    437524
    438525    network_message_send(handle, 0, buf, idx + strlen((char *)passwdcrypt) + 1, key,
    439                          COMMTYPE_CLIENT, NCD_CLIENT_ID, NULL);
     526                        COMMTYPE_CLIENT, NCD_CLIENT_ID, NULL);
    440527
    441528    // 3.1 Get login answer
    442     login_answer = network_cmd_no_data_receive(handle, &cl->ncd_msgid,
    443                     key, COMMTYPE_CLIENT);
     529    login_answer = network_cmd_no_data_receive(handle, &cl->ncd_msgid, key, COMMTYPE_CLIENT);
    444530    if(login_answer == MSG_CLIENT_2_SERVER_LOGIN_NAK)
    445531    {
     
    448534        return -3;
    449535    }
     536
    450537    if(login_answer != MSG_CLIENT_2_SERVER_LOGIN_ACK)
    451538    {
    452539        cs_log("expected MSG_CLIENT_2_SERVER_LOGIN_ACK (%02X), received %02X",
    453540                MSG_CLIENT_2_SERVER_LOGIN_ACK, login_answer);
     541
    454542        network_tcp_connection_close(cl->reader, "login error2");
    455543        return -3;
     
    462550    // 4. Send MSG_CARD_DATE_REQ
    463551    nc_des_login_key_get(cl->reader->ncd_key, passwdcrypt, strlen((char *)passwdcrypt), key);
    464 
    465     network_cmd_no_data_send(handle, &cl->ncd_msgid, MSG_CARD_DATA_REQ,
    466                             key, COMMTYPE_CLIENT);
    467     bytes_received = network_message_receive(handle, &cl->ncd_msgid, buf,
    468                      key, COMMTYPE_CLIENT);
     552    network_cmd_no_data_send(handle, &cl->ncd_msgid, MSG_CARD_DATA_REQ, key, COMMTYPE_CLIENT);
     553
     554    bytes_received = network_message_receive(handle, &cl->ncd_msgid, buf, key, COMMTYPE_CLIENT);
    469555    if(bytes_received < 16 || buf[2] != MSG_CARD_DATA)
    470556    {
    471         cs_log("expected MSG_CARD_DATA (%02X), received %02X",
    472                 MSG_CARD_DATA, buf[2]);
     557        cs_log("expected MSG_CARD_DATA (%02X), received %02X", MSG_CARD_DATA, buf[2]);
     558
    473559        network_tcp_connection_close(cl->reader, "receive error");
    474560        return -4;
     
    478564    cl->reader->caid = (uint16_t)((buf[6] << 8) | buf[7]);
    479565
    480     /* handle special serial format in newcamd. See newcamd_auth_client */
     566    // handle special serial format in newcamd. See newcamd_auth_client
    481567    newcamd_to_hexserial(buf + 10, cl->reader->hexserial, cl->reader->caid);
     568
    482569    cs_log("Newcamd Server: %s:%d - UserID: %i", cl->reader->device, cl->reader->r_port, buf[3 + 2]);
    483     cs_log("CAID: %04X - UA: %02X%02X%02X%02X%02X%02X%02X%02X - Provider # %i", cl->reader->caid, cl->reader->hexserial[0], cl->reader->hexserial[1], cl->reader->hexserial[2], cl->reader->hexserial[3], cl->reader->hexserial[4], cl->reader->hexserial[5], cl->reader->hexserial[6], cl->reader->hexserial[7], buf[14 + 2]);
     570
     571    cs_log("CAID: %04X - UA: %02X%02X%02X%02X%02X%02X%02X%02X - Provider # %i",
     572            cl->reader->caid, cl->reader->hexserial[0], cl->reader->hexserial[1], cl->reader->hexserial[2],
     573            cl->reader->hexserial[3], cl->reader->hexserial[4], cl->reader->hexserial[5], cl->reader->hexserial[6],
     574            cl->reader->hexserial[7], buf[14 + 2]);
     575
    484576    cl->reader->nprov = buf[14 + 2];
    485577    memset(cl->reader->prid, 0x00, sizeof(cl->reader->prid));
     578
    486579    for(i = 0; i < cl->reader->nprov; i++)
    487580    {
     
    496589            cl->reader->prid[i][3] = buf[17 + 2 + 11 * i];
    497590        }
     591
    498592        memcpy(&cl->reader->sa[i], buf + 22 + 2 + 11 * i, 4); // the 4 first bytes are not read
    499         cs_log("Provider ID: %02X%02X%02X - SA: %02X%02X%02X%02X", cl->reader->prid[i][1],  cl->reader->prid[i][2], cl->reader->prid[i][3], cl->reader->sa[i][0], cl->reader->sa[i][1], cl->reader->sa[i][2], cl->reader->sa[i][3]);
    500     }
     593
     594        cs_log("Provider ID: %02X%02X%02X - SA: %02X%02X%02X%02X",
     595                cl->reader->prid[i][1], cl->reader->prid[i][2], cl->reader->prid[i][3], cl->reader->sa[i][0],
     596                cl->reader->sa[i][1], cl->reader->sa[i][2], cl->reader->sa[i][3]);
     597    }
     598
    501599    memcpy(cl->reader->ncd_skey, key, 16);
    502600
     
    511609    if(cl->reader->ncd_disable_server_filt) // act like mgclient
    512610    {
    513         network_cmd_no_data_send(handle, &cl->ncd_msgid, MSG_SERVER_2_CLIENT_GET_VERSION,
    514                                  key, COMMTYPE_CLIENT);
     611        network_cmd_no_data_send(handle, &cl->ncd_msgid, MSG_SERVER_2_CLIENT_GET_VERSION, key, COMMTYPE_CLIENT);
    515612    }
    516613
     
    523620
    524621    if(cl->reader->tcp_connected < 2 && connect_newcamd_server() < 0)
    525         { return 0; }
     622    {
     623        return 0;
     624    }
    526625
    527626    if(!cl->udp_fd)
    528         { return 0; }
     627    {
     628        return 0;
     629    }
    529630
    530631    return 1;
    531632}
    532633
    533 
    534634static int32_t newcamd_send(uint8_t *buf, int32_t ml, uint16_t sid)
    535635{
     
    537637
    538638    if(!newcamd_connect())
    539         { return (-1); }
    540 
    541     return (network_message_send(cl->udp_fd, &cl->ncd_msgid,
    542                                 buf, ml, cl->reader->ncd_skey, COMMTYPE_CLIENT, sid, NULL));
     639    {
     640        return -1;
     641    }
     642
     643    return network_message_send(cl->udp_fd, &cl->ncd_msgid, buf, ml,
     644                                cl->reader->ncd_skey, COMMTYPE_CLIENT, sid, NULL);
    543645}
    544646
     
    549651    if(client->typ == 'c')
    550652    {
    551         rs = network_message_receive(client->udp_fd,
    552                                      &client->ncd_msgid, buf,
    553                                      client->ncd_skey, COMMTYPE_SERVER);
     653        rs = network_message_receive(client->udp_fd, &client->ncd_msgid, buf,
     654                                    client->ncd_skey, COMMTYPE_SERVER);
    554655    }
    555656    else
    556657    {
    557         if(!client->udp_fd) { return (-1); }
    558         rs = network_message_receive(client->udp_fd,
    559                                      &client->ncd_msgid, buf,
    560                                      client->reader->ncd_skey, COMMTYPE_CLIENT);
    561     }
    562 
    563     if(rs < 5) { rc = (-1); }
    564     else { rc = rs; }
     658        if(!client->udp_fd)
     659        {
     660            return (-1);
     661        }
     662
     663        rs = network_message_receive(client->udp_fd, &client->ncd_msgid, buf,
     664                                    client->reader->ncd_skey, COMMTYPE_CLIENT);
     665    }
     666
     667    if(rs < 5)
     668    {
     669        rc = -1;
     670    }
     671    else
     672    {
     673        rc = rs;
     674    }
    565675
    566676    cs_log_dump_dbg(D_CLIENT, buf, rs, "received %d bytes from %s", rs, remote_txt());
     677
    567678    client->last = time((time_t *) 0);
    568679
     
    570681    {
    571682        if(rs > 0)
    572             { cs_log("packet is too small (%d bytes)", rs); }
     683        {
     684            cs_log("packet is too small (%d bytes)", rs);
     685        }
    573686        else
    574             { cs_log("Connection closed to %s", remote_txt()); }
    575     }
     687        {
     688            cs_log("Connection closed to %s", remote_txt());
     689        }
     690    }
     691
    576692    return (rc);
    577693}
     
    587703    filt->caid = aureader->caid;
    588704    if(filt->caid == 0)
     705    {
    589706        filt->caid = old_filter.caid;
     707    }
    590708
    591709    for(i = 0; i < aureader->nprov && filt->nprids < CS_MAXPROV; i++)
    592         { filt->prids[filt->nprids++] = b2i(3, &aureader->prid[i][1]); }
     710    {
     711        filt->prids[filt->nprids++] = b2i(3, &aureader->prid[i][1]);
     712    }
    593713
    594714    for(i = 0; i < old_filter.nprids && filt->nprids < CS_MAXPROV; i++)
    595715    {
    596716        for(j = found = 0; (!found) && (j < filt->nprids); j++)
    597             if(old_filter.prids[i] == filt->prids[j]) { found = 1; }
     717        {
     718            if(old_filter.prids[i] == filt->prids[j])
     719            {
     720                found = 1;
     721            }
     722        }
     723
    598724        if(!found)
    599             { filt->prids[filt->nprids++] = old_filter.prids[i]; }
     725        {
     726            filt->prids[filt->nprids++] = old_filter.prids[i];
     727        }
    600728    }
    601729}
     
    610738    port_idx = cl->port_idx;
    611739    if(!cfg.ncd_ptab.ports[port_idx].ncd)
     740    {
    612741        return;
     742    }
     743
    613744    FILTER *psfilt = &cfg.ncd_ptab.ports[port_idx].ncd->ncd_ftab.filts[0];
    614745
     
    618749    {
    619750        CAIDTAB_DATA *d = &cl->ctab.ctdata[i];
     751
    620752        int32_t ctab_caid = d->caid & d->mask;
    621         if(ctab_caid) { c++; }
     753        if(ctab_caid)
     754        {
     755            c++;
     756        }
    622757
    623758        if(psfilt->caid == ctab_caid)
     
    627762        }
    628763    }
     764
    629765    if(c && !filt->caid)
    630766    {
     
    635771    // search CAID in client IDENT
    636772    cs_log_dbg(D_CLIENT, "client[%8lX].%s nfilts=%d, filt.caid=%04X", (unsigned long)pthread_self(),
    637                     cl->account->usr, cl->ftab.nfilts, filt->caid);
     773                cl->account->usr, cl->ftab.nfilts, filt->caid);
    638774
    639775    if(!filt->caid && cl->ftab.nfilts)
     
    643779        {
    644780            uint16_t ucaid = cl->ftab.filts[i].caid;
    645             if(ucaid) { fcaids++; }
     781            if(ucaid)
     782            {
     783                fcaids++;
     784            }
     785
    646786            if(ucaid && psfilt->caid == ucaid)
    647787            {
     
    650790            }
    651791        }
     792
    652793        if(fcaids == cl->ftab.nfilts && !filt->caid)
    653794        {
     
    657798        }
    658799    }
     800
    659801    // empty client CAID - use server CAID
    660     if(!filt->caid) { filt->caid = psfilt->caid; }
     802    if(!filt->caid)
     803    {
     804        filt->caid = psfilt->caid;
     805    }
    661806
    662807    // 2. PROVID
     
    669814            add = 0;
    670815            struct s_reader *rdr;
     816
    671817            for(rdr = first_active_reader; rdr ; rdr = rdr->next)
     818            {
    672819                if(rdr->grp & cl->grp)
    673820                {
    674821                    if(!rdr->ftab.nfilts)
    675822                    {
    676                         if(is_network_reader(rdr)) { add = 1; }
     823                        if(is_network_reader(rdr))
     824                        {
     825                            add = 1;
     826                        }
     827
    677828                        for(j = 0; !add && j < rdr->nprov; j++)
    678                             if(b2i(3, &rdr->prid[j][1]) == psfilt->prids[i]) { add = 1; }
     829                        {
     830                            if(b2i(3, &rdr->prid[j][1]) == psfilt->prids[i])
     831                            {
     832                                add = 1;
     833                            }
     834                        }
    679835                    }
    680836                    else
     
    686842                            {
    687843                                for(k = 0; !add && k < rdr->ftab.filts[j].nprids; k++)
    688                                     if(rdr->ftab.filts[j].prids[k] == psfilt->prids[i]) { add = 1; }
     844                                {
     845                                    if(rdr->ftab.filts[j].prids[k] == psfilt->prids[i])
     846                                    {
     847                                        add = 1;
     848                                    }
     849                                }
    689850                            }
    690851                        }
    691852                    }
    692853                }
    693             if(add) { filt->prids[filt->nprids++] = psfilt->prids[i]; }
    694         }
     854            }
     855
     856            if(add)
     857            {
     858                filt->prids[filt->nprids++] = psfilt->prids[i];
     859            }
     860        }
     861
    695862        memcpy(filt, psfilt, sizeof(*filt));
    696863        return;
     
    701868    {
    702869        uint32_t ucaid = cl->ftab.filts[j].caid;
     870
    703871        cs_log_dbg(D_CLIENT, "client caid %d: %04X", j, ucaid);
     872
    704873        if(!ucaid || ucaid == filt->caid)
    705874        {
     
    707876            {
    708877                cs_log_dbg(D_CLIENT, "search server provid %d: %06X", i, psfilt->prids[i]);
     878
    709879                if(cl->ftab.filts[j].nprids)
    710880                {
    711881                    for(k = 0; k < cl->ftab.filts[j].nprids && filt->nprids < CS_MAXPROV; k++)
     882                    {
    712883                        if(cl->ftab.filts[j].prids[k] == psfilt->prids[i])
    713                             { filt->prids[filt->nprids++] = cl->ftab.filts[j].prids[k]; }
     884                        {
     885                            filt->prids[filt->nprids++] = cl->ftab.filts[j].prids[k];
     886                        }
     887                    }
    714888                }
    715889                else
     
    766940        {
    767941            cs_log_dbg(D_CLIENT, "expected MSG_CLIENT_2_SERVER_LOGIN (%02X), received %02X",
    768                             MSG_CLIENT_2_SERVER_LOGIN, mbuf[2]);
     942                        MSG_CLIENT_2_SERVER_LOGIN, mbuf[2]);
    769943            return -1;
    770944        }
     945
    771946        usr = mbuf + 5;
    772947        pwd = usr + strlen((char *)usr) + 1;
     
    780955    cl->ncd_client_id = (mbuf[0] << 8) | mbuf[1];
    781956    const char *client_name = newcamd_get_client_name(cl->ncd_client_id);
     957
    782958#if defined(TCP_KEEPIDLE)
    783     if(cl->ncd_client_id == 0x4453)     // DiabloWifi has problems with TCPKeepAlive
     959    if(cl->ncd_client_id == 0x4453) // DiabloWifi has problems with TCPKeepAlive
    784960    {
    785961        int32_t flag = 600;
    786         if(setsockopt(cl->udp_fd, IPPROTO_TCP, TCP_KEEPIDLE, &flag, sizeof(flag)) && errno != EBADF)    //send first keepalive packet after 600 seconds of last package received (keepalive packets included)
     962
     963        // send first keepalive packet after 600 seconds of
     964        // last package received (keepalive packets included)
     965        if(setsockopt(cl->udp_fd, IPPROTO_TCP, TCP_KEEPIDLE, &flag, sizeof(flag)) && errno != EBADF)
    787966        {
    788967            cs_log("Setting TCP_KEEPIDLE failed, errno=%d, %s", errno, strerror(errno));
    789968        }
    790         else { cs_log("WARNING: Setting TCP_KEEPIDLE to 10 minutes for bugged DiabloWifi. Note that this might lead to not detected broken connections or multiple connections."); }
     969        else
     970        {
     971            cs_log("WARNING: Setting TCP_KEEPIDLE to 10 minutes for bugged DiabloWifi. Note that this might lead to not detected broken connections or multiple connections.");
     972        }
    791973    }
    792974#endif
    793975
    794     if(cl->ncd_proto == NCD_525 && 0x6D == mbuf[0]
    795             && 0x67 == mbuf[1] && 0x11 == cl->ncd_header[11])
     976    if(cl->ncd_proto == NCD_525 && 0x6D == mbuf[0] && 0x67 == mbuf[1] && 0x11 == cl->ncd_header[11])
    796977    {
    797978        sid_list = 1;
    798979    }
    799980
    800     for(ok = 0, account = cfg.account; (usr) && (account) && (!ok); account = account->next)
     981    for(ok = 0, account = cfg.account; usr && account && (!ok); account = account->next)
    801982    {
    802983        cs_log_dbg(D_CLIENT, "account->usr=%s", account->usr);
     984
    803985        if(strcmp((char *)usr, account->usr) == 0)
    804986        {
    805987            __md5_crypt(ESTR(account->pwd), "$1$abcdefgh$", (char *)passwdcrypt);
    806988            cs_log_dbg(D_CLIENT, "account->pwd=%s", passwdcrypt);
     989
    807990            if(strcmp((char *)pwd, (const char *)passwdcrypt) == 0)
    808991            {
    809992                cl->crypted = 1;
    810993                char e_txt[20];
     994
    811995                snprintf(e_txt, 20, "%s:%d", "newcamd", cfg.ncd_ptab.ports[cl->port_idx].s_port);
     996
    812997                if((rc = cs_auth_client(cl, account, e_txt)) == 2)
    813998                {
     
    8281013            }
    8291014            else
    830                 { cs_log("user %s is providing a wrong password (%s)", usr, client_name); }
     1015            {
     1016                cs_log("user %s is providing a wrong password (%s)", usr, client_name);
     1017            }
    8311018        }
    8321019    }
     
    8421029    {
    8431030        if(!cfg.ncd_ptab.ports[cl->port_idx].ncd)
    844             { continue; }
     1031        {
     1032            continue;
     1033        }
     1034
    8451035        if(rdr->caid == cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].caid)
    8461036        {
     
    8601050        {
    8611051            int32_t n;
     1052
    8621053            if(!cfg.ncd_ptab.ports[cl->port_idx].ncd)
    863                 { continue; }
     1054            {
     1055                continue;
     1056            }
    8641057
    8651058            if(cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].caid == 0
    866                 && !rdr->audisabled && (is_network_reader(rdr) || rdr->card_status == CARD_INSERTED) )
     1059                && !rdr->audisabled && (is_network_reader(rdr) || rdr->card_status == CARD_INSERTED))
    8671060            {
    8681061                aureader = rdr;
     
    8721065            for(n = 0; n < cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].nprids; n++)
    8731066            {
    874                 if(emm_reader_match(rdr, cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].caid, cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].prids[n]))
     1067                if(emm_reader_match(rdr, cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].caid,
     1068                                    cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].prids[n]))
    8751069                {
    8761070                    aureader = rdr;
     
    8781072                }
    8791073            }
     1074
    8801075            if(aureader)
    881                 { break; }
     1076            {
     1077                break;
     1078            }
    8821079        }
    8831080
     
    8931090
    8941091    network_cmd_no_data_send(cl->udp_fd, &cl->ncd_msgid,
    895                              (ok) ? MSG_CLIENT_2_SERVER_LOGIN_ACK : MSG_CLIENT_2_SERVER_LOGIN_NAK,
    896                              cl->ncd_skey, COMMTYPE_SERVER);
     1092                            (ok) ? MSG_CLIENT_2_SERVER_LOGIN_ACK : MSG_CLIENT_2_SERVER_LOGIN_NAK,
     1093                            cl->ncd_skey, COMMTYPE_SERVER);
    8971094
    8981095    if(ok)
     
    9081105        {
    9091106            int32_t j, len = 15;
     1107
    9101108            if(mbuf[2] != MSG_CARD_DATA_REQ)
    9111109            {
    9121110                cs_log_dbg(D_CLIENT, "expected MSG_CARD_DATA_REQ (%02X), received %02X",
    913                                 MSG_CARD_DATA_REQ, mbuf[2]);
     1111                            MSG_CARD_DATA_REQ, mbuf[2]);
    9141112                return -1;
    9151113            }
     
    9421140
    9431141            if(aureader)
    944                 { mbuf[3] = 1; }
     1142            {
     1143                mbuf[3] = 1;
     1144            }
    9451145            else
    946                 { mbuf[3] = get_threadnum(cl) + 10; } // Unique user number
     1146            {
     1147                mbuf[3] = get_threadnum(cl) + 10; // Unique user number
     1148            }
    9471149
    9481150            mbuf[4] = (uint8_t)(pufilt->caid >> 8);
     
    9521154
    9531155            if(aureader)
    954                 { hexserial_to_newcamd(aureader->hexserial, mbuf + 8, pufilt->caid); }
     1156            {
     1157                hexserial_to_newcamd(aureader->hexserial, mbuf + 8, pufilt->caid);
     1158            }
    9551159            else
    956                 { memset(&mbuf[8], 0, 6); } //mbuf[8] - mbuf[13]
     1160            {
     1161                memset(&mbuf[8], 0, 6); // mbuf[8] - mbuf[13]
     1162            }
    9571163
    9581164            mbuf[14] = pufilt->nprids;
     1165
    9591166            for(j = 0; j < pufilt->nprids; j++)
    9601167            {
     
    9711178                    mbuf[17 + 11 * j] = (uint8_t)(pufilt->prids[j]);
    9721179                }
     1180
    9731181                mbuf[18 + 11 * j] = 0x00;
    9741182                mbuf[19 + 11 * j] = 0x00;
    9751183                mbuf[20 + 11 * j] = 0x00;
    9761184                mbuf[21 + 11 * j] = 0x00;
     1185
    9771186                if(aureader)
    9781187                {
     
    9811190                    uint32_t rprid;
    9821191                    found = 0;
     1192
    9831193                    if(pufilt->caid == aureader->caid && aureader->typ != R_EMU)
    9841194                    {
    985                         for(k = 0; (k < aureader->nprov); k++)
     1195                        for(k = 0; k < aureader->nprov; k++)
    9861196                        {
    9871197                            rprid = b2i(3, &aureader->prid[k][1]);
     
    10021212                                    mbuf[25 + 11 * j] = aureader->sa[k][3];
    10031213                                }
     1214
    10041215                                found = 1;
    10051216                                break;
     
    10331244                    }
    10341245                }
     1246
    10351247                len += 11;
    10361248            }
     
    10421254            {
    10431255                if((aureader->blockemm & EMM_GLOBAL) && !(aureader->saveemm & EMM_GLOBAL))
    1044                     { cd.sid |= 4; }
     1256                {
     1257                    cd.sid |= 4;
     1258                }
     1259
    10451260                if((aureader->blockemm & EMM_SHARED) && !(aureader->saveemm & EMM_SHARED))
    1046                     { cd.sid |= 2; }
     1261                {
     1262                    cd.sid |= 2;
     1263                }
     1264
    10471265                if((aureader->blockemm & EMM_UNIQUE) && !(aureader->saveemm & EMM_UNIQUE))
    1048                     { cd.sid |= 1; }
    1049             }
    1050 
    1051             if(network_message_send(cl->udp_fd, &cl->ncd_msgid,
    1052                                     mbuf, len, key, COMMTYPE_SERVER, 0, &cd) < 0)
     1266                {
     1267                    cd.sid |= 1;
     1268                }
     1269            }
     1270
     1271            if(network_message_send(cl->udp_fd, &cl->ncd_msgid, mbuf, len, key, COMMTYPE_SERVER, 0, &cd) < 0)
    10531272            {
    10541273                return -1;
     
    10581277        // send SID list
    10591278        if(sid_list)
    1060             { send_sid_list(); }
     1279        {
     1280            send_sid_list();
     1281        }
    10611282    }
    10621283    else
     
    10651286        return -1;
    10661287    }
     1288
    10671289    return 0;
    10681290}
     
    10821304    cl_msgid = er->msgid;
    10831305    mbuf[0] = er->ecm[0];
    1084     if(er->rc >= E_NOTFOUND) /*not found*/
     1306
     1307    if(er->rc >= E_NOTFOUND) // not found
    10851308    {
    10861309        len = 3;
     
    10961319    cs_log_dbg(D_CLIENT, "ncd_send_dcw: er->msgid=%d, cl_msgid=%d, %02X", er->msgid, cl_msgid, mbuf[0]);
    10971320
    1098     network_message_send(client->udp_fd, &cl_msgid, mbuf, len,
    1099                          client->ncd_skey, COMMTYPE_SERVER, 0, NULL);
     1321    network_message_send(client->udp_fd, &cl_msgid, mbuf, len, client->ncd_skey, COMMTYPE_SERVER, 0, NULL);
    11001322}
    11011323
     
    11071329
    11081330    if(len < 5)
    1109         { return; }
     1331    {
     1332        return;
     1333    }
    11101334
    11111335    ecmlen = SCT_LEN((&buf[2]));
     
    11231347    er->msgid = cl->ncd_msgid;
    11241348    er->ecmlen = ecmlen;
     1349
    11251350    cs_log_dbg(D_CLIENT, "ncd_process_ecm: er->msgid=%d len=%d ecmlen=%d", er->msgid, len, er->ecmlen);
     1351
    11261352    er->srvid = cl->ncd_header[4] << 8 | cl->ncd_header[5];
    11271353    er->caid = cl->ncd_header[6] << 8 | cl->ncd_header[7];
    11281354    er->prid = cl->ncd_header[8] << 16 | cl->ncd_header[9] << 8 | cl->ncd_header[10];
     1355
    11291356    if(!er->caid)
    11301357    {
    11311358        pi = cl->port_idx;
    11321359        if(cfg.ncd_ptab.nports && cfg.ncd_ptab.nports >= pi && cfg.ncd_ptab.ports[pi].ncd)
    1133             { er->caid = cfg.ncd_ptab.ports[pi].ncd->ncd_ftab.filts[0].caid; }
    1134     }
     1360        {
     1361            er->caid = cfg.ncd_ptab.ports[pi].ncd->ncd_ftab.filts[0].caid;
     1362        }
     1363    }
     1364
    11351365    memcpy(er->ecm, buf + 2, er->ecmlen);
    11361366    get_cw(cl, er);
     
    11451375
    11461376    if(len < 3)
    1147         { return; }
     1377    {
     1378        return;
     1379    }
    11481380
    11491381    memset(&epg, 0, sizeof(epg));
     
    11511383    epg.emmlen = SCT_LEN(buf);
    11521384    if(epg.emmlen > MAX_EMM_SIZE || epg.emmlen > len)
    1153         { return; }
     1385    {
     1386        return;
     1387    }
    11541388
    11551389    caid = cfg.ncd_ptab.ports[cl->port_idx].ncd->ncd_ftab.filts[0].caid;
     1390
    11561391    epg.caid[0] = (uint8_t)(caid >> 8);
    11571392    epg.caid[1] = (uint8_t)(caid);
     
    11641399    epg.provid[3] = (uint8_t)(provid);
    11651400
    1166     /*  if (caid == 0x0500)
    1167         {
    1168             uint16_t emm_head;
    1169 
    1170             emm_head = (buf[0]<<8) | buf[1];
    1171             switch( emm_head )
    1172             {
    1173                 case 0x8e70:  // EMM-S
    1174                     memcpy(epg.hexserial+1, buf+3, 4);
    1175                     epg.hexserial[4]=aureader->hexserial[4];
    1176                     break;
    1177                 case 0x8870:  // EMM-U
    1178                 case 0x8c70:  // confidential ?
    1179                 default:
    1180                     cs_log("unsupported emm type: %04X", emm_head);
    1181                     ok=0;
    1182             }
    1183             if( !ok ) cs_log("only EMM-S supported");
    1184         }
    1185         else*/
     1401    /*if(caid == 0x0500)
     1402    {
     1403        uint16_t emm_head;
     1404
     1405        emm_head = (buf[0]<<8) | buf[1];
     1406        switch( emm_head )
     1407        {
     1408            case 0x8e70: // EMM-S
     1409                memcpy(epg.hexserial+1, buf+3, 4);
     1410                epg.hexserial[4]=aureader->hexserial[4];
     1411                break;
     1412            case 0x8870: // EMM-U
     1413            case 0x8c70: // confidential?
     1414            default:
     1415                cs_log("unsupported emm type: %04X", emm_head);
     1416                ok=0;
     1417        }
     1418
     1419        if(!ok) cs_log("only EMM-S supported");
     1420    }
     1421    else*/
    11861422
    11871423    memcpy(epg.emm, buf, epg.emmlen);
     1424
    11881425    if(ok)
    1189         { do_emm(cl, &epg); }
     1426    {
     1427        do_emm(cl, &epg);
     1428    }
    11901429
    11911430    // Should always send an answer to client (also if au is disabled),
     
    11931432    buf[1] = 0x10;
    11941433    buf[2] = 0x00;
    1195     network_message_send(cl->udp_fd, &cl->ncd_msgid, buf, 3,
    1196                         cl->ncd_skey, COMMTYPE_SERVER, 0, NULL);
     1434
     1435    network_message_send(cl->udp_fd, &cl->ncd_msgid, buf, 3, cl->ncd_skey, COMMTYPE_SERVER, 0, NULL);
    11971436}
    11981437
     
    12021441    uint8_t buf[512];
    12031442    custom_data_t *cd;
     1443
    12041444    if(!cs_malloc(&cd, sizeof(struct custom_data)))
    1205         { return; }
     1445    {
     1446        return;
     1447    }
     1448
    12061449    memset(buf, 0, sizeof(buf));
    12071450
    12081451    cd->sid = cfg.ncd_ptab.ports[client->port_idx].s_port;
    1209 
    12101452    buf[0] = MSG_SERVER_2_CLIENT_ADDCARD;
     1453
    12111454    struct s_reader *rdr;
    12121455    for(rdr = first_active_reader; rdr ; rdr = rdr->next)
    12131456    {
    12141457        int32_t flt = 0;
    1215         if(!(rdr->grp & client->grp)) { continue; } // test - skip unaccesible readers
     1458
     1459        if(!(rdr->grp & client->grp))
     1460        {
     1461            continue; // test - skip unaccesible readers
     1462        }
     1463
    12161464        if(rdr->ftab.filts)
    12171465        {
     
    12211469                {
    12221470                    cd->caid = rdr->ftab.filts[j].caid;
     1471
    12231472                    if(!rdr->ftab.filts[j].nprids)
    12241473                    {
    12251474                        cd->provid = 0;
    12261475                        cs_log_dbg(D_CLIENT, "newcamd: extended: report card %04X@%06X svc", cd->caid, cd->provid);
    1227                         network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3, client->ncd_skey, COMMTYPE_SERVER, 0, cd);
     1476
     1477                        network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3,
     1478                                            client->ncd_skey, COMMTYPE_SERVER, 0, cd);
    12281479                    }
     1480
    12291481                    for(k = 0; k < rdr->ftab.filts[j].nprids; k++)
    12301482                    {
    12311483                        cd->provid = rdr->ftab.filts[j].prids[k];
    12321484                        cs_log_dbg(D_CLIENT, "newcamd: extended: report card %04X@%06X svc", cd->caid, cd->provid);
    1233                         network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3, client->ncd_skey, COMMTYPE_SERVER, 0, cd);
     1485
     1486                        network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3,
     1487                                            client->ncd_skey, COMMTYPE_SERVER, 0, cd);
    12341488                        flt = 1;
    12351489                    }
     
    12471501                    cd->provid = 0;
    12481502                    cs_log_dbg(D_CLIENT, "newcamd: extended: report card %04X@%06X caid", cd->caid, cd->provid);
    1249                     network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3, client->ncd_skey, COMMTYPE_SERVER, 0, cd);
     1503
     1504                    network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3,
     1505                                        client->ncd_skey, COMMTYPE_SERVER, 0, cd);
    12501506                }
     1507
    12511508                for(j = 0; j < rdr->nprov; j++)
    12521509                {
    12531510                    cd->provid = (rdr->prid[j][1]) << 16 | (rdr->prid[j][2] << 8) | rdr->prid[j][3];
    12541511                    cs_log_dbg(D_CLIENT, "newcamd: extended: report card %04X@%06X caid", cd->caid, cd->provid);
    1255                     network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3, client->ncd_skey, COMMTYPE_SERVER, 0, cd);
     1512
     1513                    network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3,
     1514                                        client->ncd_skey, COMMTYPE_SERVER, 0, cd);
    12561515                }
    12571516            }
    12581517        }
    12591518    }
     1519
    12601520    if(cfg.sidtab && client->account)
    12611521    {
     
    12641524        {
    12651525            if(client->account->sidtabs.ok & ((SIDTABBITS)1 << j))
     1526            {
    12661527                for(k = 0; k < ptr->num_caid; k++)
    12671528                {
    12681529                    cd->caid = ptr->caid[k];
     1530
    12691531                    if(!ptr->num_provid)
    12701532                    {
    12711533                        cd->provid = 0;
    12721534                        cs_log_dbg(D_CLIENT, "newcamd: extended: report card %04X@%06X acs", cd->caid, cd->provid);
    1273                         network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3, client->ncd_skey, COMMTYPE_SERVER, 0, cd);
     1535
     1536                        network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3,
     1537                                            client->ncd_skey, COMMTYPE_SERVER, 0, cd);
    12741538                    }
     1539
    12751540                    for(l = 0; l < ptr->num_provid; l++)
    12761541                    {
    12771542                        cd->provid = ptr->provid[l];
    12781543                        cs_log_dbg(D_CLIENT, "newcamd: extended: report card %04X@%06X acs", cd->caid, cd->provid);
    1279                         network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3, client->ncd_skey, COMMTYPE_SERVER, 0, cd);
     1544
     1545                        network_message_send(client->udp_fd, &client->ncd_msgid, buf, 3,
     1546                                            client->ncd_skey, COMMTYPE_SERVER, 0, cd);
    12801547                    }
    12811548                }
    1282         }
    1283     }
     1549            }
     1550        }
     1551    }
     1552
    12841553    NULLFREE(cd);
    1285 
    12861554}
    12871555
     
    13261594    uint8_t buf[30];
    13271595    memset(buf, 0, sizeof(buf));
     1596
    13281597    buf[0] = MSG_SERVER_2_CLIENT_GET_VERSION;
    13291598    buf[1] = EXT_VERSION_LEN >> 8;
    13301599    buf[2] = EXT_VERSION_LEN & 0xFF;
    13311600    memcpy(buf + 3, EXT_VERSION_STR, EXT_VERSION_LEN);
    1332     network_message_send(client->udp_fd, &client->ncd_msgid, buf, EXT_VERSION_LEN + 3, client->ncd_skey, COMMTYPE_SERVER, 0, NULL);
     1601
     1602    network_message_send(client->udp_fd, &client->ncd_msgid, buf, EXT_VERSION_LEN + 3,
     1603                        client->ncd_skey, COMMTYPE_SERVER, 0, NULL);
    13331604}
    13341605
     
    13391610
    13401611    if(len < 3)
    1341         { return NULL; }
     1612    {
     1613        return NULL;
     1614    }
    13421615
    13431616    cs_log_dbg(D_CLIENT, "newcamd: got cmd %d", mbuf[2]);
     
    13451618    switch(mbuf[2])
    13461619    {
    1347     case 0x80:
    1348     case 0x81:
    1349         newcamd_process_ecm(client, mbuf, len);
    1350         break;
    1351 
    1352     case MSG_SERVER_2_CLIENT_GET_VERSION:
    1353         cs_log_dbg(D_CLIENT, "newcamd: extended: send Version 1.67");
    1354         newcamd_send_version(client);
    1355         break;
    1356 
    1357     case MSG_KEEPALIVE:
    1358         newcamd_reply_ka();
    1359         break;
    1360 
    1361     default:
    1362         if(mbuf[2] > 0x81 && mbuf[2] < 0x92)
    1363             { newcamd_process_emm(mbuf + 2, len - 2); }
    1364         else
    1365         {
    1366             cs_log_dbg(D_CLIENT, "unknown newcamd command! (%d)", mbuf[2]);
     1620        case 0x80:
     1621        case 0x81:
     1622        {
     1623            newcamd_process_ecm(client, mbuf, len);
     1624            break;
     1625        }
     1626
     1627        case MSG_SERVER_2_CLIENT_GET_VERSION:
     1628        {
     1629            cs_log_dbg(D_CLIENT, "newcamd: extended: send Version 1.67");
     1630            newcamd_send_version(client);
     1631            break;
     1632        }
     1633
     1634        case MSG_KEEPALIVE:
     1635        {
     1636            newcamd_reply_ka();
     1637            break;
     1638        }
     1639
     1640        default:
     1641        {
     1642            if(mbuf[2] > 0x81 && mbuf[2] < 0x92)
     1643            {
     1644                newcamd_process_emm(mbuf + 2, len - 2);
     1645            }
     1646            else
     1647            {
     1648                cs_log_dbg(D_CLIENT, "unknown newcamd command! (%d)", mbuf[2]);
     1649            }
    13671650        }
    13681651    }
     
    13761659    struct s_reader *rdr = client->reader;
    13771660
    1378     if(!rdr) { return; }
     1661    if(!rdr)
     1662    {
     1663        return;
     1664    }
    13791665
    13801666    if(rdr->tcp_ito > 0)
     
    13831669        time_t now;
    13841670        int32_t time_diff;
     1671
    13851672        time(&now);
    13861673        time_diff = llabs(now - rdr->last_s);
     1674
    13871675        if(time_diff > (rdr->tcp_ito))
    13881676        {
    13891677            if(client->ncd_keepalive)
    1390                 { newcamd_reply_ka(); }
     1678            {
     1679                newcamd_reply_ka();
     1680            }
    13911681            else
    1392                 { network_tcp_connection_close(client->reader, "inactivity"); }
     1682            {
     1683                network_tcp_connection_close(client->reader, "inactivity");
     1684            }
    13931685        }
    13941686    }
     
    14061698int32_t newcamd_client_init(struct s_client *client)
    14071699{
    1408 
    14091700    char ptxt[1] = { "\0" };
    14101701
    14111702    client->ncd_proto = client->reader->ncd_proto;
    14121703
    1413     cs_log("proxy %s:%d newcamd52%d (fd=%d%s)",
    1414              client->reader->device, client->reader->r_port,
    1415              (client->reader->ncd_proto == NCD_525) ? 5 : 4, client->udp_fd, ptxt);
     1704    cs_log("proxy %s:%d newcamd52%d (fd=%d%s)", client->reader->device, client->reader->r_port,
     1705            (client->reader->ncd_proto == NCD_525) ? 5 : 4, client->udp_fd, ptxt);
    14161706
    14171707    // try to connect. ignore possible failures
    14181708    // idle reconnect (tcp_ito = -1) will trigger an additional connect anyway
    14191709    if(client->reader->ncd_connect_on_init && client->reader->tcp_ito != -1)
    1420         { newcamd_connect(); }
    1421 
    1422     return (0);
     1710    {
     1711        newcamd_connect();
     1712    }
     1713
     1714    return 0;
    14231715}
    14241716
     
    14281720
    14291721    if(!newcamd_connect())
    1430         { return (-1); }
     1722    {
     1723        return -1;
     1724    }
    14311725
    14321726    // check server filters
    14331727    if(!chk_rsfilter(rdr, er))
    1434         { return (-1); }
     1728    {
     1729        return -1;
     1730    }
    14351731
    14361732    uint8_t *buf;
    14371733    if(!cs_malloc(&buf, er->ecmlen))
    1438     { return (-1); }
     1734    {
     1735        return -1;
     1736    }
    14391737
    14401738    memcpy(buf, er->ecm, er->ecmlen);
     
    14481746    client->ncd_header[10] = er->prid & 0xFF;
    14491747
    1450     int32_t rc = ((newcamd_send(buf, er->ecmlen, er->srvid) < 1) ? (-1) : 0);
     1748    int32_t rc = (newcamd_send(buf, er->ecmlen, er->srvid) < 1) ? -1 : 0;
    14511749
    14521750    NULLFREE(buf);
     
    14541752}
    14551753
    1456 
    14571754static int32_t newcamd_send_emm(EMM_PACKET *ep)
    14581755{
     
    14601757
    14611758    if(!newcamd_connect())
    1462         { return (-1); }
     1759    {
     1760        return -1;
     1761    }
    14631762
    14641763    memcpy(buf, ep->emm, ep->emmlen);
    1465     return ((newcamd_send(buf, ep->emmlen, 0) < 1) ? 0 : 1);
     1764
     1765    return (newcamd_send(buf, ep->emmlen, 0) < 1) ? 0 : 1;
    14661766}
    14671767
     
    14711771
    14721772    if(n < 5)
    1473         { return -1; }
     1773    {
     1774        return -1;
     1775    }
    14741776
    14751777    switch(buf[2])
    14761778    {
    1477     case 0x80:
    1478     case 0x81:
    1479         idx = (buf[0] << 8) | buf[1];
    1480         if(n == 5) // not found on server
    1481         {
    1482             *rc = 0;
    1483             memset(dcw, 0, 16);
     1779        case 0x80:
     1780        case 0x81:
     1781        {
     1782            idx = (buf[0] << 8) | buf[1];
     1783
     1784            if(n == 5) // not found on server
     1785            {
     1786                *rc = 0;
     1787                memset(dcw, 0, 16);
     1788                break;
     1789            }
     1790
     1791            if(n < 21)
     1792            {
     1793                cs_log_dbg(D_CLIENT, "invalid newcamd answer");
     1794                return (-1);
     1795            }
     1796
     1797            *rc = 1;
     1798            memcpy(dcw, buf + 5, 16);
    14841799            break;
    14851800        }
    14861801
    1487         if(n < 21)
    1488         {
    1489             cs_log_dbg(D_CLIENT, "invalid newcamd answer");
    1490             return (-1);
    1491         }
    1492 
    1493         *rc = 1;
    1494         memcpy(dcw, buf + 5, 16);
    1495         break;
    1496 
    1497     case MSG_KEEPALIVE:
    1498         return -1;
    1499 
    1500     case MSG_SERVER_2_CLIENT_ADDCARD:
    1501         if(client->reader)
    1502         {
    1503             client->reader->ncd_disable_server_filt = 1;
    1504         }
    1505         return -1;
    1506 
    1507     default:
    1508         if(buf[2] > 0x81 && buf[2] < 0x92) // answer to emm
     1802        case MSG_KEEPALIVE:
    15091803        {
    15101804            return -1;
    15111805        }
    1512         cs_log_dbg(D_CLIENT, "unknown newcamd command from server");
    1513         return -1;
    1514     }
    1515     return (idx);
     1806
     1807        case MSG_SERVER_2_CLIENT_ADDCARD:
     1808        {
     1809            if(client->reader)
     1810            {
     1811                client->reader->ncd_disable_server_filt = 1;
     1812            }
     1813
     1814            return -1;
     1815        }
     1816
     1817        default:
     1818        {
     1819            if(buf[2] > 0x81 && buf[2] < 0x92) // answer to emm
     1820            {
     1821                return -1;
     1822            }
     1823
     1824            cs_log_dbg(D_CLIENT, "unknown newcamd command from server");
     1825            return -1;
     1826        }
     1827    }
     1828
     1829    return idx;
    15161830}
    15171831
     
    15671881        { 0xFFFF, NULL }
    15681882    };
     1883
    15691884    int i = 0;
     1885
    15701886    while(1)
    15711887    {
    15721888        if(!ncd_service_ids[i].client)
    1573             { break; }
     1889        {
     1890            break;
     1891        }
     1892
    15741893        if(ncd_service_ids[i].id == client_id)
    1575             { return ncd_service_ids[i].client; }
     1894        {
     1895            return ncd_service_ids[i].client;
     1896        }
     1897
    15761898        i++;
    15771899    }
     1900
    15781901    return "unknown - please report";
    15791902}
Note: See TracChangeset for help on using the changeset viewer.