Changeset 11519


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

small cleanup

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/module-camd35.c

    r11472 r11519  
    2626//CMD06 - EMM (incomming EMM in server mode)
    2727//CMD19 - EMM (incomming EMM in server mode) only seen with caid 0x1830
    28 //CMD08 - Stop sending requests to the server for current srvid,prvid,caid
     28//CMD08 - Stop sending requests to the server for current srvid, prvid, caid
    2929//CMD44 - MPCS/OScam internal error notification
    3030//CMD55 - connect_on_init/keepalive
     
    3838//bytes node id ncd_skey[8] : 1=valid node id received
    3939
    40 #define REQ_SIZE    MAX_ECM_SIZE + 20 + 0x34
     40#define REQ_SIZE 20 + MAX_ECM_SIZE + 0x34
    4141
    4242static int32_t __camd35_send(struct s_client *cl, uint8_t *buf, int32_t buflen, int answer_awaited)
    4343{
    44     int32_t l;
    45     uint8_t rbuf[REQ_SIZE + 15 + 4], *sbuf = rbuf + 4;
    46 
    47     if(!cl->udp_fd || !cl->crypted) { return (-1); }  //exit if no fd or aes key not set!
    48 
    49     //Fix ECM len > 255
     44    int32_t l, status;
     45    uint8_t rbuf[4 + REQ_SIZE + 15];
     46    uint8_t *sbuf = rbuf + 4;
     47
     48    if(!cl->udp_fd || !cl->crypted)
     49    {
     50        return -1; // exit if no fd or aes key not set
     51    }
     52
     53    // Fix ECM len > 255
    5054    if(buflen <= 0)
    51         { buflen = ((buf[0] == 0) ? (((buf[21] & 0x0f) << 8) | buf[22]) + 3 : buf[1]); }
     55    {
     56        buflen = (buf[0] == 0) ? (((buf[21] & 0x0F) << 8) | buf[22]) + 3 : buf[1];
     57    }
    5258    l = 20 + (((buf[0] == 3) || (buf[0] == 4)) ? 0x34 : 0) + buflen;
     59
    5360    memcpy(rbuf, cl->ucrc, 4);
    5461    memcpy(sbuf, buf, l);
    55     memset(sbuf + l, 0xff, 15); // set unused space to 0xff for newer camd3's
     62    memset(sbuf + l, 0xFF, 15); // set unused space to 0xFF for newer camd3's
    5663    i2b_buf(4, crc32(0L, sbuf + 20, buflen), sbuf + 4);
    5764    l = boundary(4, l);
     65
    5866    cs_log_dump_dbg(cl->typ == 'c' ? D_CLIENT : D_READER, sbuf, l, "send %d bytes to %s", l, username(cl));
     67
    5968    aes_encrypt_idx(cl->aes_keys, sbuf, l);
    6069
    61     int32_t status;
    6270    if(cl->is_udp)
    6371    {
    6472        status = sendto(cl->udp_fd, rbuf, l + 4, 0, (struct sockaddr *)&cl->udp_sa, cl->udp_sa_len);
    65         if(status == -1) { set_null_ip(&SIN_GET_ADDR(cl->udp_sa)); }
     73        if(status == -1)
     74        {
     75            set_null_ip(&SIN_GET_ADDR(cl->udp_sa));
     76        }
    6677    }
    6778    else
     
    7182        if(cl->typ == 'p' && cl->reader)
    7283        {
    73             if(status == -1) { network_tcp_connection_close(cl->reader, "can't send"); }
     84            if(status == -1)
     85            {
     86                network_tcp_connection_close(cl->reader, "can't send");
     87            }
    7488        }
    7589        else if(cl->typ == 'c')
    7690        {
    77             if(status == -1) { cs_disconnect_client(cl); }
    78         }
    79     }
     91            if(status == -1)
     92            {
     93                cs_disconnect_client(cl);
     94            }
     95        }
     96    }
     97
    8098    if(status != -1)
    8199    {
     
    84102            cl->reader->last_s = time(NULL);
    85103        }
     104
    86105        if(cl->reader && !answer_awaited)
    87106        {
    88107            cl->reader->last_s = cl->reader->last_g = time(NULL);
    89108        }
     109
    90110        cl->last = time(NULL);
    91 
    92     }
     111    }
     112
    93113    return status;
    94114}
     
    114134
    115135    if(cl->upwd[0])
    116         { return (memcmp(cl->ucrc, ucrc, 4) ? 1 : 0); }
     136    {
     137        return memcmp(cl->ucrc, ucrc, 4) ? 1 : 0;
     138    }
     139
    117140    cl->crypted = 1;
    118     crc = (((ucrc[0] << 24) | (ucrc[1] << 16) | (ucrc[2] << 8) | ucrc[3]) & 0xffffffffL);
    119     for(account = cfg.account; (account) && (!cl->upwd[0]); account = account->next)
     141
     142    crc = ((ucrc[0] << 24) | (ucrc[1] << 16) | (ucrc[2] << 8) | ucrc[3]) & 0xffffffffL;
     143
     144    for(account = cfg.account; account && (!cl->upwd[0]); account = account->next)
     145    {
    120146        if(crc == crc32(0L, MD5((uint8_t *)account->usr, strlen(account->usr), md5tmp), MD5_DIGEST_LENGTH))
    121147        {
     
    125151                memcpy(cl->ucrc, ucrc, 4);
    126152                cs_strncpy((char *)cl->upwd, account->pwd, sizeof(cl->upwd));
    127                 if (!aes_set_key_alloc(&cl->aes_keys, (char *) MD5(cl->upwd, strlen((char *)cl->upwd), md5tmp)))
     153                if(!aes_set_key_alloc(&cl->aes_keys, (char *) MD5(cl->upwd, strlen((char *)cl->upwd), md5tmp)))
    128154                {
    129155                    return 1;
    130156                }
    131157
    132                 #ifdef CS_CACHEEX
     158#ifdef CS_CACHEEX
    133159                if(cl->account->cacheex.mode < 2)
    134                 #endif
     160#endif
    135161                if(!cl->is_udp && cl->tcp_nodelay == 0)
    136162                {
     
    142168            }
    143169        }
     170    }
     171
    144172    return (rc);
    145173}
     
    148176{
    149177    int32_t rc, s, rs, n = 0, buflen = 0, len = 0;
     178
    150179    for(rc = rs = s = 0; !rc; s++)
    151180    {
    152181        switch(s)
    153182        {
    154         case 0:
    155             if(!client->udp_fd) { return (-9); }
    156             if(client->is_udp && client->typ == 'c')
    157             {
    158                 rs = recv_from_udpipe(buf);
    159             }
    160             else
    161             {
    162                 //read minimum packet size (4 byte ucrc + 32 byte data) to detect packet size (tcp only)
    163 
    164                 //rs = cs_recv(client->udp_fd, buf, client->is_udp ? l : 36, 0);
    165                 if(client->is_udp){
    166                     while (1){
    167                     rs = cs_recv(client->udp_fd, buf, l, 0);
    168                         if (rs < 0){
    169                             if(errno == EINTR) { continue; }  // try again in case of interrupt
    170                             if(errno == EAGAIN) { continue; }  //EAGAIN needs select procedure again
    171                             cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "ERROR: %s (errno=%d %s)", __func__, errno, strerror(errno));
    172                             break;
    173                         }else {break;}
     183            case 0:
     184            {
     185                if(!client->udp_fd)
     186                {
     187                    return -9;
     188                }
     189
     190                if(client->is_udp && client->typ == 'c')
     191                {
     192                    rs = recv_from_udpipe(buf);
     193                }
     194                else
     195                {
     196                    // read minimum packet size (4 byte ucrc + 32 byte data)
     197                    // to detect packet size (tcp only)
     198
     199                    //rs = cs_recv(client->udp_fd, buf, client->is_udp ? l : 36, 0);
     200
     201                    if(client->is_udp)
     202                    {
     203                        while (1)
     204                        {
     205                            rs = cs_recv(client->udp_fd, buf, l, 0);
     206                            if(rs < 0)
     207                            {
     208                                if(errno == EINTR)
     209                                {
     210                                    continue; // try again in case of interrupt
     211                                }
     212
     213                                if(errno == EAGAIN)
     214                                {
     215                                    continue; // EAGAIN needs select procedure again
     216                                }
     217
     218                                cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "ERROR: %s (errno=%d %s)",
     219                                            __func__, errno, strerror(errno));
     220                                break;
     221                            }
     222                            else
     223                            {
     224                                break;
     225                            }
     226                        }
    174227                    }
    175                 }else{
    176                     int32_t tot=36, readed=0;
    177                     rs = 0;
     228                    else
     229                    {
     230                        int32_t tot = 36, readed = 0;
     231                        rs = 0;
     232
     233                        do
     234                        {
     235                            readed = cs_recv(client->udp_fd, buf + rs, tot, 0);
     236                            if(readed < 0)
     237                            {
     238                                if(errno == EINTR)
     239                                {
     240                                    continue; // try again in case of interrupt
     241                                }
     242
     243                                if(errno == EAGAIN)
     244                                {
     245                                    continue; // EAGAIN needs select procedure again
     246                                }
     247
     248                                cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "ERROR: %s (errno=%d %s)",
     249                                            __func__, errno, strerror(errno));
     250                                break;
     251                            }
     252
     253                            if(readed == 0) // nothing to read left!
     254                            {
     255                                rc = -5;
     256                                break;
     257                            }
     258
     259                            if(readed > 0) // received something, add it!
     260                            {
     261                                tot -= readed;
     262                                rs += readed;
     263                            }
     264                        }
     265                        while(tot != 0);
     266                    }
     267                }
     268
     269                if(rs < 36)
     270                {
     271                    if(rc != -5)
     272                    {
     273                        rc = -1;
     274                    }
     275
     276                    goto out;
     277                }
     278
     279                break;
     280            }
     281
     282            case 1:
     283            {
     284                switch(camd35_auth_client(client, buf))
     285                {
     286                    case 0:
     287                        break; // ok
     288
     289                    case 1:
     290                        rc = -2;
     291                        break; // unknown user
     292
     293                    default:
     294                        rc = -9;
     295                        break; // error's from cs_auth()
     296                }
     297
     298                memmove(buf, buf + 4, rs -= 4);
     299                break;
     300            }
     301
     302            case 2:
     303            {
     304                aes_decrypt(client->aes_keys, buf, rs);
     305
     306                if(rs != boundary(4, rs))
     307                {
     308                    cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER,
     309                                "WARNING: packet size has wrong decryption boundary");
     310                }
     311
     312                n = (buf[0] == 3) ? 0x34 : 0;
     313
     314                // Fix for ECM request size > 255 (use ecm length field)
     315                if(buf[0] == 0)
     316                {
     317                    buflen = (((buf[21] & 0x0F) << 8) | buf[22]) + 3;
     318                }
     319                else if(buf[0] == 0x3D || buf[0] == 0x3E || buf[0] == 0x3F) // cacheex-push
     320                {
     321                    buflen = buf[1] | (buf[2] << 8);
     322                }
     323                else
     324                {
     325                    buflen = buf[1];
     326                }
     327
     328                n = boundary(4, n + 20 + buflen);
     329
     330                if(!(client->is_udp && client->typ == 'c') && (rs < n) && ((n - 32) > 0))
     331                {
     332                    //len = cs_recv(client->udp_fd, buf+32, n-32, 0); // read the rest of the packet
     333
     334                    int32_t tot = n - 32;
     335                    int32_t readed = 0;
     336                    len = 0;
     337
    178338                    do
    179339                    {
    180                         readed = cs_recv(client->udp_fd, buf+rs, tot, 0);
    181                         if (readed < 0){
    182                             if(errno == EINTR) { continue; }  // try again in case of interrupt
    183                             if(errno == EAGAIN) { continue; }  //EAGAIN needs select procedure again
    184                             cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "ERROR: %s (errno=%d %s)", __func__, errno, strerror(errno));
     340                        readed = cs_recv(client->udp_fd, buf + 32 + len, tot, 0); // read the rest of the packet
     341                        if(readed < 0)
     342                        {
     343                            if(errno == EINTR)
     344                            {
     345                                continue; // try again in case of interrupt
     346                            }
     347
     348                            if(errno == EAGAIN)
     349                            {
     350                                continue; // EAGAIN needs select procedure again
     351                            }
     352
     353                            cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "ERROR: %s (errno=%d %s)",
     354                                        __func__, errno, strerror(errno));
    185355                            break;
    186356                        }
    187                         if (readed == 0){ // nothing to read left!
    188                             rc = -5;
     357
     358                        if(readed == 0) // nothing to read left
     359                        {
    189360                            break;
    190361                        }
    191                         if (readed > 0){ // received something, add it!
    192                             tot-=readed;
    193                         rs+=readed;
     362
     363                        if(readed > 0) // received something, add it
     364                        {
     365                            tot -= readed;
     366                            len += readed;
    194367                        }
    195368                    }
    196                     while(tot!=0);
    197                 }
    198 
    199             }
    200             if(rs < 36)
    201             {
    202                 if(rc != -5)
    203                     { rc = -1; }
    204                 goto out;
    205             }
    206             break;
    207         case 1:
    208             switch(camd35_auth_client(client, buf))
    209             {
    210             case  0:
    211                 break;  // ok
    212             case  1:
    213                 rc = -2;
    214                 break; // unknown user
    215             default:
    216                 rc = -9;
    217                 break; // error's from cs_auth()
    218             }
    219             memmove(buf, buf + 4, rs -= 4);
    220             break;
    221         case 2:
    222             aes_decrypt(client->aes_keys, buf, rs);
    223             if(rs != boundary(4, rs))
    224                 cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER,
    225                               "WARNING: packet size has wrong decryption boundary");
    226 
    227             n = (buf[0] == 3) ? 0x34 : 0;
    228 
    229             //Fix for ECM request size > 255 (use ecm length field)
    230             if(buf[0] == 0)
    231                 { buflen = (((buf[21] & 0x0f) << 8) | buf[22]) + 3; }
    232             else if(buf[0] == 0x3d || buf[0] == 0x3e || buf[0] == 0x3f)  //cacheex-push
    233                 { buflen = buf[1] | (buf[2] << 8); }
    234             else
    235                 { buflen = buf[1]; }
    236 
    237             n = boundary(4, n + 20 + buflen);
    238             if(!(client->is_udp && client->typ == 'c') && (rs < n) && ((n - 32) > 0))
    239             {
    240 
    241                 //len = cs_recv(client->udp_fd, buf+32, n-32, 0); // read the rest of the packet
    242                 int32_t tot=n-32, readed=0;
    243                 len = 0;
    244                 do{
    245                     readed = cs_recv(client->udp_fd, buf+32+len, tot, 0); // read the rest of the packet
    246                     if (readed < 0){
    247                         if(errno == EINTR) { continue; }  // try again in case of interrupt
    248                         if(errno == EAGAIN) { continue; }  //EAGAIN needs select procedure again
    249                         cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "ERROR: %s (errno=%d %s)", __func__, errno, strerror(errno));
    250                         break;
     369                    while(tot != 0);
     370
     371
     372                    if(len > 0)
     373                    {
     374                        rs += len;
     375                        aes_decrypt(client->aes_keys, buf + 32, len);
    251376                    }
    252                     if (readed == 0){ // nothing to read left!
    253                         break;
     377
     378                    if(len < 0)
     379                    {
     380                        rc = -1;
     381                        goto out;
    254382                    }
    255                     if (readed > 0){ // received something, add it!
    256                     tot-=readed;
    257                     len+=readed;
    258                     }
    259                 }
    260                 while(tot!=0);
    261 
    262 
    263                 if(len > 0)
    264                 {
    265                     rs += len;
    266                     aes_decrypt(client->aes_keys, buf + 32, len);
    267                 }
    268                 if(len < 0)
    269                 {
    270                     rc = -1;
    271                     goto out;
    272                 }
    273             }
    274 
    275             cs_log_dump_dbg(client->typ == 'c' ? D_CLIENT : D_READER,
    276                           buf, rs, "received %d bytes from %s", rs, remote_txt());
    277 
    278             if(n < rs)
    279                 cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER,
    280                               "ignoring %d bytes of garbage", rs - n);
    281             else if(n > rs) { rc = -3; }
    282             break;
    283         case 3:
    284             if(crc32(0L, buf + 20, buflen) != b2i(4, buf + 4)) { rc = -4; }
    285             if(!rc) { rc = n; }
    286             break;
     383                }
     384
     385                cs_log_dump_dbg(client->typ == 'c' ? D_CLIENT : D_READER, buf, rs, "received %d bytes from %s",
     386                                rs, remote_txt());
     387
     388                if(n < rs)
     389                {
     390                    cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "ignoring %d bytes of garbage", rs - n);
     391                }
     392                else if(n > rs)
     393                {
     394                    rc = -3;
     395                }
     396
     397                break;
     398            }
     399
     400            case 3:
     401            {
     402                if(crc32(0L, buf + 20, buflen) != b2i(4, buf + 4))
     403                {
     404                    rc = -4;
     405                }
     406
     407                if(!rc)
     408                {
     409                    rc = n;
     410                }
     411
     412                break;
     413            }
    287414        }
    288415    }
     
    292419    {
    293420        cs_log_dump_dbg(client->typ == 'c' ? D_CLIENT : D_READER, buf, rs,
    294                       "received %d bytes from %s (native)", rs, remote_txt());
    295     }
    296     if(rc >= 0) { client->last = time(NULL); }  // last client action is now
     421                        "received %d bytes from %s (native)", rs, remote_txt());
     422    }
     423
     424    if(rc >= 0)
     425    {
     426        client->last = time(NULL); // last client action is now
     427    }
     428
    297429    switch(rc)
    298430    {
    299         //case 0:   break;
    300     case -1:
    301         cs_log("packet is too small (received %d bytes, expected %d bytes)", rs, l);
    302         break;
    303     case -2:
    304         if(cs_auth_client(client, 0, "unknown user"))
    305             { cs_disconnect_client(client); }
    306         break;
    307     case -3:
    308         cs_log("incomplete request !");
    309         break;
    310     case -4:
    311         cs_log("checksum error (wrong password ?)");
    312         break;
    313     case -5:
    314         cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "connection closed");
    315         break;
    316         //default:  cs_log_dbg(D_TRACE, "camd35_recv returns rc=%d", rc); break;
     431        //case 0:
     432        //  break;
     433
     434        case -1:
     435            cs_log("packet is too small (received %d bytes, expected %d bytes)", rs, l);
     436            break;
     437
     438        case -2:
     439            if(cs_auth_client(client, 0, "unknown user"))
     440            {
     441                cs_disconnect_client(client);
     442            }
     443            break;
     444
     445        case -3:
     446            cs_log("incomplete request!");
     447            break;
     448
     449        case -4:
     450            cs_log("checksum error (wrong password?)");
     451            break;
     452
     453        case -5:
     454            cs_log_dbg(client->typ == 'c' ? D_CLIENT : D_READER, "connection closed");
     455            break;
     456
     457        //default:
     458        //  cs_log_dbg(D_TRACE, "camd35_recv returns rc=%d", rc);
     459        //  break;
    317460    }
    318461
     
    321464
    322465/*
    323  *  server functions
     466 * server functions
    324467 */
    325468
     
    332475    struct s_reader *aureader = NULL, *rdr = NULL;
    333476
    334     if(er->selected_reader && !er->selected_reader->audisabled && ll_contains(cl->aureader_list, er->selected_reader))
    335         { aureader = er->selected_reader; }
     477    if(er->selected_reader && !er->selected_reader->audisabled
     478        && ll_contains(cl->aureader_list, er->selected_reader))
     479    {
     480        aureader = er->selected_reader;
     481    }
    336482
    337483    if(!aureader && cl->aureader_list)
    338484    {
    339485        LL_ITER itr = ll_iter_create(cl->aureader_list);
     486
    340487        while((rdr = ll_iter_next(&itr)))
    341488        {
     
    349496
    350497    if(!aureader)
    351         { return; }  // TODO
     498    {
     499        return; // TODO
     500    }
    352501
    353502    uint16_t au_caid = aureader->caid;
    354503
    355     if(!au_caid && caid_is_bulcrypt(er->caid)) // Bulcrypt has 2 caids and aureader->caid can't be used. Use ECM_REQUEST caid for AU.
    356         { au_caid = er->caid; }
     504    // Bulcrypt has two caids and aureader->caid can't be used.
     505    // Use ECM_REQUEST caid for AU.
     506    if(!au_caid && caid_is_bulcrypt(er->caid))
     507    {
     508        au_caid = er->caid;
     509    }
    357510
    358511    time(&now);
     512
    359513    if(!memcmp(cl->lastserial, aureader->hexserial, 8))
    360         if(llabs(now - cl->last) < 180) { return; }
     514    {
     515        if(llabs(now - cl->last) < 180)
     516        {
     517            return;
     518        }
     519    }
    361520
    362521    memcpy(cl->lastserial, aureader->hexserial, 8);
     
    366525    {
    367526        cl->disable_counter = 0;
    368         cs_log("%s emm-request sent (reader=%s, caid=%04X, auprovid=%06X)",
    369                username(cur_client()), aureader->label, au_caid,
    370               aureader->auprovid ? aureader->auprovid : b2i(4, aureader->prid[0]));
     527
     528        cs_log("%s emm-request sent (reader=%s, caid=%04X, auprovid=%06X)", username(cur_client()),
     529                aureader->label, au_caid, aureader->auprovid ? aureader->auprovid : b2i(4, aureader->prid[0]));
    371530    }
    372531    else if(cl->disable_counter > 2)
    373         { return; }
     532    {
     533        return;
     534    }
    374535    else
    375         { cl->disable_counter++; }
     536    {
     537        cl->disable_counter++;
     538    }
    376539
    377540    memset(mbuf, 0, sizeof(mbuf));
    378     mbuf[2] = mbuf[3] = 0xff;          // must not be zero
     541    mbuf[2] = mbuf[3] = 0xFF; // must not be zero
    379542    i2b_buf(2, er->srvid, mbuf + 8);
    380543
    381     //override request provid with auprovid if set in CMD05
     544    // override request provid with auprovid if set in CMD05
    382545    if(aureader->auprovid)
    383546    {
    384547        if(aureader->auprovid != er->prid)
    385             { i2b_buf(4, aureader->auprovid, mbuf + 12); }
     548        {
     549            i2b_buf(4, aureader->auprovid, mbuf + 12);
     550        }
    386551        else
    387             { i2b_buf(4, er->prid, mbuf + 12); }
     552        {
     553            i2b_buf(4, er->prid, mbuf + 12);
     554        }
    388555    }
    389556    else
     
    395562    mbuf[0] = 5;
    396563    mbuf[1] = 111;
     564
    397565    if(au_caid)
    398566    {
    399         mbuf[39] = 1;                           // no. caids
    400         mbuf[20] = au_caid >> 8;        // caid's (max 8)
    401         mbuf[21] = au_caid & 0xff;
    402         memcpy(mbuf + 40, aureader->hexserial, 6);  // serial now 6 bytes
     567        mbuf[39] = 1; // no. caids
     568        mbuf[20] = au_caid >> 8; // caid's (max 8)
     569        mbuf[21] = au_caid & 0xFF;
     570        memcpy(mbuf + 40, aureader->hexserial, 6); // serial now 6 bytes
    403571        mbuf[47] = aureader->nprov;
     572
    404573        for(i = 0; i < aureader->nprov; i++)
    405574        {
    406             if((au_caid >= 0x1700 && au_caid <= 0x1799)  ||  // Betacrypt
    407                     (au_caid >= 0x0600 && au_caid <= 0x0699))    // Irdeto (don't know if this is correct, cause I don't own a IRDETO-Card)
     575            if(caid_is_betacrypt(au_caid) || caid_is_irdeto(au_caid))
    408576            {
    409577                mbuf[48 + (i * 5)] = aureader->prid[i][0];
     
    414582                mbuf[48 + (i * 5)] = aureader->prid[i][2];
    415583                mbuf[49 + (i * 5)] = aureader->prid[i][3];
    416                 memcpy(&mbuf[50 + (i * 5)], &aureader->sa[i][0], 4); // for conax we need at least 4 Bytes
    417             }
    418         }
    419         //we think client/server protocols should deliver all information, and only readers should discard EMM
     584                memcpy(&mbuf[50 + (i * 5)], &aureader->sa[i][0], 4); // for conax we need at least 4 bytes
     585            }
     586        }
     587
     588        // we think client/server protocols should deliver
     589        // all information, and only readers should discard EMM
    420590        mbuf[128] = (aureader->blockemm & EMM_GLOBAL && !(aureader->saveemm & EMM_GLOBAL)) ? 0 : 1;
    421591        mbuf[129] = (aureader->blockemm & EMM_SHARED && !(aureader->saveemm & EMM_SHARED)) ? 0 : 1;
     
    423593        mbuf[127] = (aureader->blockemm & EMM_UNKNOWN && !(aureader->saveemm & EMM_UNKNOWN)) ? 0 : 1;
    424594    }
    425     else        // disable emm
    426         { mbuf[20] = mbuf[39] = mbuf[40] = mbuf[47] = mbuf[49] = 1; }
     595    else // disable emm
     596    {
     597        mbuf[20] = mbuf[39] = mbuf[40] = mbuf[47] = mbuf[49] = 1;
     598    }
    427599
    428600    memcpy(mbuf + 10, mbuf + 20, 2);
    429     camd35_send(cl, mbuf, 0);       // send with data-len 111 for camd3 > 3.890
     601    camd35_send(cl, mbuf, 0); // send with data-len 111 for camd3 > 3.890
    430602    mbuf[1]++;
    431     camd35_send(cl, mbuf, 0);       // send with data-len 112 for camd3 < 3.890
     603    camd35_send(cl, mbuf, 0); // send with data-len 112 for camd3 < 3.890
    432604}
    433605
     
    443615    }
    444616
    445     if(er->rc == E_INVALID && !client->c35_suppresscmd08)  //send normal CMD08
     617    if(er->rc == E_INVALID && !client->c35_suppresscmd08) // send normal CMD08
    446618    {
    447619        buf[0] = 0x08;
    448620        buf[1] = 2;
    449621        memset(buf + 20, 0, buf[1]);
    450         buf[22] = er->rc; //put rc in byte 22 - hopefully don't break legacy camd3
    451     }
    452     else if(er->rc == E_STOPPED)  //send sleep CMD08
     622        buf[22] = er->rc; // put rc in byte 22 - hopefully don't break legacy camd3
     623    }
     624    else if(er->rc == E_STOPPED) // send sleep CMD08
    453625    {
    454626        buf[0] = 0x08;
     
    456628        buf[20] = 0;
    457629        buf[21] = 0xFF;
     630
    458631        cs_log("%s stop request send", client->account->usr);
    459632    }
     
    464637        {
    465638            if(buf[0] == 3)
    466                 { memmove(buf + 20 + 16, buf + 20 + buf[1], 0x34); }
    467             buf[0]++;
     639            {
     640                memmove(buf + 20 + 16, buf + 20 + buf[1], 0x34);
     641            }
     642
     643            buf[0]++; // ecm response (CMD01 or CMD04)
    468644            buf[1] = 16;
    469645            camd35_cacheex_init_dcw(client, er);
     
    472648        else
    473649        {
    474             // Send old CMD44 to prevent cascading problems with older mpcs/oscam versions
     650            // Send old CMD44 to prevent cascading
     651            // problems with older mpcs/oscam versions
    475652            buf[0] = 0x44;
    476653            buf[1] = 0;
    477654        }
    478655    }
     656
    479657    camd35_send(client, buf, 0);
    480658    camd35_request_emm(er);
     
    486664
    487665    if(!buf || buflen < 23)
    488         { return; }
     666    {
     667        return;
     668    }
    489669
    490670    uint16_t ecmlen = SCT_LEN((&buf[20]));
    491671
    492672    if(ecmlen > MAX_ECM_SIZE || ecmlen + 20 > buflen)
    493         { return; }
     673    {
     674        return;
     675    }
    494676
    495677    if(!(er = get_ecmtask()))
    496         { return; }
     678    {
     679        return;
     680    }
    497681
    498682    er->ecmlen = ecmlen;
    499683
    500684    if(!cs_malloc(&er->src_data, 0x34 + 20 + er->ecmlen))
    501         { NULLFREE(er); return; }
    502 
    503     memcpy(er->src_data, buf, 0x34 + 20 + er->ecmlen);  // save request
     685    {
     686        NULLFREE(er);
     687        return;
     688    }
     689
     690    memcpy(er->src_data, buf, 0x34 + 20 + er->ecmlen); // save request
    504691    er->srvid = b2i(2, buf + 8);
    505692    er->caid = b2i(2, buf + 10);
    506693    er->prid = b2i(4, buf + 12);
    507     //er->pid  = b2i(2, buf+16); value is ecmtask idx see camd35_recv_chk 941
     694    //er->idx = b2i(2, buf + 16); // ecmtask idx (see camd35_recv_chk)
    508695    memcpy(er->ecm, buf + 20, er->ecmlen);
     696
    509697    get_cw(cur_client(), er);
    510698}
     
    513701{
    514702    EMM_PACKET epg;
     703
    515704    if(!buf || buflen < 20 || emmlen + 20 > buflen)
    516         { return; }
     705    {
     706        return;
     707    }
     708
    517709    memset(&epg, 0, sizeof(epg));
     710
    518711    epg.emmlen = emmlen;
    519712    if(epg.emmlen < 3 || epg.emmlen > MAX_EMM_SIZE)
    520         { return; }
     713    {
     714        return;
     715    }
     716
    521717    memcpy(epg.caid, buf + 10, 2);
    522718    memcpy(epg.provid, buf + 12 , 4);
    523719    memcpy(epg.emm, buf + 20, epg.emmlen);
     720
    524721    do_emm(cur_client(), &epg);
    525722}
     
    527724int32_t camd35_tcp_connect(struct s_client *cl)
    528725{
    529     if(cl->is_udp)    // check for udp client
    530     {
    531         if(!IP_ISSET(SIN_GET_ADDR(cl->udp_sa)))   // check ip is set
    532         {
    533             if(!(hostResolve(cl->reader)))   // no ip -> try to resolve ip of client
     726    if(cl->is_udp) // check for udp client
     727    {
     728        if(!IP_ISSET(SIN_GET_ADDR(cl->udp_sa))) // check ip is set
     729        {
     730            if(!(hostResolve(cl->reader))) // no ip -> try to resolve ip of client
    534731            {
    535732                network_tcp_connection_close(cl->reader, "no ip");
     
    539736    }
    540737
    541     if(!cl->reader->tcp_connected)    // client not connected
     738    if(!cl->reader->tcp_connected) // client not connected
    542739    {
    543740        int32_t handle = 0;
    544741        handle = network_tcp_connection_open(cl->reader); // try to connect
    545         if(handle < 0)   // got no handle -> error!
     742        if(handle < 0) // got no handle -> error!
    546743        {
    547744            cl->reader->last_s = 0; // set last send to zero
    548745            cl->reader->last_g = 0; // set last receive to zero
    549746            cl->last = 0; // set last client action to zero
    550             return (0);
     747
     748            return 0;
    551749        }
    552750
     
    558756        cl->pfd = cl->udp_fd = handle;
    559757    }
    560     if(!cl->udp_fd) { return (0); }  // Check if client has no handle -> error
     758
     759    if(!cl->udp_fd) // Check if client has no handle -> error
     760    {
     761        return 0;
     762    }
    561763
    562764    // check if client reached timeout
    563765    if(cl->reader->tcp_rto && (cl->reader->last_s - cl->reader->last_g > cl->reader->tcp_rto))
    564766    {
    565         if(!cl->is_udp) //tcp on timeout disconnect reader
     767        if(!cl->is_udp) // tcp on timeout disconnect reader
    566768        {
    567769            network_tcp_connection_close(cl->reader, "rto");
     
    572774            IN_ADDR_T last_ip;
    573775            IP_ASSIGN(last_ip, cl->ip);
     776
    574777            if(!hostResolve(cl->reader))
    575778            {
     
    577780                return 0;
    578781            }
     782
    579783            if(!IP_EQUAL(last_ip, cl->ip))
    580784            {
     
    585789    }
    586790
    587     return (1); // all ok
     791    return 1; // all ok
    588792}
    589793
    590794/*
    591  *  client functions
     795 * client functions
    592796 */
     797
    593798static void camd35_send_keepalive(struct s_client *cl)
    594799{
    595 
    596800    if(cl->reader)
    597801    {
     
    603807                return;
    604808            }
    605             uint8_t rbuf[32];//minimal size
     809
     810            uint8_t rbuf[32]; // minimal size
    606811            memset(rbuf, 0, sizeof(rbuf));
     812
    607813            rbuf[0] = 55;
    608814            rbuf[1] = 1;
    609815            rbuf[2] = 0;
    610             camd35_send(cl, rbuf, 1); //send adds +20
    611         }
    612     }
    613 }
    614 
     816
     817            camd35_send(cl, rbuf, 1); // send adds +20
     818        }
     819    }
     820}
    615821
    616822static void camd35_send_keepalive_answer(struct s_client *cl)
     
    618824    if(check_client(cl) && cl->account)
    619825    {
    620         uint8_t rbuf[32];//minimal size
     826        uint8_t rbuf[32]; // minimal size
    621827        memset(rbuf, 0, sizeof(rbuf));
     828
    622829        rbuf[0] = 55;
    623830        rbuf[1] = 1;
    624831        rbuf[2] = 0;
    625         camd35_send(cl, rbuf, 1); //send adds +20
    626     }
    627 }
    628 
     832
     833        camd35_send(cl, rbuf, 1); // send adds +20
     834    }
     835}
    629836
    630837static int32_t camd35_client_init(struct s_client *cl)
     
    635842    cs_strncpy((char *)cl->upwd, cl->reader->r_pwd, sizeof(cl->upwd));
    636843    i2b_buf(4, crc32(0L, MD5((uint8_t *)cl->reader->r_usr, strlen(cl->reader->r_usr), md5tmp), 16), cl->ucrc);
    637     if (!aes_set_key_alloc(&cl->aes_keys, (char *)MD5(cl->upwd, strlen((char *)cl->upwd), md5tmp)))
     844
     845    if(!aes_set_key_alloc(&cl->aes_keys, (char *)MD5(cl->upwd, strlen((char *)cl->upwd), md5tmp)))
    638846    {
    639847        return 1;
    640848    }
    641     cl->crypted=1;
     849
     850    cl->crypted = 1;
    642851
    643852    rdr_log(cl->reader, "proxy %s:%d", cl->reader->device, cl->reader->r_port);
    644853
    645854    if(!cl->is_udp && cacheex_get_rdr_mode(cl->reader) < 2)
     855    {
    646856        setsockopt(cl->udp_fd, IPPROTO_TCP, TCP_NODELAY, (void *)&no_delay, sizeof(no_delay));
     857    }
    647858
    648859    if(cl->reader->keepalive)
     860    {
    649861        camd35_send_keepalive(cl);
     862    }
    650863
    651864    if(cacheex_get_rdr_mode(cl->reader) == 2)
     865    {
    652866        camd35_cacheex_send_push_filter(cl, 2);
    653 
    654     return(0);
    655 }
    656 
     867    }
     868
     869    return 0;
     870}
    657871
    658872static void camd35_idle(void)
     
    661875
    662876    if(!cl->reader)
    663         { return; }
     877    {
     878        return;
     879    }
    664880
    665881    if(cl->reader->keepalive)
     
    667883        camd35_send_keepalive(cl);
    668884    }
    669     else if(cl->reader->tcp_ito>0) // only check if user added an inactivity timeout
    670     {
    671         //inactivity timeout check
     885    else if(cl->reader->tcp_ito > 0) // only check if user added an inactivity timeout
     886    {
     887        // inactivity timeout check
    672888        time_t now;
    673889        int32_t time_diff;
     890
    674891        time(&now);
    675892        time_diff = llabs(now - cl->reader->last_s);
    676         if(time_diff>cl->reader->tcp_ito)
    677         {
    678             if(check_client(cl) && cl->reader->tcp_connected && cl->reader->ph.type==MOD_CONN_TCP)
     893
     894        if(time_diff > cl->reader->tcp_ito)
     895        {
     896            if(check_client(cl) && cl->reader->tcp_connected && cl->reader->ph.type == MOD_CONN_TCP)
    679897            {
    680898                rdr_log_dbg(cl->reader, D_READER, "inactive_timeout, close connection (fd=%d)", cl->pfd);
     
    682900            }
    683901            else
    684                 { cl->reader->last_s = now; }
     902            {
     903                cl->reader->last_s = now;
     904            }
    685905        }
    686906    }
     
    690910{
    691911    if(!client || !mbuf)
    692         { return NULL; }
     912    {
     913        return NULL;
     914    }
    693915
    694916    if(client->reader)
    695917    {
    696         client->reader->last_g = time(NULL);  // last receive is now
    697         if(mbuf[0] == 6 || mbuf[0] == 19)  // check for emm command
    698         {
    699             client->reader->last_s = time(NULL); // fixup: last send is now (if client is only sending emms connection would be dropped!)
    700         }
    701         rdr_log(client->reader, "SERVER last = %d, last_s = %d, last_g = %d", (int) client->last, (int) client->reader->last_s, (int) client->reader->last_g);
    702     }
     918        client->reader->last_g = time(NULL); // last receive is now
     919
     920        if(mbuf[0] == 6 || mbuf[0] == 19) // check for emm command
     921        {
     922            // fixup: last send is now (if client is only
     923            // sending emms, connection would be dropped!)
     924            client->reader->last_s = time(NULL);
     925        }
     926
     927        rdr_log(client->reader, "SERVER last = %d, last_s = %d, last_g = %d",
     928                (int) client->last, (int) client->reader->last_s, (int) client->reader->last_g);
     929    }
     930
    703931    client->last = time(NULL); // last client action is now
    704932
    705 
    706933    switch(mbuf[0])
    707934    {
    708     case  0:    // ECM
    709     case  3:    // ECM (cascading)
    710         camd35_process_ecm(mbuf, n);
    711         break;
    712     case  6:    // EMM
    713     case 19:  // EMM
    714         if(n > 2)
    715             { camd35_process_emm(mbuf, n, mbuf[1]); }
    716         break;
    717     case 55:
    718         //keepalive msg
    719         camd35_send_keepalive_answer(client);
    720         break;
    721     default:
    722         if (!camd35_cacheex_server(client, mbuf))
    723             cs_log("unknown [cs357x/cs378x] command from %s! (%d) n=%d", username(client), mbuf[0], n);
    724     }
    725 
    726     return NULL; //to prevent compiler message
     935        case 0: // ECM
     936        case 3: // ECM (cascading)
     937            camd35_process_ecm(mbuf, n);
     938            break;
     939
     940        case 6: // EMM
     941        case 19: // EMM
     942            if(n > 2)
     943            {
     944                camd35_process_emm(mbuf, n, mbuf[1]);
     945            }
     946            break;
     947
     948        case 55:
     949            camd35_send_keepalive_answer(client); // keepalive msg
     950            break;
     951
     952        default:
     953            if(!camd35_cacheex_server(client, mbuf))
     954            {
     955                cs_log("unknown [cs357x/cs378x] command from %s! (%d) n=%d", username(client), mbuf[0], n);
     956            }
     957    }
     958
     959    return NULL;
    727960}
    728961
    729962static int32_t camd35_send_ecm(struct s_client *client, ECM_REQUEST *er)
    730963{
    731     static const char *typtext[] = {"ok", "invalid", "sleeping"};
     964    static const char *typtext[] = { "ok", "invalid", "sleeping" };
    732965
    733966    if(client->stopped)
     
    735968        if(er->srvid == client->lastsrvid && er->caid == client->lastcaid)
    736969        {
    737             cs_log("%s is stopped - requested by server (%s)",
    738                    client->reader->label, typtext[client->stopped]);
    739             return (-1);
     970            cs_log("%s is stopped - requested by server (%s)", client->reader->label, typtext[client->stopped]);
     971            return -1;
    740972        }
    741973        else
     
    749981    client->lastpid = er->pid;
    750982
    751     if(!camd35_tcp_connect(client)) { return -1; }
    752 
    753     client->reader->card_status = CARD_INSERTED; //for udp
     983    if(!camd35_tcp_connect(client))
     984    {
     985        return -1;
     986    }
     987
     988    client->reader->card_status = CARD_INSERTED; // for udp
    754989
    755990    uint8_t *buf;
    756     if(!cs_malloc(&buf, er->ecmlen + 20 + 15))
    757     { return -1; }
     991    if(!cs_malloc(&buf, 20 + er->ecmlen + 15))
     992    {
     993        return -1;
     994    }
    758995
    759996    memset(buf, 0, 20);
    760     memset(buf + 20, 0xff, er->ecmlen + 15);
     997    memset(buf + 20, 0xFF, er->ecmlen + 15);
     998
    761999    buf[1] = er->ecmlen;
    7621000    i2b_buf(2, er->srvid, buf + 8);
     
    7641002    i2b_buf(4, er->prid, buf + 12);
    7651003    i2b_buf(2, er->idx, buf + 16);
    766     buf[18] = 0xff;
    767     buf[19] = 0xff;
     1004    buf[18] = 0xFF;
     1005    buf[19] = 0xFF;
    7681006    memcpy(buf + 20, er->ecm, er->ecmlen);
    769     int32_t rc = ((camd35_send(client, buf, 0) < 1) ? (-1) : 0);
     1007
     1008    int32_t rc = (camd35_send(client, buf, 0) < 1) ? -1 : 0;
    7701009
    7711010    NULLFREE(buf);
     
    7781017    struct s_client *cl = cur_client();
    7791018
    780     if(!camd35_tcp_connect(cl)) { return 0; }
    781     cl->reader->card_status = CARD_INSERTED; //for udp
     1019    if(!camd35_tcp_connect(cl))
     1020    {
     1021        return 0;
     1022    }
     1023
     1024    cl->reader->card_status = CARD_INSERTED; // for udp
    7821025
    7831026    if(!cs_malloc(&buf, ep->emmlen + 20 + 15))
    784     { return -1; }
     1027    {
     1028        return -1;
     1029    }
    7851030
    7861031    memset(buf, 0, 20);
    787     memset(buf + 20, 0xff, ep->emmlen + 15);
     1032    memset(buf + 20, 0xFF, ep->emmlen + 15);
    7881033
    7891034    buf[0] = 0x06;
     
    7931038    memcpy(buf + 20, ep->emm, ep->emmlen);
    7941039
    795     int32_t rc = ((camd35_send_without_timeout(cl, buf, 0) < 1) ? 0 : 1);
     1040    int32_t rc = (camd35_send_without_timeout(cl, buf, 0) < 1) ? 0 : 1;
    7961041
    7971042    NULLFREE(buf);
     
    8021047{
    8031048    uint16_t idx;
    804     static const char *typtext[] = {"ok", "invalid", "sleeping"};
     1049    static const char *typtext[] = { "ok", "invalid", "sleeping" };
    8051050    struct s_reader *rdr = client->reader;
     1051
    8061052    rdr->last_g = time(NULL); // last receive is now
    8071053
     
    8091055    if(buf[0] == 0x05 && buf[1] == 111)
    8101056    {
    811 
    8121057        //cs_log("CMD05: %s", cs_hexdump(1, buf, buf[1], tmp, sizeof(tmp)));
    813         rdr->nprov = 0; //reset if number changes on reader change
     1058
     1059        rdr->nprov = 0; // reset if number changes on reader change
    8141060        rdr->nprov = buf[47];
    8151061        rdr->caid = b2i(2, buf + 20);
     
    8181064        for(i = 0; i < rdr->nprov; i++)
    8191065        {
    820             if(((rdr->caid >= 0x1700) && (rdr->caid <= 0x1799))  ||     // Betacrypt
    821                     ((rdr->caid >= 0x0600) && (rdr->caid <= 0x0699)))   // Irdeto (don't know if this is correct, cause I don't own a IRDETO-Card)
     1066            if(caid_is_betacrypt(rdr->caid) || caid_is_irdeto(rdr->caid))
    8221067            {
    8231068                rdr->prid[i][0] = buf[48 + (i * 5)];
     
    8451090            rdr->auprovid = b2i(4, buf + 12);
    8461091        }
     1092
    8471093        cs_log("%s CMD05 AU request for caid: %04X auprovid: %06X",
    848                rdr->label,
    849                rdr->caid,
    850                rdr->auprovid);
     1094                rdr->label, rdr->caid, rdr->auprovid);
    8511095    }
    8521096
    8531097    bool rc_invalid = 0;
    854     if(buf[0] == 0x08
    855             && ((rdr->ph.type == MOD_CONN_TCP && !cfg.c35_tcp_suppresscmd08)
    856                 || (rdr->ph.type == MOD_CONN_UDP
    857                     && !cfg.c35_udp_suppresscmd08)))
     1098
     1099    if(buf[0] == 0x08 && ((rdr->ph.type == MOD_CONN_TCP && !cfg.c35_tcp_suppresscmd08)
     1100        || (rdr->ph.type == MOD_CONN_UDP && !cfg.c35_udp_suppresscmd08)))
    8581101    {
    8591102        if(buf[21] == 0xFF)
     
    8671110            {
    8681111                rc_invalid = 1;
    869             }else{
     1112            }
     1113            else
     1114            {
    8701115                client->stopped = 1; // server says invalid
    8711116                rdr->card_status = CARD_FAILURE;
     
    8731118        }
    8741119
    875         cs_log("%s CMD08 (%02X - %d) stop request by server (%s)", rdr->label, buf[21], buf[21], typtext[client->stopped]);
    876     }
    877 
    878     if (camd35_cacheex_recv_chk(client, buf))
    879         { return -1; }
    880 
    881     if(buf[0] == 55)  //keepalive answer
    882         { return -1; }
     1120        cs_log("%s CMD08 (%02X - %d) stop request by server (%s)",
     1121                rdr->label, buf[21], buf[21], typtext[client->stopped]);
     1122    }
     1123
     1124    if(camd35_cacheex_recv_chk(client, buf))
     1125    {
     1126        return -1;
     1127    }
     1128
     1129    if(buf[0] == 55) // keepalive answer
     1130    {
     1131        return -1;
     1132    }
    8831133
    8841134    // CMD44: old reject command introduced in mpcs
    8851135    // keeping this for backward compatibility
    8861136    if((buf[0] != 1) && (buf[0] != 0x44) && (buf[0] != 0x08))
    887         { return (-1); }
     1137    {
     1138        return -1;
     1139    }
    8881140
    8891141    idx = b2i(2, buf + 16);
    890 
    8911142    camd35_cacheex_recv_ce1_cwc_info(client, buf, idx);
    8921143
    8931144    *rc = ((buf[0] != 0x44) && (buf[0] != 0x08));
    894     if(rc_invalid){
    895         *rc = 2;  // INVALID sent by CMD08
     1145
     1146    if(rc_invalid)
     1147    {
     1148        *rc = 2; // INVALID sent by CMD08
    8961149    }
    8971150
    8981151    memcpy(dcw, buf + 20, 16);
    899     return (idx);
     1152
     1153    return idx;
    9001154}
    9011155
    9021156/*
    903  *  module definitions
     1157 * module definitions
    9041158 */
    9051159#ifdef MODULE_CAMD35
  • 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.