Changeset 3133
- Timestamp:
- 09/21/10 16:39:13 (14 years ago)
- Location:
- trunk
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/module-cccam.c
r3126 r3133 10 10 extern struct s_reader *reader; 11 11 12 uint8 g_flag = 0;13 int cc_use_rc4 = 0;14 15 12 //Mode names for CMD_05 command: 16 13 char *cmd05_mode_name[] = { "UNKNOWN", "PLAIN", "AES", "CC_CRYPT", "RC4", … … 26 23 } 27 24 28 char * prefix = NULL;29 30 25 char *getprefix() { 31 if (prefix) 32 return prefix; 33 34 prefix = malloc(100); 26 struct s_client *cl = &client[cs_idx]; 27 struct cc_data *cc = cl->cc; 28 if (!cc) 29 return ""; 30 31 if (cc->prefix) 32 return cc->prefix; 33 34 cc->prefix = malloc(100); 35 35 if (is_server) 36 sprintf( prefix, "cccam(s) %s: ", client[cs_idx].usr);36 sprintf(cc->prefix, "cccam(s) %s: ", cl->usr); 37 37 else 38 sprintf( prefix, "cccam(r) %s: ", reader[ridx].label);39 while (strlen( prefix) < 22)40 strcat( prefix, " ");41 return prefix;38 sprintf(cc->prefix, "cccam(r) %s: ", reader[ridx].label); 39 while (strlen(cc->prefix) < 22) 40 strcat(cc->prefix, " "); 41 return cc->prefix; 42 42 } 43 43 … … 73 73 74 74 int is_au() { 75 int au = client[cs_idx].au; 75 struct s_client *cl = &client[cs_idx]; 76 int au = cl->au; 76 77 if ((au < 0) || (au > CS_MAXREADER)) 77 78 return 0; … … 81 82 void cc_crypt(struct cc_crypt_block *block, uint8 *data, int len, 82 83 cc_crypt_mode_t mode) { 84 struct s_client *cl = &client[cs_idx]; 85 struct cc_data *cc = cl->cc; 83 86 int i; 84 87 uint8 z; … … 91 94 data[i] = z ^ block->keytable[(block->keytable[block->counter] 92 95 + block->keytable[block->sum]) & 0xff]; 93 if (!cc _use_rc4)96 if (!cc->cc_use_rc4) 94 97 data[i] ^= block->state; 95 98 if (!mode) … … 130 133 131 134 void cc_cw_crypt(uint8 *cws, uint32 cardid) { 132 struct cc_data *cc = client[cs_idx].cc; 135 struct s_client *cl = &client[cs_idx]; 136 struct cc_data *cc = cl->cc; 133 137 uint64 node_id; 134 138 uint8 tmp; … … 341 345 */ 342 346 void cc_cli_close() { 343 reader[ridx].tcp_connected = 0; 344 reader[ridx].card_status = NO_CARD; 345 reader[ridx].available = 0; 346 reader[ridx].card_system = 0; 347 reader[ridx].ncd_msgid = 0; 348 reader[ridx].last_s = reader->last_g = 0; 347 struct s_client *cl = &client[cs_idx]; 348 struct s_reader *rdr = &reader[ridx]; 349 rdr->tcp_connected = 0; 350 rdr->card_status = NO_CARD; 351 rdr->available = 0; 352 rdr->card_system = 0; 353 rdr->ncd_msgid = 0; 354 rdr->last_s = reader->last_g = 0; 349 355 350 356 //cs_sleepms(100); … … 352 358 close(pfd); 353 359 pfd = 0; 354 cl ient[cs_idx].udp_fd = 0;355 } else if (cl ient[cs_idx].udp_fd) {356 close(cl ient[cs_idx].udp_fd);357 cl ient[cs_idx].udp_fd = 0;360 cl->udp_fd = 0; 361 } else if (cl->udp_fd) { 362 close(cl->udp_fd); 363 cl->udp_fd = 0; 358 364 pfd = 0; 359 365 } 360 366 //cs_sleepms(100); 361 struct cc_data *cc = cl ient[cs_idx].cc;367 struct cc_data *cc = cl->cc; 362 368 if (cc) { 363 369 pthread_mutex_unlock(&cc->lock); … … 371 377 struct cc_extended_ecm_idx *add_extended_ecm_idx(uint8 send_idx, 372 378 ushort ecm_idx, struct cc_card *card, struct cc_srvid srvid) { 373 struct cc_data *cc = client[cs_idx].cc; 379 struct s_client *cl = &client[cs_idx]; 380 struct cc_data *cc = cl->cc; 374 381 struct cc_extended_ecm_idx *eei = 375 382 malloc(sizeof(struct cc_extended_ecm_idx)); … … 385 392 struct cc_extended_ecm_idx *get_extended_ecm_idx(uint8 send_idx, 386 393 int remove) { 387 struct cc_data *cc = client[cs_idx].cc; 394 struct s_client *cl = &client[cs_idx]; 395 struct cc_data *cc = cl->cc; 388 396 struct cc_extended_ecm_idx *eei; 389 397 LLIST_ITR itr; … … 406 414 struct cc_extended_ecm_idx *get_extended_ecm_idx_by_idx(ushort ecm_idx, 407 415 int remove) { 408 struct cc_data *cc = client[cs_idx].cc; 416 struct s_client *cl = &client[cs_idx]; 417 struct cc_data *cc = cl->cc; 409 418 struct cc_extended_ecm_idx *eei; 410 419 LLIST_ITR itr; … … 426 435 427 436 void free_extended_ecm_idx_by_card(struct cc_card *card) { 428 struct cc_data *cc = client[cs_idx].cc; 437 struct s_client *cl = &client[cs_idx]; 438 struct cc_data *cc = cl->cc; 429 439 struct cc_extended_ecm_idx *eei; 430 440 LLIST_ITR itr; … … 463 473 */ 464 474 int cc_msg_recv(uint8 *buf) { 475 struct s_client *cl = &client[cs_idx]; 476 struct s_reader *rdr = &reader[ridx]; 477 465 478 int len; 466 479 uint8 netbuf[CC_MAXMSGSIZE + 4]; 467 struct cc_data *cc = cl ient[cs_idx].cc;468 469 int handle = cl ient[cs_idx].udp_fd;480 struct cc_data *cc = cl->cc; 481 482 int handle = cl->udp_fd; 470 483 471 484 if (handle < 0) … … 474 487 len = recv(handle, netbuf, 4, MSG_WAITALL); 475 488 if (!is_server) 476 r eader[ridx].last_g = time(NULL);489 rdr->last_g = time(NULL); 477 490 478 491 if (!len) … … 488 501 cs_ddump(netbuf, 4, "cccam: decrypted header:"); 489 502 490 g_flag = netbuf[0];503 cc->g_flag = netbuf[0]; 491 504 492 505 int size = (netbuf[2] << 8) | netbuf[3]; … … 499 512 len = recv(handle, netbuf + 4, size, MSG_WAITALL); // read rest of msg 500 513 if (!is_server) 501 r eader[ridx].last_g = time(NULL);514 rdr->last_g = time(NULL); 502 515 503 516 if (len != size) { … … 522 535 */ 523 536 int cc_cmd_send(uint8 *buf, int len, cc_msg_type_t cmd) { 537 struct s_client *cl = &client[cs_idx]; 538 struct s_reader *rdr = &reader[ridx]; 539 524 540 int n; 525 541 uint8 netbuf[len + 4]; 526 struct cc_data *cc = cl ient[cs_idx].cc;542 struct cc_data *cc = cl->cc; 527 543 528 544 memset(netbuf, 0, len + 4); … … 532 548 } else { 533 549 // build command message 534 netbuf[0] = g_flag; // flags??550 netbuf[0] = cc->g_flag; // flags?? 535 551 netbuf[1] = cmd & 0xff; 536 552 netbuf[2] = len >> 8; … … 544 560 cc_crypt(&cc->block[ENCRYPT], netbuf, len, ENCRYPT); 545 561 546 n = send(cl ient[cs_idx].udp_fd, netbuf, len, 0);562 n = send(cl->udp_fd, netbuf, len, 0); 547 563 if (!is_server) 548 r eader[ridx].last_s = time(NULL);564 rdr->last_s = time(NULL); 549 565 550 566 if (n != len) { … … 589 605 */ 590 606 int cc_send_cli_data() { 607 struct s_client *cl = &client[cs_idx]; 608 struct s_reader *rdr = &reader[ridx]; 609 591 610 int i; 592 struct cc_data *cc = cl ient[cs_idx].cc;611 struct cc_data *cc = cl->cc; 593 612 594 613 cs_debug("cccam: send client data"); … … 601 620 memset(buf, 0, CC_MAXMSGSIZE); 602 621 603 memcpy(buf, r eader[ridx].r_usr, sizeof(reader[ridx].r_usr));622 memcpy(buf, rdr->r_usr, sizeof(rdr->r_usr)); 604 623 memcpy(buf + 20, cc->node_id, 8); 605 buf[28] = r eader[ridx].cc_want_emu; // <-- Client want to have EMUs, 0 - NO; 1 - YES606 memcpy(buf + 29, r eader[ridx].cc_version, sizeof(reader[ridx].cc_version)); // cccam version (ascii)607 memcpy(buf + 61, r eader[ridx].cc_build, sizeof(reader[ridx].cc_build)); // build number (ascii)624 buf[28] = rdr->cc_want_emu; // <-- Client want to have EMUs, 0 - NO; 1 - YES 625 memcpy(buf + 29, rdr->cc_version, sizeof(rdr->cc_version)); // cccam version (ascii) 626 memcpy(buf + 61, rdr->cc_build, sizeof(rdr->cc_build)); // build number (ascii) 608 627 609 628 cs_log("%s sending own version: %s, build: %s", getprefix(), 610 r eader[ridx].cc_version, reader[ridx].cc_build);629 rdr->cc_version, rdr->cc_build); 611 630 612 631 i = cc_cmd_send(buf, 20 + 8 + 6 + 26 + 4 + 28 + 1, MSG_CLI_DATA); … … 620 639 */ 621 640 int cc_send_srv_data() { 641 struct s_client *cl = &client[cs_idx]; 642 struct s_reader *rdr = &reader[ridx]; 622 643 int i; 623 struct cc_data *cc = cl ient[cs_idx].cc;644 struct cc_data *cc = cl->cc; 624 645 625 646 cs_debug("cccam: send server data"); … … 633 654 634 655 memcpy(buf, cc->node_id, 8); 635 cc_check_version((char *) cfg->cc_version, r eader[ridx].cc_build);636 memcpy(buf + 8, cfg->cc_version, sizeof(r eader[ridx].cc_version)); // cccam version (ascii)637 memcpy(buf + 40, r eader[ridx].cc_build, sizeof(reader[ridx].cc_build)); // build number (ascii)656 cc_check_version((char *) cfg->cc_version, rdr->cc_build); 657 memcpy(buf + 8, cfg->cc_version, sizeof(rdr->cc_version)); // cccam version (ascii) 658 memcpy(buf + 40, rdr->cc_build, sizeof(rdr->cc_build)); // build number (ascii) 638 659 639 660 cs_log("%s version: %s, build: %s nodeid: %s", getprefix(), 640 cfg->cc_version, r eader[ridx].cc_build, cs_hexdump(0,661 cfg->cc_version, rdr->cc_build, cs_hexdump(0, 641 662 cc->peer_node_id, 8)); 642 663 … … 675 696 */ 676 697 int send_cmd05_answer() { 677 struct cc_data *cc = client[cs_idx].cc; 678 if (!cc->cmd05_active || !reader[ridx].available) //exit if not in cmd05 or waiting for ECM answer 698 struct s_client *cl = &client[cs_idx]; 699 struct s_reader *rdr = &reader[ridx]; 700 struct cc_data *cc = cl->cc; 701 if (!cc->cmd05_active || !rdr->available) //exit if not in cmd05 or waiting for ECM answer 679 702 return 0; 680 703 … … 824 847 */ 825 848 int cc_send_ecm(ECM_REQUEST *er, uchar *buf) { 826 849 struct s_client *cl = &client[cs_idx]; 850 struct s_reader *rdr = &reader[ridx]; 851 827 852 //cs_debug_mask(D_TRACE, "%s cc_send_ecm", getprefix()); 828 853 cc_cli_init_int(); 829 854 830 855 int n, h = -1; 831 struct cc_data *cc = cl ient[cs_idx].cc;856 struct cc_data *cc = cl->cc; 832 857 struct cc_card *card; 833 858 struct cc_current_card *current_card; … … 837 862 cs_ftime(&cur_time); 838 863 839 if (!cc || (pfd < 1) || !r eader[ridx].tcp_connected) {864 if (!cc || (pfd < 1) || !rdr->tcp_connected) { 840 865 if (er) { 841 866 //er->rc = 0; … … 843 868 cs_debug_mask(D_TRACE, "%s server not init! ccinit=%d pfd=%d", 844 869 getprefix(), cc ? 1 : 0, pfd); 845 //write_ecm_answer( &reader[ridx], fd_c2m, er);870 //write_ecm_answer(rdr, fd_c2m, er); 846 871 } 847 872 cc_cli_close(); … … 849 874 } 850 875 851 if (r eader[ridx].tcp_connected != 2) {876 if (rdr->tcp_connected != 2) { 852 877 cs_debug_mask(D_TRACE, "%s Waiting for CARDS", getprefix()); 853 878 return 0; … … 856 881 //No Card? Waiting for shares 857 882 if (!llist_count(cc->cards)) { 858 r eader[ridx].fd_error++;883 rdr->fd_error++; 859 884 cs_debug_mask(D_TRACE, "%s NO CARDS!", getprefix()); 860 885 return 0; … … 892 917 } 893 918 cc->ecm_time = cur_time; 894 r eader[ridx].available = cc->extended_mode;919 rdr->available = cc->extended_mode; 895 920 896 921 //Search next ECM to send: 897 922 if ((n = cc_get_nxt_ecm()) < 0) { 898 923 if (!cc->extended_mode) { 899 r eader[ridx].available = 1;924 rdr->available = 1; 900 925 pthread_mutex_unlock(&cc->ecm_busy); 901 926 } … … 935 960 if (!card) { 936 961 //check if auto blocked: 937 if (!r eader[ridx].cc_disable_auto_block && cc_is_auto_blocked(962 if (!rdr->cc_disable_auto_block && cc_is_auto_blocked( 938 963 cc->auto_blocked, cur_er->caid, cur_er->prid, &cur_srvid, 60 939 964 * 60 * 1)) { //TODO: Timeout 60*60*1 = 1h, Config? … … 1000 1025 if (cc->server_ecm_idx >= 256) 1001 1026 cc->server_ecm_idx = 1; 1002 g_flag = cc->server_ecm_idx; //Flag is used as index!1003 send_idx = g_flag;1027 cc->g_flag = cc->server_ecm_idx; //Flag is used as index! 1028 send_idx = cc->g_flag; 1004 1029 } 1005 1030 1006 1031 add_extended_ecm_idx(send_idx, cur_er->idx, card, cur_srvid); 1007 1032 1008 r eader[ridx].cc_currenthops = card->hop;1033 rdr->cc_currenthops = card->hop; 1009 1034 1010 1035 cs_log( … … 1015 1040 1016 1041 //For EMM 1017 if (!r eader[ridx].audisabled) {1018 r eader[ridx].card_system = get_cardsystem(card->caid);1019 cc_UA_cccam2oscam(card->hexserial, r eader[ridx].hexserial);1020 1021 r eader[ridx].nprov = 0;1042 if (!rdr->audisabled) { 1043 rdr->card_system = get_cardsystem(card->caid); 1044 cc_UA_cccam2oscam(card->hexserial, rdr->hexserial); 1045 1046 rdr->nprov = 0; 1022 1047 LLIST_ITR pitr; 1023 1048 struct cc_provider *provider = llist_itr_init(card->providers, … … 1025 1050 while (provider) { 1026 1051 if (provider->prov == cur_er->prid) { 1027 memcpy(&r eader[ridx].prid[0], &provider->prov,1052 memcpy(&rdr->prid[0], &provider->prov, 1028 1053 sizeof(provider->prov)); 1029 memcpy(&r eader[ridx].sa[0], provider->sa,1054 memcpy(&rdr->sa[0], provider->sa, 1030 1055 sizeof(provider->sa)); 1031 r eader[ridx].nprov = 1;1056 rdr->nprov = 1; 1032 1057 break; 1033 1058 } … … 1041 1066 cs_debug_mask(D_EMM, 1042 1067 "%s au info: caid %04X card system: %d UA: %s SA: %s", 1043 getprefix(), card->caid, r eader[ridx].card_system,1044 cs_hexdump(0, r eader[ridx].hexserial, 8), saprov);1068 getprefix(), card->caid, rdr->card_system, 1069 cs_hexdump(0, rdr->hexserial, 8), saprov); 1045 1070 } 1046 1071 … … 1060 1085 cur_er->rc = 0; 1061 1086 cur_er->rcEx = 0x27; 1062 write_ecm_answer( &reader[ridx], fd_c2m, cur_er);1087 write_ecm_answer(rdr, fd_c2m, cur_er); 1063 1088 //cur_er->rc = 1; 1064 1089 //cur_er->rcEx = 0; 1065 1090 //cs_sleepms(300); 1066 r eader[ridx].last_s = reader[ridx].last_g;1091 rdr->last_s = rdr->last_g; 1067 1092 1068 1093 card = llist_itr_init(cc->cards, &itr); … … 1083 1108 } 1084 1109 1085 if (!r eader[ridx].cc_disable_auto_block) {1110 if (!rdr->cc_disable_auto_block) { 1086 1111 cc_add_auto_blocked(cc->auto_blocked, cur_er->caid, 1087 1112 cur_er->prid, &cur_srvid); … … 1089 1114 } 1090 1115 if (!cc->extended_mode) { 1091 r eader[ridx].available = 1;1116 rdr->available = 1; 1092 1117 pthread_mutex_unlock(&cc->ecm_busy); 1093 1118 } … … 1101 1126 int n, i; 1102 1127 time_t t;//, tls; 1103 struct cc_data *cc = r eader[ridx].cc;1128 struct cc_data *cc = rdr->cc; 1104 1129 1105 1130 t=time((time_t *)0); … … 1116 1141 ecmtask[i].rc=0; 1117 1142 ecmtask[i].rcEx=7; 1118 write_ecm_answer( &reader[ridx], fd_c2m, &ecmtask[i]);1143 write_ecm_answer(rdr, fd_c2m, &ecmtask[i]); 1119 1144 } 1120 1145 } … … 1125 1150 1126 1151 int cc_send_pending_emms() { 1127 struct cc_data *cc = client[cs_idx].cc; 1152 struct s_client *cl = &client[cs_idx]; 1153 struct s_reader *rdr = &reader[ridx]; 1154 struct cc_data *cc = cl->cc; 1128 1155 1129 1156 LLIST_ITR itr; … … 1134 1161 return 0; //send later with cc_send_ecm 1135 1162 } 1136 r eader[ridx].available = 0;1163 rdr->available = 0; 1137 1164 } 1138 1165 int size = emmbuf[11] + 12; … … 1157 1184 * */ 1158 1185 struct cc_card *get_card_by_hexserial(uint8 *hexserial, uint16 caid) { 1159 struct cc_data *cc = client[cs_idx].cc; 1186 struct s_client *cl = &client[cs_idx]; 1187 struct cc_data *cc = cl->cc; 1160 1188 LLIST_ITR itr; 1161 1189 struct cc_card *card = llist_itr_init(cc->cards, &itr); … … 1175 1203 * */ 1176 1204 int cc_send_emm(EMM_PACKET *ep) { 1205 struct s_client *cl = &client[cs_idx]; 1206 struct s_reader *rdr = &reader[ridx]; 1207 1177 1208 cc_cli_init_int(); 1178 1209 1179 struct cc_data *cc = cl ient[cs_idx].cc;1180 1181 if (!cc || (pfd < 1) || !r eader[ridx].tcp_connected) {1210 struct cc_data *cc = cl->cc; 1211 1212 if (!cc || (pfd < 1) || !rdr->tcp_connected) { 1182 1213 cs_log("%s server not init! ccinit=%d pfd=%d", getprefix(), cc ? 1 : 0, 1183 1214 pfd); 1184 1215 return 0; 1185 1216 } 1186 if (r eader[ridx].audisabled) {1217 if (rdr->audisabled) { 1187 1218 cs_log("%s au is disabled", getprefix()); 1188 1219 return 0; … … 1266 1297 */ 1267 1298 void cc_add_reported_carddata(LLIST *reported_carddatas, uint8 *buf, 1268 int len, int ridx) {1299 int len, struct s_reader *rdr) { 1269 1300 struct cc_reported_carddata *carddata = malloc( 1270 1301 sizeof(struct cc_reported_carddata)); … … 1279 1310 "%s:%s reported card %d CAID %04X UA: %02X%02X%02X%02X%02X%02X%02X%02X", 1280 1311 getprefix(), 1281 r eader[ridx].label, //label1312 rdr->label, //label 1282 1313 b2i(4, buf), //card-id 1283 1314 b2i(2, buf + 8), //CAID … … 1355 1386 pthread_mutex_destroy(&cc->lock); 1356 1387 pthread_mutex_destroy(&cc->ecm_busy); 1388 free(cc->prefix); 1357 1389 free(cc); 1358 1390 } … … 1390 1422 1391 1423 int check_extended_mode(char *msg) { 1424 struct s_client *cl = &client[cs_idx]; 1392 1425 //Extended mode: if PARTNER String is ending with [EXT], extended mode is activated 1393 1426 //For future compatibilty the syntax should be compatible with … … 1397 1430 // ECMs are numbered, Flag (byte[0] is the index 1398 1431 1399 struct cc_data *cc = cl ient[cs_idx].cc;1432 struct cc_data *cc = cl->cc; 1400 1433 int has_param = 0; 1401 1434 char *p = strtok(msg, "["); … … 1404 1437 if (p && strncmp(p, "EXT", 3) == 0) { 1405 1438 cc->extended_mode = 1; 1406 cl ient[cs_idx].cc_extended_ecm_mode = 1;1439 cl->cc_extended_ecm_mode = 1; 1407 1440 cs_log("%s extended ECM mode", getprefix()); 1408 1441 has_param = 1; … … 1413 1446 1414 1447 void cc_idle() { 1415 struct cc_data *cc = client[cs_idx].cc; 1416 if (!reader[ridx].tcp_connected) 1448 struct s_client *cl = &client[cs_idx]; 1449 struct s_reader *rdr = &reader[ridx]; 1450 struct cc_data *cc = cl->cc; 1451 if (!rdr->tcp_connected) 1417 1452 return; 1418 1453 1419 if (!r eader[ridx].cc_keepalive) {1420 network_tcp_connection_close( &reader[ridx], client[cs_idx].udp_fd);1454 if (!rdr->cc_keepalive) { 1455 network_tcp_connection_close(rdr, cl->udp_fd); 1421 1456 } else if (cc->answer_on_keepalive + 55 < time(NULL)) { 1422 1457 cc_cmd_send(NULL, 0, MSG_KEEPALIVE); … … 1426 1461 } 1427 1462 1463 /** 1464 * write card-send-request request via pipe to the reader. 1465 * reader then sends the cards by fifo-pipe 1466 * 1467 * THREADED: This function should be removed if using threaded 1468 **/ 1428 1469 int cc_request_server_cards(int ridx, int dest_cs_idx) { 1429 1470 char fname[40]; … … 1437 1478 } 1438 1479 1480 /** 1481 * closes fifo-pipe 1482 * 1483 * THREADED: This function should be removed if using threaded 1484 **/ 1439 1485 void cc_close_request_server_cards(int pipe, int dest_cs_idx) { 1440 1486 close(pipe); … … 1527 1573 1528 1574 void cc_card_removed(uint32 shareid) { 1529 struct cc_data *cc = client[cs_idx].cc; 1575 struct s_client *cl = &client[cs_idx]; 1576 struct cc_data *cc = cl->cc; 1530 1577 struct cc_card *card; 1531 1578 LLIST_ITR itr; … … 1554 1601 1555 1602 int cc_parse_msg(uint8 *buf, int l) { 1603 struct s_client *cl = &client[cs_idx]; 1604 struct s_reader *rdr = &reader[ridx]; 1605 1556 1606 int ret = buf[1]; 1557 struct cc_data *cc = cl ient[cs_idx].cc;1607 struct cc_data *cc = cl->cc; 1558 1608 1559 1609 cs_debug("%s parse_msg=%d", getprefix(), buf[1]); … … 1619 1669 // 1620 1670 } else if (l == 0x2c) { 1621 memcpy(cc->cmd05_aeskey, data + strlen(r eader[ridx].r_pwd), 16);1671 memcpy(cc->cmd05_aeskey, data + strlen(rdr->r_pwd), 16); 1622 1672 cc->cmd05_mode = MODE_AES; 1623 1673 // … … 1625 1675 // 1626 1676 } else if (l == 0x2d) { 1627 memcpy(cc->cmd05_aeskey, data + strlen(r eader[ridx].r_usr), 16);1677 memcpy(cc->cmd05_aeskey, data + strlen(rdr->r_usr), 16); 1628 1678 cc->cmd05_mode = MODE_AES; 1629 1679 // … … 1641 1691 break; 1642 1692 case MSG_NEW_CARD: { 1643 if (buf[14] >= r eader[ridx].cc_maxhop)1693 if (buf[14] >= rdr->cc_maxhop) 1644 1694 break; 1645 1695 1646 if (!chk_ctab(b2i(2, buf + 12), &r eader[ridx].ctab))1696 if (!chk_ctab(b2i(2, buf + 12), &rdr->ctab)) 1647 1697 break; 1648 1698 1649 r eader[ridx].tcp_connected = 2; //we have card1650 r eader[ridx].card_status = CARD_INSERTED;1699 rdr->tcp_connected = 2; //we have card 1700 rdr->card_status = CARD_INSERTED; 1651 1701 1652 1702 struct cc_card *card = read_card(buf + 4); … … 1724 1774 1725 1775 struct cc_extended_ecm_idx *eei = get_extended_ecm_idx( 1726 cc->extended_mode ? g_flag : 1, TRUE);1776 cc->extended_mode ? cc->g_flag : 1, TRUE); 1727 1777 if (eei == NULL) { 1728 1778 cs_log("%s received extended ecm NOK id %d but not found!", 1729 getprefix(), g_flag);1779 getprefix(), cc->g_flag); 1730 1780 //cc_cycle_connection(); 1731 1781 cc_cli_close(); … … 1746 1796 remove_good_sid(card, &srvid); 1747 1797 1748 if (!r eader[ridx].cc_disable_retry_ecm) {1798 if (!rdr->cc_disable_retry_ecm) { 1749 1799 //retry ecm: 1750 1800 int i = 0; … … 1758 1808 1759 1809 if (!cc->extended_mode) { 1760 r eader[ridx].available = 1;1810 rdr->available = 1; 1761 1811 pthread_mutex_unlock(&cc->ecm_busy); 1762 1812 } … … 1795 1845 srvid.sid = er->srvid; 1796 1846 srvid.ecmlen = er->l; 1797 add_extended_ecm_idx(cc->extended_mode ? g_flag : 1, er->idx,1847 add_extended_ecm_idx(cc->extended_mode ? cc->g_flag : 1, er->idx, 1798 1848 server_card, srvid); 1799 1849 … … 1807 1857 } else { //READER: 1808 1858 struct cc_extended_ecm_idx *eei = get_extended_ecm_idx( 1809 cc->extended_mode ? g_flag : 1, TRUE);1859 cc->extended_mode ? cc->g_flag : 1, TRUE); 1810 1860 if (eei == NULL) { 1811 1861 cs_log("%s received extended ecm id %d but not found!", 1812 getprefix(), g_flag);1862 getprefix(), cc->g_flag); 1813 1863 //cc_cycle_connection(); 1814 1864 cc_cli_close(); … … 1853 1903 1854 1904 if (!cc->extended_mode) { 1855 r eader[ridx].available = 1;1905 rdr->available = 1; 1856 1906 pthread_mutex_unlock(&cc->ecm_busy); 1857 1907 } … … 1889 1939 cc->cmd05_data_len = l; 1890 1940 memcpy(&cc->cmd05_data, buf + 4, l); 1891 if (r eader[ridx].available)1941 if (rdr->available) 1892 1942 send_cmd05_answer(); 1893 1943 } … … 1958 2008 cs_debug_mask(D_EMM, "%s EMM ACK!", getprefix()); 1959 2009 if (!cc->extended_mode) { 1960 r eader[ridx].available = 1;2010 rdr->available = 1; 1961 2011 pthread_mutex_unlock(&cc->ecm_busy); 1962 2012 } … … 1986 2036 */ 1987 2037 int cc_recv_chk(uchar *dcw, int *rc, uchar *buf) { 1988 struct cc_data *cc = client[cs_idx].cc; 2038 struct s_client *cl = &client[cs_idx]; 2039 struct cc_data *cc = cl->cc; 1989 2040 1990 2041 if (buf[1] == MSG_CW_ECM) { … … 2025 2076 */ 2026 2077 void cc_send_dcw(ECM_REQUEST *er) { 2078 struct s_client *cl = &client[cs_idx]; 2027 2079 uchar buf[16]; 2028 struct cc_data *cc = cl ient[cs_idx].cc;2080 struct cc_data *cc = cl->cc; 2029 2081 2030 2082 memset(buf, 0, sizeof(buf)); … … 2034 2086 2035 2087 if (er->rc <= 3 && eei && eei->card) { 2036 g_flag = eei->send_idx;2088 cc->g_flag = eei->send_idx; 2037 2089 memcpy(buf, er->cw, sizeof(buf)); 2038 2090 cs_debug_mask(D_TRACE, "%s send cw: %s cpti: %d", getprefix(), … … 2049 2101 2050 2102 if (eei) 2051 g_flag = eei->send_idx;2103 cc->g_flag = eei->send_idx; 2052 2104 2053 2105 int nok; … … 2063 2115 2064 2116 int cc_recv(uchar *buf, int l) { 2117 struct s_client *cl = &client[cs_idx]; 2065 2118 int n; 2066 2119 uchar *cbuf; 2067 struct cc_data *cc = cl ient[cs_idx].cc;2120 struct cc_data *cc = cl->cc; 2068 2121 2069 2122 if (buf == NULL || l <= 0) … … 2077 2130 2078 2131 cs_ddump(cbuf, n, "cccam: received %d bytes from %s", n, remote_txt()); 2079 cl ient[cs_idx].last = time((time_t *) 0);2132 cl->last = time((time_t *) 0); 2080 2133 2081 2134 if (n <= 0) { … … 2104 2157 2105 2158 int cc_cli_connect() { 2159 struct s_client *cl = &client[cs_idx]; 2160 struct s_reader *rdr = &reader[ridx]; 2161 2106 2162 int handle, n; 2107 2163 uint8 data[20]; … … 2111 2167 2112 2168 // check cred config 2113 if (r eader[ridx].device[0] == 0 || reader[ridx].r_pwd[0] == 02114 || r eader[ridx].r_usr[0] == 0 || reader[ridx].r_port == 0) {2169 if (rdr->device[0] == 0 || rdr->r_pwd[0] == 0 2170 || rdr->r_usr[0] == 0 || rdr->r_port == 0) { 2115 2171 cs_log("%s configuration error!", getprefix()); 2116 2172 return -5; … … 2128 2184 int err = errno; 2129 2185 cs_log( 2130 "%s server does not return 16 bytes (n=%d, handle=%d, udp_fd=%d, cs_idx=%d,errno=%d)",2131 getprefix(), n, handle, cl ient[cs_idx].udp_fd, cs_idx, err);2186 "%s server does not return 16 bytes (n=%d, handle=%d, udp_fd=%d, errno=%d)", 2187 getprefix(), n, handle, cl->udp_fd, err); 2132 2188 return -2; 2133 2189 } 2134 struct cc_data *cc = cl ient[cs_idx].cc;2190 struct cc_data *cc = cl->cc; 2135 2191 2136 2192 if (!cc) { … … 2143 2199 memset(cc, 0, sizeof(struct cc_data)); 2144 2200 cc->cards = llist_create(); 2145 cl ient[cs_idx].cc = cc;2201 cl->cc = cc; 2146 2202 cc->auto_blocked = llist_create(); 2147 2203 cc->pending_emms = llist_create(); … … 2159 2215 cc->answer_on_keepalive = time(NULL); 2160 2216 cc->extended_mode = 0; 2161 cl ient[cs_idx].cc_extended_ecm_mode = 0;2217 cl->cc_extended_ecm_mode = 0; 2162 2218 memset(&cc->cmd05_data, 0, sizeof(cc->cmd05_data)); 2163 2219 … … 2191 2247 2192 2248 memset(buf, 0, sizeof(buf)); 2193 memcpy(buf, r eader[ridx].r_usr, strlen(reader[ridx].r_usr));2249 memcpy(buf, rdr->r_usr, strlen(rdr->r_usr)); 2194 2250 cs_ddump(buf, 20, "cccam: username '%s':", buf); 2195 2251 cc_cmd_send(buf, 20, MSG_NO_HEADER); // send usr '0' padded -> 20 bytes … … 2200 2256 cs_debug("cccam: 'CCcam' xor"); 2201 2257 memcpy(buf, "CCcam", 5); 2202 strncpy(pwd, r eader[ridx].r_pwd, sizeof(pwd) - 1);2258 strncpy(pwd, rdr->r_pwd, sizeof(pwd) - 1); 2203 2259 cc_crypt(&cc->block[ENCRYPT], (uint8 *) pwd, strlen(pwd), ENCRYPT); 2204 2260 cc_cmd_send(buf, 6, MSG_NO_HEADER); // send 'CCcam' xor w/ pwd … … 2218 2274 } 2219 2275 2220 cs_debug("cccam: last_s=%d, last_g=%d", r eader[ridx].last_s,2221 r eader[ridx].last_g);2222 2223 pfd = cl ient[cs_idx].udp_fd;2276 cs_debug("cccam: last_s=%d, last_g=%d", rdr->last_s, 2277 rdr->last_g); 2278 2279 pfd = cl->udp_fd; 2224 2280 cs_debug("cccam: pfd=%d", pfd); 2225 2281 … … 2236 2292 } 2237 2293 2238 r eader[ridx].caid[0] = reader[ridx].ftab.filts[0].caid;2239 r eader[ridx].nprov = reader[ridx].ftab.filts[0].nprids;2240 for (n = 0; n < r eader[ridx].nprov; n++) {2241 r eader[ridx].availkeys[n][0] = 1;2242 r eader[ridx].prid[n][0] = reader[ridx].ftab.filts[0].prids[n] >> 24;2243 r eader[ridx].prid[n][1] = reader[ridx].ftab.filts[0].prids[n] >> 16;2244 r eader[ridx].prid[n][2] = reader[ridx].ftab.filts[0].prids[n] >> 8;2245 r eader[ridx].prid[n][3] = reader[ridx].ftab.filts[0].prids[n] & 0xff;2246 } 2247 2248 r eader[ridx].card_status = CARD_NEED_INIT;2249 r eader[ridx].last_g = reader[ridx].last_s = time((time_t *) 0);2250 r eader[ridx].tcp_connected = 1;2251 r eader[ridx].available = 1;2294 rdr->caid[0] = rdr->ftab.filts[0].caid; 2295 rdr->nprov = rdr->ftab.filts[0].nprids; 2296 for (n = 0; n < rdr->nprov; n++) { 2297 rdr->availkeys[n][0] = 1; 2298 rdr->prid[n][0] = rdr->ftab.filts[0].prids[n] >> 24; 2299 rdr->prid[n][1] = rdr->ftab.filts[0].prids[n] >> 16; 2300 rdr->prid[n][2] = rdr->ftab.filts[0].prids[n] >> 8; 2301 rdr->prid[n][3] = rdr->ftab.filts[0].prids[n] & 0xff; 2302 } 2303 2304 rdr->card_status = CARD_NEED_INIT; 2305 rdr->last_g = rdr->last_s = time((time_t *) 0); 2306 rdr->tcp_connected = 1; 2307 rdr->available = 1; 2252 2308 2253 2309 cc->just_logged_in = 1; … … 2410 2466 */ 2411 2467 int cc_srv_report_cards() { 2468 struct s_client *cl = &client[cs_idx]; 2412 2469 int j; 2413 2470 uint32 id; … … 2416 2473 int reshare, usr_reshare, reader_reshare, maxhops, flt = 0; 2417 2474 uint8 buf[CC_MAXMSGSIZE]; 2418 struct cc_data *cc = cl ient[cs_idx].cc;2419 2420 struct s_auth *account = get_account(cl ient[cs_idx].usr);2475 struct cc_data *cc = cl->cc; 2476 2477 struct s_auth *account = get_account(cl->usr); 2421 2478 if (account) { 2422 2479 maxhops = account->cccmaxhops; … … 2438 2495 if (!reader[r].fd || !reader[r].enable || reader[r].deleted) 2439 2496 continue; 2440 if (!(reader[r].grp & cl ient[cs_idx].grp))2497 if (!(reader[r].grp & cl->grp)) 2441 2498 continue; 2442 2499 reader_reshare = reader[r].cc_reshare; … … 2456 2513 for (j = 0; j < CS_MAXFILTERS; j++) { 2457 2514 if (reader[r].ftab.filts[j].caid && chk_ctab( 2458 reader[r].ftab.filts[j].caid, &cl ient[cs_idx].ctab)) {2515 reader[r].ftab.filts[j].caid, &cl->ctab)) { 2459 2516 int ignore = 0; 2460 2517 memset(buf, 0, sizeof(buf)); … … 2509 2566 int len = 30 + (k * 7); 2510 2567 cc_cmd_send(buf, len, MSG_NEW_CARD); 2511 cc_add_reported_carddata(reported_carddatas, buf, len, r);2568 cc_add_reported_carddata(reported_carddatas, buf, len, &reader[r]); 2512 2569 id++; 2513 2570 flt = 1; … … 2522 2579 ushort lcaid = reader[r].ctab.caid[j]; 2523 2580 2524 if (!chk_ctab(lcaid, &cl ient[cs_idx].ctab))2581 if (!chk_ctab(lcaid, &cl->ctab)) 2525 2582 continue; 2526 2583 … … 2552 2609 int len = 30 + 7; 2553 2610 cc_cmd_send(buf, len, MSG_NEW_CARD); 2554 cc_add_reported_carddata(reported_carddatas, buf, len, r);2611 cc_add_reported_carddata(reported_carddatas, buf, len, &reader[r]); 2555 2612 id++; 2556 2613 flt = 1; … … 2560 2617 2561 2618 if (reader[r].typ != R_CCCAM && reader[r].caid[0] && !flt && chk_ctab( 2562 reader[r].caid[0], &cl ient[cs_idx].ctab)) {2619 reader[r].caid[0], &cl->ctab)) { 2563 2620 //cs_log("tcp_connected: %d card_status: %d ", reader[r].tcp_connected, reader[r].card_status); 2564 2621 memset(buf, 0, sizeof(buf)); … … 2597 2654 //reader[r].cc_id = b2i(3, buf + 5); 2598 2655 int len = 30 + (j * 7); 2599 cc_add_reported_carddata(reported_carddatas, buf, len, r);2656 cc_add_reported_carddata(reported_carddatas, buf, len, &reader[r]); 2600 2657 cc_cmd_send(buf, len, MSG_NEW_CARD); 2601 2658 //cs_log("CCcam: local card or newcamd reader %02X report ADD caid: %02X%02X %d %d %s subid: %06X", buf[7], buf[8], buf[9], reader[r].card_status, reader[r].tcp_connected, reader[r].label, reader[r].cc_id); … … 2615 2672 { 2616 2673 if (card->hop <= maxhops && //card->maxdown > 0 && 2617 chk_ctab(card->caid, &cl ient[cs_idx].ctab) && chk_ctab(2674 chk_ctab(card->caid, &cl->ctab) && chk_ctab( 2618 2675 card->caid, &reader[r].ctab)) { 2619 2676 int ignore = 0; … … 2684 2741 int len = 30 + (j * 7); 2685 2742 cc_cmd_send(buf, len, MSG_NEW_CARD); 2686 cc_add_reported_carddata(reported_carddatas, buf, len, r);2743 cc_add_reported_carddata(reported_carddatas, buf, len, &reader[r]); 2687 2744 card = llist_itr_next(&itr); 2688 2745 } … … 2700 2757 2701 2758 void cc_cli_report_cards(int client_idx) { 2702 struct cc_data *cc = client[cs_idx].cc; 2759 struct s_client *cl = &client[cs_idx]; 2760 struct s_reader *rdr = &reader[ridx]; 2761 struct cc_data *cc = cl->cc; 2703 2762 int count = 0; 2704 2763 … … 2707 2766 int pipe = open((char*) buf, O_WRONLY); 2708 2767 2709 if (!cc || r eader[ridx].tcp_connected == 0)2768 if (!cc || rdr->tcp_connected == 0) 2710 2769 cc_cli_init_int(); 2711 2770 2712 if (cc && r eader[ridx].tcp_connected == 2) {2771 if (cc && rdr->tcp_connected == 2) { 2713 2772 2714 2773 LLIST_ITR itr; … … 2733 2792 2734 2793 int cc_srv_connect() { 2794 struct s_client *cl = &client[cs_idx]; 2735 2795 int i; 2736 2796 ulong cmi; … … 2740 2800 char usr[21], pwd[21]; 2741 2801 struct s_auth *account; 2742 struct cc_data *cc = cl ient[cs_idx].cc;2802 struct cc_data *cc = cl->cc; 2743 2803 2744 2804 memset(usr, 0, sizeof(usr)); … … 2754 2814 } 2755 2815 2756 cl ient[cs_idx].cc = cc;2757 memset(cl ient[cs_idx].cc, 0, sizeof(struct cc_data));2816 cl->cc = cc; 2817 memset(cl->cc, 0, sizeof(struct cc_data)); 2758 2818 cc->extended_ecm_idx = llist_create(); 2759 2819 pthread_mutex_init(&cc->lock, NULL); … … 2762 2822 cc->server_ecm_pending = 0; 2763 2823 cc->extended_mode = 0; 2764 cl ient[cs_idx].cc_extended_ecm_mode = 0;2765 cc _use_rc4 = 0;2824 cl->cc_extended_ecm_mode = 0; 2825 cc->cc_use_rc4 = 0; 2766 2826 is_server = 1; 2767 2827 … … 2777 2837 data[15] = sum & 0xff; 2778 2838 2779 send(cl ient[cs_idx].udp_fd, data, 16, 0);2839 send(cl->udp_fd, data, 16, 0); 2780 2840 2781 2841 cc_xor(data); // XOR init bytes with 'CCcam' … … 2830 2890 2831 2891 //test for nonprintable characters: 2832 cc _use_rc4 = -1;2892 cc->cc_use_rc4 = -1; 2833 2893 for (i = 0; i < 20; i++) { 2834 2894 if (usr[i] > 0 && usr[i] < 0x20) { //found nonprintable char 2835 cc _use_rc4 = 1;2895 cc->cc_use_rc4 = 1; 2836 2896 break; 2837 2897 } 2838 2898 if (usr_rc4[i] > 0 && usr_rc4[i] < 0x20) { //found nonprintable char 2839 cc _use_rc4 = 0;2899 cc->cc_use_rc4 = 0; 2840 2900 break; 2841 2901 } 2842 2902 } 2843 if (cc _use_rc4 == 0)2903 if (cc->cc_use_rc4 == 0) 2844 2904 cs_ddump(buf, 20, "cccam: username '%s':", usr); 2845 else if (cc _use_rc4 == 1)2905 else if (cc->cc_use_rc4 == 1) 2846 2906 cs_ddump(buf_rc4, 20, "cccam: username rc4 '%s':", usr_rc4); 2847 2907 else … … 2852 2912 if (strcmp(usr, account->usr) == 0) { 2853 2913 strncpy(pwd, account->pwd, sizeof(pwd)); 2854 cc _use_rc4 = 0; //We found a user by cc_crypt2914 cc->cc_use_rc4 = 0; //We found a user by cc_crypt 2855 2915 break; 2856 2916 } 2857 2917 if (strcmp(usr_rc4, account->usr) == 0) { 2858 2918 strncpy(pwd, account->pwd, sizeof(pwd)); 2859 cc _use_rc4 = 1; //We found a user by cc_rc4_crypt2919 cc->cc_use_rc4 = 1; //We found a user by cc_rc4_crypt 2860 2920 break; 2861 2921 } 2862 2922 } 2863 2923 2864 if (!account || cc _use_rc4 == -1) {2865 cs_log("account '%s' not found!", cc _use_rc4 ? usr_rc4 : usr);2924 if (!account || cc->cc_use_rc4 == -1) { 2925 cs_log("account '%s' not found!", cc->cc_use_rc4 ? usr_rc4 : usr); 2866 2926 return -1; 2867 2927 } 2868 2928 2869 if (cc _use_rc4) {2929 if (cc->cc_use_rc4) { 2870 2930 cs_log("%s client is using version 2.0.11 rc4", getprefix()); 2871 2931 memcpy(cc->block, block_rc4, sizeof(struct cc_crypt_block) * 2); … … 2883 2943 return -1; 2884 2944 2885 cl ient[cs_idx].crypted = 1;2945 cl->crypted = 1; 2886 2946 if (cs_auth_client(account, NULL)) 2887 2947 return -1; … … 2958 3018 2959 3019 void cc_srv_init() { 2960 pfd = client[cs_idx].udp_fd; 2961 //cc_auth_client(client[cs_idx].ip); 3020 struct s_client *cl = &client[cs_idx]; 3021 pfd = cl->udp_fd; 3022 //cc_auth_client(cl->ip); 2962 3023 if (cc_srv_connect() < 0) 2963 3024 cs_log("cccam: %d failed errno: %d (%s)", __LINE__, errno, strerror( … … 2969 3030 2970 3031 int cc_cli_init_int() { 2971 2972 if (reader[ridx].tcp_connected) 3032 struct s_client *cl = &client[cs_idx]; 3033 struct s_reader *rdr = &reader[ridx]; 3034 if (rdr->tcp_connected) 2973 3035 return -1; 2974 3036 … … 2977 3039 2978 3040 pfd = 0; 2979 if (r eader[ridx].r_port <= 0) {3041 if (rdr->r_port <= 0) { 2980 3042 cs_log("%s invalid port %d for server %s", getprefix(), 2981 r eader[ridx].r_port, reader[ridx].device);3043 rdr->r_port, rdr->device); 2982 3044 return (1); 2983 3045 } … … 2987 3049 p_proto = 6; 2988 3050 2989 // cl ient[cs_idx].ip = 0;3051 // cl->ip = 0; 2990 3052 // memset((char *) &loc_sa, 0, sizeof(loc_sa)); 2991 3053 // loc_sa.sin_family = AF_INET; … … 2996 3058 //#endif 2997 3059 // loc_sa.sin_addr.s_addr = INADDR_ANY; 2998 // loc_sa.sin_port = htons(r eader[ridx].l_port);2999 3000 if ((cl ient[cs_idx].udp_fd = socket(PF_INET, SOCK_STREAM, p_proto)) <= 0) {3060 // loc_sa.sin_port = htons(rdr->l_port); 3061 3062 if ((cl->udp_fd = socket(PF_INET, SOCK_STREAM, p_proto)) <= 0) { 3001 3063 cs_log("%s Socket creation failed (errno=%d, socket=%d)", getprefix(), 3002 errno, cl ient[cs_idx].udp_fd);3064 errno, cl->udp_fd); 3003 3065 return -10; 3004 3066 } 3005 //cs_log("%s 1 socket created: cs_idx=%d, fd=%d errno=%d", getprefix(), cs_idx, cl ient[cs_idx].udp_fd, errno);3067 //cs_log("%s 1 socket created: cs_idx=%d, fd=%d errno=%d", getprefix(), cs_idx, cl->udp_fd, errno); 3006 3068 3007 3069 #ifdef SO_PRIORITY 3008 3070 if (cfg->netprio) 3009 setsockopt(cl ient[cs_idx].udp_fd, SOL_SOCKET, SO_PRIORITY,3071 setsockopt(cl->udp_fd, SOL_SOCKET, SO_PRIORITY, 3010 3072 (void *)&cfg->netprio, sizeof(ulong)); 3011 3073 #endif 3012 r eader[ridx].tcp_ito = 1; //60sec...This now invokes ph_idle()3013 if (r eader[ridx].cc_maxhop <= 0)3014 r eader[ridx].cc_maxhop = 10;3015 3016 memset((char *) &cl ient[cs_idx].udp_sa, 0, sizeof(client[cs_idx].udp_sa));3017 cl ient[cs_idx].udp_sa.sin_family = AF_INET;3018 cl ient[cs_idx].udp_sa.sin_port = htons((u_short) reader[ridx].r_port);3019 3020 if (r eader[ridx].tcp_rto <= 0)3021 r eader[ridx].tcp_rto = 60 * 60 * 10; // timeout to 10 hours3022 cs_debug("cccam: reconnect timeout set to: %d", r eader[ridx].tcp_rto);3023 cc_check_version(r eader[ridx].cc_version, reader[ridx].cc_build);3074 rdr->tcp_ito = 1; //60sec...This now invokes ph_idle() 3075 if (rdr->cc_maxhop <= 0) 3076 rdr->cc_maxhop = 10; 3077 3078 memset((char *) &cl->udp_sa, 0, sizeof(cl->udp_sa)); 3079 cl->udp_sa.sin_family = AF_INET; 3080 cl->udp_sa.sin_port = htons((u_short) rdr->r_port); 3081 3082 if (rdr->tcp_rto <= 0) 3083 rdr->tcp_rto = 60 * 60 * 10; // timeout to 10 hours 3084 cs_debug("cccam: reconnect timeout set to: %d", rdr->tcp_rto); 3085 cc_check_version(rdr->cc_version, rdr->cc_build); 3024 3086 cs_log( 3025 3087 "proxy reader: %s (%s:%d) cccam v%s build %s, maxhop: %d, retry ecm: %d, auto block: %d", 3026 r eader[ridx].label, reader[ridx].device, reader[ridx].r_port,3027 r eader[ridx].cc_version, reader[ridx].cc_build,3028 r eader[ridx].cc_maxhop, !reader[ridx].cc_disable_retry_ecm,3029 !r eader[ridx].cc_disable_auto_block);3088 rdr->label, rdr->device, rdr->r_port, 3089 rdr->cc_version, rdr->cc_build, 3090 rdr->cc_maxhop, !rdr->cc_disable_retry_ecm, 3091 !rdr->cc_disable_auto_block); 3030 3092 3031 3093 return cc_cli_connect(); … … 3041 3103 /** 3042 3104 * return 1 if we are able to send requests: 3105 * 3106 * THREADED: ridx should be replaced with reader-pointer 3043 3107 */ 3044 3108 int cc_available(int ridx, int checktype) { 3045 //cs_debug_mask(D_TRACE, "checking reader %s availibility", reader[ridx].label); 3046 if (!client[reader[ridx].cs_idx].cc || reader[ridx].tcp_connected != 2 3047 || reader[ridx].card_status != CARD_INSERTED) 3109 struct s_reader *rdr = &reader[ridx]; 3110 struct s_client *cl = &client[rdr->cs_idx]; 3111 3112 //cs_debug_mask(D_TRACE, "checking reader %s availibility", rdr->label); 3113 if (!cl->cc || rdr->tcp_connected != 2 3114 || rdr->card_status != CARD_INSERTED) 3048 3115 return 1; //Not connected? Connect! 3049 3116 3050 if (checktype == AVAIL_CHECK_LOADBALANCE && !r eader[ridx].available) {3117 if (checktype == AVAIL_CHECK_LOADBALANCE && !rdr->available) { 3051 3118 cs_debug_mask(D_TRACE, "checking reader %s availibility=0 (unavail)", 3052 r eader[ridx].label);3119 rdr->label); 3053 3120 return 0; //We are processing EMMs/ECMs 3054 3121 } … … 3058 3125 3059 3126 void cc_cleanup(void) { 3127 struct s_client *cl = &client[cs_idx]; 3060 3128 if (!is_server) { 3061 3129 cc_cli_close(); // we need to close open fd's 3062 3130 } 3063 cc_free(cl ient[cs_idx].cc);3064 cl ient[cs_idx].cc = NULL;3131 cc_free(cl->cc); 3132 cl->cc = NULL; 3065 3133 } 3066 3134 -
trunk/module-cccam.h
r3126 r3133 108 108 109 109 struct cc_data { 110 uint8 g_flag; 111 int cc_use_rc4; 112 char *prefix; 113 110 114 struct cc_crypt_block block[2]; // crypto state blocks 111 115
Note:
See TracChangeset
for help on using the changeset viewer.