1 #define MODULE_LOG_PREFIX "cccam"
5 #if defined(MODULE_CCCAM) && defined(MODULE_CCCSHARE)
7 #include "module-cccam.h"
8 #include "module-cccam-data.h"
9 #include "module-cccshare.h"
10 #include "oscam-chk.h"
11 #include "oscam-client.h"
12 #include "oscam-lock.h"
13 #include "oscam-string.h"
14 #include "oscam-time.h"
15 #include "oscam-work.h"
17 extern uint32_t cfg_sidtab_generation
;
19 static uint32_t cc_share_id
= 0x64;
20 static LLIST
*reported_carddatas_list
[CAID_KEY
];
21 static CS_MUTEX_LOCK cc_shares_lock
;
23 static int32_t card_added_count
;
24 static int32_t card_removed_count
;
25 static int32_t card_dup_count
;
26 static pthread_t share_updater_thread
;
27 static bool share_updater_thread_active
;
28 static bool share_updater_refresh
;
30 int32_t card_valid_for_client(struct s_client
*cl
, struct cc_card
*card
);
33 LLIST
*get_cardlist(uint16_t caid
, LLIST
**list
)
35 caid
= (caid
>> 8) % CAID_KEY
;
37 { list
[caid
] = ll_create("card_list"); }
41 LLIST
**get_and_lock_sharelist(void)
43 cs_readlock(__func__
, &cc_shares_lock
);
44 return reported_carddatas_list
;
47 void unlock_sharelist(void)
49 cs_readunlock(__func__
, &cc_shares_lock
);
52 void add_good_sids(struct s_sidtab
*ptr
, struct cc_card
*card
)
55 for(l
= 0; l
< ptr
->num_srvid
; l
++)
57 struct cc_srvid
*srvid
;
58 if(!cs_malloc(&srvid
, sizeof(struct cc_srvid
)))
60 srvid
->sid
= ptr
->srvid
[l
];
62 srvid
->ecmlen
= 0; // 0=undefined, also not used with "O" CCcam
64 if(!ll_contains_data(card
->goodsids
, srvid
, sizeof(struct cc_srvid
)))
65 { ll_append(card
->goodsids
, srvid
); }
66 else { NULLFREE(srvid
);}
70 void add_bad_sids(struct s_sidtab
*ptr
, struct cc_card
*card
)
73 for(l
= 0; l
< ptr
->num_srvid
; l
++)
75 struct cc_srvid_block
*srvid
;
76 if(!cs_malloc(&srvid
, sizeof(struct cc_srvid_block
)))
78 srvid
->sid
= ptr
->srvid
[l
];
80 srvid
->ecmlen
= 0; // 0=undefined, also not used with "O" CCcam
81 srvid
->blocked_till
= 0;
83 if(!ll_contains_data(card
->badsids
, srvid
, sizeof(struct cc_srvid_block
)))
84 { ll_append(card
->badsids
, srvid
); }
85 else { NULLFREE(srvid
); }
89 void add_good_bad_sids_by_rdr(struct s_reader
*rdr
, struct cc_card
*card
)
93 for(n
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, n
++)
95 if(rdr
->sidtabs
.ok
& ((SIDTABBITS
)1 << n
))
97 for(i
= 0; i
< ptr
->num_caid
; i
++)
99 if(ptr
->caid
[i
] == card
->caid
)
100 { add_good_sids(ptr
, card
); }
103 else if(rdr
->sidtabs
.no
& ((SIDTABBITS
)1 << n
))
105 for(i
= 0; i
< ptr
->num_caid
; i
++)
107 if(ptr
->caid
[i
] == card
->caid
)
108 { add_bad_sids(ptr
, card
); }
114 int32_t can_use_ext(struct cc_card
*card
)
116 if(card
->card_type
== CT_REMOTECARD
)
117 { return card
->is_ext
; }
120 { return (card
->sidtab
->num_srvid
> 0); }
122 { return ll_count(card
->goodsids
) || ll_count(card
->badsids
); }
126 int32_t write_card(struct cc_data
*cc
, uint8_t *buf
, struct cc_card
*card
, int32_t add_own
, int32_t ext
, int32_t au_allowed
, struct s_client
*cl
)
128 memset(buf
, 0, CC_MAXMSGSIZE
);
129 buf
[0] = card
->id
>> 24;
130 buf
[1] = card
->id
>> 16;
131 buf
[2] = card
->id
>> 8;
132 buf
[3] = card
->id
& 0xff;
133 buf
[4] = card
->remote_id
>> 24;
134 buf
[5] = card
->remote_id
>> 16;
135 buf
[6] = card
->remote_id
>> 8;
136 buf
[7] = card
->remote_id
& 0xFF;
137 buf
[8] = card
->caid
>> 8;
138 buf
[9] = card
->caid
& 0xff;
140 buf
[11] = card
->reshare
;
142 { memcpy(buf
+ 12, card
->hexserial
, 8); }
144 // with cccam 2.2.0 we have assigned and rejected sids:
145 int32_t ofs
= ext
? 23 : 21;
148 LL_ITER it
= ll_iter_create(card
->providers
);
149 struct cc_provider
*prov
;
150 while((prov
= ll_iter_next(&it
)))
152 uint32_t prid
= prov
->prov
;
153 buf
[ofs
+ 0] = prid
>> 16;
154 buf
[ofs
+ 1] = prid
>> 8;
155 buf
[ofs
+ 2] = prid
& 0xFF;
157 { memcpy(buf
+ ofs
+ 3, prov
->sa
, 4); }
162 // write sids only if cccam 2.2.x:
168 struct s_sidtab
*ptr
= card
->sidtab
;
170 for(l
= 0; l
< ptr
->num_srvid
; l
++)
172 buf
[ofs
+ 0] = ptr
->srvid
[l
] >> 8;
173 buf
[ofs
+ 1] = ptr
->srvid
[l
] & 0xFF;
175 buf
[21]++; // nassign
182 for(n
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, n
++)
184 if((cl
->sidtabs
.no
& ((SIDTABBITS
)1 << n
)) || (card
->sidtabno
& ((SIDTABBITS
)1 << n
)))
188 for(m
= 0; m
< ptr
->num_caid
; m
++) // search bad sids for this caid:
190 if(ptr
->caid
[m
] == card
->caid
)
198 for(l
= 0; l
< ptr
->num_srvid
; l
++)
200 buf
[ofs
+ 0] = ptr
->srvid
[l
] >> 8;
201 buf
[ofs
+ 1] = ptr
->srvid
[l
] & 0xFF;
203 buf
[22]++; // nreject
217 it
= ll_iter_create(card
->goodsids
);
218 struct cc_srvid
*srvid
;
219 struct cc_srvid_block
*srvidblock
;
220 while((srvid
= ll_iter_next(&it
)))
222 buf
[ofs
+ 0] = srvid
->sid
>> 8;
223 buf
[ofs
+ 1] = srvid
->sid
& 0xFF;
225 buf
[21]++; // nassign
231 it
= ll_iter_create(card
->badsids
);
232 while((srvidblock
= ll_iter_next(&it
)))
234 if(srvidblock
->blocked_till
> 0)
238 buf
[ofs
+ 0] = srvidblock
->sid
>> 8;
239 buf
[ofs
+ 1] = srvidblock
->sid
& 0xFF;
241 buf
[22]++; // nreject
248 // write remote nodes
249 int32_t nremote_ofs
= ofs
;
251 it
= ll_iter_create(card
->remote_nodes
);
252 uint8_t *remote_node
;
253 while((remote_node
= ll_iter_next(&it
)))
255 memcpy(buf
+ ofs
, remote_node
, 8);
261 memcpy(buf
+ ofs
, cc
->node_id
, 8);
268 static int32_t is_client_au_allowed(struct cc_card
*card
, struct s_client
*cl
)
270 if(!card
|| !card
->origin_reader
)
275 if(!cl
|| !cl
->aureader_list
|| !ll_count(cl
->aureader_list
))
280 struct s_reader
*rdr
= NULL
;
281 LL_ITER itr
= ll_iter_create(cl
->aureader_list
);
282 while((rdr
= ll_iter_next(&itr
)))
284 if(rdr
== card
->origin_reader
)
293 static int32_t send_card_to_client(struct cc_card
*card
, struct s_client
*cl
)
295 uint8_t buf
[CC_MAXMSGSIZE
];
297 if(!card_valid_for_client(cl
, card
))
300 int8_t usr_reshare
= cl
->account
->cccreshare
;
301 if(usr_reshare
== -1)
302 { usr_reshare
= cfg
.cc_reshare
; }
304 int8_t ignorereshare
= cl
->account
->cccignorereshare
;
305 if(ignorereshare
== -1)
306 { ignorereshare
= cfg
.cc_ignore_reshare
; }
308 int8_t reader_reshare
= card
->origin_reader
? card
->rdr_reshare
: usr_reshare
;
309 if(reader_reshare
== -1)
310 { reader_reshare
= cfg
.cc_reshare
; }
312 int8_t reshare
= (reader_reshare
< usr_reshare
) ? reader_reshare
: usr_reshare
;
314 if(card
->card_type
== CT_CARD_BY_SERVICE_USER
)
316 new_reshare
= usr_reshare
;
318 else if(ignorereshare
)
320 new_reshare
= reshare
;
324 new_reshare
= card
->reshare
;
325 if(card
->card_type
== CT_REMOTECARD
)
327 if(new_reshare
> reshare
)
328 { new_reshare
= reshare
; }
334 { card
->id
= cc_share_id
++; }
336 struct cc_data
*cc
= cl
->cc
;
337 int32_t is_ext
= cc
->cccam220
&& can_use_ext(card
);
338 int32_t len
= write_card(cc
, buf
, card
, 1, is_ext
, is_client_au_allowed(card
, cl
), cl
);
339 //buf[10] = card->hop-1;
340 buf
[11] = new_reshare
;
342 struct s_clientmsg
*clientmsg
;
343 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
345 memcpy(clientmsg
->msg
, buf
, len
);
346 clientmsg
->len
= len
;
347 clientmsg
->cmd
= is_ext
? MSG_NEW_CARD_SIDINFO
: MSG_NEW_CARD
;
348 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
353 int32_t hide_card_to_client(struct cc_card
*card
, struct s_client
*cl
)
355 if(!card
|| !card
->id
)
359 buf
[0] = card
->id
>> 24;
360 buf
[1] = card
->id
>> 16;
361 buf
[2] = card
->id
>> 8;
362 buf
[3] = card
->id
& 0xFF;
364 struct s_clientmsg
*clientmsg
;
365 struct cc_data
*cc
= cl
->cc
;
366 if(cc
&& (cl
->typ
== 'c') && !cl
->kill
&& (get_module(cl
)->num
== R_CCCAM
)) //CCCam-Client!
368 if(card_valid_for_client(cl
, card
))
370 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
372 memcpy(clientmsg
->msg
, buf
, sizeof(buf
));
373 clientmsg
->len
= sizeof(buf
);
374 clientmsg
->cmd
= MSG_CARD_REMOVED
;
375 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
383 int32_t unhide_card_to_client(struct cc_card
*card
, struct s_client
*cl
)
385 return send_card_to_client(card
, cl
);
388 int32_t hidecards_card_valid_for_client(struct s_client
*cl
, struct cc_card
*card
)
390 return card_valid_for_client(cl
, card
);
393 int32_t send_card_to_all_clients(struct cc_card
*card
)
397 cs_readlock(__func__
, &clientlist_lock
);
398 for(cl
= first_client
; cl
; cl
= cl
->next
)
400 if(cl
->cc
&& cl
->typ
== 'c' && !cl
->kill
&& get_module(cl
)->num
== R_CCCAM
) // CCCam-Client!
402 count
+= send_card_to_client(card
, cl
);
405 cs_readunlock(__func__
, &clientlist_lock
);
409 void send_remove_card_to_clients(struct cc_card
*card
)
411 if(!card
|| !card
->id
)
415 buf
[0] = card
->id
>> 24;
416 buf
[1] = card
->id
>> 16;
417 buf
[2] = card
->id
>> 8;
418 buf
[3] = card
->id
& 0xFF;
421 struct s_clientmsg
*clientmsg
;
422 cs_readlock(__func__
, &clientlist_lock
);
423 for(cl
= first_client
; cl
; cl
= cl
->next
)
425 struct cc_data
*cc
= cl
->cc
;
426 if(cc
&& cl
->typ
== 'c' && !cl
->kill
&& get_module(cl
)->num
== R_CCCAM
) // CCCam-Client!
428 if(card_valid_for_client(cl
, card
))
430 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
432 memcpy(clientmsg
->msg
, buf
, sizeof(buf
));
433 clientmsg
->len
= sizeof(buf
);
434 clientmsg
->cmd
= MSG_CARD_REMOVED
;
435 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
440 cs_readunlock(__func__
, &clientlist_lock
);
445 * if idents defined on an cccam reader, the cards caid+provider are checked.
446 * return 1 a) if no ident defined b) card is in identlist
447 * 0 if card is not in identlist
449 * a card is in the identlist, if the cards caid is matching and mininum a provider is matching
451 int32_t chk_ident(FTAB
*ftab
, struct cc_card
*card
)
457 if(ftab
&& ftab
->filts
)
459 for(j
= 0; j
< ftab
->nfilts
; j
++)
461 if(ftab
->filts
[j
].caid
)
464 if(ftab
->filts
[j
].caid
== card
->caid
) // caid matches!
467 int32_t nprids
= ftab
->filts
[j
].nprids
;
468 if(!nprids
) // No Provider ->Ok
472 LL_ITER it
= ll_iter_create(card
->providers
);
473 struct cc_provider
*prov
;
475 while((prov
= ll_iter_next(&it
)))
477 for(k
= 0; k
< nprids
; k
++)
479 uint32_t prid
= ftab
->filts
[j
].prids
[k
];
480 if(prid
== prov
->prov
) // Provider matches
493 int32_t cc_clear_reported_carddata(LLIST
*reported_carddatas
, LLIST
*except
, int32_t send_removed
)
496 LL_ITER it
= ll_iter_create(reported_carddatas
);
497 struct cc_card
*card
;
498 while((card
= ll_iter_next(&it
)))
500 struct cc_card
*card2
= NULL
;
503 LL_ITER it2
= ll_iter_create(except
);
504 while((card2
= ll_iter_next(&it2
)))
511 if(!card2
&& ll_iter_remove(&it
)) // check result of ll_iter_remove, because another thread could removed it
515 cs_log_dbg(D_TRACE
, "s-card removed: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
516 card
->id
, card
->remote_id
, card
->caid
, card
->hop
, card
->reshare
, card
->origin_id
, card
->card_type
);
518 send_remove_card_to_clients(card
);
527 int32_t cc_free_reported_carddata(LLIST
*reported_carddatas
, LLIST
*except
, int32_t send_removed
)
530 if(reported_carddatas
)
532 i
= cc_clear_reported_carddata(reported_carddatas
, except
, send_removed
);
533 ll_destroy(&reported_carddatas
);
538 int32_t card_valid_for_client(struct s_client
*cl
, struct cc_card
*card
)
542 if(card
->grp
&& !(card
->grp
& cl
->grp
))
546 if(!chk_ident(&cl
->ftab
, card
))
550 if(!chk_ctab(card
->caid
, &cl
->ctab
))
554 if(card
->card_type
== CT_REMOTECARD
)
556 int8_t ignorereshare
= cl
->account
->cccignorereshare
;
557 if(ignorereshare
== -1) { ignorereshare
= cfg
.cc_ignore_reshare
; }
558 if(!ignorereshare
&& !card
->reshare
)
562 // Check account maxhops:
563 if(cl
->account
->cccmaxhops
< card
->hop
)
566 // Check remote node id, if card is from there, ignore it!
567 LL_ITER it
= ll_iter_create(card
->remote_nodes
);
569 struct cc_data
*cc
= cl
->cc
;
570 while((node
= ll_iter_next(&it
)))
572 if(!memcmp(node
, cc
->peer_node_id
, 8))
579 if(ll_count(card
->providers
))
581 it
= ll_iter_create(card
->providers
);
582 struct cc_provider
*prov
;
584 while((prov
= ll_iter_next(&it
)))
586 uint32_t prid
= prov
->prov
;
587 if(chk_srvid_by_caid_prov(cl
, card
->caid
, prid
))
593 if(!found
) { return 0; }
597 if(!chk_srvid_by_caid_prov(cl
, card
->caid
, 0))
601 // Check Card created by Service:
604 struct s_sidtab
*ptr
;
606 int32_t ok
= !cl
->sidtabs
.ok
&& !cl
->sidtabs
.no
; // default valid if no positive services and no negative services
609 if(!cl
->sidtabs
.ok
) // no positive services, so ok by default if no negative found
612 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
614 if(ptr
== card
->sidtab
)
616 if(cl
->sidtabs
.no
& ((SIDTABBITS
)1 << j
))
618 if(cl
->sidtabs
.ok
& ((SIDTABBITS
)1 << j
))
631 uint32_t get_reader_prid(struct s_reader
*rdr
, int32_t j
)
633 return b2i(3, &rdr
->prid
[j
][1]);
635 //uint32_t get_reader_prid(struct s_reader *rdr, int32_t j) {
637 // if (!is_cascading_reader(rdr)) { // Real cardreaders have 4-byte Providers
638 // prid = b2i(4, &rdr->prid[j][0]);
639 // //prid = (rdr->prid[j][0] << 24) | (rdr->prid[j][1] << 16)
640 // // | (rdr->prid[j][2] << 8) | (rdr->prid[j][3] & 0xFF);
641 // } else { // Cascading/Network-reader 3-bytes Providers
642 // prid = b2i(3, &rdr->prid[j][0]);
643 // //prid = (rdr->prid[j][0] << 16) | (rdr->prid[j][1] << 8)
644 // // | (rdr->prid[j][2] & 0xFF);
650 void copy_good_sids(LLIST
*dst
, LLIST
*src
)
652 LL_ITER it_src
= ll_iter_create(src
);
653 LL_ITER it_dst
= ll_iter_create(dst
);
654 struct cc_srvid
*srvid_src
;
655 struct cc_srvid
*srvid_dst
;
656 while((srvid_src
= ll_iter_next(&it_src
)))
658 ll_iter_reset(&it_dst
);
659 while((srvid_dst
= ll_iter_next(&it_dst
)))
661 if(sid_eq(srvid_src
, srvid_dst
))
666 if(!cs_malloc(&srvid_dst
, sizeof(struct cc_srvid
)))
668 memcpy(srvid_dst
, srvid_src
, sizeof(struct cc_srvid
));
669 ll_iter_insert(&it_dst
, srvid_dst
);
674 void copy_bad_sids(LLIST
*dst
, LLIST
*src
)
676 LL_ITER it_src
= ll_iter_create(src
);
677 LL_ITER it_dst
= ll_iter_create(dst
);
678 struct cc_srvid_block
*srvid_src
;
679 struct cc_srvid_block
*srvid_dst
;
680 while((srvid_src
= ll_iter_next(&it_src
)))
682 ll_iter_reset(&it_dst
);
683 while((srvid_dst
= ll_iter_next(&it_dst
)))
685 if(sid_eq_bb(srvid_src
, srvid_dst
))
690 if(!cs_malloc(&srvid_dst
, sizeof(struct cc_srvid_block
)))
692 memcpy(srvid_dst
, srvid_src
, sizeof(struct cc_srvid_block
));
693 ll_iter_insert(&it_dst
, srvid_dst
);
698 int32_t add_card_providers(struct cc_card
*dest_card
, struct cc_card
*card
, int32_t copy_remote_nodes
)
700 int32_t modified
= 0;
702 // 1. Copy nonexisting providers, ignore double:
703 struct cc_provider
*prov_info
;
704 LL_ITER it_src
= ll_iter_create(card
->providers
);
705 LL_ITER it_dst
= ll_iter_create(dest_card
->providers
);
707 struct cc_provider
*provider
;
708 while((provider
= ll_iter_next(&it_src
)))
710 ll_iter_reset(&it_dst
);
711 while((prov_info
= ll_iter_next(&it_dst
)))
713 if(prov_info
->prov
== provider
->prov
)
718 struct cc_provider
*prov_new
;
719 if(!cs_malloc(&prov_new
, sizeof(struct cc_provider
)))
721 memcpy(prov_new
, provider
, sizeof(struct cc_provider
));
722 ll_iter_insert(&it_dst
, prov_new
);
727 if(copy_remote_nodes
)
729 // 2. Copy nonexisting remote_nodes, ignoring existing:
730 it_src
= ll_iter_create(card
->remote_nodes
);
731 it_dst
= ll_iter_create(dest_card
->remote_nodes
);
732 uint8_t *remote_node
;
733 uint8_t *remote_node2
;
734 while((remote_node
= ll_iter_next(&it_src
)))
736 ll_iter_reset(&it_dst
);
737 while((remote_node2
= ll_iter_next(&it_dst
)))
739 if(memcmp(remote_node
, remote_node2
, 8) == 0)
744 uint8_t *remote_node_new
;
745 if(!cs_malloc(&remote_node_new
, 8))
747 memcpy(remote_node_new
, remote_node
, 8);
748 ll_iter_insert(&it_dst
, remote_node_new
);
756 #define TIMEOUT_SECONDS 3600
758 void set_card_timeout(struct cc_card
*card
)
760 card
->timeout
= time(NULL
) + TIMEOUT_SECONDS
+ ((rand() & 0xff) - 128) * 2;
763 struct cc_card
*create_card(struct cc_card
*card
)
765 struct cc_card
*card2
;
766 if(!cs_malloc(&card2
, sizeof(struct cc_card
)))
769 { memcpy(card2
, card
, sizeof(struct cc_card
)); }
771 { memset(card2
, 0, sizeof(struct cc_card
)); }
772 card2
->providers
= ll_create("providers");
773 card2
->badsids
= ll_create("badsids");
774 card2
->goodsids
= ll_create("goodsids");
775 card2
->remote_nodes
= ll_create("remote_nodes");
779 copy_good_sids(card2
->goodsids
, card
->goodsids
);
780 copy_bad_sids(card2
->badsids
, card
->badsids
);
784 { set_card_timeout(card2
); }
789 struct cc_card
*create_card2(struct s_reader
*rdr
, int32_t j
, uint16_t caid
, uint8_t reshare
)
792 struct cc_card
*card
= create_card(NULL
);
795 card
->remote_id
= (rdr
? (rdr
->cc_id
<< 16) : 0x7F7F8000) | j
;
797 card
->reshare
= reshare
;
798 card
->origin_reader
= rdr
;
801 card
->grp
= rdr
->grp
;
802 card
->rdr_reshare
= rdr
->cc_reshare
> -1 ? rdr
->cc_reshare
: cfg
.cc_reshare
; //copy reshare because reader could go offline
803 card
->sidtabno
= rdr
->sidtabs
.no
;
804 card
->hop
= rdr
->cc_hop
;
806 else { card
->rdr_reshare
= reshare
; }
811 * num_same_providers checks if card1 has exactly the same providers as card2
812 * returns same provider count
814 int32_t num_same_providers(struct cc_card
*card1
, struct cc_card
*card2
)
819 LL_ITER it1
= ll_iter_create(card1
->providers
);
820 LL_ITER it2
= ll_iter_create(card2
->providers
);
822 struct cc_provider
*prov1
, *prov2
;
824 while((prov1
= ll_iter_next(&it1
)))
828 while((prov2
= ll_iter_next(&it2
)))
830 if(prov1
->prov
== prov2
->prov
)
842 * equal_providers checks if card1 has exactly the same providers as card2
843 * returns 1=equal 0=different
845 int32_t equal_providers(struct cc_card
*card1
, struct cc_card
*card2
)
848 if(ll_count(card1
->providers
) != ll_count(card2
->providers
))
850 if(ll_count(card1
->providers
) == 0)
853 LL_ITER it1
= ll_iter_create(card1
->providers
);
854 LL_ITER it2
= ll_iter_create(card2
->providers
);
856 struct cc_provider
*prov1
, *prov2
;
858 while((prov1
= ll_iter_next(&it1
)))
862 while((prov2
= ll_iter_next(&it2
)))
864 if(prov1
->prov
== prov2
->prov
)
870 if(!prov2
) { break; }
872 return (prov1
== NULL
);
875 int32_t is_au_card(struct cc_card
*card
)
877 if(card
&& card
->origin_reader
)
878 { return !card
->origin_reader
->audisabled
&& cc_UA_valid(card
->hexserial
); }
882 void merge_sids(struct cc_card
*carddst
, struct cc_card
*cardsrc
)
885 struct cc_srvid
*srvid
;
886 struct cc_srvid_block
*srvidb
;
888 int32_t goodSidCountSrc
= ll_count(cardsrc
->goodsids
);
889 int32_t goodSidCountDst
= ll_count(carddst
->goodsids
);
891 if(goodSidCountDst
== 0)
893 // remove sid blocks good+notbad from src
894 it
= ll_iter_create(cardsrc
->goodsids
);
895 while((srvid
= ll_iter_next(&it
)))
897 if(!is_sid_blocked(cardsrc
, srvid
))
898 { remove_sid_block(carddst
, srvid
); }
903 if(goodSidCountSrc
== 0)
905 // del goods from dst
906 ll_clear(carddst
->goodsids
);
909 ll_clear(carddst
->badsids
);
912 it
= ll_iter_create(cardsrc
->badsids
);
913 while((srvidb
= ll_iter_next(&it
)))
915 { add_sid_block(carddst
, (struct cc_srvid
*)srvidb
, false); }
920 // add good sid good+notbad from src
921 it
= ll_iter_create(cardsrc
->goodsids
);
922 while((srvid
= ll_iter_next(&it
)))
924 if(!is_sid_blocked(cardsrc
, srvid
))
925 { add_good_sid(carddst
, srvid
); }
933 * Adds a new card to a cardlist.
935 int32_t add_card_to_serverlist(LLIST
*cardlist
, struct cc_card
*card
, int8_t free_card
)
938 int32_t modified
= 0;
942 LL_ITER it
= ll_iter_create(cardlist
);
943 struct cc_card
*card2
;
945 // Minimize all, transmit just CAID, merge providers:
946 if(cfg
.cc_minimize_cards
== MINIMIZE_CAID
&& !cfg
.cc_forward_origin_card
)
948 while((card2
= ll_iter_next(&it
)))
950 // compare caid, hexserial, cardtype and sidtab (if any):
951 if(same_card2(card
, card2
, 0))
953 // Merge cards only if resulting providercount is smaller than CS_MAXPROV
954 int32_t nsame
, ndiff
, nnew
;
956 nsame
= num_same_providers(card
, card2
); // count same cards
957 ndiff
= ll_count(card
->providers
) - nsame
; // cound different cards, this cound will be added
958 nnew
= ndiff
+ ll_count(card2
->providers
); // new card count after add. because its limited to CS_MAXPROV, dont add it
960 if(nnew
<= CS_MAXPROV
)
965 if(!card2
) // Not found->add it:
967 if(free_card
) // Use this card
970 ll_iter_insert(&it
, card
);
974 card2
= create_card(card
); // Copy card
978 ll_iter_insert(&it
, card2
);
979 add_card_providers(card2
, card
, 1); // copy providers to new card. Copy remote nodes to new card
984 else // found, merge providers:
987 card2
->grp
|= card
->grp
; // add group to the card
988 add_card_providers(card2
, card
, 0); // merge all providers
989 ll_clear_data(card2
->remote_nodes
); // clear remote nodes
990 merge_sids(card2
, card
);
994 // Removed duplicate cards, keeping card with lower hop:
995 else if(cfg
.cc_minimize_cards
== MINIMIZE_HOPS
&& !cfg
.cc_forward_origin_card
)
997 while((card2
= ll_iter_next(&it
)))
999 // compare caid, hexserial, cardtype, sidtab (if any), providers:
1000 if(same_card2(card
, card2
, 0) && equal_providers(card
, card2
))
1006 if(card2
&& card2
->hop
> card
->hop
) // hop is smaller, drop old card
1008 ll_iter_remove(&it
);
1009 cc_free_card(card2
);
1014 if(!card2
) // Not found->add it:
1016 if(free_card
) // use this card
1019 ll_iter_insert(&it
, card
);
1023 card2
= create_card(card
); // copy card
1025 { return modified
; }
1026 ll_iter_insert(&it
, card2
);
1027 add_card_providers(card2
, card
, 1); // copy providers to new card. Copy remote nodes to new card
1031 else // found, merge cards (providers are same!)
1034 card2
->grp
|= card
->grp
; //add group to the card
1035 add_card_providers(card2
, card
, 0);
1036 merge_sids(card2
, card
);
1041 else // just remove duplicate cards (same ids)
1043 while((card2
= ll_iter_next(&it
)))
1045 // compare remote_id, first_node, caid, hexserial, cardtype, sidtab (if any), providers:
1046 if(same_card(card
, card2
))
1050 if(card2
&& card2
->hop
> card
->hop
) // same card, if hop greater drop card
1052 ll_iter_remove(&it
);
1053 cc_free_card(card2
);
1057 if(!card2
) // Not found, add it:
1062 ll_iter_insert(&it
, card
);
1066 card2
= create_card(card
);
1068 { return modified
; }
1069 ll_iter_insert(&it
, card2
);
1070 add_card_providers(card2
, card
, 1);
1074 else // Found, everything is same (including providers)
1081 { cc_free_card(card
); }
1087 * returns true if timeout-time is reached
1088 * only local cards needs to be renewed after 1h. "O" CCCam throws away cards older than 1,2h
1090 int32_t card_timed_out(struct cc_card
*card
)
1092 //!=CT_REMOTECARD = LOCALCARD (or virtual cards by caid/ident/service)
1093 //timeout is set in future, so if current time is bigger, timeout is reached
1094 int32_t res
= (card
->card_type
!= CT_REMOTECARD
) && (card
->timeout
< time(NULL
)); //local card is older than 1h?
1096 { cs_log_dbg(D_TRACE
, "card %08X timed out! refresh forced", card
->id
? card
->id
: card
->origin_id
); }
1101 * returns true if card1 is already reported.
1102 * "reported" means, we already have this card1 in our sharelist.
1103 * if the card1 is already reported, we throw it away, because we build a new sharelist
1104 * so after finding all reported cards, we have a list of reported cards, which aren't used anymore
1106 int32_t find_reported_card(struct cc_card
*card1
)
1108 LL_ITER it
= ll_iter_create(get_cardlist(card1
->caid
, reported_carddatas_list
));
1109 struct cc_card
*card2
;
1110 while((card2
= ll_iter_next(&it
)))
1112 if(same_card(card1
, card2
) && !card_timed_out(card2
))
1114 card1
->id
= card2
->id
; //Set old id !!
1115 card1
->timeout
= card2
->timeout
;
1116 cc_free_card(card2
);
1117 ll_iter_remove(&it
);
1118 return 1; //Old card and new card are equal!
1121 return 0; //Card not found
1126 * Adds a cccam-carddata buffer to the list of reported carddatas
1128 void cc_add_reported_carddata(LLIST
*reported_carddatas
, struct cc_card
*card
)
1130 ll_append(reported_carddatas
, card
);
1134 * adds the card to the list of the new reported carddatas - this is the new sharelist
1135 * if this card is not already reported, we send them to the clients
1136 * if this card is already reported, find_reported_card throws the "origin" card away
1137 * so the "old" sharelist is reduced
1139 void report_card(struct cc_card
*card
, LLIST
*new_reported_carddatas
, LLIST
*new_cards
)
1141 if(!find_reported_card(card
)) //Add new card:
1144 cs_log_dbg(D_TRACE
, "s-card added: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
1145 card
->id
, card
->remote_id
, card
->caid
, card
->hop
, card
->reshare
, card
->origin_id
, card
->card_type
);
1147 ll_append(new_cards
, card
);
1151 cc_add_reported_carddata(new_reported_carddatas
, card
);
1157 * Reports all caid/providers to the connected clients
1158 * returns 1=ok, 0=error
1159 * cfg.cc_reshare_services =0 CCCAM reader reshares only received cards + defined reader services
1160 * =1 CCCAM reader reshares received cards + defined services
1161 * =2 CCCAM reader reshares only defined reader-services as virtual cards
1162 * =3 CCCAM reader reshares only defined user-services as virtual cards
1163 * =4 CCCAM reader reshares only received cards
1165 void update_card_list(void)
1167 int32_t i
, j
, k
, l
, card_count
= 0;
1169 LLIST
*server_cards
[CAID_KEY
];
1170 LLIST
*new_reported_carddatas
[CAID_KEY
];
1173 struct cc_card
*card
;
1175 memset(server_cards
, 0, sizeof(server_cards
));
1176 memset(new_reported_carddatas
, 0, sizeof(new_reported_carddatas
));
1178 card_added_count
= 0;
1179 card_removed_count
= 0;
1183 if(cfg
.cc_reshare_services
== 3 && cfg
.sidtab
)
1185 struct s_sidtab
*ptr
;
1186 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
1188 for(k
= 0; k
< ptr
->num_caid
; k
++)
1190 card
= create_card2(NULL
, (j
<< 8) | k
, ptr
->caid
[k
], cfg
.cc_reshare
);
1193 card
->card_type
= CT_CARD_BY_SERVICE_USER
;
1195 for(l
= 0; l
< ptr
->num_provid
; l
++)
1197 struct cc_provider
*prov
;
1198 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1200 prov
->prov
= ptr
->provid
[l
];
1201 ll_append(card
->providers
, prov
);
1204 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 1);
1211 struct s_reader
*rdr
;
1214 cs_readlock(__func__
, &readerlist_lock
);
1216 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1218 //Generate a uniq reader id:
1222 struct s_reader
*rdr2
;
1223 for(rdr2
= first_active_reader
; rdr2
; rdr2
= rdr2
->next
)
1225 if(rdr2
!= rdr
&& rdr2
->cc_id
== rdr
->cc_id
)
1227 rdr2
= first_active_reader
;
1235 int8_t reshare
= rdr
->cc_reshare
> -1 ? rdr
->cc_reshare
: cfg
.cc_reshare
;
1238 if((cfg
.cc_reshare_services
== 1 || cfg
.cc_reshare_services
== 2 || (!rdr
->caid
&& rdr
->typ
!= R_CCCAM
&& cfg
.cc_reshare_services
!= 4)) &&
1239 cfg
.sidtab
&& (rdr
->sidtabs
.no
|| rdr
->sidtabs
.ok
))
1241 struct s_sidtab
*ptr
;
1242 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
1244 if(!(rdr
->sidtabs
.no
& ((SIDTABBITS
)1 << j
)) && (rdr
->sidtabs
.ok
& ((SIDTABBITS
)1 << j
)))
1246 for(k
= 0; k
< ptr
->num_caid
; k
++)
1248 card
= create_card2(rdr
, (j
<< 8) | k
, ptr
->caid
[k
], reshare
);
1251 cs_readunlock(__func__
, &readerlist_lock
);
1254 card
->card_type
= CT_CARD_BY_SERVICE_READER
;
1256 for(l
= 0; l
< ptr
->num_provid
; l
++)
1258 struct cc_provider
*prov
;
1259 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1261 cs_readunlock(__func__
, &readerlist_lock
);
1264 prov
->prov
= ptr
->provid
[l
];
1265 ll_append(card
->providers
, prov
);
1268 if(chk_ident(&rdr
->ftab
, card
) && chk_ctab(card
->caid
, &rdr
->ctab
))
1270 if(!rdr
->audisabled
)
1271 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, card
->caid
); }
1273 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 1);
1277 { cc_free_card(card
); }
1283 //Filts by Hardware readers:
1284 if((rdr
->typ
!= R_CCCAM
) && rdr
->ftab
.filts
&& !flt
)
1286 for(j
= 0; j
< rdr
->ftab
.nfilts
; j
++)
1288 uint16_t caid
= rdr
->ftab
.filts
[j
].caid
;
1291 card
= create_card2(rdr
, j
, caid
, reshare
);
1294 cs_readunlock(__func__
, &readerlist_lock
);
1297 card
->card_type
= CT_LOCALCARD
;
1299 //Setting UA: (Unique Address):
1300 if(!rdr
->audisabled
)
1301 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1302 //cs_log("Ident CCcam card report caid: %04X readr %s subid: %06X", rdr->ftab.filts[j].caid, rdr->label, rdr->cc_id);
1303 for(k
= 0; k
< rdr
->ftab
.filts
[j
].nprids
; k
++)
1305 struct cc_provider
*prov
;
1306 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1308 cs_readunlock(__func__
, &readerlist_lock
);
1311 prov
->prov
= rdr
->ftab
.filts
[j
].prids
[k
];
1313 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1314 if(!rdr
->audisabled
)
1316 for(l
= 0; l
< rdr
->nprov
; l
++)
1318 uint32_t rprid
= get_reader_prid(rdr
, l
);
1319 if(rprid
== prov
->prov
)
1320 { cc_SA_oscam2cccam(&rdr
->sa
[l
][0], prov
->sa
); }
1324 ll_append(card
->providers
, prov
);
1327 add_good_bad_sids_by_rdr(rdr
, card
);
1328 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1334 if((rdr
->typ
!= R_CCCAM
) && !rdr
->caid
&& !flt
)
1336 for(j
= 0; j
< rdr
->ctab
.ctnum
; j
++)
1338 CAIDTAB_DATA
*d
= &rdr
->ctab
.ctdata
[j
];
1339 //cs_log("CAID map CCcam card report caid: %04X cmap: %04X", d->caid, d->cmap);
1340 uint16_t lcaid
= d
->caid
;
1342 if(!lcaid
|| (lcaid
== 0xFFFF))
1343 { lcaid
= d
->cmap
; }
1345 if(lcaid
&& (lcaid
!= 0xFFFF))
1347 card
= create_card2(rdr
, j
, lcaid
, reshare
);
1350 cs_readunlock(__func__
, &readerlist_lock
);
1353 card
->card_type
= CT_CARD_BY_CAID1
;
1354 if(!rdr
->audisabled
)
1355 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, lcaid
); }
1357 add_good_bad_sids_by_rdr(rdr
, card
);
1358 add_card_to_serverlist(get_cardlist(lcaid
, server_cards
), card
, 1);
1364 if((rdr
->typ
!= R_CCCAM
) && rdr
->ctab
.ctnum
&& !flt
)
1366 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1368 if(rdr
->tcp_connected
|| rdr
->card_status
== CARD_INSERTED
)
1370 for(c
= 0; c
< rdr
->ctab
.ctnum
; c
++)
1372 CAIDTAB_DATA
*d
= &rdr
->ctab
.ctdata
[c
];
1373 uint16_t caid
= d
->caid
;
1374 if(!caid
) { break; }
1376 card
= create_card2(rdr
, c
, caid
, reshare
);
1379 card
->card_type
= CT_CARD_BY_CAID2
;
1381 if(!rdr
->audisabled
)
1382 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1383 for(j
= 0; j
< rdr
->nprov
; j
++)
1385 uint32_t prid
= get_reader_prid(rdr
, j
);
1386 struct cc_provider
*prov
;
1387 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1389 cs_readunlock(__func__
, &readerlist_lock
);
1393 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1394 if(!rdr
->audisabled
)
1396 //Setting SA (Shared Addresses):
1397 cc_SA_oscam2cccam(rdr
->sa
[j
], prov
->sa
);
1399 ll_append(card
->providers
, prov
);
1400 //cs_log("Main CCcam card report provider: %02X%02X%02X%02X", buf[21+(j*7)], buf[22+(j*7)], buf[23+(j*7)], buf[24+(j*7)]);
1402 add_good_bad_sids_by_rdr(rdr
, card
);
1403 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1410 if((rdr
->typ
!= R_CCCAM
) && rdr
->caid
&& !flt
)
1412 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1413 if(rdr
->tcp_connected
|| rdr
->card_status
== CARD_INSERTED
)
1415 uint16_t caid
= rdr
->caid
;
1416 card
= create_card2(rdr
, 1, caid
, reshare
);
1419 cs_readunlock(__func__
, &readerlist_lock
);
1422 card
->card_type
= CT_CARD_BY_CAID3
;
1424 if(!rdr
->audisabled
)
1425 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1426 for(j
= 0; j
< rdr
->nprov
; j
++)
1428 uint32_t prid
= get_reader_prid(rdr
, j
);
1429 struct cc_provider
*prov
;
1430 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1432 cs_readunlock(__func__
, &readerlist_lock
);
1436 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1437 if(!rdr
->audisabled
)
1439 //Setting SA (Shared Addresses):
1440 cc_SA_oscam2cccam(rdr
->sa
[j
], prov
->sa
);
1442 ll_append(card
->providers
, prov
);
1443 //cs_log("Main CCcam card report provider: %02X%02X%02X%02X", buf[21+(j*7)], buf[22+(j*7)], buf[23+(j*7)], buf[24+(j*7)]);
1445 add_good_bad_sids_by_rdr(rdr
, card
);
1446 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1450 if(rdr
->typ
== R_CCCAM
&& rdr
->tcp_connected
&&
1451 (cfg
.cc_reshare_services
< 2 || cfg
.cc_reshare_services
== 4) && rdr
->card_status
!= CARD_FAILURE
)
1454 cs_log_dbg(D_TRACE
, "asking reader %s for cards...", rdr
->label
);
1456 struct s_client
*rc
= rdr
->client
;
1457 struct cc_data
*rcc
= rc
? rc
->cc
: NULL
;
1460 if(rcc
&& rcc
->cards
&& !rc
->kill
)
1462 cs_readlock(__func__
, &rcc
->cards_busy
);
1464 it
= ll_iter_create(rcc
->cards
);
1465 while((card
= ll_iter_next(&it
)))
1467 if(chk_ctab(card
->caid
, &rdr
->ctab
))
1469 int32_t dont_ignore
= ll_count(card
->providers
) ? 0 : 1;
1471 it2
= ll_iter_create(card
->providers
);
1472 struct cc_provider
*prov
;
1473 while((prov
= ll_iter_next(&it2
)))
1475 uint32_t prid
= prov
->prov
;
1476 if(chk_srvid_by_caid_prov(rc
, card
->caid
, prid
))
1483 if(dont_ignore
) //Filtered by service
1485 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 0);
1490 cs_readunlock(__func__
, &rcc
->cards_busy
);
1493 { cs_log_dbg(D_TRACE
, "reader %s not active!", rdr
->label
); }
1494 cs_log_dbg(D_TRACE
, "got %d cards from %s", count
, rdr
->label
);
1497 cs_readunlock(__func__
, &readerlist_lock
);
1500 LLIST
*new_cards
= ll_create("new_cards"); //List of new (added) cards
1502 cs_writelock(__func__
, &cc_shares_lock
);
1504 //report reshare cards:
1505 //cs_log_dbg(D_TRACE, "%s reporting %d cards", getprefix(), ll_count(server_cards));
1506 for(i
= 0; i
< CAID_KEY
; i
++)
1510 it
= ll_iter_create(server_cards
[i
]);
1512 //we compare every card of our new list (server_cards) with the last list.
1513 while((card
= ll_iter_next(&it
)))
1515 //cs_log_dbg(D_TRACE, "%s card %d caid %04X hop %d", getprefix(), card->id, card->caid, card->hop);
1517 if(!new_reported_carddatas
[i
])
1518 { new_reported_carddatas
[i
] = ll_create("new_cardlist"); }
1519 report_card(card
, new_reported_carddatas
[i
], new_cards
);
1520 ll_iter_remove(&it
);
1522 cc_free_cardlist(server_cards
[i
], 1);
1525 //remove unsed, remaining cards:
1526 card_removed_count
+= cc_free_reported_carddata(reported_carddatas_list
[i
], new_reported_carddatas
[i
], 1);
1527 reported_carddatas_list
[i
] = new_reported_carddatas
[i
];
1528 card_count
+= ll_count(reported_carddatas_list
[i
]);
1529 //cs_log_dbg(D_TRACE, "CARDS FOR INDEX %d=%d", i, ll_count(reported_carddatas[i]));
1532 //now send new cards. Always remove first, then add new:
1533 it
= ll_iter_create(new_cards
);
1534 while((card
= ll_iter_next(&it
)))
1536 send_card_to_all_clients(card
);
1538 ll_destroy(&new_cards
);
1541 cs_writeunlock(__func__
, &cc_shares_lock
);
1543 cs_log_dbg(D_TRACE
, "reported/updated +%d/-%d/dup %d of %d cards to sharelist",
1544 card_added_count
, card_removed_count
, card_dup_count
, card_count
);
1547 int32_t cc_srv_report_cards(struct s_client
*cl
)
1550 struct cc_card
*card
;
1551 int32_t i
, count
= 0;
1553 cs_readlock(__func__
, &cc_shares_lock
);
1554 for(i
= 0; i
< CAID_KEY
; i
++)
1556 if(reported_carddatas_list
[i
])
1558 it
= ll_iter_create(reported_carddatas_list
[i
]);
1559 while(cl
->cc
&& !cl
->kill
&& (card
= ll_iter_next(&it
)))
1561 count
+= send_card_to_client(card
, cl
);
1565 cs_readunlock(__func__
, &cc_shares_lock
);
1566 cs_log_dbg(D_TRACE
, "reported %d cards for %s", count
, username(cl
));
1568 return cl
->cc
&& !cl
->kill
;
1571 void refresh_shares(void)
1576 #define DEFAULT_INTERVAL 30
1578 void share_updater(void)
1580 int32_t i
= DEFAULT_INTERVAL
+ cfg
.waitforcards_extra_delay
/ 1000;
1581 uint32_t last_check
= 0;
1582 uint32_t last_check_rdroptions
= 0;
1583 uint32_t cur_check_rdroptions
= 0;
1584 uint32_t last_card_check
= 0;
1585 uint32_t last_sidtab_generation
= 0;
1586 uint32_t card_count
= 0;
1587 while(share_updater_thread_active
)
1589 const uint32_t sleep_step
= 500;
1590 uint32_t sleep_time
;
1592 if(i
> 0 && card_count
< 100) //fast refresh only if we have less cards
1594 cs_log_dbg(D_TRACE
, "share-updater mode=initfast t=1s i=%d", i
);
1600 cs_log_dbg(D_TRACE
, "share-updater mode=initslow t=6s i=%d", i
);
1601 sleep_time
= 6000; //1s later than garbage collector because this list uses much space
1606 if(cfg
.cc_update_interval
<= 10)
1607 { cfg
.cc_update_interval
= DEFAULT_UPDATEINTERVAL
; }
1608 cs_log_dbg(D_TRACE
, "share-updater mode=interval t=%ds", cfg
.cc_update_interval
);
1609 sleep_time
= cfg
.cc_update_interval
* 1000;
1611 for(slept
= 0; slept
< sleep_time
; slept
+= sleep_step
)
1613 if(!share_updater_thread_active
|| share_updater_refresh
)
1615 share_updater_refresh
= 0;
1618 cs_sleepms(sleep_step
);
1620 if(!share_updater_thread_active
)
1623 cs_log_dbg(D_TRACE
, "share-updater check");
1625 uint32_t cur_check
= 0;
1626 uint32_t cur_card_check
= 0;
1627 int8_t rdroptionchange
= 0;
1629 struct s_reader
*rdr
;
1632 cs_readlock(__func__
, &readerlist_lock
);
1634 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1636 struct s_client
*cl
= rdr
->client
;
1637 if(cl
&& (cc
= cl
->cc
)) //check cccam-cardlist:
1639 cur_card_check
+= cc
->card_added_count
;
1640 cur_card_check
+= cc
->card_removed_count
;
1641 card_count
+= ll_count(cc
->cards
);
1643 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->tcp_connected
, sizeof(rdr
->tcp_connected
));
1644 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->card_status
, sizeof(rdr
->card_status
));
1646 //Check hexserial/UA changes only on lokal readers:
1647 if(!is_network_reader(rdr
))
1649 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->hexserial
, 8); //check hexserial
1650 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->prid
, rdr
->nprov
* sizeof(rdr
->prid
[0])); //check providers
1651 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->sa
, rdr
->nprov
* sizeof(rdr
->sa
[0])); //check provider-SA
1654 if(rdr
->changes_since_shareupdate
)
1656 rdr
->changes_since_shareupdate
= 0;
1657 rdroptionchange
= 1;
1662 cur_check_rdroptions
= 0;
1663 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1665 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->ftab
, sizeof(FTAB
)); //check reader
1666 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->ctab
, sizeof(CAIDTAB
)); //check caidtab
1667 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->fchid
, sizeof(FTAB
)); //check chids
1668 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->sidtabs
.ok
, sizeof(rdr
->sidtabs
.ok
)); //check assigned ok services
1669 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->sidtabs
.no
, sizeof(rdr
->sidtabs
.no
)); //check assigned no services
1673 cs_readunlock(__func__
, &readerlist_lock
);
1675 //update cardlist if reader config has changed, also set interval to 1s / 30times
1676 if(cur_check
!= last_check
|| last_sidtab_generation
!= cfg_sidtab_generation
|| last_check_rdroptions
!= cur_check_rdroptions
)
1678 last_sidtab_generation
= cfg_sidtab_generation
;
1679 i
= DEFAULT_INTERVAL
;
1680 cs_log_dbg(D_TRACE
, "share-update [1] %u %u", cur_check
, last_check
);
1682 last_check
= cur_check
;
1683 last_card_check
= cur_card_check
;
1685 //update cardlist if cccam cards has changed:
1686 else if(cur_card_check
!= last_card_check
)
1688 cs_log_dbg(D_TRACE
, "share-update [2] %u %u", cur_card_check
, last_card_check
);
1690 last_card_check
= cur_card_check
;
1692 last_check_rdroptions
= cur_check_rdroptions
;
1694 for(i
= 0; i
< CAID_KEY
; i
++)
1695 { cc_free_reported_carddata(reported_carddatas_list
[i
], NULL
, 0); }
1698 int32_t compare_cards_by_hop(struct cc_card
**pcard1
, struct cc_card
**pcard2
)
1700 struct cc_card
*card1
= (*pcard1
), *card2
= (*pcard2
);
1702 int32_t res
= card1
->hop
- card2
->hop
;
1703 if(res
) { return res
; }
1704 res
= card1
->caid
- card2
->caid
;
1705 if(res
) { return res
; }
1706 res
= card1
->reshare
- card2
->reshare
;
1707 if(res
) { return res
; }
1708 res
= card1
->id
- card2
->id
;
1712 int32_t compare_cards_by_hop_r(struct cc_card
**pcard1
, struct cc_card
**pcard2
)
1714 return -compare_cards_by_hop(pcard1
, pcard2
);
1717 struct cc_card
**get_sorted_card_copy(LLIST
*cards
, int32_t reverse
, int32_t *size
)
1720 { return (struct cc_card
**)ll_sort(cards
, compare_cards_by_hop_r
, size
); }
1722 { return (struct cc_card
**)ll_sort(cards
, compare_cards_by_hop
, size
); }
1725 void cccam_init_share(void)
1727 memset(reported_carddatas_list
, 0, sizeof(reported_carddatas_list
));
1728 cs_lock_create(__func__
, &cc_shares_lock
, "cc_shares_lock", 200000);
1730 share_updater_thread
= 0;
1731 share_updater_thread_active
= 1;
1732 share_updater_refresh
= 0;
1735 int32_t ret
= start_thread("share updater", (void *)&share_updater
, NULL
, &temp
, 1, 1);
1738 share_updater_thread
= temp
;
1742 void cccam_done_share(void)
1744 if(share_updater_thread
)
1746 share_updater_thread_active
= 0;
1747 share_updater_thread
= 0;
1751 void cccam_refresh_share(void)
1753 share_updater_refresh
= 1;