Changeset 3600
- Timestamp:
- 10/17/10 17:50:19 (13 years ago)
- Location:
- trunk
- Files:
-
- 2 deleted
- 3 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/module-cccam.c
r3592 r3600 3 3 #include "globals.h" 4 4 #include "module-cccam.h" 5 #include "module-obj-llist.h"6 5 #include <time.h> 7 6 #include "reader-common.h" … … 146 145 147 146 int is_sid_blocked(struct cc_card *card, struct cc_srvid *srvid_blocked) { 148 LL IST_D__ITR sitr;149 struct cc_srvid *srvid = llist_itr_init(card->badsids, &sitr);150 while ( srvid) {147 LL_ITER *it = ll_iter_create(card->badsids); 148 struct cc_srvid *srvid; 149 while ((srvid = ll_iter_next(it))) { 151 150 if (sid_eq(srvid, srvid_blocked)) { 151 ll_iter_release(it); 152 152 return 1; 153 153 } 154 srvid = llist_itr_next(&sitr);155 } 154 } 155 ll_iter_release(it); 156 156 return 0; 157 157 } 158 158 159 159 int is_good_sid(struct cc_card *card, struct cc_srvid *srvid_good) { 160 LL IST_D__ITR sitr;161 struct cc_srvid *srvid = llist_itr_init(card->goodsids, &sitr);162 while ( srvid) {160 LL_ITER *it = ll_iter_create(card->goodsids); 161 struct cc_srvid *srvid; 162 while ((srvid = ll_iter_next(it))) { 163 163 if (sid_eq(srvid, srvid_good)) { 164 ll_iter_release(it); 164 165 return 1; 165 166 } 166 srvid = llist_itr_next(&sitr);167 } 167 } 168 ll_iter_release(it); 168 169 return 0; 169 170 } … … 176 177 if (srvid) { 177 178 *srvid = *srvid_blocked; 178 ll ist_append(card->badsids, srvid);179 ll_append(card->badsids, srvid); 179 180 cs_debug_mask(D_TRACE, "%s added sid block %04X(%d) for card %08x", 180 181 getprefix(), srvid_blocked->sid, srvid_blocked->ecmlen, … … 185 186 void remove_sid_block(struct cc_card *card, 186 187 struct cc_srvid *srvid_blocked) { 187 LLIST_D__ITR sitr; 188 struct cc_srvid *srvid = llist_itr_init(card->badsids, &sitr); 189 while (srvid) { 190 if (sid_eq(srvid, srvid_blocked)) { 191 free(srvid); 192 srvid = llist_itr_remove(&sitr); 193 } else 194 srvid = llist_itr_next(&sitr); 195 } 188 LL_ITER *it = ll_iter_create(card->badsids); 189 struct cc_srvid *srvid; 190 while ((srvid = ll_iter_next(it))) 191 if (sid_eq(srvid, srvid_blocked)) 192 ll_iter_remove_data(it); 193 ll_iter_release(it); 196 194 } 197 195 198 196 void remove_good_sid(struct cc_card *card, struct cc_srvid *srvid_good) { 199 LLIST_D__ITR sitr; 200 struct cc_srvid *srvid = llist_itr_init(card->goodsids, &sitr); 201 while (srvid) { 202 if (sid_eq(srvid, srvid_good)) { 203 free(srvid); 204 srvid = llist_itr_remove(&sitr); 205 } else 206 srvid = llist_itr_next(&sitr); 207 } 197 LL_ITER *it = ll_iter_create(card->goodsids); 198 struct cc_srvid *srvid; 199 while ((srvid = ll_iter_next(it))) 200 if (sid_eq(srvid, srvid_good)) 201 ll_iter_remove_data(it); 202 ll_iter_release(it); 208 203 } 209 204 … … 216 211 if (srvid) { 217 212 memcpy(srvid, srvid_good, sizeof(struct cc_srvid)); 218 ll ist_append(card->goodsids, srvid);213 ll_append(card->goodsids, srvid); 219 214 cs_debug_mask(D_TRACE, "%s added good sid %04X(%d) for card %08x", 220 215 getprefix(), srvid_good->sid, srvid_good->ecmlen, card->id); … … 222 217 } 223 218 224 void free_current_cards(LLIST_D_ *current_cards) { 225 LLIST_D__ITR itr; 226 struct cc_current_card *c = llist_itr_init(current_cards, &itr); 227 while (c) { 228 free(c); 229 c = llist_itr_remove(&itr); 230 } 219 void free_current_cards(LLIST *current_cards) { 220 LL_ITER *it = ll_iter_create(current_cards); 221 struct cc_current_card *c; 222 while ((c = ll_iter_next(it))) 223 c = ll_iter_remove(it); 224 ll_iter_release(it); 231 225 } 232 226 … … 269 263 eei->card = card; 270 264 eei->srvid = srvid; 271 ll ist_append(cc->extended_ecm_idx, eei);265 ll_append(cc->extended_ecm_idx, eei); 272 266 //cs_debug_mask(D_TRACE, "%s add extended ecm-idx: %d:%d", getprefix(), send_idx, ecm_idx); 273 267 return eei; … … 278 272 struct cc_data *cc = cl->cc; 279 273 struct cc_extended_ecm_idx *eei; 280 LLIST_D__ITR itr; 281 eei = llist_itr_init(cc->extended_ecm_idx, &itr); 282 while (eei) { 274 LL_ITER *it = ll_iter_create(cc->extended_ecm_idx); 275 while ((eei = ll_iter_next(it))) { 283 276 if (eei->send_idx == send_idx) { 284 277 if (remove) 285 llist_itr_remove(&itr);278 ll_iter_remove(it); 286 279 //cs_debug_mask(D_TRACE, "%s get by send-idx: %d FOUND: %d", 287 280 // getprefix(), send_idx, eei->ecm_idx); 281 ll_iter_release(it); 288 282 return eei; 289 283 } 290 eei = llist_itr_next(&itr);291 } 284 } 285 ll_iter_release(it); 292 286 cs_debug_mask(D_TRACE, "%s get by send-idx: %d NOT FOUND", getprefix(), 293 287 send_idx); … … 299 293 struct cc_data *cc = cl->cc; 300 294 struct cc_extended_ecm_idx *eei; 301 LLIST_D__ITR itr; 302 eei = llist_itr_init(cc->extended_ecm_idx, &itr); 303 while (eei) { 295 LL_ITER *it = ll_iter_create(cc->extended_ecm_idx); 296 while ((eei = ll_iter_next(it))) { 304 297 if (eei->ecm_idx == ecm_idx) { 305 298 if (remove) 306 ll ist_itr_remove(&itr);299 ll_iter_remove(it); 307 300 //cs_debug_mask(D_TRACE, "%s get by ecm-idx: %d FOUND: %d", 308 301 // getprefix(), ecm_idx, eei->send_idx); 309 return eei; 310 } 311 eei = llist_itr_next(&itr); 302 ll_iter_release(it); 303 return eei; 304 } 305 ll_iter_release(it); 312 306 } 313 307 cs_debug_mask(D_TRACE, "%s get by ecm-idx: %d NOT FOUND", getprefix(), … … 317 311 318 312 void free_extended_ecm_idx_by_card(struct s_client *cl, struct cc_card *card) { 319 313 struct cc_data *cc = cl->cc; 320 314 struct cc_extended_ecm_idx *eei; 321 LLIST_D__ITR itr; 322 323 eei = llist_itr_init(cc->extended_ecm_idx, &itr); 324 while (eei) { 325 if (eei->card == card) { 326 free(eei); 327 eei = llist_itr_remove(&itr); 328 } else 329 eei = llist_itr_next(&itr); 330 } 315 LL_ITER *it = ll_iter_create(cc->extended_ecm_idx); 316 while ((eei = ll_iter_next(it))) 317 if (eei->card == card) 318 ll_iter_remove_data(it); 319 ll_iter_release(it); 331 320 } 332 321 333 322 void free_extended_ecm_idx(struct cc_data *cc) { 334 323 struct cc_extended_ecm_idx *eei; 335 LLIST_D__ITR itr; 336 eei = llist_itr_init(cc->extended_ecm_idx, &itr); 337 while (eei) { 338 free(eei); 339 eei = llist_itr_remove(&itr); 340 } 324 LL_ITER *it = ll_iter_create(cc->extended_ecm_idx); 325 while ((eei = ll_iter_next(it))) 326 ll_iter_remove_data(it); 327 ll_iter_release(it); 341 328 } 342 329 … … 650 637 struct cc_current_card *cc_find_current_card(struct cc_data *cc, 651 638 struct cc_card *card) { 652 LLIST_D__ITR itr; 653 struct cc_current_card *c = llist_itr_init(cc->current_cards, &itr); 654 while (c) { 655 if (c->card == card) 639 LL_ITER *it = ll_iter_create(cc->current_cards); 640 struct cc_current_card *c; 641 while ((c = ll_iter_next(it))) 642 if (c->card == card) { 643 ll_iter_release(it); 656 644 return c; 657 c = llist_itr_next(&itr); 658 } 645 } 646 ll_iter_release(it); 659 647 return NULL; 660 648 } … … 662 650 struct cc_current_card *cc_find_current_card_by_srvid( 663 651 struct cc_data *cc, ushort caid, ulong prov, struct cc_srvid *srvid) { 664 LLIST_D__ITR itr;665 struct cc_current_card *c = llist_itr_init(cc->current_cards, &itr);666 while (c) { 652 LL_ITER *it = ll_iter_create(cc->current_cards); 653 struct cc_current_card *c; 654 while ((c = ll_iter_next(it))) 667 655 if (c->card->caid == caid && c->prov == prov 668 && sid_eq(&c->srvid, srvid)) 656 && sid_eq(&c->srvid, srvid)) { 657 ll_iter_release(it); 669 658 return c; 670 c = llist_itr_next(&itr); 671 } 659 } 660 ll_iter_release(it); 672 661 return NULL; 673 662 } … … 675 664 void cc_remove_current_card(struct cc_data *cc, 676 665 struct cc_current_card *current_card) { 677 LLIST_D__ITR itr; 678 struct cc_current_card *c = llist_itr_init(cc->current_cards, &itr); 679 while (c) { 680 if (c == current_card) { 681 free(c); 682 c = llist_itr_remove(&itr); 683 } else 684 c = llist_itr_next(&itr); 685 } 666 LL_ITER *it = ll_iter_create(cc->current_cards); 667 struct cc_current_card *c; 668 while ((c = ll_iter_next(it))) 669 if (c == current_card) 670 ll_iter_remove_data(it); 671 ll_iter_release(it); 686 672 687 673 } … … 774 760 struct cc_card *card; 775 761 struct cc_current_card *current_card; 776 LL IST_D__ITR itr;762 LL_ITER *it; 777 763 ECM_REQUEST *cur_er; 778 764 struct timeb cur_time; … … 798 784 799 785 //No Card? Waiting for shares 800 if (!ll ist_count(cc->cards)) {786 if (!ll_count(cc->cards)) { 801 787 rdr->fd_error++; 802 788 cs_debug_mask(D_TRACE, "%s NO CARDS!", getprefix()); … … 880 866 //then check all other cards 881 867 if (!card) { 882 struct cc_card *ncard = llist_itr_init(cc->cards, &itr); 883 while (ncard) { 868 it = ll_iter_create(cc->cards); 869 struct cc_card *ncard; 870 while ((ncard = ll_iter_next(it))) { 884 871 if (ncard->caid == cur_er->caid) { // caid matches 885 872 int s = is_sid_blocked(ncard, &cur_srvid); 886 873 887 LLIST_D__ITR pitr; 888 struct cc_provider *provider = llist_itr_init( 889 ncard->providers, &pitr); 890 while (provider && !s) { 874 LL_ITER *it2 = ll_iter_create(ncard->providers); 875 struct cc_provider *provider; 876 while ((provider = ll_iter_next(it)) && !s) { 891 877 if (!cur_er->prid || !provider->prov || provider->prov 892 878 == cur_er->prid) { // provid matches … … 898 884 } 899 885 } 900 provider = llist_itr_next(&pitr);901 886 } 887 ll_iter_release(it2); 902 888 } 903 ncard = llist_itr_next(&itr);904 889 } 890 ll_iter_release(it); 905 891 } 906 892 … … 911 897 current_card->prov = cur_er->prid; 912 898 current_card->srvid = cur_srvid; 913 llist_insert_first(cc->current_cards, current_card);899 ll_insert_at(cc->current_cards, current_card, 0); 914 900 } 915 901 … … 959 945 960 946 rdr->nprov = 0; 961 LLIST_D__ITR pitr; 962 struct cc_provider *provider = llist_itr_init(card->providers, 963 &pitr); 964 while (provider) { 947 LL_ITER *it2 = ll_iter_create(card->providers); 948 struct cc_provider *provider; 949 while ((provider = ll_iter_next(it2))) { 965 950 if (provider->prov == cur_er->prid) { 966 951 memcpy(&rdr->prid[0], &provider->prov, … … 970 955 break; 971 956 } 972 provider = llist_itr_next(&pitr);973 957 } 958 ll_iter_release(it2); 974 959 char saprov[20] = { 0 }; 975 960 if (provider) … … 1000 985 //cs_sleepms(300); 1001 986 rdr->last_s = rdr->last_g; 1002 1003 card = llist_itr_init(cc->cards, &itr); 1004 while (card) { 987 it = ll_iter_create(cc->cards); 988 while ((card = ll_iter_next(it))) { 1005 989 if (card->caid == cur_er->caid) { // caid matches 1006 LLIST_D__ITR sitr; 1007 struct cc_srvid *srvid = llist_itr_init(card->badsids, 1008 &sitr); 1009 while (srvid) { 1010 if (sid_eq(srvid, &cur_srvid)) { 1011 free(srvid); 1012 srvid = llist_itr_remove(&sitr); 1013 } else 1014 srvid = llist_itr_next(&sitr); 990 LL_ITER *it2 = ll_iter_create(card->badsids); 991 struct cc_srvid *srvid; 992 while ((srvid = ll_iter_next(it2))) 993 if (sid_eq(srvid, &cur_srvid)) 994 ll_iter_remove_data(it2); 995 ll_iter_release(it2); 1015 996 } 1016 997 } 1017 card = llist_itr_next(&itr); 1018 } 1019 } 1020 pthread_mutex_unlock(&cc->cards_busy); 1021 if (!cc->extended_mode) { 1022 rdr->available = 1; 1023 pthread_mutex_unlock(&cc->ecm_busy); 1024 } 1025 cs_debug_mask(D_FUT, "cc_send_ecm out"); 1026 return -1; 1027 } 998 } 999 ll_iter_release(it); 1000 } 1001 pthread_mutex_unlock(&cc->cards_busy); 1002 if (!cc->extended_mode) { 1003 rdr->available = 1; 1004 pthread_mutex_unlock(&cc->ecm_busy); 1005 } 1006 cs_debug_mask(D_FUT, "cc_send_ecm out"); 1007 return -1; 1028 1008 } 1029 1009 … … 1060 1040 struct cc_data *cc = cl->cc; 1061 1041 1062 LL IST_D__ITR itr;1063 uint8 *emmbuf = llist_itr_init(cc->pending_emms, &itr);1064 if ( emmbuf) {1042 LL_ITER *it = ll_iter_create(cc->pending_emms);; 1043 uint8 *emmbuf; 1044 if ((emmbuf = ll_iter_next(it))) { 1065 1045 if (!cc->extended_mode) { 1066 1046 if (pthread_mutex_trylock(&cc->ecm_busy) == EBUSY) { //Unlock by NOK or ECM ACK … … 1078 1058 1079 1059 cc_cmd_send(cl, emmbuf, size, MSG_EMM_ACK); // send emm 1080 free(emmbuf); 1081 llist_itr_remove(&itr); 1082 return size; 1083 } 1060 1061 ll_iter_remove_data(it); 1062 ll_iter_release(it); 1063 1064 return size; 1065 } 1066 ll_iter_release(it); 1067 1084 1068 cs_debug_mask(D_FUT, "cc_send_pending_emms out"); 1085 1069 return 0; … … 1092 1076 struct cc_card *get_card_by_hexserial(struct s_client *cl, uint8 *hexserial, uint16 caid) { 1093 1077 struct cc_data *cc = cl->cc; 1094 LL IST_D__ITR itr;1095 struct cc_card *card = llist_itr_init(cc->cards, &itr);1096 while ( card) {1078 LL_ITER *it = ll_iter_create(cc->cards);; 1079 struct cc_card *card; 1080 while ((card = ll_iter_next(it))) 1097 1081 if (card->caid == caid && memcmp(card->hexserial, hexserial, 8) == 0) { //found it! 1082 ll_iter_release(it); 1098 1083 return card; 1099 1084 } 1100 card = llist_itr_next(&itr); 1101 } 1085 ll_iter_release(it); 1102 1086 return NULL; 1103 1087 } … … 1131 1115 //Last used card is first card of current_cards: 1132 1116 pthread_mutex_lock(&cc->cards_busy); 1133 LLIST_D__ITR itr; 1134 struct cc_current_card *current_card = llist_itr_init(cc->current_cards, 1135 &itr); 1136 while (current_card && current_card->card->caid != caid) { 1137 current_card = llist_itr_next(&itr); 1138 } 1139 struct cc_card *emm_card = (current_card != NULL) ? current_card->card 1117 LL_ITER *it = ll_iter_create(cc->current_cards); 1118 struct cc_current_card *current_card; 1119 while ((current_card = ll_iter_next(it)) && current_card->card->caid != caid); 1120 ll_iter_release(it); 1121 1122 struct cc_card *emm_card = (current_card != NULL) ? current_card->card 1140 1123 : NULL; 1141 1124 … … 1178 1161 pthread_mutex_unlock(&cc->cards_busy); 1179 1162 1180 ll ist_append(cc->pending_emms, emmbuf);1163 ll_append(cc->pending_emms, emmbuf); 1181 1164 cc_send_pending_emms(cl); 1182 1165 … … 1189 1172 return; 1190 1173 1191 if (card->providers) { 1192 LLIST_D__ITR bitr; 1193 struct cc_provider *provider = llist_itr_init(card->providers, &bitr); 1194 while (provider) { 1195 free(provider); 1196 provider = llist_itr_remove(&bitr); 1197 } 1198 llist_destroy(card->providers); 1199 } 1200 if (card->badsids) 1201 llist_destroy(card->badsids); 1202 if (card->goodsids) 1203 llist_destroy(card->goodsids); 1204 if (card->remote_nodes) 1205 llist_destroy(card->remote_nodes); 1206 free(card); 1174 ll_destroy_data(card->providers); 1175 ll_destroy_data(card->badsids); 1176 ll_destroy_data(card->goodsids); 1177 ll_destroy_data(card->remote_nodes); 1178 1179 free(card); 1207 1180 } 1208 1181 … … 1211 1184 * Adds a cccam-carddata buffer to the list of reported carddatas 1212 1185 */ 1213 void cc_add_reported_carddata(struct s_client *cl, LLIST _D_*reported_carddatas, uint8 *buf,1186 void cc_add_reported_carddata(struct s_client *cl, LLIST *reported_carddatas, uint8 *buf, 1214 1187 int len, struct s_reader *D_USE(rdr)) { 1215 1188 struct cc_reported_carddata *carddata = malloc( … … 1219 1192 carddata->buf = buf_copy; 1220 1193 carddata->len = len; 1221 ll ist_append(reported_carddatas, carddata);1194 ll_append(reported_carddatas, carddata); 1222 1195 1223 1196 cs_debug_mask( … … 1240 1213 } 1241 1214 1242 void cc_clear_reported_carddata(struct s_client *cl, LLIST _D_*reported_carddatas,1215 void cc_clear_reported_carddata(struct s_client *cl, LLIST *reported_carddatas, 1243 1216 int send_removed) { 1244 LLIST_D__ITR itr; 1245 struct cc_reported_carddata *carddata = llist_itr_init(reported_carddatas, 1246 &itr); 1247 while (carddata) { 1217 LL_ITER *it = ll_iter_create(reported_carddatas); 1218 struct cc_reported_carddata *carddata; 1219 while ((carddata = ll_iter_next(it))) { 1248 1220 if (send_removed) 1249 1221 cc_cmd_send(cl, carddata->buf, 4, MSG_CARD_REMOVED); 1250 1222 free(carddata->buf); 1251 free(carddata); 1252 carddata = llist_itr_remove(&itr); 1253 } 1254 1255 } 1256 1257 void cc_free_reported_carddata(struct s_client *cl, LLIST_D_ *reported_carddatas, 1223 ll_iter_remove_data(it); 1224 } 1225 ll_iter_release(it); 1226 } 1227 1228 void cc_free_reported_carddata(struct s_client *cl, LLIST *reported_carddatas, 1258 1229 int send_removed) { 1259 1230 if (reported_carddatas) { 1260 1231 cc_clear_reported_carddata(cl, reported_carddatas, send_removed); 1261 llist_destroy(reported_carddatas); 1262 } 1263 } 1264 1265 void cc_free_cardlist(LLIST_D_ *card_list) { 1266 if (card_list) { 1267 LLIST_D__ITR itr; 1268 struct cc_card *card = llist_itr_init(card_list, &itr); 1269 while (card) { 1270 cc_free_card(card); 1271 card = llist_itr_remove(&itr); 1272 } 1273 llist_destroy(card_list); 1274 } 1275 } 1232 ll_destroy(reported_carddatas); 1233 } 1234 } 1235 1236 void cc_free_cardlist(LLIST *card_list) { 1237 ll_destroy_data(card_list); 1238 } 1239 1276 1240 /** 1277 1241 * Clears and free the cc datas … … 1285 1249 cc_free_cardlist(cc->cards); 1286 1250 cc_free_reported_carddata(cl, cc->reported_carddatas, 0); 1287 if (cc->pending_emms) { 1288 LLIST_D__ITR itr; 1289 uint8 *ep = llist_itr_init(cc->pending_emms, &itr); 1290 while (ep) { 1291 free(ep); 1292 ep = llist_itr_remove(&itr); 1293 } 1294 llist_destroy(cc->pending_emms); 1295 cc->pending_emms = NULL; 1296 } 1297 if (cc->current_cards) { 1298 free_current_cards(cc->current_cards); 1299 llist_destroy(cc->current_cards); 1300 } 1251 ll_destroy_data(cc->pending_emms); 1252 free_current_cards(cc->current_cards); 1253 ll_destroy(cc->current_cards); 1301 1254 if (cc->extended_ecm_idx) 1302 1255 free_extended_ecm_idx(cc); … … 1383 1336 memset(card, 0, sizeof(struct cc_card)); 1384 1337 1385 card->providers = ll ist_create();1386 card->badsids = ll ist_create();1387 card->goodsids = ll ist_create();1388 card->remote_nodes = ll ist_create();1338 card->providers = ll_create(); 1339 card->badsids = ll_create(); 1340 card->goodsids = ll_create(); 1341 card->remote_nodes = ll_create(); 1389 1342 card->id = b2i(4, buf); 1390 1343 card->remote_id = b2i(4, buf + 4); … … 1396 1349 //cs_debug("cccam: card %08x added, caid %04X, hop %d, key %s, count %d", 1397 1350 // card->id, card->caid, card->hop, cs_hexdump(0, card->hexserial, 8), 1398 // ll ist_count(cc->cards));1351 // ll_count(cc->cards)); 1399 1352 1400 1353 int i; … … 1407 1360 prov->sa)); 1408 1361 1409 ll ist_append(card->providers, prov);1362 ll_append(card->providers, prov); 1410 1363 } 1411 1364 } … … 1416 1369 uint8 *remote_node = malloc(8); 1417 1370 memcpy(remote_node, ptr+i*8, 8); 1418 ll ist_append(card->remote_nodes, remote_node);1371 ll_append(card->remote_nodes, remote_node); 1419 1372 } 1420 1373 return card; … … 1439 1392 memcpy(buf + 12, card->hexserial, 8); 1440 1393 int j = 0; 1441 LLIST_D__ITR itr_prov;1442 struct cc_provider *prov = llist_itr_init(card->providers, &itr_prov);1443 while ( prov) {1394 LL_ITER *it = ll_iter_create(card->providers); 1395 struct cc_provider *prov; 1396 while ((prov = ll_iter_next(it))) { 1444 1397 ulong prid = prov->prov; 1445 1398 buf[21 + (j * 7)] = prid >> 16; … … 1447 1400 buf[23 + (j * 7)] = prid & 0xFF; 1448 1401 memcpy(buf + 24 + (j * 7), prov->sa, 4); 1449 prov = llist_itr_next(&itr_prov);1450 1402 j++; 1451 1403 } 1404 ll_iter_release(it); 1452 1405 buf[20] = j; 1453 1406 … … 1461 1414 struct cc_data *cc = cl->cc; 1462 1415 struct cc_card *card; 1463 LL IST_D__ITR itr;1416 LL_ITER *it = ll_iter_create(cc->cards); 1464 1417 1465 1418 pthread_mutex_lock(&cc->cards_busy); 1466 card = llist_itr_init(cc->cards, &itr); 1467 while (card) { 1419 while ((card = ll_iter_next(it))) { 1468 1420 if (card->id == shareid) {// && card->sub_id == b2i (3, buf + 9)) { 1469 1421 //cs_debug("cccam: card %08x removed, caid %04X, count %d", 1470 // card->id, card->caid, llist_count(cc->cards)); 1471 struct cc_card *next_card = llist_itr_remove(&itr); 1422 // card->id, card->caid, ll_count(cc->cards)); 1423 struct cc_card *next_card; 1424 ll_iter_remove(it); 1472 1425 struct cc_current_card *current_card; 1473 1426 while ((current_card = cc_find_current_card(cc, card))) { … … 1481 1434 cc->cards_modified++; 1482 1435 //break; 1483 } else {1484 card = llist_itr_next(&itr);1485 1436 } 1486 1437 } 1487 1438 pthread_mutex_unlock(&cc->cards_busy); 1439 ll_iter_release(it); 1488 1440 } 1489 1441 … … 1614 1566 //SS: Hack: 1615 1567 //Check if we already have this card: 1616 LLIST_D__ITR itr;1617 struct cc_card *old_card = llist_itr_init(cc->cards, &itr);1618 while ( old_card) {1568 LL_ITER *it = ll_iter_create(cc->cards); 1569 struct cc_card *old_card; 1570 while ((old_card = ll_iter_next(it))) { 1619 1571 if (old_card->id == card->id) { //we aready have this card, delete it 1620 1572 cc_free_card(card); … … 1622 1574 break; 1623 1575 } 1624 old_card = llist_itr_next(&itr);1625 } 1576 } 1577 ll_iter_release(it); 1626 1578 1627 1579 card->time = time((time_t) 0); 1628 1580 if (!old_card) 1629 ll ist_append(cc->cards, card);1581 ll_append(cc->cards, card); 1630 1582 cc->cards_modified++; 1631 1583 … … 2114 2066 //1. Copy nonexisting providers, ignore double: 2115 2067 struct cc_provider *prov_info; 2116 LLIST_D__ITR itr_dest; 2117 LLIST_D__ITR itr_src; 2118 struct cc_provider *provider = llist_itr_init(card->providers, &itr_src); 2119 while (provider) { 2120 prov_info = llist_itr_init(dest_card->providers, &itr_dest); 2121 while (prov_info) { 2068 LL_ITER *it_dst, *it_src = ll_iter_create(card->providers); 2069 struct cc_provider *provider; 2070 while ((provider = ll_iter_next(it_src))) { 2071 it_dst = ll_iter_create(dest_card->providers); 2072 while ((prov_info = ll_iter_next(it_dst))) { 2122 2073 if (prov_info->prov == provider->prov) 2123 2074 break; 2124 prov_info = llist_itr_next(&itr_dest);2125 } 2075 } 2076 ll_iter_release(it_dst); 2126 2077 if (!prov_info) { 2127 2078 struct cc_provider *prov_new = malloc(sizeof(struct cc_provider)); 2128 2079 memcpy(prov_new, provider, sizeof(struct cc_provider)); 2129 ll ist_append(dest_card->providers, prov_new);2080 ll_append(dest_card->providers, prov_new); 2130 2081 modified = 1; 2131 2082 } 2132 provider = llist_itr_next(&itr_src);2133 } 2083 } 2084 ll_iter_release(it_src); 2134 2085 2135 2086 if (copy_remote_nodes) { 2136 2087 //2. Copy nonexisting remote_nodes, ignoring existing: 2137 uint8 *remote_node = llist_itr_init(card->remote_nodes, &itr_src); 2088 it_src = ll_iter_create(card->remote_nodes); 2089 uint8 *remote_node; 2138 2090 uint8 *remote_node2; 2139 while ( remote_node) {2140 remote_node2 = llist_itr_init(dest_card->remote_nodes, &itr_dest);2141 while ( remote_node2) {2091 while ((remote_node = ll_iter_next(it_src))) { 2092 it_dst = ll_iter_create(dest_card->remote_nodes); 2093 while ((remote_node2 = ll_iter_next(it_dst))) { 2142 2094 if (memcmp(remote_node, remote_node2, 8) == 0) 2143 2095 break; 2144 remote_node2 = llist_itr_next(&itr_dest);2145 2096 } 2097 ll_iter_release(it_dst); 2146 2098 if (!remote_node2) { 2147 2099 uint8* remote_node_new = malloc(8); 2148 2100 memcpy(remote_node_new, remote_node, 8); 2149 ll ist_append(dest_card->remote_nodes, remote_node_new);2101 ll_append(dest_card->remote_nodes, remote_node_new); 2150 2102 modified = 1; 2151 2103 } 2152 remote_node = llist_itr_next(&itr_src);2153 } 2104 } 2105 ll_iter_release(it_src); 2154 2106 } 2155 2107 return modified; … … 2159 2111 struct cc_card *card2 = malloc(sizeof(struct cc_card)); 2160 2112 memcpy(card2, card, sizeof(struct cc_card)); 2161 card2->providers = ll ist_create();2162 card2->badsids = ll ist_create();2163 card2->goodsids = ll ist_create();2164 card2->remote_nodes = ll ist_create();2113 card2->providers = ll_create(); 2114 card2->badsids = ll_create(); 2115 card2->goodsids = ll_create(); 2116 card2->remote_nodes = ll_create(); 2165 2117 return card2; 2166 2118 } 2167 2119 2168 2120 int same_last_node(struct cc_card *card1, struct cc_card *card2) { 2169 2170 if (!card1->remote_nodes->last || !card2->remote_nodes->last) 2171 return 0; 2172 2173 uint8 *node1 = card1->remote_nodes->last->obj; 2174 uint8 *node2 = card2->remote_nodes->last->obj; 2121 uint8 *node1 = NULL, *node2 = NULL; 2122 int i; 2123 int nodes1 = ll_count(card1->remote_nodes), nodes2 = ll_count(card2->remote_nodes); 2124 2125 LL_ITER *it = ll_iter_create(card1->remote_nodes); 2126 for (i = 0; i < nodes1; i++) node1 = ll_iter_next(it); 2127 ll_iter_release(it); 2128 2129 it = ll_iter_create(card2->remote_nodes); 2130 for (i = 0; i < nodes2; i++) node2 = ll_iter_next(it); 2131 ll_iter_release(it); 2132 2133 if (!node1 || !node2) return 0; 2175 2134 2176 2135 return !memcmp(node1, node2, 8); … … 2180 2139 * Adds a new card to a cardlist. 2181 2140 */ 2182 int add_card_to_serverlist(LLIST _D_*cardlist, struct cc_card *card, int reshare) {2141 int add_card_to_serverlist(LLIST *cardlist, struct cc_card *card, int reshare) { 2183 2142 int modified = 0; 2184 LLIST_D__ITR itr;2185 struct cc_card *card2 = llist_itr_init(cardlist, &itr);2143 LL_ITER *it = ll_iter_create(cardlist); 2144 struct cc_card *card2; 2186 2145 2187 2146 //Minimize all, transmit just CAID 2188 2147 if (cfg->cc_minimize_cards == MINIMIZE_CAID) { 2189 while ( card2) {2148 while ((card2 = ll_iter_next(it))) 2190 2149 if (card2->caid == card->caid) 2191 2150 break; 2192 card2 = llist_itr_next(&itr);2193 }2194 2151 if (!card2) { 2195 2152 card2 = create_card(card); … … 2197 2154 card2->remote_id = card->remote_id; 2198 2155 card2->maxdown = reshare; 2199 ll ist_append(cardlist, card2);2156 ll_append(cardlist, card2); 2200 2157 modified = 1; 2201 2158 … … 2203 2160 struct cc_provider *prov_new = malloc(sizeof(struct cc_provider)); 2204 2161 memset(prov_new, 0, sizeof(struct cc_provider)); 2205 ll ist_append(card2->providers, prov_new);2162 ll_append(card2->providers, prov_new); 2206 2163 } else { 2207 2164 if (card->hop < card2->hop) { … … 2212 2169 2213 2170 } else if (cfg->cc_minimize_cards == MINIMIZE_HOPS) { 2214 while ( card2) {2215 if (card2->caid == card->caid && ll ist_count(card2->providers)2171 while ((card2 = ll_iter_next(it))) { 2172 if (card2->caid == card->caid && ll_count(card2->providers) 2216 2173 < CS_MAXPROV) 2217 2174 break; 2218 card2 = llist_itr_next(&itr);2219 2175 } 2220 2176 if (!card2) { … … 2223 2179 card2->remote_id = card->remote_id; 2224 2180 card2->maxdown = reshare; 2225 ll ist_append(cardlist, card2);2181 ll_append(cardlist, card2); 2226 2182 modified = 1; 2227 2183 } else { … … 2234 2190 modified = 1; 2235 2191 } else { 2236 while ( card2) {2192 while ((card2 = ll_iter_next(it))) { 2237 2193 if (card2->caid == card->caid 2238 2194 && card2->remote_id == card->remote_id 2239 2195 && same_last_node(card2, card)) 2240 2196 break; 2241 card2 = llist_itr_next(&itr);2242 2197 } 2243 2198 if (!card2) { … … 2246 2201 card2->remote_id = card->remote_id; 2247 2202 card2->maxdown = reshare; 2248 ll ist_append(cardlist, card2);2203 ll_append(cardlist, card2); 2249 2204 modified = 1; 2250 2205 if (add_card_providers(card2, card, 1)) … … 2252 2207 } 2253 2208 } 2209 ll_iter_release(it); 2254 2210 return modified; 2255 2211 } … … 2286 2242 id = cc->report_carddata_id; 2287 2243 2288 LLIST _D_ *server_cards = llist_create();2289 LLIST _D_ *reported_carddatas = llist_create();2244 LLIST *server_cards = ll_create(); 2245 LLIST *reported_carddatas = ll_create(); 2290 2246 2291 2247 int isau = is_au(cl); … … 2471 2427 pthread_mutex_lock(&rcc->cards_busy); 2472 2428 2473 LLIST_D__ITR itr; 2474 card = llist_itr_init(rcc->cards, &itr); 2475 while (card) { 2429 LL_ITER *it = ll_iter_create(rcc->cards); 2430 while ((card = ll_iter_next(it))) { 2476 2431 if (card->hop <= maxhops && 2477 2432 chk_ctab(card->caid, &cl->ctab) && chk_ctab( … … 2481 2436 int ignore = 0; 2482 2437 2483 LLIST_D__ITR itr_prov; 2484 struct cc_provider *prov = llist_itr_init( 2485 card->providers, &itr_prov); 2486 while (prov) { 2438 LL_ITER *it2 = ll_iter_create(card->providers); 2439 struct cc_provider *prov; 2440 while ((prov = ll_iter_next(it2))) { 2487 2441 ulong prid = prov->prov; 2488 prov = llist_itr_next(&itr_prov);2489 2442 if (!chk_srvid_by_caid_prov(cl, card->caid, prid) || 2490 2443 !chk_srvid_by_caid_prov(rdr->client, card->caid, prid)) { … … 2493 2446 } 2494 2447 } 2448 ll_iter_release(it2); 2495 2449 if (!ignore) { //Filtered by service 2496 2450 int new_reshare=cfg->cc_ignore_reshare?reshare:(card->maxdown-1); … … 2502 2456 } 2503 2457 } 2504 card = llist_itr_next(&itr);2505 2506 2458 } 2459 ll_iter_release(it); 2507 2460 pthread_mutex_unlock(&rcc->cards_busy); 2508 2461 } … … 2513 2466 2514 2467 //report reshare cards: 2515 //cs_debug_mask(D_TRACE, "%s reporting %d cards", getprefix(), ll ist_count(server_cards));2516 LLIST_D__ITR itr;2517 struct cc_card *card = llist_itr_init(server_cards, &itr);2518 while ( card) {2468 //cs_debug_mask(D_TRACE, "%s reporting %d cards", getprefix(), ll_count(server_cards)); 2469 LL_ITER *it = ll_iter_create(server_cards); 2470 struct cc_card *card; 2471 while ((card = ll_iter_next(it))) { 2519 2472 //cs_debug_mask(D_TRACE, "%s card %d caid %04X hop %d", getprefix(), card->id, card->caid, card->hop); 2520 2473 memset(buf, 0, sizeof(buf)); … … 2534 2487 memcpy(buf + 12, card->hexserial, 8); 2535 2488 int j = 0; 2536 LLIST_D__ITR itr_prov;2537 struct cc_provider *prov = llist_itr_init(card->providers, &itr_prov);2538 while ( prov) {2489 LL_ITER *it2 = ll_iter_create(card->providers); 2490 struct cc_provider *prov; 2491 while ((prov = ll_iter_next(it2))) { 2539 2492 ulong prid = prov->prov; 2540 2493 buf[21 + (j * 7)] = prid >> 16; … … 2543 2496 if (isau) 2544 2497 memcpy(buf+24+(j*7), prov->sa, 4); 2545 prov = llist_itr_next(&itr_prov);2546 2498 //cs_debug_mask(D_TRACE, "%s prov %06X", getprefix(), prid); 2547 2499 j++; 2548 2500 } 2501 ll_iter_release(it2); 2549 2502 buf[20] = j; 2550 2503 int ofs = 21+(j*7); 2551 buf[ofs] = 1+ll ist_count(card->remote_nodes);2504 buf[ofs] = 1+ll_count(card->remote_nodes); 2552 2505 //cs_debug_mask(D_TRACE, "%s count=%d", getprefix(), buf[ofs]); 2553 2506 ofs++; 2554 2507 2555 2508 //Add all the others node id: 2556 LL IST_D__ITR itr_node;2557 uint8 *remote_node = llist_itr_init(card->remote_nodes, &itr_node);2558 while ( remote_node) {2509 LL_ITER *itr_node = ll_iter_create(card->remote_nodes); 2510 uint8 *remote_node; 2511 while ((remote_node = ll_iter_next(itr_node))) { 2559 2512 memcpy(buf+ofs, remote_node, 8); 2560 remote_node = llist_itr_next(&itr_node);2561 2513 ofs+=8; 2562 2514 } 2515 ll_iter_release(itr_node); 2563 2516 2564 2517 //Add own node id: … … 2571 2524 cc_cmd_send(cl, buf, ofs, MSG_NEW_CARD); 2572 2525 cc_add_reported_carddata(cl, reported_carddatas, buf, ofs, &reader[r]); 2573 card = llist_itr_next(&itr);2574 } 2526 } 2527 ll_iter_release(it); 2575 2528 cc_free_cardlist(server_cards); 2576 2529 … … 2578 2531 cc->reported_carddatas = reported_carddatas; 2579 2532 2580 int count = ll ist_count(reported_carddatas);2533 int count = ll_count(reported_carddatas); 2581 2534 cs_log("%s reported %d cards to client", getprefix(), count); 2582 2535 return count; … … 2658 2611 cl->cc = cc; 2659 2612 memset(cl->cc, 0, sizeof(struct cc_data)); 2660 cc->extended_ecm_idx = ll ist_create();2613 cc->extended_ecm_idx = ll_create(); 2661 2614 2662 2615 cc_init_cc(cc); … … 2887 2840 } 2888 2841 memset(cc, 0, sizeof(struct cc_data)); 2889 cc->cards = ll ist_create();2842 cc->cards = ll_create(); 2890 2843 cl->cc = cc; 2891 cc->pending_emms = ll ist_create();2892 cc->extended_ecm_idx = ll ist_create();2893 cc->current_cards = ll ist_create();2844 cc->pending_emms = ll_create(); 2845 cc->extended_ecm_idx = ll_create(); 2846 cc->current_cards = ll_create(); 2894 2847 cc_init_cc(cc); 2895 2848 }else … … 2897 2850 if (cc->cards) 2898 2851 { 2899 LLIST_D__ITR itr; 2900 struct cc_card *card = llist_itr_init(cc->cards, &itr); 2901 while (card) 2902 { 2852 LL_ITER *it = ll_iter_create(cc->cards); 2853 struct cc_card *card; 2854 while ((card = ll_iter_next(it))) { 2903 2855 cc_free_card(card); 2904 card = llist_itr_remove(&itr); 2905 } 2906 } 2856 ll_iter_remove(it); 2857 } 2858 ll_iter_release(it); 2859 } 2907 2860 if (cc->current_cards) 2908 2861 free_current_cards(cc->current_cards); … … 3169 3122 cc_node_id[7] = sum & 0xff; 3170 3123 } 3124 -
trunk/module-cccam.h
r3592 r3600 8 8 #define MODULECCCAM_H_ 9 9 10 #include " module-obj-llist.h"10 #include "oscam-datastruct-llist.h" 11 11 12 12 #define CC_MAXMSGSIZE 512 … … 67 67 uint8 maxdown; 68 68 uint8 hexserial[8]; // card serial (for au) 69 LLIST _D_*providers; // providers (struct cc_provider)70 LLIST _D_*badsids; // sids that have failed to decode (struct cc_srvid)69 LLIST *providers; // providers (struct cc_provider) 70 LLIST *badsids; // sids that have failed to decode (struct cc_srvid) 71 71 time_t time; 72 LLIST _D_*goodsids; //sids that could decoded (struct cc_srvid)73 LLIST _D_*remote_nodes; //remote note id, 8 bytes72 LLIST *goodsids; //sids that could decoded (struct cc_srvid) 73 LLIST *remote_nodes; //remote note id, 8 bytes 74 74 }; 75 75 … … 130 130 uint8 receive_buffer[CC_MAXMSGSIZE]; 131 131 132 LLIST _D_*cards; // cards list132 LLIST *cards; // cards list 133 133 int cards_modified; 134 134 … … 136 136 int ecm_counter; 137 137 uint32 report_carddata_id; //Server only 138 LLIST _D_*reported_carddatas; //struct cc_reported_carddata //struct cc_reported_carddata138 LLIST *reported_carddatas; //struct cc_reported_carddata //struct cc_reported_carddata 139 139 int just_logged_in; //true for checking NOK direct after login 140 140 uint8 key_table; //key for CMD 0B 141 141 142 LLIST _D_*pending_emms; //pending emm list142 LLIST *pending_emms; //pending emm list 143 143 144 144 uint32 recv_ecmtask; 145 145 146 LLIST _D_*current_cards; //reader: current card cache146 LLIST *current_cards; //reader: current card cache 147 147 int server_ecm_pending; //initialized by server 148 LLIST _D_*server_caid_infos[CS_MAXREADER];148 LLIST *server_caid_infos[CS_MAXREADER]; 149 149 long server_caid_size[CS_MAXREADER]; 150 150 ushort server_ecm_idx; … … 159 159 //Extended Mode for SPECIAL clients: 160 160 int extended_mode; 161 LLIST _D_*extended_ecm_idx;161 LLIST *extended_ecm_idx; 162 162 }; 163 163 -
trunk/oscam-http.c
r3599 r3600 1605 1605 pthread_mutex_lock(&rcc->cards_busy); 1606 1606 1607 LLIST_D__ITR itr; 1608 card = llist_itr_init(rcc->cards, &itr); 1609 while (card) { 1610 char *node_str = malloc(llist_count(card->remote_nodes)*(16+2)); 1607 LL_ITER *it = ll_iter_create(rcc->cards); 1608 while ((card = ll_iter_next(it))) { 1609 char *node_str = malloc(ll_count(card->remote_nodes)*(16+2)); 1611 1610 char *node_ptr = node_str; 1612 LLIST_D__ITR nitr;1613 uint8 *node = llist_itr_init(card->remote_nodes, &nitr);1614 while ( node) {1611 LL_ITER *nit = ll_iter_create(card->remote_nodes); 1612 uint8 *node; 1613 while ((node = ll_iter_next(nit))) { 1615 1614 if (node_ptr != node_str) { 1616 1615 strcat(node_ptr, ","); … … 1620 1619 node[0], node[1], node[2], node[3], node[4], node[5], node[6], node[7]); 1621 1620 node_ptr += 16; 1622 node = llist_itr_next(&nitr);1623 1621 } 1622 ll_iter_release(nit); 1624 1623 1625 1624 tpl_printf(vars, 1, "LOGHISTORY", … … 1629 1628 1630 1629 int provcount = 0; 1631 LLIST_D__ITR pitr; 1632 struct cc_provider *prov = llist_itr_init(card->providers, 1633 &pitr); 1634 while (prov) { 1630 LL_ITER *pit = ll_iter_create(card->providers); 1631 struct cc_provider *prov; 1632 while ((prov = ll_iter_next(pit))) { 1635 1633 provider = get_provider(card->caid, prov->prov); 1636 1634 … … 1639 1637 " -- Provider %d: %06X -- %s<BR>\n", 1640 1638 provcount, prov->prov, provider); 1641 prov = llist_itr_next(&pitr);1642 1639 } 1640 ll_iter_release(pit); 1643 1641 1644 1642 tpl_addVar(vars, 1, "LOGHISTORY", "<BR>\n"); 1645 1643 caidcount++; 1646 card = llist_itr_next(&itr);1647 1644 } 1645 ll_iter_release(it); 1648 1646 pthread_mutex_unlock(&rcc->cards_busy); 1649 1647
Note:
See TracChangeset
for help on using the changeset viewer.