source: trunk/module-cccam.c @ 5365

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

WebIf: Allow emptying au arameter. CCCam: Do not try to wake up reader if it is currently blocked or in shutdown so that pipe is not filled up by useless requests.

  • Property svn:mime-type set to text/plain
File size: 87.6 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                                    if (card->origin_id && ordr && ordr->client && ordr->client->cc) { //only if we have a origin from a cccam reader
2130                                        struct cc_data *rcc = ordr->client->cc;
2131                                       
2132                                        itr = ll_iter_create(rcc->cards);
2133                                        while ((rcard=ll_iter_next(&itr))) {
2134                                                if (rcard->id == card->origin_id) //found it!
2135                                                        break;
2136                                        }
2137                                    }
2138                                    else
2139                                        rcard = card;
2140                                }
2141                                er->origin_reader = ordr;
2142                        }
2143                       
2144                        er->origin_card = rcard;
2145                        if (!rcard || !ordr) {
2146                                cs_debug_mask(D_TRACE, "%s forward card: share %d not found!", getprefix(), server_card->id);
2147                                er->rc = E_NOTFOUND;
2148                                er->rcEx = E2_CCCAM_NOK1; //share not found!
2149                        }
2150                        else
2151                                cs_debug_mask(D_TRACE, "%s forward card: share %d forwarded to %s origin as id %d", getprefix(),
2152                                        card->id, ordr->label, rcard->id);
2153                        unlock_sharelist();
2154                }
2155                       
2156                cs_debug_mask(
2157                        D_CLIENT,
2158                        "%s ECM request from client: caid %04x srvid %04x(%d) prid %06x",
2159                        getprefix(), er->caid, er->srvid, er->l, er->prid);
2160
2161                struct cc_srvid srvid;
2162                srvid.sid = er->srvid;
2163                srvid.ecmlen = er->l;
2164                add_extended_ecm_idx(cl, cc->extended_mode ? cc->g_flag : 1,
2165                        er->idx, server_card, srvid, 1);
2166
2167                get_cw(cl, er);
2168
2169            } else {
2170                cs_debug_mask(D_CLIENT, "%s NO ECMTASK!!!!", getprefix());
2171                free(server_card);
2172            }
2173
2174        } else { //READER:
2175            while (cs_trylock(&cc->cards_busy)) {
2176                cs_debug_mask(D_TRACE, "%s trylock MSG_CW_ECM cards waiting", getprefix());
2177                cs_sleepms(fast_rnd());
2178            }
2179            cc->recv_ecmtask = -1;
2180            struct cc_extended_ecm_idx *eei = get_extended_ecm_idx(cl,
2181                    cc->extended_mode ? cc->g_flag : 1, TRUE);
2182            if (!eei) {
2183                cs_debug_mask(D_READER, "%s received extended ecm id %d but not found!",
2184                        getprefix(), cc->g_flag);
2185            }
2186            else
2187            {
2188                uint16_t ecm_idx = eei->ecm_idx;
2189                cc->recv_ecmtask = ecm_idx;
2190                struct cc_card *card = eei->card;
2191                struct cc_srvid srvid = eei->srvid;
2192                free(eei);
2193
2194                if (card) {
2195
2196                    if (!cc->extended_mode) {
2197                        cc_cw_crypt(cl, buf + 4, card->id);
2198                        cc_crypt_cmd0c(cl, buf + 4, 16);
2199                    }
2200
2201                    memcpy(cc->dcw, buf + 4, 16);
2202                    //fix_dcw(cc->dcw);
2203                    if (!cc->extended_mode)
2204                        cc_crypt(&cc->block[DECRYPT], buf + 4, l - 4, ENCRYPT); // additional crypto step
2205
2206                    if (is_null_dcw(cc->dcw)) {
2207                        cs_debug_mask(D_READER, "%s null dcw received! sid=%04X(%d)", getprefix(),
2208                                srvid.sid, srvid.ecmlen);
2209                        add_sid_block(cl, card, &srvid);
2210                        //ecm retry:
2211                        cc_reset_pending(cl, ecm_idx);
2212                        buf[1] = MSG_CW_NOK2; //So it's really handled like a nok!
2213                    } else {
2214                        cs_debug_mask(D_READER, "%s cws: %d %s", getprefix(),
2215                                ecm_idx, cs_hexdump(0, cc->dcw, 16));
2216                        add_good_sid(cl, card, &srvid);
2217                       
2218                        //check response time, if > fallbacktime, switch cards!
2219                        struct timeb tpe;
2220                        cs_ftime(&tpe);
2221                        uint32_t cwlastresptime = 1000*(tpe.time-cc->ecm_time.time)+tpe.millitm-cc->ecm_time.millitm;
2222                        if (cwlastresptime > cfg.ftimeout && !cc->extended_mode) {
2223                            cs_debug_mask(D_READER, "%s card %04X is too slow, moving to the end...", getprefix(), card->id);
2224                            move_card_to_end(cl, card);
2225                        }
2226                       
2227                    }
2228                } else {
2229                    cs_debug_mask(D_READER,
2230                            "%s warning: ECM-CWS respond by CCCam server without current card!",
2231                            getprefix());
2232                }
2233            }
2234            cs_unlock(&cc->cards_busy);
2235
2236            if (!cc->extended_mode) {
2237                rdr->available = 1;
2238                cs_unlock(&cc->ecm_busy);
2239            }
2240
2241            //cc_abort_user_ecms();
2242
2243            cc_send_ecm(cl, NULL, NULL);
2244
2245            if (cc->max_ecms)
2246                cc->ecm_counter++;
2247        }
2248        break;
2249
2250    case MSG_KEEPALIVE:
2251        if (cl->typ != 'c') {
2252            cs_debug_mask(D_READER, "cccam: keepalive ack");
2253        } else {
2254            //Checking if last answer is one minute ago:
2255            if (cc->just_logged_in || cc->answer_on_keepalive + 55 <= time(NULL)) {
2256                cc_cmd_send(cl, NULL, 0, MSG_KEEPALIVE);
2257                cs_debug_mask(D_CLIENT, "cccam: keepalive");
2258                cc->answer_on_keepalive = time(NULL);
2259            }
2260        }
2261        cc->just_logged_in = 0;
2262        break;
2263
2264    case MSG_CMD_05:
2265        if (cl->typ != 'c') {
2266            cc->just_logged_in = 0;
2267            l = l - 4;//Header Length=4 Byte
2268
2269            cs_debug_mask(D_READER, "%s MSG_CMD_05 recvd, payload length=%d mode=%d",
2270                    getprefix(), l, cc->cmd05_mode);
2271            cc->cmd05_active = 1;
2272            cc->cmd05_data_len = l;
2273            memcpy(&cc->cmd05_data, buf + 4, l);
2274            if (rdr->available && ll_has_elements(cc->cards))
2275                send_cmd05_answer(cl);
2276        }
2277        break;
2278    case MSG_CMD_0B: {
2279        // by Project:Keynation
2280        cs_debug_mask(D_READER, "%s MSG_CMD_0B received (payload=%d)!",
2281                getprefix(), l - 4);
2282
2283        AES_KEY key;
2284        uint8_t aeskey[16];
2285        uint8_t out[16];
2286
2287        memcpy(aeskey, cc->cmd0b_aeskey, 16);
2288        memset(&key, 0, sizeof(key));
2289
2290        //cs_ddump_mask(D_READER, aeskey, 16, "%s CMD_0B AES key:", getprefix());
2291        //cs_ddump_mask(D_READER, data, 16, "%s CMD_0B received data:", getprefix());
2292
2293        AES_set_encrypt_key((unsigned char *) &aeskey, 128, &key);
2294        AES_encrypt((unsigned char *) data, (unsigned char *) &out, &key);
2295
2296        cs_debug_mask(D_TRACE, "%s sending CMD_0B! ", getprefix());
2297        //cs_ddump_mask(D_READER, out, 16, "%s CMD_0B out:", getprefix());
2298        cc_cmd_send(cl, out, 16, MSG_CMD_0B);
2299
2300        break;
2301    }
2302
2303    case MSG_CMD_0C: { //New CCCAM 2.2.0 Server/Client fake check!
2304        int32_t len = l-4;
2305
2306        if (cl->typ == 'c') { //Only im comming from "client"
2307            cs_debug_mask(D_CLIENT, "%s MSG_CMD_0C received (payload=%d)!", getprefix(), len);
2308       
2309            uint8_t bytes[0x20];
2310            if (len < 0x20) //if less then 0x20 bytes, clear others:
2311                memset(data+len, 0, 0x20-len);
2312       
2313            //change first 0x10 bytes to the second:
2314            memcpy(bytes, data+0x10, 0x10);
2315            memcpy(bytes+0x10, data, 0x10);
2316       
2317            //xor data:
2318            int32_t i;
2319            for (i=0;i<0x20;i++)
2320                bytes[i] ^= (data[i] & 0x7F);
2321           
2322                //key is now the 16bit hash of md5:
2323            uint8_t md5hash[0x10];
2324            MD5(data, 0x20, md5hash);
2325            memcpy(bytes, md5hash, 0x10);
2326           
2327            cs_debug_mask(D_CLIENT, "%s sending CMD_0C! ", getprefix());
2328            //cs_ddump_mask(D_CLIENT, bytes, 0x20, "%s CMD_0C out:", getprefix());
2329            cc_cmd_send(cl, bytes, 0x20, MSG_CMD_0C);   
2330        }
2331        else //reader
2332        {           
2333            // by Project:Keynation + Oscam team
2334            cc_crypt_cmd0c(cl, data, len);
2335
2336            uint8_t CMD_0x0C_Command = data[0];
2337
2338            switch (CMD_0x0C_Command) {
2339               
2340                case 0 : { //RC6
2341                    cc->cmd0c_mode = MODE_CMD_0x0C_RC6;
2342                    break;
2343                }                   
2344                           
2345                case 1: { //RC4
2346                    cc->cmd0c_mode = MODE_CMD_0x0C_RC4;
2347                    break;
2348                }
2349                   
2350                case 2: { //CC_CRYPT
2351                    cc->cmd0c_mode = MODE_CMD_0x0C_CC_CRYPT;
2352                    break;
2353                }       
2354                   
2355                case 3: { //AES
2356                    cc->cmd0c_mode = MODE_CMD_0x0C_AES;
2357                    break;
2358                }   
2359                   
2360                case 4 : { //IDEA
2361                    cc->cmd0c_mode = MODE_CMD_0x0C_IDEA;
2362                    break;
2363                }   
2364               
2365                default: {
2366                    cc->cmd0c_mode = MODE_CMD_0x0C_NONE;
2367                }
2368            }   
2369           
2370            set_cmd0c_cryptkey(cl, data, len);
2371
2372            cs_debug_mask(D_READER, "%s received MSG_CMD_0C from server! CMD_0x0C_CMD=%d, MODE=%s",
2373                getprefix(), CMD_0x0C_Command, cmd0c_mode_name[cc->cmd0c_mode]);
2374        }
2375        break;
2376    }
2377
2378    case MSG_CMD_0D: { //key update for the active cmd0x0c algo
2379        int32_t len = l-4;
2380        if (cc->cmd0c_mode == MODE_CMD_0x0C_NONE)
2381            break;
2382
2383        cc_crypt_cmd0c(cl, data, len);
2384        set_cmd0c_cryptkey(cl, data, len);
2385
2386        cs_debug_mask(D_READER, "%s received MSG_CMD_0D from server! MODE=%s",
2387            getprefix(), cmd0c_mode_name[cc->cmd0c_mode]);
2388        break;
2389    }
2390       
2391    case MSG_CMD_0E: {
2392        cs_debug_mask(D_READER, "cccam 2.2.x commands not implemented: 0x%02X", buf[1]);
2393        //Unkwon commands...need workout algo
2394        if (cl->typ == 'c') //client connection
2395        {
2396            //switching to an oder version and then disconnect...
2397            cs_strncpy(cfg.cc_version, version[0], sizeof(cfg.cc_version));
2398            ret = -1;
2399        }
2400        else //reader connection
2401        {
2402            cs_strncpy(cl->reader->cc_version, version[0], sizeof(cl->reader->cc_version));
2403            cs_strncpy(cl->reader->cc_build, build[0], sizeof(cl->reader->cc_build));
2404            cc_cli_close(cl, TRUE);
2405        }
2406        break;
2407    }
2408                                   
2409    case MSG_EMM_ACK: {
2410        cc->just_logged_in = 0;
2411        if (cl->typ == 'c') { //EMM Request received
2412            cc_cmd_send(cl, NULL, 0, MSG_EMM_ACK); //Send back ACK
2413            if (l > 4) {
2414                cs_debug_mask(D_EMM, "%s EMM Request received!", getprefix());
2415
2416                if (!ll_count(cl->aureader_list)) {
2417                        cs_debug_mask(
2418                            D_EMM,
2419                            "%s EMM Request discarded because au is not assigned to an reader!",
2420                            getprefix());
2421                    return MSG_EMM_ACK;
2422                }
2423
2424                EMM_PACKET *emm = cs_malloc(&emm, sizeof(EMM_PACKET), QUITERROR);
2425                memset(emm, 0, sizeof(EMM_PACKET));
2426                emm->caid[0] = buf[4];
2427                emm->caid[1] = buf[5];
2428                emm->provid[0] = buf[7];
2429                emm->provid[1] = buf[8];
2430                emm->provid[2] = buf[9];
2431                emm->provid[3] = buf[10];
2432                //emm->hexserial[0] = buf[11];
2433                //emm->hexserial[1] = buf[12];
2434                //emm->hexserial[2] = buf[13];
2435                //emm->hexserial[3] = buf[14];
2436                emm->l = buf[15];
2437                memcpy(emm->emm, buf + 16, emm->l);
2438                //emm->type = UNKNOWN;
2439                //emm->cidx = cs_idx;
2440                do_emm(cl, emm);
2441                free(emm);
2442            }
2443        } else { //Our EMM Request Ack!
2444            cs_debug_mask(D_EMM, "%s EMM ACK!", getprefix());
2445            if (!cc->extended_mode) {
2446                rdr->available = 1;
2447                cs_unlock(&cc->ecm_busy);
2448            }
2449            cc_send_ecm(cl, NULL, NULL);
2450        }
2451        break;
2452    }
2453    default:
2454        //cs_ddump_mask(D_CLIENT, buf, l, "%s unhandled msg: %d len=%d", getprefix(), buf[1], l);
2455        break;
2456    }
2457
2458    if (cc->max_ecms && (cc->ecm_counter > cc->max_ecms)) {
2459        cs_debug_mask(D_READER, "%s max ecms (%d) reached, cycle connection!", getprefix(),
2460                cc->max_ecms);
2461        //cc_cycle_connection();
2462        cc_cli_close(cl, TRUE);
2463        //cc_send_ecm(NULL, NULL);
2464    }
2465    return ret;
2466}
2467
2468/**
2469 * Reader: write dcw to receive
2470 */
2471int32_t cc_recv_chk(struct s_client *cl, uchar *dcw, int32_t *rc, uchar *buf, int32_t UNUSED(n)) {
2472    struct cc_data *cc = cl->cc;
2473
2474    if (buf[1] == MSG_CW_ECM) {
2475        memcpy(dcw, cc->dcw, 16);
2476        //cs_debug_mask(D_CLIENT, "cccam: recv chk - MSG_CW %d - %s", cc->recv_ecmtask,
2477        //      cs_hexdump(0, dcw, 16));
2478        *rc = 1;
2479        return (cc->recv_ecmtask);
2480    } else if ((buf[1] == (MSG_CW_NOK1)) || (buf[1] == (MSG_CW_NOK2))) {
2481        *rc = 0;
2482        //if (cc->is_oscam_cccam)
2483        if (cfg.cc_forward_origin_card)
2484                return (cc->recv_ecmtask);
2485        else
2486                return -1;
2487    }
2488
2489    return (-1);
2490}
2491
2492//int32_t is_softfail(int32_t rc)
2493//{
2494//  //see oscam.c send_dcw() for a full list
2495//  switch(rc)
2496//  {
2497//      case 5: // 5 = timeout
2498//      case 6: // 6 = sleeping
2499//      case 7: // 7 = fake
2500//      case 10:// 10= no card
2501//      case 11:// 11= expdate
2502//      case 12:// 12= disabled
2503//      case 13:// 13= stopped
2504//      case 14:// 100= unhandled
2505//          return TRUE;
2506//  }
2507//  return FALSE;
2508//}
2509
2510
2511
2512/**
2513 * Server: send DCW to client
2514 */
2515void cc_send_dcw(struct s_client *cl, ECM_REQUEST *er) {
2516    uchar buf[16];
2517    struct cc_data *cc = cl->cc;
2518
2519    memset(buf, 0, sizeof(buf));
2520
2521    struct cc_extended_ecm_idx *eei = get_extended_ecm_idx_by_idx(cl, er->idx,
2522            TRUE);
2523
2524    if (er->rc < E_NOTFOUND && eei && eei->card) { //found:
2525        memcpy(buf, er->cw, sizeof(buf));
2526        //fix_dcw(buf);
2527        //cs_debug_mask(D_TRACE, "%s send cw: %s cpti: %d", getprefix(),
2528        //      cs_hexdump(0, buf, 16), er->cpti);
2529        if (!cc->extended_mode)
2530            cc_cw_crypt(cl, buf, eei->card->id);
2531        else
2532            cc->g_flag = eei->send_idx;
2533        cc_cmd_send(cl, buf, 16, MSG_CW_ECM);
2534        if (!cc->extended_mode)
2535            cc_crypt(&cc->block[ENCRYPT], buf, 16, ENCRYPT); // additional crypto step
2536       
2537    } else { //NOT found:
2538        //cs_debug_mask(D_TRACE, "%s send cw: NOK cpti: %d", getprefix(),
2539        //      er->cpti);
2540
2541        if (eei && cc->extended_mode)
2542            cc->g_flag = eei->send_idx;
2543
2544        int32_t nok;
2545        if (!eei || !eei->card)
2546            nok = MSG_CW_NOK1; //share no more available
2547        else {
2548            if (cfg.cc_forward_origin_card && er->origin_card == eei->card)
2549                nok = (er->rcEx==E2_CCCAM_NOK1)?MSG_CW_NOK1:MSG_CW_NOK2;
2550            else
2551                nok = MSG_CW_NOK2; //can't decode
2552        }
2553        cc_cmd_send(cl, NULL, 0, nok);
2554    }
2555    cc->server_ecm_pending--;
2556    if (eei) {
2557        free(eei->card);
2558        free(eei);
2559    }
2560}
2561
2562int32_t cc_recv(struct s_client *cl, uchar *buf, int32_t l) {
2563    int32_t n;
2564    uchar *cbuf;
2565
2566    if (buf == NULL || l <= 0)
2567        return -1;
2568    cbuf = cs_malloc(&cbuf, l, QUITERROR);
2569    memcpy(cbuf, buf, l); // make a copy of buf
2570
2571    n = cc_msg_recv(cl, cbuf, l); // recv and decrypt msg
2572
2573    //cs_ddump_mask(D_CLIENT, cbuf, n, "cccam: received %d bytes from %s", n, remote_txt());
2574    cl->last = time((time_t *) 0);
2575
2576    if (n <= 0) {
2577        cs_log("%s connection closed by %s", getprefix(), remote_txt());
2578        n = -1;
2579    } else if (n < 4) {
2580        cs_log("%s packet to small (%d bytes)", getprefix(), n);
2581        n = -1;
2582    } else {
2583        // parse it and write it back, if we have received something of value
2584        n = cc_parse_msg(cl, cbuf, n);
2585        memcpy(buf, cbuf, l);
2586    }
2587
2588    NULLFREE(cbuf);
2589
2590    if (n == -1) {
2591        if (cl->typ != 'c')
2592            cc_cli_close(cl, TRUE);
2593    }
2594
2595    return n;
2596}
2597
2598void cc_init_cc(struct cc_data *cc) {
2599    pthread_mutex_init(&cc->lockcmd, NULL); //No recursive lock
2600    pthread_mutex_init(&cc->ecm_busy, NULL); //No recusive lock
2601    pthread_mutex_init(&cc->cards_busy, NULL); //No (more) recursive lock
2602}
2603
2604/**
2605 * Starting readers to get cards:
2606 **/
2607int32_t cc_srv_wakeup_readers(struct s_client *cl) {
2608    int32_t wakeup = 0;
2609    struct s_reader *rdr;
2610    struct s_client *client;
2611    struct cc_data *cc;
2612    for (rdr = first_active_reader; rdr; rdr = rdr->next) {
2613        if (rdr->typ != R_CCCAM)
2614            continue;
2615        if (rdr->tcp_connected == 2)
2616            continue;
2617        if (!(rdr->grp & cl->grp))
2618            continue;
2619        if (rdr->cc_keepalive) //if reader has keepalive but is NOT connected, reader can't connect. so don't ask him
2620            continue;
2621        if((client = rdr->client) == NULL || (cc = client->cc) == NULL || cc->mode == CCCAM_MODE_SHUTDOWN)  //reader is in shutdown
2622            continue;
2623        if(is_connect_blocked(rdr)) //reader cannot be waked up currently because its blocked
2624            continue;
2625       
2626        //This wakeups the reader:
2627        uchar dummy = 0;
2628        write_to_pipe(rdr->fd, PIP_ID_CIN, &dummy, sizeof(dummy));
2629        wakeup++;
2630    }
2631    return wakeup;
2632}
2633
2634
2635int32_t check_cccam_compat(struct cc_data *cc) {
2636    int32_t res = 0;
2637    if (strcmp(cfg.cc_version, "2.2.0") == 0 || strcmp(cfg.cc_version, "2.2.1") == 0) {
2638   
2639        if (strcmp(cc->remote_version, "2.2.0") == 0 || strcmp(cc->remote_version, "2.2.1") == 0) {
2640            res = 1;
2641        }
2642    }
2643    return res;
2644}
2645
2646int32_t cc_srv_connect(struct s_client *cl) {
2647    int32_t i, wait_for_keepalive;
2648    uint8_t data[16];
2649    char usr[21], pwd[65];
2650    struct s_auth *account;
2651    struct cc_data *cc;
2652
2653    memset(usr, 0, sizeof(usr));
2654    memset(pwd, 0, sizeof(pwd));
2655
2656    // init internals data struct
2657    cc = cs_malloc(&cc, sizeof(struct cc_data), QUITERROR);
2658    cl->cc = cc;
2659    memset(cl->cc, 0, sizeof(struct cc_data));
2660    cc->extended_ecm_idx = ll_create();
2661
2662    cc_init_cc(cc);
2663    uint8_t *buf = cc->send_buffer;
2664   
2665    cc->mode = CCCAM_MODE_NOTINIT;
2666    cc->server_ecm_pending = 0;
2667    cc->extended_mode = 0;
2668
2669    int32_t keep_alive = 1;
2670    setsockopt(cl->udp_fd, SOL_SOCKET, SO_KEEPALIVE,
2671        (void *)&keep_alive, sizeof(keep_alive));
2672                       
2673    //Create checksum for "O" cccam:
2674    for (i = 0; i < 12; i++) {
2675        data[i] = fast_rnd();
2676    }
2677    for (i = 0; i < 4; i++) {
2678        data[12 + i] = (data[i] + data[4 + i] + data[8 + i]) & 0xff;
2679    }
2680
2681    cs_debug_mask(D_TRACE, "send ccc checksum");
2682   
2683    send(cl->udp_fd, data, 16, 0);
2684
2685    cc_xor(data); // XOR init bytes with 'CCcam'
2686
2687    SHA_CTX ctx;
2688    SHA1_Init(&ctx);
2689    SHA1_Update(&ctx, data, 16);
2690    SHA1_Final(buf, &ctx);
2691
2692    cc_init_crypt(&cc->block[ENCRYPT], buf, 20);
2693    cc_crypt(&cc->block[ENCRYPT], data, 16, DECRYPT);
2694    cc_init_crypt(&cc->block[DECRYPT], data, 16);
2695    cc_crypt(&cc->block[DECRYPT], buf, 20, DECRYPT);
2696
2697    cs_debug_mask(D_TRACE, "receive ccc checksum");
2698    if ((i = cc_recv_to(cl, buf, 20)) == 20) {
2699        //cs_ddump_mask(D_CLIENT, buf, 20, "cccam: recv:");
2700        cc_crypt(&cc->block[DECRYPT], buf, 20, DECRYPT);
2701        //cs_ddump_mask(D_CLIENT, buf, 20, "cccam: hash:");
2702    } else
2703        return -1;
2704
2705    // receive username
2706    memset(buf, 0, CC_MAXMSGSIZE);
2707    if ((i = cc_recv_to(cl, buf, 20)) == 20) {
2708        cc_crypt(&cc->block[DECRYPT], buf, 20, DECRYPT);
2709
2710        strncpy(usr, (char *) buf, sizeof(usr));
2711
2712        //test for nonprintable characters:
2713        for (i = 0; i < 20; i++) {
2714            if (usr[i] > 0 && usr[i] < 0x20) { //found nonprintable char
2715                cs_log("illegal username received");
2716                return -3;
2717            }
2718        }
2719        //cs_ddump_mask(D_CLIENT, buf, 20, "cccam: username '%s':", usr);
2720    } else
2721        return -2;
2722    cs_debug_mask(D_TRACE, "ccc username received %s", usr);
2723
2724    cl->crypted = 1;
2725
2726    //CCCam only supports len=20 usr/pass. So we could have more than one user that matches the first 20 chars.
2727   
2728    //receive password-CCCam encrypted Hash:
2729    if (cc_recv_to(cl, buf, 6) != 6)
2730        return -2;
2731   
2732    cs_debug_mask(D_TRACE, "ccc passwdhash received %s", usr);
2733   
2734    account = cfg.account;
2735    struct cc_crypt_block *save_block = cs_malloc(&save_block, sizeof(struct cc_crypt_block), QUITERROR);
2736    memcpy(save_block, cc->block, sizeof(struct cc_crypt_block));
2737    int32_t found = 0;
2738    while (1) {
2739        while (account) {
2740            if (strncmp(usr, account->usr, 20) == 0) {
2741                memset(pwd, 0, sizeof(pwd));
2742                strncpy(pwd, account->pwd, sizeof(pwd));
2743                found=1;
2744                break;
2745            }
2746            account = account->next;
2747        }
2748
2749        if (!account)
2750            break;
2751           
2752        // receive passwd / 'CCcam'
2753        memcpy(cc->block, save_block, sizeof(struct cc_crypt_block));
2754        cc_crypt(&cc->block[DECRYPT], (uint8_t *) pwd, strlen(pwd), ENCRYPT);
2755        cc_crypt(&cc->block[DECRYPT], buf, 6, DECRYPT);
2756        //cs_ddump_mask(D_CLIENT, buf, 6, "cccam: pwd check '%s':", buf); //illegal buf-bytes could kill the logger!
2757        if (memcmp(buf, "CCcam\0", 6) == 0) //Password Hash OK!
2758            break; //account is set
2759           
2760        account = account->next;
2761    }
2762    free(save_block);
2763
2764    if (cs_auth_client(cl, account, NULL)) { //cs_auth_client returns 0 if account is valid/active/accessible
2765        if (!found)
2766            cs_log("account '%s' not found!", usr);
2767        else
2768            cs_log("password for '%s' invalid!", usr);
2769        return -2;
2770    }
2771    if (cl->dup) {
2772        cs_log("account '%s' duplicate login, disconnect!", usr);
2773        return -3;
2774    }
2775    if (cl->disabled) {
2776        cs_log("account '%s' disabled, blocking+disconnect!", usr);
2777        return -2;
2778    }
2779    if (account->cccmaxhops<0) {
2780            cs_log("account '%s' has cccmaxhops<0, cccam can't handle this, disconnect!", usr);
2781            return -3;
2782    }
2783   
2784    cs_debug_mask(D_TRACE, "ccc user authenticated %s", usr);
2785
2786    cc->prefix = cs_malloc(&cc->prefix, strlen(cl->account->usr)+20, QUITERROR);
2787    snprintf(cc->prefix, strlen(cl->account->usr)+20, "cccam(s) %s: ", cl->account->usr);
2788
2789    //Starting readers to get cards:
2790    cc_srv_wakeup_readers(cl);
2791
2792    // send passwd ack
2793    memset(buf, 0, 20);
2794    memcpy(buf, "CCcam\0", 6);
2795    cs_ddump_mask(D_CLIENT, buf, 20, "cccam: send ack:");
2796    cc_crypt(&cc->block[ENCRYPT], buf, 20, ENCRYPT);
2797    send(cl->pfd, buf, 20, 0);
2798
2799    // recv cli data
2800    memset(buf, 0, CC_MAXMSGSIZE);
2801    i = cc_msg_recv(cl, buf, CC_MAXMSGSIZE);
2802    if (i < 0)
2803        return -1;
2804    cs_ddump_mask(D_CLIENT, buf, i, "cccam: cli data:");
2805    memcpy(cc->peer_node_id, buf + 24, 8);
2806    //chk_peer_node_for_oscam(cc);
2807   
2808    strncpy(cc->remote_version, (char*)buf+33, sizeof(cc->remote_version)-1);
2809    strncpy(cc->remote_build, (char*)buf+65, sizeof(cc->remote_build)-1);
2810   
2811    cs_debug_mask(D_CLIENT, "%s client '%s' (%s) running v%s (%s)", getprefix(), buf + 4,
2812            cs_hexdump(0, cc->peer_node_id, 8), cc->remote_version, cc->remote_build);
2813
2814    // send cli data ack
2815    cc_cmd_send(cl, NULL, 0, MSG_CLI_DATA);
2816
2817    cs_debug_mask(D_TRACE, "ccc send srv_data %s", usr);
2818    if (cc_send_srv_data(cl) < 0)
2819        return -1;
2820
2821    cc->cccam220 = check_cccam_compat(cc);
2822    cc->just_logged_in = TRUE;
2823    cc->answer_on_keepalive = time(NULL);
2824   
2825    //Wait for Partner detection (NOK1 with data) before reporting cards
2826    //When Partner is detected, cccam220=1 is set. then we can report extended card data
2827    i = process_input(buf, CC_MAXMSGSIZE, 1);
2828    if (i<=0 && i != -9)
2829        return 0; //disconnected
2830       
2831    if (cc->cccam220)
2832        cs_debug_mask(D_CLIENT, "%s extended sid mode activated", getprefix());
2833    else
2834        cs_debug_mask(D_CLIENT, "%s 2.1.x compatibility mode", getprefix());
2835
2836    cs_debug_mask(D_TRACE, "ccc send cards %s", usr);
2837 
2838    if (!cc_srv_report_cards(cl))
2839        return -1;
2840    cs_ftime(&cc->ecm_time);
2841
2842    time_t timeout = time(NULL);
2843    wait_for_keepalive = 100;
2844    cc->mode = CCCAM_MODE_NORMAL;
2845    //some clients, e.g. mgcamd, does not support keepalive. So if not answered, keep connection
2846    // check for client timeout, if timeout occurs try to send keepalive
2847    cs_debug_mask(D_TRACE, "ccc connected and waiting for data %s", usr);
2848    while (cl->pfd && cl->udp_fd && cc->mode == CCCAM_MODE_NORMAL && !cl->dup)
2849    {
2850        i = process_input(buf, CC_MAXMSGSIZE, 10);
2851        if (i <= 0 && i != -9)
2852            break; //Disconnected by client     
2853           
2854        //data is parsed!
2855        if (i == MSG_CW_ECM)
2856            timeout = time(NULL);
2857        else if (i == MSG_KEEPALIVE) {
2858            wait_for_keepalive = 0;
2859            timeout = time(NULL);
2860        }
2861       
2862        //new timeout check:
2863        if (time(NULL)-timeout > (time_t)cfg.cmaxidle) {
2864            cs_debug_mask(D_TRACE, "ccc idle %s", usr);
2865            //cs_debug_mask(D_TRACE, "client timeout user %s idle=%d client max idle=%d", usr, cmi, cfg.cmaxidle);
2866            if (cfg.cc_keep_connected || cl->account->ncd_keepalive) {
2867                if (cc_cmd_send(cl, NULL, 0, MSG_KEEPALIVE) < 0)
2868                    break;
2869                if (wait_for_keepalive<3 || wait_for_keepalive == 100) {
2870                    cs_debug_mask(D_CLIENT, "cccam: keepalive");
2871                    cc->answer_on_keepalive = time(NULL);
2872                    wait_for_keepalive++;
2873                }
2874                else if (wait_for_keepalive<100) break;
2875                timeout = time(NULL);
2876            } else {
2877                cs_debug_mask(D_CLIENT, "%s keepalive after maxidle is reached",
2878                    getprefix());
2879                break; //Disconnect client
2880            }
2881        }
2882    }
2883    cc->mode = CCCAM_MODE_SHUTDOWN;
2884    return 0;
2885}
2886
2887void * cc_srv_init(struct s_client *cl) {
2888    cl->thread = pthread_self();
2889    pthread_setspecific(getclient, cl);
2890
2891    if (cl->ip)
2892        cs_debug_mask(D_CLIENT, "cccam: new connection from %s", cs_inet_ntoa(cl->ip));
2893               
2894    cl->pfd = cl->udp_fd;
2895    int32_t ret;
2896    if ((ret=cc_srv_connect(cl)) < 0) {
2897        if (errno != 0)
2898            cs_debug_mask(D_CLIENT, "cccam: failed errno: %d (%s)", errno, strerror(errno));
2899        else
2900            cs_debug_mask(D_CLIENT, "cccam: failed ret: %d", ret);
2901        if (ret == -2)
2902            cs_add_violation((uint)cl->ip);
2903    }
2904    cs_disconnect_client(cl);
2905    return NULL; //suppress compiler warning
2906}
2907
2908int32_t cc_cli_connect(struct s_client *cl) {
2909    struct s_reader *rdr = cl->reader;
2910    struct cc_data *cc = cl->cc;
2911    rdr->card_status = CARD_FAILURE;
2912
2913    if (cc && cc->mode == CCCAM_MODE_SHUTDOWN)
2914        return -99;
2915
2916    if (!cc) {
2917        // init internals data struct
2918        cc = cs_malloc(&cc, sizeof(struct cc_data), QUITERROR);
2919        memset(cc, 0, sizeof(struct cc_data));
2920        cc_init_cc(cc);
2921        cc->cards = ll_create();
2922        cl->cc = cc;
2923        cc->pending_emms = ll_create();
2924        cc->extended_ecm_idx = ll_create();
2925    } else {
2926        if (cc->cards) {
2927            while (cs_trylock(&cc->cards_busy)) {
2928                cs_debug_mask(D_TRACE, "%s trylock cc_cli_connect cards waiting", getprefix());
2929                cs_sleepms(fast_rnd());
2930            }
2931                           
2932            cc_free_cardlist(cc->cards, FALSE);
2933            cs_unlock(&cc->cards_busy);
2934        }
2935        if (cc->extended_ecm_idx)
2936            free_extended_ecm_idx(cc);
2937
2938        cs_trylock(&cc->ecm_busy);
2939        cs_unlock(&cc->ecm_busy);
2940    }
2941    if (!cc->prefix)
2942        cc->prefix = cs_malloc(&cc->prefix, strlen(cl->reader->label)+20, QUITERROR);
2943    snprintf(cc->prefix, strlen(cl->reader->label)+20, "cccam(r) %s: ", cl->reader->label);
2944   
2945    if (!cl->udp_fd) {
2946        cc_cli_init_int(cl);
2947        return -1; // cc_cli_init_int calls cc_cli_connect, so exit here!
2948    }
2949       
2950    if (is_connect_blocked(rdr)) {
2951        struct timeb cur_time;
2952        cs_ftime(&cur_time);
2953        int32_t time = 1000*(rdr->tcp_block_connect_till.time-cur_time.time)
2954                +rdr->tcp_block_connect_till.millitm-cur_time.millitm;
2955        cs_log("%s connection blocked, retrying in %ds", rdr->label, time/1000);
2956        return -1;
2957    }
2958   
2959    int32_t handle, n;
2960    uint8_t data[20];
2961    uint8_t hash[SHA_DIGEST_LENGTH];
2962    uint8_t *buf = cc->send_buffer;
2963    char pwd[64];
2964
2965    // check cred config
2966    if (rdr->device[0] == 0 || rdr->r_pwd[0] == 0 || rdr->r_usr[0] == 0
2967            || rdr->r_port == 0) {
2968        cs_log("%s configuration error!", rdr->label);
2969        return -5;
2970    }
2971
2972    // connect
2973    handle = network_tcp_connection_open();
2974    if (handle <= 0) {
2975        cs_log("%s network connect error!", rdr->label);
2976        return -1;
2977    }
2978    if (errno == EISCONN) {
2979        cc_cli_close(cl, FALSE);
2980       
2981        block_connect(rdr);
2982        return -1;
2983    }
2984
2985    // get init seed
2986    if ((n = cc_recv_to(cl, data, 16)) != 16) {
2987        int32_t err = errno;
2988        if (n <= 0)
2989            cs_log("%s server blocked connection!", rdr->label);
2990        else
2991            cs_log("%s server does not return 16 bytes (n=%d, errno=%d %s)",
2992                rdr->label, n, err, strerror(errno));
2993        block_connect(rdr);
2994        return -2;
2995    }
2996
2997
2998    cc->ecm_counter = 0;
2999    cc->max_ecms = 0;
3000    cc->cmd05_mode = MODE_UNKNOWN;
3001    cc->cmd05_offset = 0;
3002    cc->cmd05_active = 0;
3003    cc->cmd05_data_len = 0;
3004    cc->answer_on_keepalive = time(NULL);
3005    cc->extended_mode = 0;
3006    cc->last_emm_card = NULL;
3007    cc->num_hop1 = 0;
3008    cc->num_hop2 = 0;
3009    cc->num_hopx = 0;
3010    cc->num_reshare0 = 0;
3011    cc->num_reshare1 = 0;
3012    cc->num_reshare2 = 0;
3013    cc->num_resharex = 0;   
3014    memset(&cc->cmd05_data, 0, sizeof(cc->cmd05_data));
3015    memset(&cc->receive_buffer, 0, sizeof(cc->receive_buffer));
3016    cc->cmd0c_mode = MODE_CMD_0x0C_NONE;
3017
3018    cs_ddump_mask(D_CLIENT, data, 16, "cccam: server init seed:");
3019
3020    uint16_t sum = 0x1234;
3021    uint16_t recv_sum = (data[14] << 8) | data[15];
3022    int32_t i;
3023    for (i = 0; i < 14; i++) {
3024        sum += data[i];
3025    }
3026    //Create special data to detect oscam-cccam:
3027    cc->is_oscam_cccam = sum == recv_sum;
3028
3029    cc_xor(data); // XOR init bytes with 'CCcam'
3030
3031    SHA_CTX ctx;
3032    SHA1_Init(&ctx);
3033    SHA1_Update(&ctx, data, 16);
3034    SHA1_Final(hash, &ctx);
3035
3036    cs_ddump_mask(D_CLIENT, hash, sizeof(hash), "cccam: sha1 hash:");
3037
3038    //initialisate crypto states
3039    cc_init_crypt(&cc->block[DECRYPT], hash, 20);
3040    cc_crypt(&cc->block[DECRYPT], data, 16, DECRYPT);
3041    cc_init_crypt(&cc->block[ENCRYPT], data, 16);
3042    cc_crypt(&cc->block[ENCRYPT], hash, 20, DECRYPT);
3043
3044    cc_cmd_send(cl, hash, 20, MSG_NO_HEADER); // send crypted hash to server
3045
3046    memset(buf, 0, CC_MAXMSGSIZE);
3047    memcpy(buf, rdr->r_usr, strlen(rdr->r_usr));
3048    cs_ddump_mask(D_CLIENT, buf, 20, "cccam: username '%s':", buf);
3049    cc_cmd_send(cl, buf, 20, MSG_NO_HEADER); // send usr '0' padded -> 20 bytes
3050
3051    memset(buf, 0, CC_MAXMSGSIZE);
3052    memset(pwd, 0, sizeof(pwd));
3053
3054    //cs_debug_mask(D_CLIENT, "cccam: 'CCcam' xor");
3055    memcpy(buf, "CCcam", 5);
3056    strncpy(pwd, rdr->r_pwd, sizeof(pwd) - 1);
3057    cc_crypt(&cc->block[ENCRYPT], (uint8_t *) pwd, strlen(pwd), ENCRYPT);
3058    cc_cmd_send(cl, buf, 6, MSG_NO_HEADER); // send 'CCcam' xor w/ pwd
3059
3060    if ((n = cc_recv_to(cl, data, 20)) != 20) {
3061        cs_log("%s login failed, pwd ack not received (n = %d)", getprefix(), n);
3062        return -2;
3063    }
3064    cc_crypt(&cc->block[DECRYPT], data, 20, DECRYPT);
3065    cs_ddump_mask(D_CLIENT, data, 20, "cccam: pwd ack received:");
3066
3067    if (memcmp(data, buf, 5)) { // check server response
3068        cs_log("%s login failed, usr/pwd invalid", getprefix());
3069        return -2;
3070    } else {
3071        cs_debug_mask(D_READER, "%s login succeeded", getprefix());
3072    }
3073
3074    cs_debug_mask(D_READER, "cccam: last_s=%d, last_g=%d", rdr->last_s, rdr->last_g);
3075
3076    cl->pfd = cl->udp_fd;
3077    cs_debug_mask(D_READER, "cccam: pfd=%d", cl->pfd);
3078
3079    if (cc_send_cli_data(cl) <= 0) {
3080        cs_log("%s login failed, could not send client data", getprefix());
3081        return -3;
3082    }
3083
3084    rdr->caid = rdr->ftab.filts[0].caid;
3085    rdr->nprov = rdr->ftab.filts[0].nprids;
3086    for (n = 0; n < rdr->nprov; n++) {
3087        rdr->availkeys[n][0] = 1;
3088        rdr->prid[n][0] = rdr->ftab.filts[0].prids[n] >> 24;
3089        rdr->prid[n][1] = rdr->ftab.filts[0].prids[n] >> 16;
3090        rdr->prid[n][2] = rdr->ftab.filts[0].prids[n] >> 8;
3091        rdr->prid[n][3] = rdr->ftab.filts[0].prids[n] & 0xff;
3092    }
3093
3094    rdr->card_status = CARD_NEED_INIT;
3095    rdr->last_g = rdr->last_s = time((time_t *) 0);
3096    rdr->tcp_connected = 1;
3097    rdr->available = 1;
3098
3099    cc->just_logged_in = 1;
3100    cc->mode = CCCAM_MODE_NORMAL;
3101    cl->crypted = 1;
3102
3103    return 0;
3104}
3105
3106int32_t cc_cli_init_int(struct s_client *cl) {
3107    struct s_reader *rdr = cl->reader;
3108    if (rdr->tcp_connected)
3109        return 1;
3110
3111    if (cl->pfd) {
3112        close(cl->pfd);
3113        if (cl->pfd == cl->udp_fd)
3114            cl->udp_fd = 0;
3115        cl->pfd = 0;
3116    }
3117
3118    if (cl->udp_fd) {
3119        close(cl->udp_fd);
3120        cl->udp_fd = 0;
3121    }
3122
3123    if (rdr->r_port <= 0) {
3124        cs_log("%s invalid port %d for server %s", rdr->label, rdr->r_port,
3125                rdr->device);
3126        return 1;
3127    }
3128    //      cl->ip = 0;
3129    //      memset((char *) &loc_sa, 0, sizeof(loc_sa));
3130    //      loc_sa.sin_family = AF_INET;
3131    //#ifdef LALL
3132    //      if (cfg.serverip[0])
3133    //      loc_sa.sin_addr.s_addr = inet_addr(cfg.serverip);
3134    //      else
3135    //#endif
3136    //      loc_sa.sin_addr.s_addr = INADDR_ANY;
3137    //      loc_sa.sin_port = htons(rdr->l_port);
3138
3139       
3140    if ((cl->udp_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) <= 0) {
3141        cs_log("%s Socket creation failed (socket=%d, errno=%d %s)", rdr->label,
3142                cl->udp_fd, errno, strerror(errno));
3143        return 1;
3144    }
3145    //cs_log("%s 1 socket created: cs_idx=%d, fd=%d errno=%d", getprefix(), cs_idx, cl->udp_fd, errno);
3146
3147#ifdef SO_PRIORITY
3148    if (cfg.netprio)
3149        setsockopt(cl->udp_fd, SOL_SOCKET, SO_PRIORITY,
3150            (void *)&cfg.netprio, sizeof(uintptr_t));
3151#endif
3152    int32_t keep_alive = 1;
3153    setsockopt(cl->udp_fd, SOL_SOCKET, SO_KEEPALIVE,
3154        (void *)&keep_alive, sizeof(keep_alive));
3155                   
3156    rdr->tcp_ito = 1; //60sec...This now invokes ph_idle()
3157    if (rdr->cc_maxhop < 0)
3158        rdr->cc_maxhop = 10;
3159
3160    memset((char *) &cl->udp_sa, 0, sizeof(cl->udp_sa));
3161    cl->udp_sa.sin_family = AF_INET;
3162    cl->udp_sa.sin_port = htons((uint16_t) rdr->r_port);
3163
3164    if (rdr->tcp_rto <= 2)
3165        rdr->tcp_rto = 2; // timeout to 120s
3166    cs_debug_mask(D_READER, "cccam: timeout set to: %d", rdr->tcp_rto);
3167    cc_check_version(rdr->cc_version, rdr->cc_build);
3168    cs_debug_mask(D_READER, "proxy reader: %s (%s:%d) cccam v%s build %s, maxhop: %d",
3169        rdr->label, rdr->device, rdr->r_port, rdr->cc_version,
3170        rdr->cc_build, rdr->cc_maxhop);
3171
3172    return 0;
3173}
3174
3175int32_t cc_cli_init(struct s_client *cl) {
3176    struct cc_data *cc = cl->cc;
3177    struct s_reader *reader = cl->reader;
3178   
3179    if ((cc && cc->mode == CCCAM_MODE_SHUTDOWN))
3180        return -1;
3181       
3182    int32_t res = cc_cli_init_int(cl); //Create socket
3183   
3184    if (res == 0 && reader && (reader->cc_keepalive || !cl->cc) && !reader->tcp_connected) {
3185       
3186        cc_cli_connect(cl); //connect to remote server
3187       
3188//      while (!reader->tcp_connected && reader->cc_keepalive && cfg.reader_restart_seconds > 0) {
3189//
3190//          if ((cc && cc->mode == CCCAM_MODE_SHUTDOWN))
3191//              return -1;
3192//             
3193//          if (!reader->tcp_connected) {
3194//              cc_cli_close(cl, FALSE);
3195//              res = cc_cli_init_int(cl);
3196//              if (res)
3197//                  return res;
3198//          }
3199//          cs_debug_mask(D_READER, "%s restarting reader in %d seconds", reader->label, cfg.reader_restart_seconds);
3200//          cs_sleepms(cfg.reader_restart_seconds*1000);
3201//          cs_debug_mask(D_READER, "%s restarting reader...", reader->label);
3202//          cc_cli_connect(cl);
3203//      }
3204    }
3205    return res;
3206}
3207
3208/**
3209 * return 1 if we are able to send requests:
3210 *
3211 */
3212int32_t cc_available(struct s_reader *rdr, int32_t checktype) {
3213    if (!rdr || !rdr->client) return 0;
3214   
3215    struct s_client *cl = rdr->client;
3216    if(!cl) return 0;
3217    //cs_debug_mask(D_TRACE, "checking reader %s availibility", rdr->label);
3218    if (!cl->cc || rdr->tcp_connected != 2 || rdr->card_status != CARD_INSERTED) {
3219        //Two cases:
3220        // 1. Keepalive ON but not connected: Do NOT send requests,
3221        //     because we can't connect - problem of full running pipes
3222        // 2. Keepalive OFF but not connected: Send requests to connect
3223        //     pipe won't run full, because we are reading from pipe to
3224        //     get the ecm request
3225        if (rdr->cc_keepalive)
3226            return 0;
3227    }
3228
3229    if (checktype == AVAIL_CHECK_LOADBALANCE && !rdr->available) {
3230        cs_debug_mask(D_TRACE, "checking reader %s availibility=0 (unavail)",
3231                rdr->label);
3232        return 0; //We are processing EMMs/ECMs
3233    }
3234
3235    return 1;
3236}
3237
3238/**
3239 *
3240 *
3241 **/
3242void cc_card_info() {
3243    struct s_client *cl = cur_client();
3244    struct s_reader *rdr = cl->reader;
3245
3246    if (rdr && !rdr->tcp_connected)
3247        cc_cli_connect(cl);
3248}
3249
3250void cc_cleanup(struct s_client *cl) {
3251    struct cc_data *cc = cl->cc;
3252    if (cc) cc->mode = CCCAM_MODE_SHUTDOWN;
3253   
3254    if (cl->typ != 'c') {
3255        cc_cli_close(cl, FALSE); // we need to close open fd's
3256    }
3257    cc_free(cl);
3258}
3259
3260void cc_update_nodeid()
3261{
3262    //Partner Detection:
3263    init_rnd();
3264    uint16_t sum = 0x1234; //This is our checksum
3265    int32_t i;
3266    for (i = 0; i < 4; i++) {
3267        cc_node_id[i] = fast_rnd();
3268        sum += cc_node_id[i];
3269    }
3270   
3271    // Partner ID:
3272    cc_node_id[4] = 0x10; // (Oscam 0x10, vPlugServer 0x11, Hadu 0x12,...)
3273    sum += cc_node_id[4];
3274                   
3275    // generate checksum for Partner ID:
3276    cc_node_id[5] = 0xAA;
3277    for (i = 0; i < 5; i++) {
3278      cc_node_id[5] ^= cc_node_id[i];
3279    }
3280    sum += cc_node_id[5];       
3281   
3282    cc_node_id[6] = sum >> 8;
3283    cc_node_id[7] = sum & 0xff;
3284   
3285    int valid = 0;
3286    if (cfg.cc_use_fixed_nodeid) {
3287        for (i=0;i<8;i++)
3288            if (cfg.cc_fixed_nodeid[i])
3289                valid = 1;
3290    }
3291    if (valid)
3292        memcpy(cc_node_id, cfg.cc_fixed_nodeid, 8);
3293    else
3294        memcpy(cfg.cc_fixed_nodeid, cc_node_id, 8);
3295}
3296
3297void module_cccam(struct s_module *ph) {
3298    cs_strncpy(ph->desc, "cccam", sizeof(ph->desc));
3299    ph->type = MOD_CONN_TCP;
3300    ph->logtxt = ", crypted";
3301    ph->watchdog = 1;
3302    ph->recv = cc_recv;
3303    ph->cleanup = cc_cleanup;
3304    ph->multi = 1;
3305    ph->c_multi = 1;
3306    ph->c_init = cc_cli_init;
3307    ph->c_idle = cc_idle;
3308    ph->c_recv_chk = cc_recv_chk;
3309    ph->c_send_ecm = cc_send_ecm;
3310    ph->c_send_emm = cc_send_emm;
3311    ph->s_ip = cfg.cc_srvip;
3312    ph->s_handler = cc_srv_init;
3313    ph->send_dcw = cc_send_dcw;
3314    ph->c_available = cc_available;
3315    ph->c_card_info = cc_card_info;
3316    static PTAB ptab; //since there is always only 1 cccam server running, this is threadsafe
3317    memset(&ptab, 0, sizeof(PTAB));
3318    int32_t i;
3319    for (i=0;i<CS_MAXPORTS;i++) {
3320        if (!cfg.cc_port[i]) break;
3321        ptab.ports[i].s_port = cfg.cc_port[i];
3322        ptab.nports++;
3323    }
3324           
3325    ph->ptab = &ptab;
3326    ph->num = R_CCCAM;
3327
3328    cc_update_nodeid();
3329   
3330    if (cfg.cc_port)
3331            init_share();       
3332}
3333#endif
Note: See TracBrowser for help on using the repository browser.