source: trunk/module-cccam.c @ 5375

Last change on this file since 5375 was 5370, checked in by Admin, 8 years ago

Cleanup memory in pipe on client exit. Fix some possible segfault sources. Fix wrong display of au parameter on WebIf status page if config includes an empty au line.

  • Property svn:mime-type set to text/plain
File size: 87.7 KB
Line 
1#include "globals.h"
2
3#ifdef MODULE_CCCAM
4
5#include <stdlib.h>
6#include "module-cccam.h"
7#include <time.h>
8#include "reader-common.h"
9#include <poll.h>
10#include "module-cccshare.h"
11
12//Mode names for CMD_05 command:
13const char *cmd05_mode_name[] = { "UNKNOWN", "PLAIN", "AES", "CC_CRYPT", "RC4",
14        "LEN=0" };
15
16//Mode names for CMD_0C command:
17const char *cmd0c_mode_name[] = { "NONE", "RC6", "RC4", "CC_CRYPT", "AES", "IDEA" };
18
19static uint8_t cc_node_id[8];
20
21#define getprefix() (!cl?"":(!cl->cc?"":(((struct cc_data *)(cl->cc))->prefix)))
22
23void cc_init_crypt(struct cc_crypt_block *block, uint8_t *key, int32_t len) {
24    int32_t i = 0;
25    uint8_t j = 0;
26
27    for (i = 0; i < 256; i++) {
28        block->keytable[i] = i;
29    }
30
31    for (i = 0; i < 256; i++) {
32        j += key[i % len] + block->keytable[i];
33        SWAPC(&block->keytable[i], &block->keytable[j]);
34    }
35
36    block->state = *key;
37    block->counter = 0;
38    block->sum = 0;
39}
40
41void cc_crypt(struct cc_crypt_block *block, uint8_t *data, int32_t len,
42        cc_crypt_mode_t mode) {
43    int32_t i;
44    uint8_t z;
45
46    for (i = 0; i < len; i++) {
47        block->counter++;
48        block->sum += block->keytable[block->counter];
49        SWAPC(&block->keytable[block->counter], &block->keytable[block->sum]);
50        z = data[i];
51        data[i] = z ^ block->keytable[(block->keytable[block->counter]
52                + block->keytable[block->sum]) & 0xff];
53        data[i] ^= block->state;
54        if (!mode)
55            z = data[i];
56        block->state = block->state ^ z;
57    }
58}
59
60void cc_rc4_crypt(struct cc_crypt_block *block, uint8_t *data, int32_t len,
61        cc_crypt_mode_t mode) {
62    int32_t i;
63    uint8_t z;
64
65    for (i = 0; i < len; i++) {
66        block->counter++;
67        block->sum += block->keytable[block->counter];
68        SWAPC(&block->keytable[block->counter], &block->keytable[block->sum]);
69        z = data[i];
70        data[i] = z ^ block->keytable[(block->keytable[block->counter]
71                + block->keytable[block->sum]) & 0xff];
72        if (!mode)
73            z = data[i];
74        block->state = block->state ^ z;
75    }
76}
77
78void cc_xor(uint8_t *buf) {
79    const char cccam[] = "CCcam";
80    uint8_t i;
81
82    for (i = 0; i < 8; i++) {
83        buf[8 + i] = i * buf[i];
84        if (i <= 5) {
85            buf[i] ^= cccam[i];
86        }
87    }
88}
89
90void cc_cw_crypt(struct s_client *cl, uint8_t *cws, uint32_t cardid) {
91    struct cc_data *cc = cl->cc;
92    int64_t node_id;
93    uint8_t tmp;
94    int32_t i;
95
96    if (cl->typ != 'c') {
97        node_id = b2ll(8, cc->node_id);
98    } else {
99        node_id = b2ll(8, cc->peer_node_id);
100    }
101
102    for (i = 0; i < 16; i++) {
103        tmp = cws[i] ^ (node_id >> (4 * i));
104        if (i & 1)
105            tmp = ~tmp;
106        cws[i] = (cardid >> (2 * i)) ^ tmp;
107    }
108}
109
110/** swap endianness (int) */
111static void SwapLBi(unsigned char *buff, int32_t len)
112{
113#if __BYTE_ORDER != __BIG_ENDIAN
114    return;
115#endif
116 
117    int32_t i;
118    unsigned char swap[4];
119        for (i = 0; i < len / 4; i++) {
120            memcpy(swap, buff, 4);
121            buff[0] = swap[3];
122        buff[1] = swap[2];
123                buff[2] = swap[1];
124                buff[3] = swap[0];
125                buff += 4;
126    }
127}
128
129void cc_crypt_cmd0c(struct s_client *cl, uint8_t *buf, int32_t len) {
130    struct cc_data *cc = cl->cc;
131    uint8_t *out = cs_malloc(&out, len, QUITERROR);
132
133    switch (cc->cmd0c_mode) {
134        case MODE_CMD_0x0C_NONE: { // none additional encryption
135            memcpy(out, buf, len);
136            break;
137        }
138        case MODE_CMD_0x0C_RC6 : { //RC6           
139            int32_t i;
140            SwapLBi(buf, len);
141            for (i = 0; i < len / 16; i++)
142                rc6_block_decrypt((uint32_t*)(buf+i*16), (uint32_t*)(out+i*16), 1, cc->cmd0c_RC6_cryptkey);
143            SwapLBi(out, len);
144            break;
145        }
146        case MODE_CMD_0x0C_RC4: { // RC4
147            cc_rc4_crypt(&cc->cmd0c_cryptkey, buf, len, ENCRYPT);
148            memcpy(out, buf, len);
149            break;
150        }
151        case MODE_CMD_0x0C_CC_CRYPT: { // cc_crypt
152            cc_crypt(&cc->cmd0c_cryptkey, buf, len, DECRYPT);
153            memcpy(out, buf, len);
154            break;
155        }   
156        case MODE_CMD_0x0C_AES: { // AES
157            int32_t i;
158            for (i = 0; i<len / 16; i++)
159                AES_decrypt((unsigned char *) buf + i * 16,
160                        (unsigned char *) out + i * 16, &cc->cmd0c_AES_key);
161            break;
162        }
163        case MODE_CMD_0x0C_IDEA : { //IDEA
164            int32_t i=0;
165            int32_t j;
166
167            while (i < len) {
168                idea_ecb_encrypt(buf + i, out + i, &cc->cmd0c_IDEA_dkey);
169                i += 8;
170            }
171           
172            i = 8;
173            while (i < len) {
174                for (j=0; j < 8; j++)
175                    out[j+i] ^= buf[j+i-8];
176                i += 8;     
177            }
178           
179            break;
180        }
181    }
182    memcpy(buf, out, len);
183    free(out);
184}
185
186
187
188void set_cmd0c_cryptkey(struct s_client *cl, uint8_t *key, uint8_t len) {
189    struct cc_data *cc = cl->cc;
190    uint8_t key_buf[32];
191
192    memset(&key_buf, 0, sizeof(key_buf));
193   
194    if (len > 32)
195        len = 32;
196
197    memcpy(key_buf, key, len);
198
199    switch (cc->cmd0c_mode) {
200                   
201        case MODE_CMD_0x0C_NONE : { //NONE
202            break;
203        }
204       
205        case MODE_CMD_0x0C_RC6 : { //RC6
206            rc6_key_setup(key_buf, 32, cc->cmd0c_RC6_cryptkey);
207            break;
208        }                   
209                       
210        case MODE_CMD_0x0C_RC4:  //RC4
211        case MODE_CMD_0x0C_CC_CRYPT: { //CC_CRYPT
212            cc_init_crypt(&cc->cmd0c_cryptkey, key_buf, 32);
213            break;
214        }
215                   
216        case MODE_CMD_0x0C_AES: { //AES
217            memset(&cc->cmd0c_AES_key, 0, sizeof(cc->cmd0c_AES_key));           
218            AES_set_decrypt_key((unsigned char *) key_buf, 256, &cc->cmd0c_AES_key);               
219            break;
220        }   
221                   
222        case MODE_CMD_0x0C_IDEA : { //IDEA
223            uint8_t key_buf_idea[16];
224            memcpy(key_buf_idea, key_buf, 16);
225            IDEA_KEY_SCHEDULE ekey;
226
227            idea_set_encrypt_key(key_buf_idea, &ekey);
228            idea_set_decrypt_key(&ekey,&cc->cmd0c_IDEA_dkey);
229            break;
230        }   
231    }
232}
233
234int32_t sid_eq(struct cc_srvid *srvid1, struct cc_srvid *srvid2) {
235    return (srvid1->sid == srvid2->sid && (srvid1->ecmlen == srvid2->ecmlen || !srvid1->ecmlen || !srvid2->ecmlen));
236}
237
238int32_t is_sid_blocked(struct cc_card *card, struct cc_srvid *srvid_blocked) {
239    LL_ITER it = ll_iter_create(card->badsids);
240    struct cc_srvid *srvid;
241    while ((srvid = ll_iter_next(&it))) {
242        if (sid_eq(srvid, srvid_blocked)) {
243            break;
244        }
245    }
246    return (srvid != 0);
247}
248
249int32_t is_good_sid(struct cc_card *card, struct cc_srvid *srvid_good) {
250    LL_ITER it = ll_iter_create(card->goodsids);
251    struct cc_srvid *srvid;
252    while ((srvid = ll_iter_next(&it))) {
253        if (sid_eq(srvid, srvid_good)) {
254            break;
255        }
256    }
257    return (srvid != 0);
258}
259
260void add_sid_block(struct s_client *cl __attribute__((unused)), struct cc_card *card,
261        struct cc_srvid *srvid_blocked) {
262    if (is_sid_blocked(card, srvid_blocked))
263        return;
264
265    struct cc_srvid *srvid = cs_malloc(&srvid, sizeof(struct cc_srvid), QUITERROR);
266    memcpy(srvid, srvid_blocked, sizeof(struct cc_srvid));
267    ll_append(card->badsids, srvid);
268    cs_debug_mask(D_READER, "%s added sid block %04X(%d) for card %08x",
269            getprefix(), srvid_blocked->sid, srvid_blocked->ecmlen,
270            card->id);
271}
272
273void remove_sid_block(struct cc_card *card, struct cc_srvid *srvid_blocked) {
274    LL_ITER it = ll_iter_create(card->badsids);
275    struct cc_srvid *srvid;
276    while ((srvid = ll_iter_next(&it)))
277        if (sid_eq(srvid, srvid_blocked))
278            ll_iter_remove_data(&it);
279}
280
281void remove_good_sid(struct cc_card *card, struct cc_srvid *srvid_good) {
282    LL_ITER it = ll_iter_create(card->goodsids);
283    struct cc_srvid *srvid;
284    while ((srvid = ll_iter_next(&it)))
285        if (sid_eq(srvid, srvid_good))
286            ll_iter_remove_data(&it);
287}
288
289void add_good_sid(struct s_client *cl __attribute__((unused)), struct cc_card *card,
290        struct cc_srvid *srvid_good) {
291    if (is_good_sid(card, srvid_good))
292        return;
293
294    remove_sid_block(card, srvid_good);
295    struct cc_srvid *srvid = cs_malloc(&srvid, sizeof(struct cc_srvid), QUITERROR);
296    memcpy(srvid, srvid_good, sizeof(struct cc_srvid));
297    ll_append(card->goodsids, srvid);
298    cs_debug_mask(D_READER, "%s added good sid %04X(%d) for card %08x",
299            getprefix(), srvid_good->sid, srvid_good->ecmlen, card->id);
300}
301
302/**
303 * reader
304 * clears and frees values for reinit
305 */
306void cc_cli_close(struct s_client *cl, int32_t call_conclose) {
307    struct s_reader *rdr = cl->reader;
308    struct cc_data *cc = cl->cc;
309    if (!rdr || !cc)
310        return;
311       
312    rdr->tcp_connected = 0;
313    rdr->card_status = NO_CARD;
314    rdr->available = 0;
315    rdr->ncd_msgid = 0;
316    rdr->last_s = rdr->last_g = 0;
317
318    if (cc->mode == CCCAM_MODE_NORMAL && call_conclose)
319        network_tcp_connection_close(cl, cl->udp_fd);
320    else {
321        if (cl->udp_fd)
322            close(cl->udp_fd);
323        cl->udp_fd = 0;
324        cl->pfd = 0;
325    }
326   
327    cc->just_logged_in = 0;
328}
329
330struct cc_extended_ecm_idx *add_extended_ecm_idx(struct s_client *cl,
331        uint8_t send_idx, uint16_t ecm_idx, struct cc_card *card,
332        struct cc_srvid srvid, int8_t free_card) {
333    struct cc_data *cc = cl->cc;
334    struct cc_extended_ecm_idx *eei =
335            cs_malloc(&eei, sizeof(struct cc_extended_ecm_idx), QUITERROR);
336    eei->send_idx = send_idx;
337    eei->ecm_idx = ecm_idx;
338    eei->card = card;
339    eei->srvid = srvid;
340    eei->free_card = free_card;
341    ll_append(cc->extended_ecm_idx, eei);
342    //cs_debug_mask(D_TRACE, "%s add extended ecm-idx: %d:%d", getprefix(), send_idx, ecm_idx);
343    return eei;
344}
345
346struct cc_extended_ecm_idx *get_extended_ecm_idx(struct s_client *cl,
347        uint8_t send_idx, int32_t remove) {
348    struct cc_data *cc = cl->cc;
349    struct cc_extended_ecm_idx *eei;
350    LL_ITER it = ll_iter_create(cc->extended_ecm_idx);
351    while ((eei = ll_iter_next(&it))) {
352        if (eei->send_idx == send_idx) {
353            if (remove)
354                ll_iter_remove(&it);
355            //cs_debug_mask(D_TRACE, "%s get by send-idx: %d FOUND: %d",
356            //      getprefix(), send_idx, eei->ecm_idx);
357            return eei;
358        }
359    }
360    cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s get by send-idx: %d NOT FOUND", getprefix(),
361            send_idx);
362    return NULL;
363}
364
365struct cc_extended_ecm_idx *get_extended_ecm_idx_by_idx(struct s_client *cl,
366        uint16_t ecm_idx, int32_t remove) {
367    struct cc_data *cc = cl->cc;
368    struct cc_extended_ecm_idx *eei;
369    LL_ITER it = ll_iter_create(cc->extended_ecm_idx);
370    while ((eei = ll_iter_next(&it))) {
371        if (eei->ecm_idx == ecm_idx) {
372            if (remove)
373                ll_iter_remove(&it);
374            //cs_debug_mask(D_TRACE, "%s get by ecm-idx: %d FOUND: %d",
375            //      getprefix(), ecm_idx, eei->send_idx);
376            return eei;
377        }
378    }
379    cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s get by ecm-idx: %d NOT FOUND", getprefix(),
380            ecm_idx);
381    return NULL;
382}
383
384void cc_reset_pending(struct s_client *cl, int32_t ecm_idx) {
385    int32_t i = 0;
386    for (i = 0; i < CS_MAXPENDING; i++) {
387        if (cl->ecmtask[i].idx == ecm_idx && cl->ecmtask[i].rc == 101)
388            cl->ecmtask[i].rc = 100; //Mark unused
389    }
390}
391
392void free_extended_ecm_idx_by_card(struct s_client *cl, struct cc_card *card) {
393    struct cc_data *cc = cl->cc;
394    struct cc_extended_ecm_idx *eei;
395    LL_ITER it = ll_iter_create(cc->extended_ecm_idx);
396    while ((eei = ll_iter_next(&it))) {
397        if (eei->card == card) {
398            cc_reset_pending(cl, eei->ecm_idx);
399            if (eei->free_card)
400                free(eei->card);
401            ll_iter_remove_data(&it);
402        }
403    }
404}
405
406void free_extended_ecm_idx(struct cc_data *cc) {
407    struct cc_extended_ecm_idx *eei;
408    LL_ITER it = ll_iter_create(cc->extended_ecm_idx);
409    while ((eei = ll_iter_next(&it))) {
410        if (eei->free_card)
411            free(eei->card);
412        ll_iter_remove_data(&it);
413    }
414}
415
416int32_t cc_recv_to(struct s_client *cl, uint8_t *buf, int32_t len) {
417    int32_t rc;
418    struct pollfd pfd;
419
420    while (1) {
421        pfd.fd = cl->udp_fd;
422        pfd.events = POLLIN | POLLPRI;
423
424        rc = poll(&pfd, 1, 2000);
425   
426        if (rc < 0) {
427            if (errno==EINTR) continue;
428            return(-1); //error!!
429        }
430                                                                     
431        if (rc == 1)
432            break;
433        return (-2); //timeout!!
434    }   
435    return recv(cl->udp_fd, buf, len, MSG_WAITALL);
436}
437
438/**
439 * reader
440 * closes the connection and reopens it.
441 */
442//static void cc_cycle_connection() {
443//  cc_cli_close();
444//  cc_cli_init();
445//}
446
447/**
448 * reader+server:
449 * receive a message
450 */
451int32_t cc_msg_recv(struct s_client *cl, uint8_t *buf, int32_t maxlen) {
452    struct s_reader *rdr = (cl->typ == 'c') ? NULL : cl->reader;
453
454    int32_t len;
455    struct cc_data *cc = cl->cc;
456
457    int32_t handle = cl->udp_fd;
458
459    if (handle <= 0 || maxlen < 4)
460        return -1;
461
462    while (cl->cc && cc->mode != CCCAM_MODE_SHUTDOWN && cs_trylock(&cc->lockcmd)) {
463        cs_debug_mask(D_TRACE, "%s trylock recv waiting", getprefix());
464        cs_sleepms(fast_rnd());
465    }
466    if (!cl->cc || cc->mode == CCCAM_MODE_SHUTDOWN) return -1;
467
468    len = recv(handle, buf, 4, MSG_WAITALL);
469    if (rdr)
470        rdr->last_g = time(NULL);
471
472    if (len != 4) { // invalid header length read
473        if (len <= 0)
474            cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s disconnected by remote server", getprefix());
475        else
476            cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s invalid header length (expected 4, read %d)", getprefix(), len);
477        cs_unlock(&cc->lockcmd);
478        return -1;
479    }
480
481    cc_crypt(&cc->block[DECRYPT], buf, 4, DECRYPT);
482    //cs_ddump_mask(D_CLIENT, buf, 4, "cccam: decrypted header:");
483
484    cc->g_flag = buf[0];
485
486    int32_t size = (buf[2] << 8) | buf[3];
487    if (size) { // check if any data is expected in msg
488        if (size > maxlen) {
489            cs_unlock(&cc->lockcmd);
490            cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s message too big (size=%d max=%d)", getprefix(), size, maxlen);
491            return 0;
492        }
493
494        len = recv(handle, buf + 4, size, MSG_WAITALL); // read rest of msg
495        if (rdr)
496            rdr->last_g = time(NULL);
497
498        if (len != size) {
499            cs_unlock(&cc->lockcmd);
500            if (len <= 0)
501                cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s disconnected by remote", getprefix());
502            else
503                cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s invalid message length read (expected %d, read %d)",
504                    getprefix(), size, len);
505            return -1;
506        }
507
508        cc_crypt(&cc->block[DECRYPT], buf + 4, len, DECRYPT);
509        len += 4;
510    }
511   
512    cs_unlock(&cc->lockcmd);
513
514    //cs_ddump_mask(cl->typ=='c'?D_CLIENT:D_READER, buf, len, "cccam: full decrypted msg, len=%d:", len);
515
516    return len;
517}
518
519/**
520 * reader+server
521 * send a message
522 */
523int32_t cc_cmd_send(struct s_client *cl, uint8_t *buf, int32_t len, cc_msg_type_t cmd) {
524    if (!cl->udp_fd) //disconnected
525        return -1;
526
527    struct s_reader *rdr = (cl->typ == 'c') ? NULL : cl->reader;
528
529    int32_t n;
530    uint8_t *netbuf = cs_malloc(&netbuf, len + 4, 0);
531    struct cc_data *cc = cl->cc;
532
533    while (cl->cc && cc->mode != CCCAM_MODE_SHUTDOWN && cs_trylock(&cc->lockcmd)) { //We need this because cc_cmd_send is called from cccshare
534        cs_debug_mask(D_TRACE, "%s trylock send waiting", getprefix());
535        cs_sleepms(fast_rnd());
536    }
537    if (!cl->cc || cc->mode == CCCAM_MODE_SHUTDOWN) return -1;
538   
539    if (cmd == MSG_NO_HEADER) {
540        memcpy(netbuf, buf, len);
541    } else {
542        // build command message
543        netbuf[0] = cc->g_flag; // flags??
544        netbuf[1] = cmd & 0xff;
545        netbuf[2] = len >> 8;
546        netbuf[3] = len & 0xff;
547        if (buf)
548            memcpy(netbuf + 4, buf, len);
549        len += 4;
550    }
551
552    //cs_ddump_mask(D_CLIENT, netbuf, len, "cccam: send:");
553    cc_crypt(&cc->block[ENCRYPT], netbuf, len, ENCRYPT);
554
555    n = send(cl->udp_fd, netbuf, len, 0);
556    if (rdr)
557        rdr->last_s = time(NULL);
558
559    cs_unlock(&cc->lockcmd);
560
561    free(netbuf);
562           
563    if (n != len) {
564        if (rdr)
565            cc_cli_close(cl, TRUE);
566        n = -1;
567    }
568
569    return n;
570}
571
572#define CC_DEFAULT_VERSION 1
573char *version[] = { "2.0.11", "2.1.1", "2.1.2", "2.1.3", "2.1.4", "2.2.0", "2.2.1", "" };
574char *build[] = { "2892", "2971", "3094", "3165", "3191", "3290", "3316", "" };
575
576/**
577 * reader+server
578 * checks the cccam-version in the configuration
579 */
580void cc_check_version(char *cc_version, char *cc_build) {
581    int32_t i;
582    for (i = 0; strlen(version[i]); i++) {
583        if (!memcmp(cc_version, version[i], strlen(version[i]))) {
584            memcpy(cc_build, build[i], strlen(build[i]) + 1);
585            cs_debug_mask(D_CLIENT, "cccam: auto build set for version: %s build: %s",
586                    cc_version, cc_build);
587            return;
588        }
589    }
590    memcpy(cc_version, version[CC_DEFAULT_VERSION], strlen(
591            version[CC_DEFAULT_VERSION]));
592    memcpy(cc_build, build[CC_DEFAULT_VERSION], strlen(
593            build[CC_DEFAULT_VERSION]));
594
595    cs_debug_mask(D_CLIENT, "cccam: auto version set: %s build: %s", cc_version, cc_build);
596}
597
598/**
599 * reader
600 * sends own version information to the CCCam server
601 */
602int32_t cc_send_cli_data(struct s_client *cl) {
603    struct s_reader *rdr = cl->reader;
604
605    int32_t i;
606    struct cc_data *cc = cl->cc;
607    const int32_t size = 20 + 8 + 6 + 26 + 4 + 28 + 1;
608   
609    cs_debug_mask(D_READER, "cccam: send client data");
610
611    memcpy(cc->node_id, cc_node_id, sizeof(cc_node_id));
612
613    uint8_t *buf = cs_malloc(&buf, size, 0);
614
615    memcpy(buf, rdr->r_usr, sizeof(rdr->r_usr));
616    memcpy(buf + 20, cc->node_id, 8);
617    buf[28] = rdr->cc_want_emu; // <-- Client want to have EMUs, 0 - NO; 1 - YES
618    memcpy(buf + 29, rdr->cc_version, sizeof(rdr->cc_version)); // cccam version (ascii)
619    memcpy(buf + 61, rdr->cc_build, sizeof(rdr->cc_build)); // build number (ascii)
620
621    cs_debug_mask(D_READER, "%s sending own version: %s, build: %s", getprefix(),
622            rdr->cc_version, rdr->cc_build);
623
624    i = cc_cmd_send(cl, buf, size, MSG_CLI_DATA);
625
626    free(buf);
627   
628    return i;
629}
630
631/**
632 * server
633 * sends version information to the client
634 */
635int32_t cc_send_srv_data(struct s_client *cl) {
636    struct cc_data *cc = cl->cc;
637
638    cs_debug_mask(D_CLIENT, "cccam: send server data");
639
640    memcpy(cc->node_id, cc_node_id, sizeof(cc_node_id));
641
642    uint8_t buf[0x48];
643    memset(buf, 0, 0x48);
644
645    int32_t stealth = cl->account->cccstealth;
646    if (stealth == -1)
647        stealth = cfg.cc_stealth;
648    if (stealth) cc->node_id[7]++;
649   
650    memcpy(buf, cc->node_id, 8);
651       
652    char cc_build[7];
653    cc_check_version((char *) cfg.cc_version, cc_build);
654    memcpy(buf + 8, cfg.cc_version, sizeof(cfg.cc_version)); // cccam version (ascii)
655    memcpy(buf + 40, cc_build, sizeof(cc_build)); // build number (ascii)
656
657    cs_debug_mask(D_CLIENT, "%s version: %s, build: %s nodeid: %s", getprefix(),
658            cfg.cc_version, cc_build, cs_hexdump(0, cc->peer_node_id, 8));
659
660    return cc_cmd_send(cl, buf, 0x48, MSG_SRV_DATA);
661}
662
663int32_t loop_check(uint8_t *myid, struct s_client *cl) {
664        if (!cl)
665                return 0;
666               
667        struct cc_data *cc = cl->cc;
668        if (!cc)
669                return 0;
670               
671        return !memcmp(myid, cc->peer_node_id, sizeof(cc->peer_node_id)); // same nodeid? ignore
672}
673
674/**
675 * reader
676 * retrieves the next waiting ecm request
677 */
678int32_t cc_get_nxt_ecm(struct s_client *cl) {
679    struct cc_data *cc = cl->cc;   
680    ECM_REQUEST *er, *ern = NULL;
681    int32_t n, i, pending=0;
682    time_t t;
683
684    t = time(NULL);
685    n = -1;
686    for (i = 0; i < CS_MAXPENDING; i++) {
687        er = &cl->ecmtask[i];   
688        if ((t - (uint32_t) er->tps.time > ((cfg.ctimeout + 500)
689                / 1000) + 1) && (er->rc >= 10)) // drop timeouts
690        {
691            er->rc = 0;
692#ifdef WITH_LB
693            send_reader_stat(cl->reader, er, E_TIMEOUT);
694#endif
695        }
696
697        else if (er->rc >= 10 && er->rc != 101) { // stil active and waiting
698            pending++;
699            if (loop_check(cc->peer_node_id, er->client)) {
700                er->rc = E_RDR_NOTFOUND;
701                er->rcEx = E2_CCCAM_LOOP;
702                cs_debug_mask(D_READER, "%s ecm loop detected! client %s (%8X)",
703                        getprefix(), er->client->account->usr, er->client->thread);
704                write_ecm_answer(cl->reader, &cl->ecmtask[i]);
705            }
706            else       
707            // search for the ecm with the lowest time, this should be the next to go
708            if (n < 0 || (ern->tps.time - er->tps.time < 0)) {
709                   
710                //check for already pending:
711                if (cc->extended_mode) {
712                    int32_t j,found;
713                    ECM_REQUEST *erx;
714                    for (found=j=0;j<CS_MAXPENDING;j++) {
715                        erx = &cl->ecmtask[j]; 
716                        if (i!=j && erx->rc == 101 &&
717                            er->caid==erx->caid &&
718                            er->ecmd5==erx->ecmd5) {
719                                    found=1;
720                                    break;
721                        }
722                    }
723                    if (!found) {
724                        n = i;
725                        ern = er;
726                    }
727                }
728                else {
729                    n = i;
730                    ern = er;
731                }
732            }
733        }
734    }
735    cl->pending=pending;
736    return n;
737}
738
739/**
740 * sends the secret cmd05 answer to the server
741 */
742int32_t send_cmd05_answer(struct s_client *cl) {
743    struct s_reader *rdr = cl->reader;
744    struct cc_data *cc = cl->cc;
745    if (!cc->cmd05_active || !rdr->available) //exit if not in cmd05 or waiting for ECM answer
746        return 0;
747
748    cc->cmd05_active--;
749    if (cc->cmd05_active)
750        return 0;
751
752    uint8_t *data = cc->cmd05_data;
753    cc_cmd05_mode cmd05_mode = MODE_UNKNOWN;
754
755    // by Project:Keynation
756    switch (cc->cmd05_data_len) {
757    case 0: { //payload 0, return with payload 0!
758        cc_cmd_send(cl, NULL, 0, MSG_CMD_05);
759        cmd05_mode = MODE_LEN0;
760        break;
761    }
762    case 256: {
763        cmd05_mode = cc->cmd05_mode;
764        switch (cmd05_mode) {
765        case MODE_PLAIN: { //Send plain unencrypted back
766            cc_cmd_send(cl, data, 256, MSG_CMD_05);
767            break;
768        }
769        case MODE_AES: { //encrypt with received aes128 key:
770            AES_KEY key;
771            uint8_t aeskey[16];
772            uint8_t out[256];
773
774            memcpy(aeskey, cc->cmd05_aeskey, 16);
775            memset(&key, 0, sizeof(key));
776
777            AES_set_encrypt_key((unsigned char *) &aeskey, 128, &key);
778            int32_t i;
779            for (i = 0; i < 256; i += 16)
780                AES_encrypt((unsigned char *) data + i, (unsigned char *) &out
781                        + i, &key);
782
783            cc_cmd_send(cl, out, 256, MSG_CMD_05);
784            break;
785        }
786        case MODE_CC_CRYPT: { //encrypt with cc_crypt:
787            cc_crypt(&cc->cmd05_cryptkey, data, 256, ENCRYPT);
788            cc_cmd_send(cl, data, 256, MSG_CMD_05);
789            break;
790        }
791        case MODE_RC4_CRYPT: {//special xor crypt:
792            cc_rc4_crypt(&cc->cmd05_cryptkey, data, 256, DECRYPT);
793            cc_cmd_send(cl, data, 256, MSG_CMD_05);
794            break;
795        }
796        default:
797            cmd05_mode = MODE_UNKNOWN;
798        }
799        break;
800    }
801    default:
802        cmd05_mode = MODE_UNKNOWN;
803    }
804
805    //unhandled types always needs cycle connection after 50 ECMs!!
806    if (cmd05_mode == MODE_UNKNOWN) {
807        cc_cmd_send(cl, NULL, 0, MSG_CMD_05);
808        if (!cc->max_ecms) { //max_ecms already set?
809            cc->max_ecms = 50;
810            cc->ecm_counter = 0;
811        }
812    }
813    cs_debug_mask(D_READER, "%s sending CMD_05 back! MODE: %s len=%d",
814            getprefix(), cmd05_mode_name[cmd05_mode], cc->cmd05_data_len);
815
816    cc->cmd05NOK = 1;
817    return 1;
818}
819
820int32_t get_UA_ofs(uint16_t caid) {
821    int32_t ofs = 0;
822    switch (caid >> 8) {
823    case 0x05: //VIACCESS:
824    case 0x0D: //CRYPTOWORKS:
825        ofs = 1;
826        break;
827    case 0x4B: //TONGFANG:
828    case 0x09: //VIDEOGUARD:
829    case 0x0B: //CONAX:
830    case 0x18: //NAGRA:
831    case 0x17: //BETACRYPT
832    case 0x06: //IRDETO:
833        ofs = 2;
834        break;
835    }
836    return ofs;
837}
838
839int32_t UA_len(uint8_t *ua) {
840    int32_t i, len=0;
841    for (i=0;i<8;i++)
842        if (ua[i]) len++;
843    return len;
844}
845
846void UA_left(uint8_t *in, uint8_t *out, int32_t len) {
847    int32_t ofs = 0;
848    int32_t maxlen = 8;
849    int32_t orglen = len;
850    while (len) {
851        memset(out, 0, orglen);
852        memcpy(out, in+ofs, len);
853        if (out[0]) break;
854        ofs++;
855        maxlen--;
856        if (len>maxlen)
857            len=maxlen;
858    }
859}
860
861void UA_right(uint8_t *in, uint8_t *out, int32_t len) {
862    int32_t ofs = 0;
863    while (len) {
864        memcpy(out+ofs, in, len);
865        len--;
866        if (out[len]) break;
867        ofs++;
868        out[0]=0;
869    }
870}
871
872/**
873 * cccam uses UA right justified
874 **/
875void cc_UA_oscam2cccam(uint8_t *in, uint8_t *out, uint16_t caid) {
876    uint8_t tmp[8];
877    memset(out, 0, 8);
878    memset(tmp, 0, 8);
879    //switch (caid>>8) {
880    //  case 0x17: //IRDETO/Betacrypt:
881    //      //oscam: AA BB CC DD 00 00 00 00
882    //      //cccam: 00 00 00 00 DD AA BB CC
883    //      out[4] = in[3]; //Hexbase
884    //      out[5] = in[0];
885    //      out[6] = in[1];
886    //      out[7] = in[2];
887    //      return;
888    //     
889    //  //Place here your own adjustments!
890    //}
891    hexserial_to_newcamd(in, tmp+2, caid);
892    UA_right(tmp, out, 8);
893}
894
895/**
896 * oscam has a special format, depends on offset or type:
897 **/
898void cc_UA_cccam2oscam(uint8_t *in, uint8_t *out, uint16_t caid) {
899    uint8_t tmp[8];
900    memset(out, 0, 8);
901    memset(tmp, 0, 8);
902    //switch(caid>>8) {
903    //  case 0x17: //IRDETO/Betacrypt:
904    //      //cccam: 00 00 00 00 DD AA BB CC
905    //      //oscam: AA BB CC DD 00 00 00 00
906    //      out[0] = in[5];
907    //      out[1] = in[6];
908    //      out[2] = in[7];
909    //      out[3] = in[4]; //Hexbase
910    //      return;
911           
912    //  //Place here your own adjustments!
913    //}
914    int32_t ofs = get_UA_ofs(caid);
915    int32_t len = 8-ofs;
916    UA_left(in, tmp+ofs, len);
917    newcamd_to_hexserial(tmp, out, caid);
918}
919
920void cc_SA_oscam2cccam(uint8_t *in, uint8_t *out) {
921    memcpy(out, in, 4);
922}
923
924void cc_SA_cccam2oscam(uint8_t *in, uint8_t *out) {
925    memcpy(out, in, 4);
926}
927
928int32_t cc_UA_valid(uint8_t *ua) {
929    int32_t i;
930    for (i = 0; i < 8; i++)
931        if (ua[i])
932            return 1;
933    return 0;
934}
935
936/**
937 * Updates AU Data: UA (Unique ID / Hexserial) und SA (Shared ID - Provider)
938 */
939void set_au_data(struct s_client *cl, struct s_reader *rdr, struct cc_card *card, ECM_REQUEST *cur_er) {
940    if (rdr->audisabled || !cc_UA_valid(card->hexserial))
941        return;
942       
943    struct cc_data *cc = cl->cc;   
944    cc->last_emm_card = card;
945
946    cc_UA_cccam2oscam(card->hexserial, rdr->hexserial, rdr->caid);
947
948    cs_debug_mask(D_EMM,
949            "%s au info: caid %04X UA: %s",
950            getprefix(), card->caid, cs_hexdump(0,
951                    rdr->hexserial, 8));
952
953    rdr->nprov = 0;
954    LL_ITER it2 = ll_iter_create(card->providers);
955    struct cc_provider *provider;
956    int32_t p = 0;
957    while ((provider = ll_iter_next(&it2))) {
958        if (!cur_er || provider->prov == cur_er->prid || !provider->prov || !cur_er->prid) {
959            rdr->prid[p][0] = provider->prov >> 24;
960            rdr->prid[p][1] = provider->prov >> 16;
961            rdr->prid[p][2] = provider->prov >> 8;
962            rdr->prid[p][3] = provider->prov & 0xFF;
963            cc_SA_cccam2oscam(provider->sa, rdr->sa[p]);
964
965            cs_debug_mask(D_EMM, "%s au info: provider: %06lX:%02X%02X%02X%02X", getprefix(),
966                provider->prov,
967                provider->sa[0], provider->sa[1], provider->sa[2], provider->sa[3]);
968
969            p++;
970            rdr->nprov = p;
971            if (p >= CS_MAXPROV) break;
972        }
973    }
974   
975    if (!rdr->nprov) { //No Providers? Add null-provider:
976        memset(rdr->prid[0], 0, sizeof(rdr->prid[0]));
977        rdr->nprov = 1;
978    }
979
980    rdr->caid = card->caid;
981    if (cur_er)
982        rdr->auprovid = cur_er->prid;
983}
984
985int32_t same_first_node(struct cc_card *card1, struct cc_card *card2) {
986    uint8_t * node1 = ll_has_elements(card1->remote_nodes);
987    uint8_t * node2 = ll_has_elements(card2->remote_nodes);
988
989    if (!node1 && !node2) return 1; //both NULL, same!
990   
991    if (!node1 || !node2) return 0; //one NULL, not same!
992   
993    return !memcmp(node1, node2, 8); //same?
994}
995
996int32_t same_card2(struct cc_card *card1, struct cc_card *card2) {
997    return (card1->caid == card2->caid &&
998        card1->card_type == card2->card_type &&
999        card1->sidtab == card2->sidtab &&
1000        card1->grp == card2->grp &&
1001        !memcmp(card1->hexserial, card2->hexserial, sizeof(card1->hexserial)));
1002}
1003
1004int32_t same_card(struct cc_card *card1, struct cc_card *card2) {
1005    return (card1->remote_id == card2->remote_id &&
1006        same_card2(card1, card2) &&
1007        same_first_node(card1, card2));
1008}
1009
1010/**
1011 * reader
1012 * sends a ecm request to the connected CCCam Server
1013 */
1014int32_t cc_send_ecm(struct s_client *cl, ECM_REQUEST *er, uchar *buf) {
1015    struct s_reader *rdr = cl->reader;
1016
1017    //cs_debug_mask(D_TRACE, "%s cc_send_ecm", getprefix());
1018    if (!rdr->tcp_connected)
1019        cc_cli_connect(cl);
1020
1021    int32_t n, h = -1;
1022    struct cc_data *cc = cl->cc;
1023    struct cc_card *card = NULL;
1024    LL_ITER it;
1025    ECM_REQUEST *cur_er;
1026    struct timeb cur_time;
1027    cs_ftime(&cur_time);
1028
1029    if (!cc || (cl->pfd < 1) || !rdr->tcp_connected) {
1030        if (er) {
1031            er->rc = E_RDR_NOTFOUND;
1032            er->rcEx = E2_CCCAM_NOCARD;
1033            cs_debug_mask(D_READER, "%s server not init! ccinit=%d pfd=%d",
1034                    rdr->label, cc ? 1 : 0, cl->pfd);
1035            write_ecm_answer(rdr, er);
1036        }
1037        //cc_cli_close(cl);
1038        return 0;
1039    }
1040
1041    if (rdr->tcp_connected != 2) {
1042        cs_debug_mask(D_READER, "%s Waiting for CARDS", getprefix());
1043        return 0;
1044    }
1045
1046    //No Card? Waiting for shares
1047    if (!ll_has_elements(cc->cards)) {
1048        rdr->fd_error++;
1049        cs_debug_mask(D_READER, "%s NO CARDS!", getprefix());
1050        return 0;
1051    }
1052
1053    cc->just_logged_in = 0;
1054
1055    if (!cc->extended_mode) {
1056        //Without extended mode, only one ecm at a time could be send
1057        //this is a limitation of "O" CCCam
1058        if (cs_trylock(&cc->ecm_busy) == EBUSY) { //Unlock by NOK or ECM ACK
1059            cs_debug_mask(D_READER,
1060                "%s ecm trylock: ecm busy, retrying later after msg-receive",
1061                getprefix());
1062
1063            struct timeb timeout;
1064            timeout = cc->ecm_time;
1065            uint32_t tt = cfg.ctimeout+500;
1066            timeout.time += tt / 1000;
1067            timeout.millitm += tt % 1000;
1068
1069            if (comp_timeb(&cur_time, &timeout) < 0) { //TODO: Configuration?
1070                return 0; //pending send...
1071            } else {
1072                cs_debug_mask(D_READER,
1073                        "%s unlocked-cycleconnection! timeout %ds",
1074                        getprefix(), tt / 1000);
1075                //cc_cycle_connection();
1076                cc_cli_close(cl, TRUE);
1077                return 0;
1078            }
1079        }
1080        cs_debug_mask(D_READER, "cccam: ecm trylock: got lock");
1081    }
1082    do {
1083    cc->ecm_time = cur_time;
1084    rdr->available = cc->extended_mode;
1085
1086    //Search next ECM to send:
1087    if ((n = cc_get_nxt_ecm(cl)) < 0) {
1088        if (!cc->extended_mode) {
1089            rdr->available = 1;
1090            cs_unlock(&cc->ecm_busy);
1091        }
1092        cs_debug_mask(D_READER, "%s no ecm pending!", getprefix());
1093        if (!cc_send_pending_emms(cl))
1094            send_cmd05_answer(cl);
1095        return 0; // no queued ecms
1096    }
1097    cur_er = &cl->ecmtask[n];
1098    cur_er->rc = 101; //mark ECM as already send
1099    cs_debug_mask(D_READER, "cccam: ecm-task %d", cur_er->idx);
1100
1101    if (buf)
1102        memcpy(buf, cur_er->ecm, cur_er->l);
1103
1104    struct cc_srvid cur_srvid;
1105    cur_srvid.sid = cur_er->srvid;
1106    cur_srvid.ecmlen = cur_er->l;
1107
1108    while (cs_trylock(&cc->cards_busy)) {
1109        cs_debug_mask(D_TRACE, "%s trylock send_ecm cards waiting", getprefix());
1110        cs_sleepms(fast_rnd());
1111    }
1112    //forward_origin:
1113    if (cfg.cc_forward_origin_card && cur_er->origin_reader == rdr && cur_er->origin_card) {
1114        it = ll_iter_create(cc->cards);
1115        struct cc_card *ncard;
1116        while ((ncard = ll_iter_next(&it))) {
1117                if (ncard == cur_er->origin_card) { //Search the origin card
1118                        card = ncard; //found it, use it!
1119                        break;
1120                }
1121        }
1122    }
1123   
1124    if (!card) {
1125        it = ll_iter_create(cc->cards);
1126        struct cc_card *ncard, *xcard = NULL;
1127        while ((ncard = ll_iter_next(&it))) {
1128            if (ncard->caid == cur_er->caid) { // caid matches
1129                if (is_sid_blocked(ncard, &cur_srvid))
1130                    continue;
1131               
1132                if (ncard->caid>>8==0x18 && (!xcard || ncard->hop < xcard->hop))
1133                    xcard = ncard; //remember card (D+ / 1810 fix) if request has no provider, but card has
1134                       
1135                if (!cur_er->prid && !ll_count(ncard->providers)) { //card has no providers:
1136                    if (h < 0 || ncard->hop < h || (ncard->hop == h
1137                            && cc_UA_valid(ncard->hexserial))) {
1138                        // ncard is closer
1139                        card = ncard;
1140                        h = ncard->hop; // ncard has been matched
1141                    }
1142                   
1143                }
1144                else { //card has providers
1145                    LL_ITER it2 = ll_iter_create(ncard->providers);
1146                    struct cc_provider *provider;
1147                    while ((provider = ll_iter_next(&it2))) {
1148                        if (provider->prov  == cur_er->prid) { // provid matches
1149                            if (h < 0 || ncard->hop < h || (ncard->hop == h
1150                                    && cc_UA_valid(ncard->hexserial))) {
1151                                // ncard is closer
1152                                card = ncard;
1153                                h = ncard->hop; // ncard has been matched
1154                            }
1155                        }
1156                    }
1157                }
1158            }
1159        }
1160        if (!card)
1161                card = xcard; //18xx: if request has no provider and we have no card, we try this card
1162    }   
1163
1164    if (card) {
1165        uint8_t *ecmbuf = cs_malloc(&ecmbuf, cur_er->l+13, 0);
1166
1167        // build ecm message
1168        ecmbuf[0] = card->caid >> 8;
1169        ecmbuf[1] = card->caid & 0xff;
1170        ecmbuf[2] = cur_er->prid >> 24;
1171        ecmbuf[3] = cur_er->prid >> 16;
1172        ecmbuf[4] = cur_er->prid >> 8;
1173        ecmbuf[5] = cur_er->prid & 0xff;
1174        ecmbuf[6] = card->id >> 24;
1175        ecmbuf[7] = card->id >> 16;
1176        ecmbuf[8] = card->id >> 8;
1177        ecmbuf[9] = card->id & 0xff;
1178        ecmbuf[10] = cur_er->srvid >> 8;
1179        ecmbuf[11] = cur_er->srvid & 0xff;
1180        ecmbuf[12] = cur_er->l & 0xff;
1181        memcpy(ecmbuf + 13, cur_er->ecm, cur_er->l);
1182
1183        uint8_t send_idx = 1;
1184        if (cc->extended_mode) {
1185            cc->server_ecm_idx++;
1186            if (cc->server_ecm_idx >= 256)
1187                cc->server_ecm_idx = 1;
1188            cc->g_flag = cc->server_ecm_idx; //Flag is used as index!
1189            send_idx = cc->g_flag;
1190        }
1191
1192        struct cc_extended_ecm_idx *eei = get_extended_ecm_idx(cl, send_idx, FALSE);
1193        if (eei) {
1194            eei->ecm_idx = cur_er->idx;
1195            eei->card = card;
1196            eei->srvid = cur_srvid;
1197        }
1198        else
1199            add_extended_ecm_idx(cl, send_idx, cur_er->idx, card, cur_srvid, 0);
1200
1201        rdr->cc_currenthops = card->hop;
1202
1203        cs_debug_mask(D_READER,
1204                "%s sending ecm for sid %04X(%d) to card %08x, hop %d, ecmtask %d",
1205                getprefix(), cur_er->srvid, cur_er->l, card->id, card->hop,
1206                cur_er->idx);
1207        cc_cmd_send(cl, ecmbuf, cur_er->l + 13, MSG_CW_ECM); // send ecm
1208
1209        free(ecmbuf);
1210       
1211        //For EMM
1212        set_au_data(cl, rdr, card, cur_er);
1213        cs_unlock(&cc->cards_busy);
1214       
1215        if (cc->extended_mode)
1216                continue; //process next pending ecm!
1217        return 0;
1218    } else {
1219        //When connecting, it could happen than ecm requests come before all cards are received.
1220        //So if the last Message was a MSG_NEW_CARD, this "card receiving" is not already done
1221        //if this happens, we do not autoblock it and do not set rc status
1222        //So fallback could resolve it
1223        if (cc->last_msg != MSG_NEW_CARD && cc->last_msg != MSG_NEW_CARD_SIDINFO && !cc->just_logged_in) {
1224            cs_debug_mask(D_READER, "%s no suitable card on server", getprefix());
1225
1226            cur_er->rc = E_RDR_NOTFOUND;
1227            cur_er->rcEx = E2_CCCAM_NOCARD;
1228            write_ecm_answer(rdr, cur_er);
1229            //cur_er->rc = 1;
1230            //cur_er->rcEx = 0;
1231            //cs_sleepms(300);
1232            rdr->last_s = rdr->last_g;
1233           
1234            //reopen all blocked sids for this srvid:
1235            it = ll_iter_create(cc->cards);
1236            while ((card = ll_iter_next(&it))) {
1237                if (card->caid == cur_er->caid) { // caid matches
1238                    LL_ITER it2 = ll_iter_create(card->badsids);
1239                    struct cc_srvid *srvid;
1240                    while ((srvid = ll_iter_next(&it2)))
1241                        if (srvid->ecmlen > 0 && sid_eq(srvid, &cur_srvid)) //ecmlen==0: From remote peer, so do not remove
1242                            ll_iter_remove_data(&it2);
1243                }
1244            }
1245        }
1246    }
1247    cs_unlock(&cc->cards_busy);
1248
1249    //process next pending ecm!
1250    } while (cc->extended_mode);
1251
1252    if (!cc->extended_mode) {
1253        rdr->available = 1;
1254        cs_unlock(&cc->ecm_busy);
1255    }
1256   
1257    return -1;
1258}
1259
1260/*
1261 int32_t cc_abort_user_ecms(){
1262 int32_t n, i;
1263 time_t t;//, tls;
1264 struct cc_data *cc = rdr->cc;
1265
1266 t=time((time_t *)0);
1267 for (i=1,n=1; i<CS_MAXPENDING; i++)
1268 {
1269 if ((t-cl->ecmtask[i].tps.time > ((cfg.ctimeout + 500) / 1000) + 1) &&
1270 (cl->ecmtask[i].rc>=10))      // drop timeouts
1271 {
1272 cl->ecmtask[i].rc=0;
1273 }
1274 int32_t td=abs(1000*(ecmtask[i].tps.time-cc->found->tps.time)+ecmtask[i].tps.millitm-cc->found->tps.millitm);
1275 if (ecmtask[i].rc>=10 && ecmtask[i].cidx==cc->found->cidx && &ecmtask[i]!=cc->found){
1276 cs_log("aborting idx:%d caid:%04x client:%d timedelta:%d",ecmtask[i].idx,ecmtask[i].caid,ecmtask[i].cidx,td);
1277 ecmtask[i].rc=0;
1278 ecmtask[i].rcEx=7;
1279 write_ecm_answer(rdr, fd_c2m, &ecmtask[i]);
1280 }
1281 }
1282 return n;
1283
1284 }
1285 */
1286
1287int32_t cc_send_pending_emms(struct s_client *cl) {
1288    struct s_reader *rdr = cl->reader;
1289    struct cc_data *cc = cl->cc;
1290
1291    LL_ITER it = ll_iter_create(cc->pending_emms);
1292    uint8_t *emmbuf;
1293    int32_t size = 0;
1294    if ((emmbuf = ll_iter_next(&it))) {
1295        if (!cc->extended_mode) {
1296            if (cs_trylock(&cc->ecm_busy) == EBUSY) { //Unlock by NOK or ECM ACK
1297                return 0; //send later with cc_send_ecm
1298            }
1299            rdr->available = 0;
1300        }
1301        size = emmbuf[11] + 12;
1302
1303        cc->just_logged_in = 0;
1304        cs_ftime(&cc->ecm_time);
1305
1306        cs_debug_mask(D_EMM, "%s emm send for card %08X", getprefix(), b2i(4,
1307                emmbuf + 7));
1308
1309        cc_cmd_send(cl, emmbuf, size, MSG_EMM_ACK); // send emm
1310
1311        ll_iter_remove_data(&it);
1312    }
1313
1314    return size;
1315}
1316
1317/**
1318 * READER only:
1319 * find card by hexserial
1320 * */
1321struct cc_card *get_card_by_hexserial(struct s_client *cl, uint8_t *hexserial,
1322        uint16_t caid) {
1323    struct cc_data *cc = cl->cc;
1324    LL_ITER it = ll_iter_create(cc->cards);
1325    struct cc_card *card;
1326    while ((card = ll_iter_next(&it)))
1327        if (card->caid == caid && memcmp(card->hexserial, hexserial, 8) == 0) { //found it!
1328            break;
1329        }
1330    return card;
1331}
1332
1333/**
1334 * EMM Procession
1335 * Copied from http://85.17.209.13:6100/file/8ec3c0c5d257/systems/cardclient/cccam2.c
1336 * ProcessEmm
1337 * */
1338int32_t cc_send_emm(EMM_PACKET *ep) {
1339    struct s_client *cl = cur_client();
1340    struct s_reader *rdr = cl->reader;
1341
1342    if (!rdr->tcp_connected)
1343        cc_cli_connect(cl);
1344
1345    struct cc_data *cc = cl->cc;
1346
1347    if (!cc || (cl->pfd < 1) || !rdr->tcp_connected) {
1348        cs_debug_mask(D_READER, "%s server not init! ccinit=%d pfd=%d", getprefix(), cc ? 1 : 0,
1349                cl->pfd);
1350        return 0;
1351    }
1352    if (rdr->audisabled) {
1353        cs_debug_mask(D_READER, "%s au is disabled", getprefix());
1354        return 0;
1355    }
1356
1357    uint16_t caid = b2i(2, ep->caid);
1358
1359    //Last used card is first card of current_cards:
1360    while (cs_trylock(&cc->cards_busy)) {
1361        cs_debug_mask(D_TRACE, "trylock send_emm cards waiting", getprefix());
1362        cs_sleepms(fast_rnd());
1363    }
1364
1365    struct cc_card *emm_card = cc->last_emm_card;
1366
1367    if (!emm_card) {
1368        uint8_t hs[8];
1369        cc_UA_oscam2cccam(ep->hexserial, hs, caid);
1370        cs_debug_mask(D_EMM,
1371            "%s au info: searching card for caid %04X oscam-UA: %s",
1372            getprefix(), b2i(2, ep->caid), cs_hexdump(0, ep->hexserial, 8));
1373        cs_debug_mask(D_EMM,
1374            "%s au info: searching card for caid %04X cccam-UA: %s",
1375            getprefix(), b2i(2, ep->caid), cs_hexdump(0, hs, 8));
1376
1377        emm_card = get_card_by_hexserial(cl, hs, caid);
1378    }
1379
1380    if (!emm_card) { //Card for emm not found!
1381        cs_debug_mask(D_EMM, "%s emm for client %8X not possible, no card found!",
1382                getprefix(), ep->client->thread);
1383        cs_unlock(&cc->cards_busy);
1384        return 0;
1385    }
1386
1387    cs_debug_mask(D_EMM,
1388            "%s emm received for client %8X caid %04X for card %08X",
1389            getprefix(), ep->client->thread, caid, emm_card->id);
1390
1391    int32_t size = ep->l + 12;
1392    uint8_t *emmbuf = cs_malloc(&emmbuf, size, QUITERROR);
1393    memset(emmbuf, 0, size);
1394
1395    // build ecm message
1396    emmbuf[0] = ep->caid[0];
1397    emmbuf[1] = ep->caid[1];
1398    emmbuf[2] = 0;
1399    emmbuf[3] = ep->provid[0];
1400    emmbuf[4] = ep->provid[1];
1401    emmbuf[5] = ep->provid[2];
1402    emmbuf[6] = ep->provid[3];
1403    emmbuf[7] = emm_card->id >> 24;
1404    emmbuf[8] = emm_card->id >> 16;
1405    emmbuf[9] = emm_card->id >> 8;
1406    emmbuf[10] = emm_card->id & 0xff;
1407    emmbuf[11] = ep->l;
1408    memcpy(emmbuf + 12, ep->emm, ep->l);
1409
1410    cs_unlock(&cc->cards_busy);
1411
1412    ll_append(cc->pending_emms, emmbuf);
1413    cc_send_pending_emms(cl);
1414
1415#ifdef WEBIF
1416    rdr->emmwritten[ep->type]++;
1417#endif 
1418    return 1;
1419}
1420
1421void cc_free_card(struct cc_card *card) {
1422    if (!card)
1423        return;
1424
1425    ll_destroy_data(card->providers);
1426    ll_destroy_data(card->badsids);
1427    ll_destroy_data(card->goodsids);
1428    ll_destroy_data(card->remote_nodes);
1429
1430    add_garbage(card);
1431}
1432
1433struct cc_card *cc_get_card_by_id(uint32_t card_id, LLIST *cards) {
1434    if (!cards)
1435        return NULL;
1436    LL_ITER it = ll_iter_create(cards);
1437    struct cc_card *card;
1438    while ((card=ll_iter_next(&it))) {
1439        if (card->id==card_id) {
1440            break;
1441        }
1442    }
1443    return card;
1444}
1445
1446void cc_free_cardlist(LLIST *card_list, int32_t destroy_list) {
1447    if (card_list) {
1448        LL_ITER it = ll_iter_create(card_list);
1449        struct cc_card *card;
1450        while ((card = ll_iter_next(&it))) {
1451            cc_free_card(card);
1452            ll_iter_remove(&it);
1453        }
1454        if (destroy_list)
1455            ll_destroy_data(card_list);
1456    }
1457}
1458
1459/**
1460 * Clears and free the cc datas
1461 */
1462void cc_free(struct s_client *cl) {
1463    struct cc_data *cc = cl->cc;
1464    if (!cc) return;
1465   
1466    cc->mode = CCCAM_MODE_SHUTDOWN;
1467   
1468    cl->cc=NULL;
1469   
1470    int i = 10;
1471    while (cs_trylock(&cc->lockcmd) && i--) cs_sleepms(110);
1472    cs_trylock(&cc->ecm_busy);
1473    cs_trylock(&cc->cards_busy);
1474   
1475    cs_debug_mask(D_TRACE, "exit cccam1/3");
1476    cc_free_cardlist(cc->cards, TRUE);
1477    ll_destroy_data(cc->pending_emms);
1478    if (cc->extended_ecm_idx)
1479        free_extended_ecm_idx(cc);
1480    ll_destroy_data(cc->extended_ecm_idx);
1481
1482    cs_unlock(&cc->lockcmd);
1483    pthread_mutex_destroy(&cc->lockcmd);
1484
1485    cs_debug_mask(D_TRACE, "exit cccam2/3");
1486    cs_unlock(&cc->ecm_busy);
1487    pthread_mutex_destroy(&cc->ecm_busy);
1488
1489    cs_unlock(&cc->cards_busy);
1490    pthread_mutex_destroy(&cc->cards_busy);
1491   
1492    add_garbage(cc->prefix);
1493    add_garbage(cc);
1494   
1495    cs_debug_mask(D_TRACE, "exit cccam3/3");
1496}
1497
1498int32_t is_null_dcw(uint8_t *dcw) {
1499    int32_t i;
1500    for (i = 0; i < 15; i++)
1501        if (dcw[i])
1502            return 0;
1503    return 1;
1504}
1505
1506/*int32_t is_dcw_corrupted(uchar *dcw)
1507 {
1508 int32_t i;
1509 int32_t c, cs;
1510
1511 for (i=0; i<16; i+=4)
1512 {
1513 c = (dcw[i] + dcw[i+1] + dcw[i+2]) & 0xFF;
1514 cs = dcw[i+3];
1515 if (cs!=c) return (1);
1516 }
1517 return 0;
1518 }
1519*/
1520
1521int32_t check_extended_mode(struct s_client *cl, char *msg) {
1522    //Extended mode: if PARTNER String is ending with [PARAM], extended mode is activated
1523    //For future compatibilty the syntax should be compatible with
1524    //[PARAM1,PARAM2...PARAMn]
1525    //
1526    // EXT: Extended ECM Mode: Multiple ECMs could be send and received
1527    //                         ECMs are numbered, Flag (byte[0] is the index
1528    //
1529    // SID: Exchange of good sids/bad sids activated (like cccam 2.2.x)
1530    //      card exchange command MSG_NEW_CARD_SIDINFO instead MSG_NEW_CARD is used
1531    //
1532
1533    struct cc_data *cc = cl->cc;
1534    char *saveptr1 = NULL;
1535    int32_t has_param = 0;
1536    char *p = strtok_r(msg, "[", &saveptr1);
1537    while (p) {
1538        p = strtok_r(NULL, ",]", &saveptr1);
1539        if (p && strncmp(p, "EXT", 3) == 0) {
1540            cc->extended_mode = 1;
1541            cs_debug_mask(D_CLIENT, "%s extended ECM mode", getprefix());
1542            has_param = 1;
1543        }
1544        else if (p && strncmp(p, "SID", 3)==0) {
1545            cc->cccam220 = 1;
1546            cs_debug_mask(D_CLIENT, "%s extra SID mode", getprefix());
1547            has_param = 1;
1548        }
1549    }
1550    return has_param;
1551}
1552
1553void cc_idle() {
1554    struct s_client *cl = cur_client();
1555    struct s_reader *rdr = cl->reader;
1556    struct cc_data *cc = cl->cc;
1557   
1558    if (rdr && rdr->cc_keepalive && !rdr->tcp_connected)
1559        cc_cli_connect(cl);
1560       
1561    if (!rdr || !rdr->tcp_connected || !cl || !cc)
1562        return;
1563
1564    if (rdr->cc_keepalive) {
1565        if (cc->answer_on_keepalive + 55 <= time(NULL)) {
1566            cc_cmd_send(cl, NULL, 0, MSG_KEEPALIVE);
1567            cs_debug_mask(D_READER, "cccam: keepalive");
1568            cc->answer_on_keepalive = time(NULL);
1569        }
1570    }
1571    else
1572    {
1573        int32_t rto = abs(rdr->last_s - rdr->last_g);
1574        if (rto >= (rdr->tcp_rto*60))
1575            network_tcp_connection_close(cl, cl->udp_fd);
1576    }
1577}
1578
1579#define TIMEOUT_SECONDS 3600
1580
1581void set_card_timeout(struct cc_card *card)
1582{
1583    card->timeout = time(NULL)+TIMEOUT_SECONDS+(fast_rnd()-128)*2;
1584}
1585
1586struct cc_card *read_card(uint8_t *buf, int32_t ext) {
1587    struct cc_card *card = cs_malloc(&card, sizeof(struct cc_card), QUITERROR);
1588    memset(card, 0, sizeof(struct cc_card));
1589
1590    int32_t nprov, nassign = 0, nreject = 0, offset = 21;
1591
1592    card->providers = ll_create();
1593    card->badsids = ll_create();
1594    card->goodsids = ll_create();
1595    card->remote_nodes = ll_create();
1596    card->id = b2i(4, buf);
1597    card->remote_id = b2i(4, buf + 4);
1598    card->caid = b2i(2, buf + 8);
1599    card->hop = buf[10];
1600    card->reshare = buf[11];
1601    card->is_ext = ext;
1602    card->card_type = CT_REMOTECARD;
1603    set_card_timeout(card);
1604    memcpy(card->hexserial, buf + 12, 8); //HEXSERIAL!!
1605
1606    //cs_debug_mask(D_CLIENT, "cccam: card %08x added, caid %04X, hop %d, key %s, count %d",
1607    //      card->id, card->caid, card->hop, cs_hexdump(0, card->hexserial, 8),
1608    //      ll_count(cc->cards));
1609
1610    nprov = buf[20];
1611
1612    if (ext) {
1613        nassign = buf[21];
1614        nreject = buf[22];
1615
1616        offset += 2;
1617    }
1618
1619    int32_t i;
1620    for (i = 0; i < nprov; i++) { // providers
1621        struct cc_provider *prov = cs_malloc(&prov, sizeof(struct cc_provider), QUITERROR);
1622        prov->prov = b2i(3, buf + offset);
1623        if (prov->prov == 0xFFFFFF && (card->caid >> 8) == 0x17)
1624            prov->prov = i;
1625        memcpy(prov->sa, buf + offset + 3, 4);
1626        //cs_debug_mask(D_CLIENT, "      prov %d, %06x, sa %08x", i + 1, prov->prov, b2i(4,
1627        //      prov->sa));
1628
1629        ll_append(card->providers, prov);
1630        offset+=7;
1631    }
1632
1633    uint8_t *ptr = buf + offset;
1634
1635    if (ext) {
1636        for (i = 0; i < nassign; i++) {
1637            uint16_t sid = b2i(2, ptr);
1638            //cs_debug_mask(D_CLIENT, "      assigned sid = %04X, added to good sid list", sid);
1639
1640            struct cc_srvid *srvid = cs_malloc(&srvid, sizeof(struct cc_srvid), QUITERROR);
1641            srvid->sid = sid;
1642            srvid->ecmlen = 0;
1643            ll_append(card->goodsids, srvid);
1644            ptr+=2;
1645        }
1646
1647        for (i = 0; i < nreject; i++) {
1648            uint16_t sid = b2i(2, ptr);
1649            //cs_debug_mask(D_CLIENT, "      rejected sid = %04X, added to sid block list", sid);
1650
1651            struct cc_srvid *srvid = cs_malloc(&srvid, sizeof(struct cc_srvid), QUITERROR);
1652            srvid->sid = sid;
1653            srvid->ecmlen = 0;
1654            ll_append(card->badsids, srvid);
1655            ptr+=2;
1656        }
1657    }
1658
1659    int32_t remote_count = ptr[0];
1660    ptr++;
1661    for (i = 0; i < remote_count; i++) {
1662        uint8_t *remote_node = cs_malloc(&remote_node, 8, QUITERROR);
1663        memcpy(remote_node, ptr, 8);
1664        ll_append(card->remote_nodes, remote_node);
1665        ptr+=8;
1666    }
1667    return card;
1668}
1669
1670void cc_card_removed(struct s_client *cl, uint32_t shareid) {
1671    struct cc_data *cc = cl->cc;
1672    struct cc_card *card;
1673    LL_ITER it = ll_iter_create(cc->cards);
1674
1675    while ((card = ll_iter_next(&it))) {
1676        if (card->id == shareid) {// && card->sub_id == b2i (3, buf + 9)) {
1677            //cs_debug_mask(D_CLIENT, "cccam: card %08x removed, caid %04X, count %d",
1678            //      card->id, card->caid, ll_count(cc->cards));
1679            ll_iter_remove(&it);
1680            if (cc->last_emm_card == card) {
1681                cc->last_emm_card = NULL;
1682                cs_debug_mask(D_READER, "%s current card %08x removed!",
1683                        getprefix(), card->id);
1684            }       
1685            free_extended_ecm_idx_by_card(cl, card);
1686           
1687            if (card->hop == 1) cc->num_hop1--;
1688            else if (card->hop == 2) cc->num_hop2--;
1689            else cc->num_hopx--;
1690           
1691            if (card->reshare == 0) cc->num_reshare0--;
1692            else if (card->reshare == 1) cc->num_reshare1--;
1693            else if (card->reshare == 2) cc->num_reshare2--;
1694            else cc->num_resharex--;
1695
1696            cc_free_card(card);
1697            cc->card_removed_count++;
1698            //break;
1699        }
1700    }
1701}
1702
1703void move_card_to_end(struct s_client * cl, struct cc_card *card_to_move) {
1704
1705    struct cc_data *cc = cl->cc;
1706
1707    LL_ITER it = ll_iter_create(cc->cards);
1708    struct cc_card *card;
1709    while ((card = ll_iter_next(&it))) {
1710        if (card == card_to_move) {
1711            ll_iter_remove(&it);
1712            break;
1713        }
1714    }
1715    if (card) {
1716        cs_debug_mask(D_READER, "%s CMD05: Moving card %08X to the end...", getprefix(), card_to_move->id);
1717        free_extended_ecm_idx_by_card(cl, card);
1718        ll_append(cc->cards, card_to_move);
1719    }
1720}
1721
1722
1723
1724/*void fix_dcw(uchar *dcw)
1725{
1726    int32_t i;
1727    for (i=0; i<16; i+=4)
1728    {
1729        dcw[i+3] = (dcw[i] + dcw[i+1] + dcw[i+2]) & 0xFF;
1730    }
1731}*/
1732
1733void addParam(char *param, char *value)
1734{
1735    if (strlen(param) < 4)
1736        strcat(param, value);
1737    else {
1738        strcat(param, ",");
1739        strcat(param, value);
1740    }
1741}
1742
1743static void chk_peer_node_for_oscam(struct cc_data *cc)
1744{
1745    if (!cc->is_oscam_cccam) {//Allready discovered oscam-cccam:
1746        uint16_t sum = 0x1234;
1747        uint16_t recv_sum = (cc->peer_node_id[6] << 8)
1748                | cc->peer_node_id[7];
1749        int32_t i;
1750        for (i = 0; i < 6; i++) {
1751            sum += cc->peer_node_id[i];
1752        }
1753        //Create special data to detect oscam-cccam:
1754        cc->is_oscam_cccam = sum == recv_sum;
1755    }
1756}
1757
1758int32_t cc_parse_msg(struct s_client *cl, uint8_t *buf, int32_t l) {
1759    struct s_reader *rdr = (cl->typ == 'c') ? NULL : cl->reader;
1760    int32_t ret = buf[1];
1761    struct cc_data *cc = cl->cc;
1762    if (!cc || cc->mode == CCCAM_MODE_SHUTDOWN)
1763        return -1;
1764
1765    cs_debug_mask(cl->typ=='c'?D_CLIENT:D_READER, "%s parse_msg=%d", getprefix(), buf[1]);
1766
1767    uint8_t *data = buf + 4;
1768    memcpy(&cc->receive_buffer, data, l - 4);
1769    cc->last_msg = buf[1];
1770    switch (buf[1]) {
1771    case MSG_CLI_DATA:
1772        cs_debug_mask(D_CLIENT, "cccam: client data ack");
1773        break;
1774    case MSG_SRV_DATA:
1775        l -= 4;
1776        cs_debug_mask(D_READER, "%s MSG_SRV_DATA (payload=%d, hex=%02X)", getprefix(), l, l);
1777        data = cc->receive_buffer;
1778
1779        if (l == 0x48) { //72 bytes: normal server data
1780            while (cs_trylock(&cc->cards_busy)) {
1781                cs_debug_mask(D_TRACE, "%s trylock MSG_SRV_DATA cards waiting", getprefix());
1782                cs_sleepms(fast_rnd());
1783            }
1784            cc_free_cardlist(cc->cards, FALSE);
1785            free_extended_ecm_idx(cc);
1786            cc->last_emm_card = NULL;
1787            cc->num_hop1 = 0;
1788            cc->num_hop2 = 0;
1789            cc->num_hopx = 0;
1790            cc->num_reshare0 = 0;
1791            cc->num_reshare1 = 0;
1792            cc->num_reshare2 = 0;
1793            cc->num_resharex = 0;
1794            cs_unlock(&cc->cards_busy);
1795                           
1796            memcpy(cc->peer_node_id, data, 8);
1797            memcpy(cc->peer_version, data + 8, 8);
1798
1799            memcpy(cc->cmd0b_aeskey, cc->peer_node_id, 8);
1800            memcpy(cc->cmd0b_aeskey + 8, cc->peer_version, 8);
1801           
1802            strncpy(cc->remote_version, (char*)data+8, sizeof(cc->remote_version)-1);
1803            strncpy(cc->remote_build, (char*)data+40, sizeof(cc->remote_build)-1);
1804                                   
1805            cs_debug_mask(D_READER, "%s remove server %s running v%s (%s)", getprefix(), cs_hexdump(0,
1806                    cc->peer_node_id, 8), cc->remote_version, cc->remote_build);
1807
1808            chk_peer_node_for_oscam(cc);
1809            //Trick: when discovered partner is an Oscam Client, then we send him our version string:
1810            if (cc->is_oscam_cccam) {
1811                uint8_t token[256];
1812                snprintf((char *)token, sizeof(token),
1813                        "PARTNER: OSCam v%s, build #%s (%s) [EXT,SID]", CS_VERSION,
1814                        CS_SVN_VERSION, CS_OSTYPE);
1815                cc_cmd_send(cl, token, strlen((char *)token) + 1, MSG_CW_NOK1);
1816            }
1817
1818            cc->cmd05_mode = MODE_PLAIN;
1819            //
1820            //Keyoffset is payload-size:
1821            //
1822        } else if (l >= 0x00 && l <= 0x0F) {
1823            cc->cmd05_offset = l;
1824            //
1825            //16..43 bytes: RC4 encryption:
1826            //
1827        } else if ((l >= 0x10 && l <= 0x1f) || (l >= 0x24 && l <= 0x2b)) {
1828            cc_init_crypt(&cc->cmd05_cryptkey, data, l);
1829            cc->cmd05_mode = MODE_RC4_CRYPT;
1830            //
1831            //32 bytes: set AES128 key for CMD_05, Key=16 bytes offset keyoffset
1832            //
1833        } else if (l == 0x20) {
1834            memcpy(cc->cmd05_aeskey, data + cc->cmd05_offset, 16);
1835            cc->cmd05_mode = MODE_AES;
1836            //
1837            //33 bytes: xor-algo mit payload-bytes, offset keyoffset
1838            //
1839        } else if (l == 0x21) {
1840            cc_init_crypt(&cc->cmd05_cryptkey, data + cc->cmd05_offset, l);
1841            cc->cmd05_mode = MODE_CC_CRYPT;
1842            //
1843            //34 bytes: cmd_05 plain back
1844            //
1845        } else if (l == 0x22) {
1846            cc->cmd05_mode = MODE_PLAIN;
1847            //
1848            //35 bytes: Unknown!! 2 256 byte keys exchange
1849            //
1850        } else if (l == 0x23) {
1851            cc->cmd05_mode = MODE_UNKNOWN;
1852            //cycle_connection(); //Absolute unknown handling!
1853            cc_cli_close(cl, TRUE);
1854            //
1855            //44 bytes: set aes128 key, Key=16 bytes [Offset=len(password)]
1856            //
1857        } else if (l == 0x2c) {
1858            memcpy(cc->cmd05_aeskey, data + strlen(rdr->r_pwd), 16);
1859            cc->cmd05_mode = MODE_AES;
1860            //
1861            //45 bytes: set aes128 key, Key=16 bytes [Offset=len(username)]
1862            //
1863        } else if (l == 0x2d) {
1864            memcpy(cc->cmd05_aeskey, data + strlen(rdr->r_usr), 16);
1865            cc->cmd05_mode = MODE_AES;
1866            //
1867            //Unknown!!
1868            //
1869        } else {
1870            cs_debug_mask(D_READER,
1871                    "%s received improper MSG_SRV_DATA! No change to current mode, mode=%d",
1872                    getprefix(), cc->cmd05_mode);
1873            break;
1874        }
1875        cs_debug_mask(D_READER, "%s MSG_SRV_DATA MODE=%s, len=%d", getprefix(),
1876                cmd05_mode_name[cc->cmd05_mode], l);
1877
1878        break;
1879    case MSG_NEW_CARD_SIDINFO:
1880    case MSG_NEW_CARD: {
1881        uint16_t caid = b2i(2, buf + 12);
1882        //filter caid==0 and maxhop:
1883        if (!caid || buf[14] >= rdr->cc_maxhop+1)
1884            break;
1885
1886        //filter mindown:
1887        if (buf[15] < rdr->cc_mindown)
1888            break;
1889           
1890        //caid check
1891        if (!chk_ctab(caid, &rdr->ctab))
1892            break;
1893           
1894        rdr->tcp_connected = 2; //we have card
1895        rdr->card_status = CARD_INSERTED;
1896
1897        while (cs_trylock(&cc->cards_busy)) {
1898            cs_debug_mask(D_TRACE, "%s trylock MSG_NEW_CARD cards waiting", getprefix());
1899            cs_sleepms(fast_rnd());
1900        }
1901
1902        struct cc_card *card = read_card(data, buf[1]==MSG_NEW_CARD_SIDINFO);
1903        card->origin_reader = rdr;
1904        card->origin_id = card->id;
1905        card->grp = rdr->grp;
1906        card->rdr_reshare = rdr->cc_reshare;
1907
1908        //Check if this card is from us:
1909        LL_ITER it = ll_iter_create(card->remote_nodes);
1910        uint8_t *node_id;
1911        while ((node_id = ll_iter_next(&it))) {
1912            if (memcmp(node_id, cc_node_id, sizeof(cc_node_id)) == 0) { //this card is from us!
1913                cs_debug_mask(D_READER, "filtered card because of recursive nodeid: id=%08X, caid=%04X", card->id, card->caid);
1914                cc_free_card(card);
1915                card=NULL;
1916                break;
1917            }
1918        }
1919       
1920        //Check Ident filter:
1921        if (card) {
1922            if (!chk_ident(&rdr->ftab, card)) {
1923                cc_free_card(card);
1924                card=NULL;
1925            }
1926        }
1927               
1928        if (card) {
1929            //Check if we already have this card:
1930            it = ll_iter_create(cc->cards);
1931            struct cc_card *old_card;
1932            while ((old_card = ll_iter_next(&it))) {
1933                if (old_card->id == card->id || //we aready have this card, delete it
1934                        same_card(old_card, card)) {
1935                    cc_free_card(card);
1936                    card = old_card;
1937                    break;
1938                }
1939            }
1940
1941            if (!old_card) {
1942                card->card_type = CT_REMOTECARD;
1943                card->hop++; //inkrementing hop
1944                ll_append(cc->cards, card);
1945                set_au_data(cl, rdr, card, NULL);
1946                cc->card_added_count++;
1947               
1948                if (card->hop == 1) cc->num_hop1++;
1949                else if (card->hop == 2) cc->num_hop2++;
1950                else cc->num_hopx++;
1951               
1952                if (card->reshare == 0) cc->num_reshare0++;
1953                else if (card->reshare == 1) cc->num_reshare1++;
1954                else if (card->reshare == 2) cc->num_reshare2++;
1955                else cc->num_resharex++;
1956            }
1957        }
1958
1959        cs_unlock(&cc->cards_busy);
1960
1961        break;
1962    }
1963
1964    case MSG_CARD_REMOVED: {
1965        while (cs_trylock(&cc->cards_busy)) {
1966            cs_debug_mask(D_TRACE, "%s trylock MSG_CARD_REMOVED cards waiting", getprefix());
1967            cs_sleepms(fast_rnd());
1968        }
1969        cc_card_removed(cl, b2i(4, buf + 4));
1970        cs_unlock(&cc->cards_busy);
1971        break;
1972    }
1973
1974    case MSG_CW_NOK1:
1975    case MSG_CW_NOK2:
1976        if (l > 4) {
1977            //Received NOK with payload:
1978            char *msg = (char*) buf + 4;
1979
1980            //Check for PARTNER connection:
1981            if (strncmp(msg, "PARTNER:", 8) == 0) {
1982                //When Data starts with "PARTNER:" we have an Oscam-cccam-compatible client/server!
1983               
1984                strncpy(cc->remote_oscam, msg+9, sizeof(cc->remote_oscam)-1);
1985                int32_t has_param = check_extended_mode(cl, msg);
1986                if (!cc->is_oscam_cccam) {
1987                    cc->is_oscam_cccam = 1;
1988
1989                    //send params back. At the moment there is only "EXT"
1990                    char param[14];
1991                    if (!has_param)
1992                        param[0] = 0;
1993                    else {
1994                        cs_strncpy(param, " [", sizeof(param));
1995                        if (cc->extended_mode)
1996                            addParam(param, "EXT");
1997                        if (cc->cccam220)
1998                            addParam(param, "SID");
1999                        strcat(param, "]");
2000                    }
2001
2002                    uchar token[256];
2003                    snprintf((char *)token, sizeof(token),
2004                        "PARTNER: OSCam v%s, build #%s (%s)%s",
2005                        CS_VERSION, CS_SVN_VERSION, CS_OSTYPE, param);
2006                    cc_cmd_send(cl, token, strlen((char *)token) + 1, MSG_CW_NOK1);
2007                }
2008            }
2009            return ret;
2010        }
2011
2012        if (cl->typ == 'c') //for reader only
2013            return ret;
2014
2015        cc->recv_ecmtask = -1;
2016       
2017        if (cc->just_logged_in)
2018            return -1; // reader restart needed
2019
2020        while (cs_trylock(&cc->cards_busy)) {
2021            cs_debug_mask(D_TRACE, "%s trylock MSG_CW_NOK cards waiting", getprefix());
2022            cs_sleepms(fast_rnd());
2023        }
2024
2025        struct cc_extended_ecm_idx *eei = get_extended_ecm_idx(cl,
2026                cc->extended_mode ? cc->g_flag : 1, TRUE);
2027        if (!eei) {
2028            cs_debug_mask(D_READER, "%s received extended ecm NOK id %d but not found!",
2029                    getprefix(), cc->g_flag);
2030        }
2031        else
2032        {
2033            uint16_t ecm_idx = eei->ecm_idx;
2034            cc->recv_ecmtask = ecm_idx;
2035            struct cc_card *card = eei->card;
2036            struct cc_srvid srvid = eei->srvid;
2037            free(eei);
2038
2039            if (card) {
2040                if (buf[1] == MSG_CW_NOK1) //MSG_CW_NOK1: share no more available
2041                    cc_card_removed(cl, card->id);
2042                else if (cc->cmd05NOK) {
2043                    move_card_to_end(cl, card);
2044                    add_sid_block(cl, card, &srvid);
2045                }
2046                else if (!is_good_sid(card, &srvid)) //MSG_CW_NOK2: can't decode
2047                    add_sid_block(cl, card, &srvid);
2048                else
2049                    remove_good_sid(card, &srvid);
2050
2051                if (cfg.cc_forward_origin_card && card->origin_reader == rdr) {
2052                        //this card is from us but it can't decode this ecm
2053                        //also origin card is only set on cccam clients
2054                        //so wie send back the nok to the client
2055                        int32_t i = 0;
2056                        for (i=0;i<CS_MAXPENDING;i++) {
2057                                if (cl->ecmtask[i].idx == ecm_idx) {
2058                                        cs_debug_mask(D_TRACE, "%s forward card: %s", getprefix(), (buf[1]==MSG_CW_NOK1)?"NOK1":"NOK2");
2059                                        ECM_REQUEST *er = &cl->ecmtask[i];
2060                                        er->rc = E_RDR_NOTFOUND;
2061                                        er->rcEx = (buf[1] == MSG_CW_NOK1)?E2_CCCAM_NOK1:E2_CCCAM_NOK2;
2062                                        cl->pending--;
2063                                        write_ecm_answer(rdr, er);
2064                                        break;
2065                                }
2066                        }       
2067                }
2068                else {
2069                        //retry ecm:
2070                        cc_reset_pending(cl, ecm_idx);
2071                }
2072            } else
2073                cs_debug_mask(D_READER, "%S NOK: NO CARD!", getprefix());
2074        }
2075        cc->cmd05NOK = 0;
2076        cs_unlock(&cc->cards_busy);
2077
2078        if (!cc->extended_mode) {
2079            rdr->available = 1;
2080            cs_unlock(&cc->ecm_busy);
2081        }
2082
2083        cc_send_ecm(cl, NULL, NULL);
2084        break;
2085       
2086    case MSG_CW_ECM:
2087        cc->just_logged_in = 0;
2088        if (cl->typ == 'c') { //SERVER:
2089            ECM_REQUEST *er;
2090
2091            struct cc_card *server_card = cs_malloc(&server_card, sizeof(struct cc_card), QUITERROR);
2092            memset(server_card, 0, sizeof(struct cc_card));
2093            server_card->id = buf[10] << 24 | buf[11] << 16 | buf[12] << 8
2094                    | buf[13];
2095            server_card->caid = b2i(2, data);
2096
2097            if ((er = get_ecmtask())) {
2098                er->caid = b2i(2, buf + 4);
2099                er->srvid = b2i(2, buf + 14);
2100                er->l = buf[16];
2101                memcpy(er->ecm, buf + 17, er->l);
2102                er->prid = b2i(4, buf + 6);
2103                cc->server_ecm_pending++;
2104                er->idx = ++cc->server_ecm_idx;
2105
2106                if (cfg.cc_forward_origin_card) { //search my shares for this card:
2107                        cs_debug_mask(D_TRACE, "%s forward card: %04X:%04x search share %d", getprefix(), er->caid, er->srvid, server_card->id);
2108                        LL_ITER itr = ll_iter_create(get_and_lock_sharelist());
2109                        struct cc_card *card;
2110                        struct cc_card *rcard = NULL;
2111                        while ((card=ll_iter_next(&itr))) {
2112                                if (card->id == server_card->id) { //found it
2113                                        break;
2114                                }
2115                        }
2116                        cs_debug_mask(D_TRACE, "%s forward card: share %d found: %d", getprefix(), server_card->id, card?1:0);
2117                       
2118                        struct s_reader *ordr = NULL;
2119                        if (card && card->origin_reader) { // found own card, now search reader card:
2120                                //Search reader in list, because it is maybe offline?
2121                                for (ordr=first_active_reader; ordr; ordr=ordr->next) {
2122                                    if (ordr == card->origin_reader) break;
2123                                }
2124                                   
2125                                if (!ordr)
2126                                    cs_debug_mask(D_TRACE, "%s origin reader not found!", getprefix());
2127                                else {
2128                                    cs_debug_mask(D_TRACE, "%s forward card: share %d origin reader %s origin id %d", getprefix(), card->id, ordr->label, card->origin_id);
2129                                    struct s_client *cl = ordr->client;
2130                                    if (card->origin_id && cl && cl->cc) { //only if we have a origin from a cccam reader
2131                                        struct cc_data *rcc = ordr->client->cc;
2132                                       
2133                                        if(rcc){
2134                                            itr = ll_iter_create(rcc->cards);
2135                                            while ((rcard=ll_iter_next(&itr))) {
2136                                                    if (rcard->id == card->origin_id) //found it!
2137                                                            break;
2138                                            }
2139                                        }
2140                                    }
2141                                    else
2142                                        rcard = card;
2143                                }
2144                                er->origin_reader = ordr;
2145                        }
2146                       
2147                        er->origin_card = rcard;
2148                        if (!rcard || !ordr) {
2149                                cs_debug_mask(D_TRACE, "%s forward card: share %d not found!", getprefix(), server_card->id);
2150                                er->rc = E_NOTFOUND;
2151                                er->rcEx = E2_CCCAM_NOK1; //share not found!
2152                        }
2153                        else
2154                                cs_debug_mask(D_TRACE, "%s forward card: share %d forwarded to %s origin as id %d", getprefix(),
2155                                        card->id, ordr->label, rcard->id);
2156                        unlock_sharelist();
2157                }
2158                       
2159                cs_debug_mask(
2160                        D_CLIENT,
2161                        "%s ECM request from client: caid %04x srvid %04x(%d) prid %06x",
2162                        getprefix(), er->caid, er->srvid, er->l, er->prid);
2163
2164                struct cc_srvid srvid;
2165                srvid.sid = er->srvid;
2166                srvid.ecmlen = er->l;
2167                add_extended_ecm_idx(cl, cc->extended_mode ? cc->g_flag : 1,
2168                        er->idx, server_card, srvid, 1);
2169
2170                get_cw(cl, er);
2171
2172            } else {
2173                cs_debug_mask(D_CLIENT, "%s NO ECMTASK!!!!", getprefix());
2174                free(server_card);
2175            }
2176
2177        } else { //READER:
2178            while (cs_trylock(&cc->cards_busy)) {
2179                cs_debug_mask(D_TRACE, "%s trylock MSG_CW_ECM cards waiting", getprefix());
2180                cs_sleepms(fast_rnd());
2181            }
2182            cc->recv_ecmtask = -1;
2183            struct cc_extended_ecm_idx *eei = get_extended_ecm_idx(cl,
2184                    cc->extended_mode ? cc->g_flag : 1, TRUE);
2185            if (!eei) {
2186                cs_debug_mask(D_READER, "%s received extended ecm id %d but not found!",
2187                        getprefix(), cc->g_flag);
2188            }
2189            else
2190            {
2191                uint16_t ecm_idx = eei->ecm_idx;
2192                cc->recv_ecmtask = ecm_idx;
2193                struct cc_card *card = eei->card;
2194                struct cc_srvid srvid = eei->srvid;
2195                free(eei);
2196
2197                if (card) {
2198
2199                    if (!cc->extended_mode) {
2200                        cc_cw_crypt(cl, buf + 4, card->id);
2201                        cc_crypt_cmd0c(cl, buf + 4, 16);
2202                    }
2203
2204                    memcpy(cc->dcw, buf + 4, 16);
2205                    //fix_dcw(cc->dcw);
2206                    if (!cc->extended_mode)
2207                        cc_crypt(&cc->block[DECRYPT], buf + 4, l - 4, ENCRYPT); // additional crypto step
2208
2209                    if (is_null_dcw(cc->dcw)) {
2210                        cs_debug_mask(D_READER, "%s null dcw received! sid=%04X(%d)", getprefix(),
2211                                srvid.sid, srvid.ecmlen);
2212                        add_sid_block(cl, card, &srvid);
2213                        //ecm retry:
2214                        cc_reset_pending(cl, ecm_idx);
2215                        buf[1] = MSG_CW_NOK2; //So it's really handled like a nok!
2216                    } else {
2217                        cs_debug_mask(D_READER, "%s cws: %d %s", getprefix(),
2218                                ecm_idx, cs_hexdump(0, cc->dcw, 16));
2219                        add_good_sid(cl, card, &srvid);
2220                       
2221                        //check response time, if > fallbacktime, switch cards!
2222                        struct timeb tpe;
2223                        cs_ftime(&tpe);
2224                        uint32_t cwlastresptime = 1000*(tpe.time-cc->ecm_time.time)+tpe.millitm-cc->ecm_time.millitm;
2225                        if (cwlastresptime > cfg.ftimeout && !cc->extended_mode) {
2226                            cs_debug_mask(D_READER, "%s card %04X is too slow, moving to the end...", getprefix(), card->id);
2227                            move_card_to_end(cl, card);
2228                        }
2229                       
2230                    }
2231                } else {
2232                    cs_debug_mask(D_READER,
2233                            "%s warning: ECM-CWS respond by CCCam server without current card!",
2234                            getprefix());
2235                }
2236            }
2237            cs_unlock(&cc->cards_busy);
2238
2239            if (!cc->extended_mode) {
2240                rdr->available = 1;
2241                cs_unlock(&cc->ecm_busy);
2242            }
2243
2244            //cc_abort_user_ecms();
2245
2246            cc_send_ecm(cl, NULL, NULL);
2247
2248            if (cc->max_ecms)
2249                cc->ecm_counter++;
2250        }
2251        break;
2252
2253    case MSG_KEEPALIVE:
2254        if (cl->typ != 'c') {
2255            cs_debug_mask(D_READER, "cccam: keepalive ack");
2256        } else {
2257            //Checking if last answer is one minute ago:
2258            if (cc->just_logged_in || cc->answer_on_keepalive + 55 <= time(NULL)) {
2259                cc_cmd_send(cl, NULL, 0, MSG_KEEPALIVE);
2260                cs_debug_mask(D_CLIENT, "cccam: keepalive");
2261                cc->answer_on_keepalive = time(NULL);
2262            }
2263        }
2264        cc->just_logged_in = 0;
2265        break;
2266
2267    case MSG_CMD_05:
2268        if (cl->typ != 'c') {
2269            cc->just_logged_in = 0;
2270            l = l - 4;//Header Length=4 Byte
2271
2272            cs_debug_mask(D_READER, "%s MSG_CMD_05 recvd, payload length=%d mode=%d",
2273                    getprefix(), l, cc->cmd05_mode);
2274            cc->cmd05_active = 1;
2275            cc->cmd05_data_len = l;
2276            memcpy(&cc->cmd05_data, buf + 4, l);
2277            if (rdr->available && ll_has_elements(cc->cards))
2278                send_cmd05_answer(cl);
2279        }
2280        break;
2281    case MSG_CMD_0B: {
2282        // by Project:Keynation
2283        cs_debug_mask(D_READER, "%s MSG_CMD_0B received (payload=%d)!",
2284                getprefix(), l - 4);
2285
2286        AES_KEY key;
2287        uint8_t aeskey[16];
2288        uint8_t out[16];
2289
2290        memcpy(aeskey, cc->cmd0b_aeskey, 16);
2291        memset(&key, 0, sizeof(key));
2292
2293        //cs_ddump_mask(D_READER, aeskey, 16, "%s CMD_0B AES key:", getprefix());
2294        //cs_ddump_mask(D_READER, data, 16, "%s CMD_0B received data:", getprefix());
2295
2296        AES_set_encrypt_key((unsigned char *) &aeskey, 128, &key);
2297        AES_encrypt((unsigned char *) data, (unsigned char *) &out, &key);
2298
2299        cs_debug_mask(D_TRACE, "%s sending CMD_0B! ", getprefix());
2300        //cs_ddump_mask(D_READER, out, 16, "%s CMD_0B out:", getprefix());
2301        cc_cmd_send(cl, out, 16, MSG_CMD_0B);
2302
2303        break;
2304    }
2305
2306    case MSG_CMD_0C: { //New CCCAM 2.2.0 Server/Client fake check!
2307        int32_t len = l-4;
2308
2309        if (cl->typ == 'c') { //Only im comming from "client"
2310            cs_debug_mask(D_CLIENT, "%s MSG_CMD_0C received (payload=%d)!", getprefix(), len);
2311       
2312            uint8_t bytes[0x20];
2313            if (len < 0x20) //if less then 0x20 bytes, clear others:
2314                memset(data+len, 0, 0x20-len);
2315       
2316            //change first 0x10 bytes to the second:
2317            memcpy(bytes, data+0x10, 0x10);
2318            memcpy(bytes+0x10, data, 0x10);
2319       
2320            //xor data:
2321            int32_t i;
2322            for (i=0;i<0x20;i++)
2323                bytes[i] ^= (data[i] & 0x7F);
2324           
2325                //key is now the 16bit hash of md5:
2326            uint8_t md5hash[0x10];
2327            MD5(data, 0x20, md5hash);
2328            memcpy(bytes, md5hash, 0x10);
2329           
2330            cs_debug_mask(D_CLIENT, "%s sending CMD_0C! ", getprefix());
2331            //cs_ddump_mask(D_CLIENT, bytes, 0x20, "%s CMD_0C out:", getprefix());
2332            cc_cmd_send(cl, bytes, 0x20, MSG_CMD_0C);   
2333        }
2334        else //reader
2335        {           
2336            // by Project:Keynation + Oscam team
2337            cc_crypt_cmd0c(cl, data, len);
2338
2339            uint8_t CMD_0x0C_Command = data[0];
2340
2341            switch (CMD_0x0C_Command) {
2342               
2343                case 0 : { //RC6
2344                    cc->cmd0c_mode = MODE_CMD_0x0C_RC6;
2345                    break;
2346                }                   
2347                           
2348                case 1: { //RC4
2349                    cc->cmd0c_mode = MODE_CMD_0x0C_RC4;
2350                    break;
2351                }
2352                   
2353                case 2: { //CC_CRYPT
2354                    cc->cmd0c_mode = MODE_CMD_0x0C_CC_CRYPT;
2355                    break;
2356                }       
2357                   
2358                case 3: { //AES
2359                    cc->cmd0c_mode = MODE_CMD_0x0C_AES;
2360                    break;
2361                }   
2362                   
2363                case 4 : { //IDEA
2364                    cc->cmd0c_mode = MODE_CMD_0x0C_IDEA;
2365                    break;
2366                }   
2367               
2368                default: {
2369                    cc->cmd0c_mode = MODE_CMD_0x0C_NONE;
2370                }
2371            }   
2372           
2373            set_cmd0c_cryptkey(cl, data, len);
2374
2375            cs_debug_mask(D_READER, "%s received MSG_CMD_0C from server! CMD_0x0C_CMD=%d, MODE=%s",
2376                getprefix(), CMD_0x0C_Command, cmd0c_mode_name[cc->cmd0c_mode]);
2377        }
2378        break;
2379    }
2380
2381    case MSG_CMD_0D: { //key update for the active cmd0x0c algo
2382        int32_t len = l-4;
2383        if (cc->cmd0c_mode == MODE_CMD_0x0C_NONE)
2384            break;
2385
2386        cc_crypt_cmd0c(cl, data, len);
2387        set_cmd0c_cryptkey(cl, data, len);
2388
2389        cs_debug_mask(D_READER, "%s received MSG_CMD_0D from server! MODE=%s",
2390            getprefix(), cmd0c_mode_name[cc->cmd0c_mode]);
2391        break;
2392    }
2393       
2394    case MSG_CMD_0E: {
2395        cs_debug_mask(D_READER, "cccam 2.2.x commands not implemented: 0x%02X", buf[1]);
2396        //Unkwon commands...need workout algo
2397        if (cl->typ == 'c') //client connection
2398        {
2399            //switching to an oder version and then disconnect...
2400            cs_strncpy(cfg.cc_version, version[0], sizeof(cfg.cc_version));
2401            ret = -1;
2402        }
2403        else //reader connection
2404        {
2405            cs_strncpy(cl->reader->cc_version, version[0], sizeof(cl->reader->cc_version));
2406            cs_strncpy(cl->reader->cc_build, build[0], sizeof(cl->reader->cc_build));
2407            cc_cli_close(cl, TRUE);
2408        }
2409        break;
2410    }
2411                                   
2412    case MSG_EMM_ACK: {
2413        cc->just_logged_in = 0;
2414        if (cl->typ == 'c') { //EMM Request received
2415            cc_cmd_send(cl, NULL, 0, MSG_EMM_ACK); //Send back ACK
2416            if (l > 4) {
2417                cs_debug_mask(D_EMM, "%s EMM Request received!", getprefix());
2418
2419                if (!ll_count(cl->aureader_list)) {
2420                        cs_debug_mask(
2421                            D_EMM,
2422                            "%s EMM Request discarded because au is not assigned to an reader!",
2423                            getprefix());
2424                    return MSG_EMM_ACK;
2425                }
2426
2427                EMM_PACKET *emm = cs_malloc(&emm, sizeof(EMM_PACKET), QUITERROR);
2428                memset(emm, 0, sizeof(EMM_PACKET));
2429                emm->caid[0] = buf[4];
2430                emm->caid[1] = buf[5];
2431                emm->provid[0] = buf[7];
2432                emm->provid[1] = buf[8];
2433                emm->provid[2] = buf[9];
2434                emm->provid[3] = buf[10];
2435                //emm->hexserial[0] = buf[11];
2436                //emm->hexserial[1] = buf[12];
2437                //emm->hexserial[2] = buf[13];
2438                //emm->hexserial[3] = buf[14];
2439                emm->l = buf[15];
2440                memcpy(emm->emm, buf + 16, emm->l);
2441                //emm->type = UNKNOWN;
2442                //emm->cidx = cs_idx;
2443                do_emm(cl, emm);
2444                free(emm);
2445            }
2446        } else { //Our EMM Request Ack!
2447            cs_debug_mask(D_EMM, "%s EMM ACK!", getprefix());
2448            if (!cc->extended_mode) {
2449                rdr->available = 1;
2450                cs_unlock(&cc->ecm_busy);
2451            }
2452            cc_send_ecm(cl, NULL, NULL);
2453        }
2454        break;
2455    }
2456    default:
2457        //cs_ddump_mask(D_CLIENT, buf, l, "%s unhandled msg: %d len=%d", getprefix(), buf[1], l);
2458        break;
2459    }
2460
2461    if (cc->max_ecms && (cc->ecm_counter > cc->max_ecms)) {
2462        cs_debug_mask(D_READER, "%s max ecms (%d) reached, cycle connection!", getprefix(),
2463                cc->max_ecms);
2464        //cc_cycle_connection();
2465        cc_cli_close(cl, TRUE);
2466        //cc_send_ecm(NULL, NULL);
2467    }
2468    return ret;
2469}
2470
2471/**
2472 * Reader: write dcw to receive
2473 */
2474int32_t cc_recv_chk(struct s_client *cl, uchar *dcw, int32_t *rc, uchar *buf, int32_t UNUSED(n)) {
2475    struct cc_data *cc = cl->cc;
2476
2477    if (buf[1] == MSG_CW_ECM) {
2478        memcpy(dcw, cc->dcw, 16);
2479        //cs_debug_mask(D_CLIENT, "cccam: recv chk - MSG_CW %d - %s", cc->recv_ecmtask,
2480        //      cs_hexdump(0, dcw, 16));
2481        *rc = 1;
2482        return (cc->recv_ecmtask);
2483    } else if ((buf[1] == (MSG_CW_NOK1)) || (buf[1] == (MSG_CW_NOK2))) {
2484        *rc = 0;
2485        //if (cc->is_oscam_cccam)
2486        if (cfg.cc_forward_origin_card)
2487                return (cc->recv_ecmtask);
2488        else
2489                return -1;
2490    }
2491
2492    return (-1);
2493}
2494
2495//int32_t is_softfail(int32_t rc)
2496//{
2497//  //see oscam.c send_dcw() for a full list
2498//  switch(rc)
2499//  {
2500//      case 5: // 5 = timeout
2501//      case 6: // 6 = sleeping
2502//      case 7: // 7 = fake
2503//      case 10:// 10= no card
2504//      case 11:// 11= expdate
2505//      case 12:// 12= disabled
2506//      case 13:// 13= stopped
2507//      case 14:// 100= unhandled
2508//          return TRUE;
2509//  }
2510//  return FALSE;
2511//}
2512
2513
2514
2515/**
2516 * Server: send DCW to client
2517 */
2518void cc_send_dcw(struct s_client *cl, ECM_REQUEST *er) {
2519    uchar buf[16];
2520    struct cc_data *cc = cl->cc;
2521
2522    memset(buf, 0, sizeof(buf));
2523
2524    struct cc_extended_ecm_idx *eei = get_extended_ecm_idx_by_idx(cl, er->idx,
2525            TRUE);
2526
2527    if (er->rc < E_NOTFOUND && eei && eei->card) { //found:
2528        memcpy(buf, er->cw, sizeof(buf));
2529        //fix_dcw(buf);
2530        //cs_debug_mask(D_TRACE, "%s send cw: %s cpti: %d", getprefix(),
2531        //      cs_hexdump(0, buf, 16), er->cpti);
2532        if (!cc->extended_mode)
2533            cc_cw_crypt(cl, buf, eei->card->id);
2534        else
2535            cc->g_flag = eei->send_idx;
2536        cc_cmd_send(cl, buf, 16, MSG_CW_ECM);
2537        if (!cc->extended_mode)
2538            cc_crypt(&cc->block[ENCRYPT], buf, 16, ENCRYPT); // additional crypto step
2539       
2540    } else { //NOT found:
2541        //cs_debug_mask(D_TRACE, "%s send cw: NOK cpti: %d", getprefix(),
2542        //      er->cpti);
2543
2544        if (eei && cc->extended_mode)
2545            cc->g_flag = eei->send_idx;
2546
2547        int32_t nok;
2548        if (!eei || !eei->card)
2549            nok = MSG_CW_NOK1; //share no more available
2550        else {
2551            if (cfg.cc_forward_origin_card && er->origin_card == eei->card)
2552                nok = (er->rcEx==E2_CCCAM_NOK1)?MSG_CW_NOK1:MSG_CW_NOK2;
2553            else
2554                nok = MSG_CW_NOK2; //can't decode
2555        }
2556        cc_cmd_send(cl, NULL, 0, nok);
2557    }
2558    cc->server_ecm_pending--;
2559    if (eei) {
2560        free(eei->card);
2561        free(eei);
2562    }
2563}
2564
2565int32_t cc_recv(struct s_client *cl, uchar *buf, int32_t l) {
2566    int32_t n;
2567    uchar *cbuf;
2568
2569    if (buf == NULL || l <= 0)
2570        return -1;
2571    cbuf = cs_malloc(&cbuf, l, QUITERROR);
2572    memcpy(cbuf, buf, l); // make a copy of buf
2573
2574    n = cc_msg_recv(cl, cbuf, l); // recv and decrypt msg
2575
2576    //cs_ddump_mask(D_CLIENT, cbuf, n, "cccam: received %d bytes from %s", n, remote_txt());
2577    cl->last = time((time_t *) 0);
2578
2579    if (n <= 0) {
2580        cs_log("%s connection closed by %s", getprefix(), remote_txt());
2581        n = -1;
2582    } else if (n < 4) {
2583        cs_log("%s packet to small (%d bytes)", getprefix(), n);
2584        n = -1;
2585    } else {
2586        // parse it and write it back, if we have received something of value
2587        n = cc_parse_msg(cl, cbuf, n);
2588        memcpy(buf, cbuf, l);
2589    }
2590
2591    NULLFREE(cbuf);
2592
2593    if (n == -1) {
2594        if (cl->typ != 'c')
2595            cc_cli_close(cl, TRUE);
2596    }
2597
2598    return n;
2599}
2600
2601void cc_init_cc(struct cc_data *cc) {
2602    pthread_mutex_init(&cc->lockcmd, NULL); //No recursive lock
2603    pthread_mutex_init(&cc->ecm_busy, NULL); //No recusive lock
2604    pthread_mutex_init(&cc->cards_busy, NULL); //No (more) recursive lock
2605}
2606
2607/**
2608 * Starting readers to get cards:
2609 **/
2610int32_t cc_srv_wakeup_readers(struct s_client *cl) {
2611    int32_t wakeup = 0;
2612    struct s_reader *rdr;
2613    struct s_client *client;
2614    struct cc_data *cc;
2615    for (rdr = first_active_reader; rdr; rdr = rdr->next) {
2616        if (rdr->typ != R_CCCAM)
2617            continue;
2618        if (rdr->tcp_connected == 2)
2619            continue;
2620        if (!(rdr->grp & cl->grp))
2621            continue;
2622        if (rdr->cc_keepalive) //if reader has keepalive but is NOT connected, reader can't connect. so don't ask him
2623            continue;
2624        if((client = rdr->client) == NULL || (cc = client->cc) == NULL || cc->mode == CCCAM_MODE_SHUTDOWN)  //reader is in shutdown
2625            continue;
2626        if(is_connect_blocked(rdr)) //reader cannot be waked up currently because its blocked
2627            continue;
2628       
2629        //This wakeups the reader:
2630        uchar dummy = 0;
2631        write_to_pipe(rdr->fd, PIP_ID_CIN, &dummy, sizeof(dummy));
2632        wakeup++;
2633    }
2634    return wakeup;
2635}
2636
2637
2638int32_t check_cccam_compat(struct cc_data *cc) {
2639    int32_t res = 0;
2640    if (strcmp(cfg.cc_version, "2.2.0") == 0 || strcmp(cfg.cc_version, "2.2.1") == 0) {
2641   
2642        if (strcmp(cc->remote_version, "2.2.0") == 0 || strcmp(cc->remote_version, "2.2.1") == 0) {
2643            res = 1;
2644        }
2645    }
2646    return res;
2647}
2648
2649int32_t cc_srv_connect(struct s_client *cl) {
2650    int32_t i, wait_for_keepalive;
2651    uint8_t data[16];
2652    char usr[21], pwd[65];
2653    struct s_auth *account;
2654    struct cc_data *cc;
2655
2656    memset(usr, 0, sizeof(usr));
2657    memset(pwd, 0, sizeof(pwd));
2658
2659    // init internals data struct
2660    cc = cs_malloc(&cc, sizeof(struct cc_data), QUITERROR);
2661    cl->cc = cc;
2662    memset(cl->cc, 0, sizeof(struct cc_data));
2663    cc->extended_ecm_idx = ll_create();
2664
2665    cc_init_cc(cc);
2666    uint8_t *buf = cc->send_buffer;
2667   
2668    cc->mode = CCCAM_MODE_NOTINIT;
2669    cc->server_ecm_pending = 0;
2670    cc->extended_mode = 0;
2671
2672    int32_t keep_alive = 1;
2673    setsockopt(cl->udp_fd, SOL_SOCKET, SO_KEEPALIVE,
2674        (void *)&keep_alive, sizeof(keep_alive));
2675                       
2676    //Create checksum for "O" cccam:
2677    for (i = 0; i < 12; i++) {
2678        data[i] = fast_rnd();
2679    }
2680    for (i = 0; i < 4; i++) {
2681        data[12 + i] = (data[i] + data[4 + i] + data[8 + i]) & 0xff;
2682    }
2683
2684    cs_debug_mask(D_TRACE, "send ccc checksum");
2685   
2686    send(cl->udp_fd, data, 16, 0);
2687
2688    cc_xor(data); // XOR init bytes with 'CCcam'
2689
2690    SHA_CTX ctx;
2691    SHA1_Init(&ctx);
2692    SHA1_Update(&ctx, data, 16);
2693    SHA1_Final(buf, &ctx);
2694
2695    cc_init_crypt(&cc->block[ENCRYPT], buf, 20);
2696    cc_crypt(&cc->block[ENCRYPT], data, 16, DECRYPT);
2697    cc_init_crypt(&cc->block[DECRYPT], data, 16);
2698    cc_crypt(&cc->block[DECRYPT], buf, 20, DECRYPT);
2699
2700    cs_debug_mask(D_TRACE, "receive ccc checksum");
2701    if ((i = cc_recv_to(cl, buf, 20)) == 20) {
2702        //cs_ddump_mask(D_CLIENT, buf, 20, "cccam: recv:");
2703        cc_crypt(&cc->block[DECRYPT], buf, 20, DECRYPT);
2704        //cs_ddump_mask(D_CLIENT, buf, 20, "cccam: hash:");
2705    } else
2706        return -1;
2707
2708    // receive username
2709    memset(buf, 0, CC_MAXMSGSIZE);
2710    if ((i = cc_recv_to(cl, buf, 20)) == 20) {
2711        cc_crypt(&cc->block[DECRYPT], buf, 20, DECRYPT);
2712
2713        strncpy(usr, (char *) buf, sizeof(usr));
2714
2715        //test for nonprintable characters:
2716        for (i = 0; i < 20; i++) {
2717            if (usr[i] > 0 && usr[i] < 0x20) { //found nonprintable char
2718                cs_log("illegal username received");
2719                return -3;
2720            }
2721        }
2722        //cs_ddump_mask(D_CLIENT, buf, 20, "cccam: username '%s':", usr);
2723    } else
2724        return -2;
2725    cs_debug_mask(D_TRACE, "ccc username received %s", usr);
2726
2727    cl->crypted = 1;
2728
2729    //CCCam only supports len=20 usr/pass. So we could have more than one user that matches the first 20 chars.
2730   
2731    //receive password-CCCam encrypted Hash:
2732    if (cc_recv_to(cl, buf, 6) != 6)
2733        return -2;
2734   
2735    cs_debug_mask(D_TRACE, "ccc passwdhash received %s", usr);
2736   
2737    account = cfg.account;
2738    struct cc_crypt_block *save_block = cs_malloc(&save_block, sizeof(struct cc_crypt_block), QUITERROR);
2739    memcpy(save_block, cc->block, sizeof(struct cc_crypt_block));
2740    int32_t found = 0;
2741    while (1) {
2742        while (account) {
2743            if (strncmp(usr, account->usr, 20) == 0) {
2744                memset(pwd, 0, sizeof(pwd));
2745                strncpy(pwd, account->pwd, sizeof(pwd));
2746                found=1;
2747                break;
2748            }
2749            account = account->next;
2750        }
2751
2752        if (!account)
2753            break;
2754           
2755        // receive passwd / 'CCcam'
2756        memcpy(cc->block, save_block, sizeof(struct cc_crypt_block));
2757        cc_crypt(&cc->block[DECRYPT], (uint8_t *) pwd, strlen(pwd), ENCRYPT);
2758        cc_crypt(&cc->block[DECRYPT], buf, 6, DECRYPT);
2759        //cs_ddump_mask(D_CLIENT, buf, 6, "cccam: pwd check '%s':", buf); //illegal buf-bytes could kill the logger!
2760        if (memcmp(buf, "CCcam\0", 6) == 0) //Password Hash OK!
2761            break; //account is set
2762           
2763        account = account->next;
2764    }
2765    free(save_block);
2766
2767    if (cs_auth_client(cl, account, NULL)) { //cs_auth_client returns 0 if account is valid/active/accessible
2768        if (!found)
2769            cs_log("account '%s' not found!", usr);
2770        else
2771            cs_log("password for '%s' invalid!", usr);
2772        return -2;
2773    }
2774    if (cl->dup) {
2775        cs_log("account '%s' duplicate login, disconnect!", usr);
2776        return -3;
2777    }
2778    if (cl->disabled) {
2779        cs_log("account '%s' disabled, blocking+disconnect!", usr);
2780        return -2;
2781    }
2782    if (account->cccmaxhops<0) {
2783            cs_log("account '%s' has cccmaxhops<0, cccam can't handle this, disconnect!", usr);
2784            return -3;
2785    }
2786   
2787    cs_debug_mask(D_TRACE, "ccc user authenticated %s", usr);
2788
2789    cc->prefix = cs_malloc(&cc->prefix, strlen(cl->account->usr)+20, QUITERROR);
2790    snprintf(cc->prefix, strlen(cl->account->usr)+20, "cccam(s) %s: ", cl->account->usr);
2791
2792    //Starting readers to get cards:
2793    cc_srv_wakeup_readers(cl);
2794
2795    // send passwd ack
2796    memset(buf, 0, 20);
2797    memcpy(buf, "CCcam\0", 6);
2798    cs_ddump_mask(D_CLIENT, buf, 20, "cccam: send ack:");
2799    cc_crypt(&cc->block[ENCRYPT], buf, 20, ENCRYPT);
2800    send(cl->pfd, buf, 20, 0);
2801
2802    // recv cli data
2803    memset(buf, 0, CC_MAXMSGSIZE);
2804    i = cc_msg_recv(cl, buf, CC_MAXMSGSIZE);
2805    if (i < 0)
2806        return -1;
2807    cs_ddump_mask(D_CLIENT, buf, i, "cccam: cli data:");
2808    memcpy(cc->peer_node_id, buf + 24, 8);
2809    //chk_peer_node_for_oscam(cc);
2810   
2811    strncpy(cc->remote_version, (char*)buf+33, sizeof(cc->remote_version)-1);
2812    strncpy(cc->remote_build, (char*)buf+65, sizeof(cc->remote_build)-1);
2813   
2814    cs_debug_mask(D_CLIENT, "%s client '%s' (%s) running v%s (%s)", getprefix(), buf + 4,
2815            cs_hexdump(0, cc->peer_node_id, 8), cc->remote_version, cc->remote_build);
2816
2817    // send cli data ack
2818    cc_cmd_send(cl, NULL, 0, MSG_CLI_DATA);
2819
2820    cs_debug_mask(D_TRACE, "ccc send srv_data %s", usr);
2821    if (cc_send_srv_data(cl) < 0)
2822        return -1;
2823
2824    cc->cccam220 = check_cccam_compat(cc);
2825    cc->just_logged_in = TRUE;
2826    cc->answer_on_keepalive = time(NULL);
2827   
2828    //Wait for Partner detection (NOK1 with data) before reporting cards
2829    //When Partner is detected, cccam220=1 is set. then we can report extended card data
2830    i = process_input(buf, CC_MAXMSGSIZE, 1);
2831    if (i<=0 && i != -9)
2832        return 0; //disconnected
2833       
2834    if (cc->cccam220)
2835        cs_debug_mask(D_CLIENT, "%s extended sid mode activated", getprefix());
2836    else
2837        cs_debug_mask(D_CLIENT, "%s 2.1.x compatibility mode", getprefix());
2838
2839    cs_debug_mask(D_TRACE, "ccc send cards %s", usr);
2840 
2841    if (!cc_srv_report_cards(cl))
2842        return -1;
2843    cs_ftime(&cc->ecm_time);
2844
2845    time_t timeout = time(NULL);
2846    wait_for_keepalive = 100;
2847    cc->mode = CCCAM_MODE_NORMAL;
2848    //some clients, e.g. mgcamd, does not support keepalive. So if not answered, keep connection
2849    // check for client timeout, if timeout occurs try to send keepalive
2850    cs_debug_mask(D_TRACE, "ccc connected and waiting for data %s", usr);
2851    while (cl->pfd && cl->udp_fd && cc->mode == CCCAM_MODE_NORMAL && !cl->dup)
2852    {
2853        i = process_input(buf, CC_MAXMSGSIZE, 10);
2854        if (i <= 0 && i != -9)
2855            break; //Disconnected by client     
2856           
2857        //data is parsed!
2858        if (i == MSG_CW_ECM)
2859            timeout = time(NULL);
2860        else if (i == MSG_KEEPALIVE) {
2861            wait_for_keepalive = 0;
2862            timeout = time(NULL);
2863        }
2864       
2865        //new timeout check:
2866        if (time(NULL)-timeout > (time_t)cfg.cmaxidle) {
2867            cs_debug_mask(D_TRACE, "ccc idle %s", usr);
2868            //cs_debug_mask(D_TRACE, "client timeout user %s idle=%d client max idle=%d", usr, cmi, cfg.cmaxidle);
2869            if (cfg.cc_keep_connected || cl->account->ncd_keepalive) {
2870                if (cc_cmd_send(cl, NULL, 0, MSG_KEEPALIVE) < 0)
2871                    break;
2872                if (wait_for_keepalive<3 || wait_for_keepalive == 100) {
2873                    cs_debug_mask(D_CLIENT, "cccam: keepalive");
2874                    cc->answer_on_keepalive = time(NULL);
2875                    wait_for_keepalive++;
2876                }
2877                else if (wait_for_keepalive<100) break;
2878                timeout = time(NULL);
2879            } else {
2880                cs_debug_mask(D_CLIENT, "%s keepalive after maxidle is reached",
2881                    getprefix());
2882                break; //Disconnect client
2883            }
2884        }
2885    }
2886    cc->mode = CCCAM_MODE_SHUTDOWN;
2887    return 0;
2888}
2889
2890void * cc_srv_init(struct s_client *cl) {
2891    cl->thread = pthread_self();
2892    pthread_setspecific(getclient, cl);
2893
2894    if (cl->ip)
2895        cs_debug_mask(D_CLIENT, "cccam: new connection from %s", cs_inet_ntoa(cl->ip));
2896               
2897    cl->pfd = cl->udp_fd;
2898    int32_t ret;
2899    if ((ret=cc_srv_connect(cl)) < 0) {
2900        if (errno != 0)
2901            cs_debug_mask(D_CLIENT, "cccam: failed errno: %d (%s)", errno, strerror(errno));
2902        else
2903            cs_debug_mask(D_CLIENT, "cccam: failed ret: %d", ret);
2904        if (ret == -2)
2905            cs_add_violation((uint)cl->ip);
2906    }
2907    cs_disconnect_client(cl);
2908    return NULL; //suppress compiler warning
2909}
2910
2911int32_t cc_cli_connect(struct s_client *cl) {
2912    struct s_reader *rdr = cl->reader;
2913    struct cc_data *cc = cl->cc;
2914    rdr->card_status = CARD_FAILURE;
2915
2916    if (cc && cc->mode == CCCAM_MODE_SHUTDOWN)
2917        return -99;
2918
2919    if (!cc) {
2920        // init internals data struct
2921        cc = cs_malloc(&cc, sizeof(struct cc_data), QUITERROR);
2922        memset(cc, 0, sizeof(struct cc_data));
2923        cc_init_cc(cc);
2924        cc->cards = ll_create();
2925        cl->cc = cc;
2926        cc->pending_emms = ll_create();
2927        cc->extended_ecm_idx = ll_create();
2928    } else {
2929        if (cc->cards) {
2930            while (cs_trylock(&cc->cards_busy)) {
2931                cs_debug_mask(D_TRACE, "%s trylock cc_cli_connect cards waiting", getprefix());
2932                cs_sleepms(fast_rnd());
2933            }
2934                           
2935            cc_free_cardlist(cc->cards, FALSE);
2936            cs_unlock(&cc->cards_busy);
2937        }
2938        if (cc->extended_ecm_idx)
2939            free_extended_ecm_idx(cc);
2940
2941        cs_trylock(&cc->ecm_busy);
2942        cs_unlock(&cc->ecm_busy);
2943    }
2944    if (!cc->prefix)
2945        cc->prefix = cs_malloc(&cc->prefix, strlen(cl->reader->label)+20, QUITERROR);
2946    snprintf(cc->prefix, strlen(cl->reader->label)+20, "cccam(r) %s: ", cl->reader->label);
2947   
2948    if (!cl->udp_fd) {
2949        cc_cli_init_int(cl);
2950        return -1; // cc_cli_init_int calls cc_cli_connect, so exit here!
2951    }
2952       
2953    if (is_connect_blocked(rdr)) {
2954        struct timeb cur_time;
2955        cs_ftime(&cur_time);
2956        int32_t time = 1000*(rdr->tcp_block_connect_till.time-cur_time.time)
2957                +rdr->tcp_block_connect_till.millitm-cur_time.millitm;
2958        cs_log("%s connection blocked, retrying in %ds", rdr->label, time/1000);
2959        return -1;
2960    }
2961   
2962    int32_t handle, n;
2963    uint8_t data[20];
2964    uint8_t hash[SHA_DIGEST_LENGTH];
2965    uint8_t *buf = cc->send_buffer;
2966    char pwd[64];
2967
2968    // check cred config
2969    if (rdr->device[0] == 0 || rdr->r_pwd[0] == 0 || rdr->r_usr[0] == 0
2970            || rdr->r_port == 0) {
2971        cs_log("%s configuration error!", rdr->label);
2972        return -5;
2973    }
2974
2975    // connect
2976    handle = network_tcp_connection_open();
2977    if (handle <= 0) {
2978        cs_log("%s network connect error!", rdr->label);
2979        return -1;
2980    }
2981    if (errno == EISCONN) {
2982        cc_cli_close(cl, FALSE);
2983       
2984        block_connect(rdr);
2985        return -1;
2986    }
2987
2988    // get init seed
2989    if ((n = cc_recv_to(cl, data, 16)) != 16) {
2990        int32_t err = errno;
2991        if (n <= 0)
2992            cs_log("%s server blocked connection!", rdr->label);
2993        else
2994            cs_log("%s server does not return 16 bytes (n=%d, errno=%d %s)",
2995                rdr->label, n, err, strerror(errno));
2996        block_connect(rdr);
2997        return -2;
2998    }
2999
3000
3001    cc->ecm_counter = 0;
3002    cc->max_ecms = 0;
3003    cc->cmd05_mode = MODE_UNKNOWN;
3004    cc->cmd05_offset = 0;
3005    cc->cmd05_active = 0;
3006    cc->cmd05_data_len = 0;
3007    cc->answer_on_keepalive = time(NULL);
3008    cc->extended_mode = 0;
3009    cc->last_emm_card = NULL;
3010    cc->num_hop1 = 0;
3011    cc->num_hop2 = 0;
3012    cc->num_hopx = 0;
3013    cc->num_reshare0 = 0;
3014    cc->num_reshare1 = 0;
3015    cc->num_reshare2 = 0;
3016    cc->num_resharex = 0;   
3017    memset(&cc->cmd05_data, 0, sizeof(cc->cmd05_data));
3018    memset(&cc->receive_buffer, 0, sizeof(cc->receive_buffer));
3019    cc->cmd0c_mode = MODE_CMD_0x0C_NONE;
3020
3021    cs_ddump_mask(D_CLIENT, data, 16, "cccam: server init seed:");
3022
3023    uint16_t sum = 0x1234;
3024    uint16_t recv_sum = (data[14] << 8) | data[15];
3025    int32_t i;
3026    for (i = 0; i < 14; i++) {
3027        sum += data[i];
3028    }
3029    //Create special data to detect oscam-cccam:
3030    cc->is_oscam_cccam = sum == recv_sum;
3031
3032    cc_xor(data); // XOR init bytes with 'CCcam'
3033
3034    SHA_CTX ctx;
3035    SHA1_Init(&ctx);
3036    SHA1_Update(&ctx, data, 16);
3037    SHA1_Final(hash, &ctx);
3038
3039    cs_ddump_mask(D_CLIENT, hash, sizeof(hash), "cccam: sha1 hash:");
3040
3041    //initialisate crypto states
3042    cc_init_crypt(&cc->block[DECRYPT], hash, 20);
3043    cc_crypt(&cc->block[DECRYPT], data, 16, DECRYPT);
3044    cc_init_crypt(&cc->block[ENCRYPT], data, 16);
3045    cc_crypt(&cc->block[ENCRYPT], hash, 20, DECRYPT);
3046
3047    cc_cmd_send(cl, hash, 20, MSG_NO_HEADER); // send crypted hash to server
3048
3049    memset(buf, 0, CC_MAXMSGSIZE);
3050    memcpy(buf, rdr->r_usr, strlen(rdr->r_usr));
3051    cs_ddump_mask(D_CLIENT, buf, 20, "cccam: username '%s':", buf);
3052    cc_cmd_send(cl, buf, 20, MSG_NO_HEADER); // send usr '0' padded -> 20 bytes
3053
3054    memset(buf, 0, CC_MAXMSGSIZE);
3055    memset(pwd, 0, sizeof(pwd));
3056
3057    //cs_debug_mask(D_CLIENT, "cccam: 'CCcam' xor");
3058    memcpy(buf, "CCcam", 5);
3059    strncpy(pwd, rdr->r_pwd, sizeof(pwd) - 1);
3060    cc_crypt(&cc->block[ENCRYPT], (uint8_t *) pwd, strlen(pwd), ENCRYPT);
3061    cc_cmd_send(cl, buf, 6, MSG_NO_HEADER); // send 'CCcam' xor w/ pwd
3062
3063    if ((n = cc_recv_to(cl, data, 20)) != 20) {
3064        cs_log("%s login failed, pwd ack not received (n = %d)", getprefix(), n);
3065        return -2;
3066    }
3067    cc_crypt(&cc->block[DECRYPT], data, 20, DECRYPT);
3068    cs_ddump_mask(D_CLIENT, data, 20, "cccam: pwd ack received:");
3069
3070    if (memcmp(data, buf, 5)) { // check server response
3071        cs_log("%s login failed, usr/pwd invalid", getprefix());
3072        return -2;
3073    } else {
3074        cs_debug_mask(D_READER, "%s login succeeded", getprefix());
3075    }
3076
3077    cs_debug_mask(D_READER, "cccam: last_s=%d, last_g=%d", rdr->last_s, rdr->last_g);
3078
3079    cl->pfd = cl->udp_fd;
3080    cs_debug_mask(D_READER, "cccam: pfd=%d", cl->pfd);
3081
3082    if (cc_send_cli_data(cl) <= 0) {
3083        cs_log("%s login failed, could not send client data", getprefix());
3084        return -3;
3085    }
3086
3087    rdr->caid = rdr->ftab.filts[0].caid;
3088    rdr->nprov = rdr->ftab.filts[0].nprids;
3089    for (n = 0; n < rdr->nprov; n++) {
3090        rdr->availkeys[n][0] = 1;
3091        rdr->prid[n][0] = rdr->ftab.filts[0].prids[n] >> 24;
3092        rdr->prid[n][1] = rdr->ftab.filts[0].prids[n] >> 16;
3093        rdr->prid[n][2] = rdr->ftab.filts[0].prids[n] >> 8;
3094        rdr->prid[n][3] = rdr->ftab.filts[0].prids[n] & 0xff;
3095    }
3096
3097    rdr->card_status = CARD_NEED_INIT;
3098    rdr->last_g = rdr->last_s = time((time_t *) 0);
3099    rdr->tcp_connected = 1;
3100    rdr->available = 1;
3101
3102    cc->just_logged_in = 1;
3103    cc->mode = CCCAM_MODE_NORMAL;
3104    cl->crypted = 1;
3105
3106    return 0;
3107}
3108
3109int32_t cc_cli_init_int(struct s_client *cl) {
3110    struct s_reader *rdr = cl->reader;
3111    if (rdr->tcp_connected)
3112        return 1;
3113
3114    if (cl->pfd) {
3115        close(cl->pfd);
3116        if (cl->pfd == cl->udp_fd)
3117            cl->udp_fd = 0;
3118        cl->pfd = 0;
3119    }
3120
3121    if (cl->udp_fd) {
3122        close(cl->udp_fd);
3123        cl->udp_fd = 0;
3124    }
3125
3126    if (rdr->r_port <= 0) {
3127        cs_log("%s invalid port %d for server %s", rdr->label, rdr->r_port,
3128                rdr->device);
3129        return 1;
3130    }
3131    //      cl->ip = 0;
3132    //      memset((char *) &loc_sa, 0, sizeof(loc_sa));
3133    //      loc_sa.sin_family = AF_INET;
3134    //#ifdef LALL
3135    //      if (cfg.serverip[0])
3136    //      loc_sa.sin_addr.s_addr = inet_addr(cfg.serverip);
3137    //      else
3138    //#endif
3139    //      loc_sa.sin_addr.s_addr = INADDR_ANY;
3140    //      loc_sa.sin_port = htons(rdr->l_port);
3141
3142       
3143    if ((cl->udp_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) <= 0) {
3144        cs_log("%s Socket creation failed (socket=%d, errno=%d %s)", rdr->label,
3145                cl->udp_fd, errno, strerror(errno));
3146        return 1;
3147    }
3148    //cs_log("%s 1 socket created: cs_idx=%d, fd=%d errno=%d", getprefix(), cs_idx, cl->udp_fd, errno);
3149
3150#ifdef SO_PRIORITY
3151    if (cfg.netprio)
3152        setsockopt(cl->udp_fd, SOL_SOCKET, SO_PRIORITY,
3153            (void *)&cfg.netprio, sizeof(uintptr_t));
3154#endif
3155    int32_t keep_alive = 1;
3156    setsockopt(cl->udp_fd, SOL_SOCKET, SO_KEEPALIVE,
3157        (void *)&keep_alive, sizeof(keep_alive));
3158                   
3159    rdr->tcp_ito = 1; //60sec...This now invokes ph_idle()
3160    if (rdr->cc_maxhop < 0)
3161        rdr->cc_maxhop = 10;
3162
3163    memset((char *) &cl->udp_sa, 0, sizeof(cl->udp_sa));
3164    cl->udp_sa.sin_family = AF_INET;
3165    cl->udp_sa.sin_port = htons((uint16_t) rdr->r_port);
3166
3167    if (rdr->tcp_rto <= 2)
3168        rdr->tcp_rto = 2; // timeout to 120s
3169    cs_debug_mask(D_READER, "cccam: timeout set to: %d", rdr->tcp_rto);
3170    cc_check_version(rdr->cc_version, rdr->cc_build);
3171    cs_debug_mask(D_READER, "proxy reader: %s (%s:%d) cccam v%s build %s, maxhop: %d",
3172        rdr->label, rdr->device, rdr->r_port, rdr->cc_version,
3173        rdr->cc_build, rdr->cc_maxhop);
3174
3175    return 0;
3176}
3177
3178int32_t cc_cli_init(struct s_client *cl) {
3179    struct cc_data *cc = cl->cc;
3180    struct s_reader *reader = cl->reader;
3181   
3182    if ((cc && cc->mode == CCCAM_MODE_SHUTDOWN))
3183        return -1;
3184       
3185    int32_t res = cc_cli_init_int(cl); //Create socket
3186   
3187    if (res == 0 && reader && (reader->cc_keepalive || !cl->cc) && !reader->tcp_connected) {
3188       
3189        cc_cli_connect(cl); //connect to remote server
3190       
3191//      while (!reader->tcp_connected && reader->cc_keepalive && cfg.reader_restart_seconds > 0) {
3192//
3193//          if ((cc && cc->mode == CCCAM_MODE_SHUTDOWN))
3194//              return -1;
3195//             
3196//          if (!reader->tcp_connected) {
3197//              cc_cli_close(cl, FALSE);
3198//              res = cc_cli_init_int(cl);
3199//              if (res)
3200//                  return res;
3201//          }
3202//          cs_debug_mask(D_READER, "%s restarting reader in %d seconds", reader->label, cfg.reader_restart_seconds);
3203//          cs_sleepms(cfg.reader_restart_seconds*1000);
3204//          cs_debug_mask(D_READER, "%s restarting reader...", reader->label);
3205//          cc_cli_connect(cl);
3206//      }
3207    }
3208    return res;
3209}
3210
3211/**
3212 * return 1 if we are able to send requests:
3213 *
3214 */
3215int32_t cc_available(struct s_reader *rdr, int32_t checktype) {
3216    if (!rdr || !rdr->client) return 0;
3217   
3218    struct s_client *cl = rdr->client;
3219    if(!cl) return 0;
3220    //cs_debug_mask(D_TRACE, "checking reader %s availibility", rdr->label);
3221    if (!cl->cc || rdr->tcp_connected != 2 || rdr->card_status != CARD_INSERTED) {
3222        //Two cases:
3223        // 1. Keepalive ON but not connected: Do NOT send requests,
3224        //     because we can't connect - problem of full running pipes
3225        // 2. Keepalive OFF but not connected: Send requests to connect
3226        //     pipe won't run full, because we are reading from pipe to
3227        //     get the ecm request
3228        if (rdr->cc_keepalive)
3229            return 0;
3230    }
3231
3232    if (checktype == AVAIL_CHECK_LOADBALANCE && !rdr->available) {
3233        cs_debug_mask(D_TRACE, "checking reader %s availibility=0 (unavail)",
3234                rdr->label);
3235        return 0; //We are processing EMMs/ECMs
3236    }
3237
3238    return 1;
3239}
3240
3241/**
3242 *
3243 *
3244 **/
3245void cc_card_info() {
3246    struct s_client *cl = cur_client();
3247    struct s_reader *rdr = cl->reader;
3248
3249    if (rdr && !rdr->tcp_connected)
3250        cc_cli_connect(cl);
3251}
3252
3253void cc_cleanup(struct s_client *cl) {
3254    struct cc_data *cc = cl->cc;
3255    if (cc) cc->mode = CCCAM_MODE_SHUTDOWN;
3256   
3257    if (cl->typ != 'c') {
3258        cc_cli_close(cl, FALSE); // we need to close open fd's
3259    }
3260    cc_free(cl);
3261}
3262
3263void cc_update_nodeid()
3264{
3265    //Partner Detection:
3266    init_rnd();
3267    uint16_t sum = 0x1234; //This is our checksum
3268    int32_t i;
3269    for (i = 0; i < 4; i++) {
3270        cc_node_id[i] = fast_rnd();
3271        sum += cc_node_id[i];
3272    }
3273   
3274    // Partner ID:
3275    cc_node_id[4] = 0x10; // (Oscam 0x10, vPlugServer 0x11, Hadu 0x12,...)
3276    sum += cc_node_id[4];
3277                   
3278    // generate checksum for Partner ID:
3279    cc_node_id[5] = 0xAA;
3280    for (i = 0; i < 5; i++) {
3281      cc_node_id[5] ^= cc_node_id[i];
3282    }
3283    sum += cc_node_id[5];       
3284   
3285    cc_node_id[6] = sum >> 8;
3286    cc_node_id[7] = sum & 0xff;
3287   
3288    int valid = 0;
3289    if (cfg.cc_use_fixed_nodeid) {
3290        for (i=0;i<8;i++)
3291            if (cfg.cc_fixed_nodeid[i])
3292                valid = 1;
3293    }
3294    if (valid)
3295        memcpy(cc_node_id, cfg.cc_fixed_nodeid, 8);
3296    else
3297        memcpy(cfg.cc_fixed_nodeid, cc_node_id, 8);
3298}
3299
3300void module_cccam(struct s_module *ph) {
3301    cs_strncpy(ph->desc, "cccam", sizeof(ph->desc));
3302    ph->type = MOD_CONN_TCP;
3303    ph->logtxt = ", crypted";
3304    ph->watchdog = 1;
3305    ph->recv = cc_recv;
3306    ph->cleanup = cc_cleanup;
3307    ph->multi = 1;
3308    ph->c_multi = 1;
3309    ph->c_init = cc_cli_init;
3310    ph->c_idle = cc_idle;
3311    ph->c_recv_chk = cc_recv_chk;
3312    ph->c_send_ecm = cc_send_ecm;
3313    ph->c_send_emm = cc_send_emm;
3314    ph->s_ip = cfg.cc_srvip;
3315    ph->s_handler = cc_srv_init;
3316    ph->send_dcw = cc_send_dcw;
3317    ph->c_available = cc_available;
3318    ph->c_card_info = cc_card_info;
3319    static PTAB ptab; //since there is always only 1 cccam server running, this is threadsafe
3320    memset(&ptab, 0, sizeof(PTAB));
3321    int32_t i;
3322    for (i=0;i<CS_MAXPORTS;i++) {
3323        if (!cfg.cc_port[i]) break;
3324        ptab.ports[i].s_port = cfg.cc_port[i];
3325        ptab.nports++;
3326    }
3327           
3328    ph->ptab = &ptab;
3329    ph->num = R_CCCAM;
3330
3331    cc_update_nodeid();
3332   
3333    if (cfg.cc_port)
3334            init_share();       
3335}
3336#endif
Note: See TracBrowser for help on using the repository browser.