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
);
32 LLIST
*get_cardlist(uint16_t caid
, LLIST
**list
)
34 caid
= (caid
>> 8) % CAID_KEY
;
36 { list
[caid
] = ll_create("card_list"); }
40 LLIST
**get_and_lock_sharelist(void)
42 cs_readlock(__func__
, &cc_shares_lock
);
43 return reported_carddatas_list
;
46 void unlock_sharelist(void)
48 cs_readunlock(__func__
, &cc_shares_lock
);
51 void add_good_sids(struct s_sidtab
*ptr
, struct cc_card
*card
)
54 for(l
= 0; l
< ptr
->num_srvid
; l
++)
56 struct cc_srvid
*srvid
;
57 if(!cs_malloc(&srvid
, sizeof(struct cc_srvid
)))
59 srvid
->sid
= ptr
->srvid
[l
];
61 srvid
->ecmlen
= 0; // 0=undefined, also not used with "O" CCcam
63 if(!ll_contains_data(card
->goodsids
, srvid
, sizeof(struct cc_srvid
)))
64 { ll_append(card
->goodsids
, srvid
); }
65 else { NULLFREE(srvid
);}
69 void add_bad_sids(struct s_sidtab
*ptr
, struct cc_card
*card
)
72 for(l
= 0; l
< ptr
->num_srvid
; l
++)
74 struct cc_srvid_block
*srvid
;
75 if(!cs_malloc(&srvid
, sizeof(struct cc_srvid_block
)))
77 srvid
->sid
= ptr
->srvid
[l
];
79 srvid
->ecmlen
= 0; // 0=undefined, also not used with "O" CCcam
80 srvid
->blocked_till
= 0;
82 if(!ll_contains_data(card
->badsids
, srvid
, sizeof(struct cc_srvid_block
)))
83 { ll_append(card
->badsids
, srvid
); }
84 else { NULLFREE(srvid
); }
88 void add_good_bad_sids_by_rdr(struct s_reader
*rdr
, struct cc_card
*card
)
92 for(n
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, n
++)
94 if(rdr
->sidtabs
.ok
& ((SIDTABBITS
)1 << n
))
96 for(i
= 0; i
< ptr
->num_caid
; i
++)
98 if(ptr
->caid
[i
] == card
->caid
)
99 { add_good_sids(ptr
, card
); }
102 else if(rdr
->sidtabs
.no
& ((SIDTABBITS
)1 << n
))
104 for(i
= 0; i
< ptr
->num_caid
; i
++)
106 if(ptr
->caid
[i
] == card
->caid
)
107 { add_bad_sids(ptr
, card
); }
113 int32_t can_use_ext(struct cc_card
*card
)
115 if(card
->card_type
== CT_REMOTECARD
)
116 { return card
->is_ext
; }
119 { return (card
->sidtab
->num_srvid
> 0); }
121 { return ll_count(card
->goodsids
) || ll_count(card
->badsids
); }
125 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
)
127 memset(buf
, 0, CC_MAXMSGSIZE
);
128 buf
[0] = card
->id
>> 24;
129 buf
[1] = card
->id
>> 16;
130 buf
[2] = card
->id
>> 8;
131 buf
[3] = card
->id
& 0xff;
132 buf
[4] = card
->remote_id
>> 24;
133 buf
[5] = card
->remote_id
>> 16;
134 buf
[6] = card
->remote_id
>> 8;
135 buf
[7] = card
->remote_id
& 0xFF;
136 buf
[8] = card
->caid
>> 8;
137 buf
[9] = card
->caid
& 0xff;
139 buf
[11] = card
->reshare
;
141 { memcpy(buf
+ 12, card
->hexserial
, 8); }
143 // with cccam 2.2.0 we have assigned and rejected sids:
144 int32_t ofs
= ext
? 23 : 21;
147 LL_ITER it
= ll_iter_create(card
->providers
);
148 struct cc_provider
*prov
;
149 while((prov
= ll_iter_next(&it
)))
151 uint32_t prid
= prov
->prov
;
152 buf
[ofs
+ 0] = prid
>> 16;
153 buf
[ofs
+ 1] = prid
>> 8;
154 buf
[ofs
+ 2] = prid
& 0xFF;
156 { memcpy(buf
+ ofs
+ 3, prov
->sa
, 4); }
161 // write sids only if cccam 2.2.x:
167 struct s_sidtab
*ptr
= card
->sidtab
;
169 for(l
= 0; l
< ptr
->num_srvid
; l
++)
171 buf
[ofs
+ 0] = ptr
->srvid
[l
] >> 8;
172 buf
[ofs
+ 1] = ptr
->srvid
[l
] & 0xFF;
174 buf
[21]++; // nassign
181 for(n
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, n
++)
183 if((cl
->sidtabs
.no
& ((SIDTABBITS
)1 << n
)) || (card
->sidtabno
& ((SIDTABBITS
)1 << n
)))
187 for(m
= 0; m
< ptr
->num_caid
; m
++) // search bad sids for this caid:
189 if(ptr
->caid
[m
] == card
->caid
)
197 for(l
= 0; l
< ptr
->num_srvid
; l
++)
199 buf
[ofs
+ 0] = ptr
->srvid
[l
] >> 8;
200 buf
[ofs
+ 1] = ptr
->srvid
[l
] & 0xFF;
202 buf
[22]++; // nreject
216 it
= ll_iter_create(card
->goodsids
);
217 struct cc_srvid
*srvid
;
218 struct cc_srvid_block
*srvidblock
;
219 while((srvid
= ll_iter_next(&it
)))
221 buf
[ofs
+ 0] = srvid
->sid
>> 8;
222 buf
[ofs
+ 1] = srvid
->sid
& 0xFF;
224 buf
[21]++; // nassign
230 it
= ll_iter_create(card
->badsids
);
231 while((srvidblock
= ll_iter_next(&it
)))
233 if(srvidblock
->blocked_till
> 0)
237 buf
[ofs
+ 0] = srvidblock
->sid
>> 8;
238 buf
[ofs
+ 1] = srvidblock
->sid
& 0xFF;
240 buf
[22]++; // nreject
247 // write remote nodes
248 int32_t nremote_ofs
= ofs
;
250 it
= ll_iter_create(card
->remote_nodes
);
251 uint8_t *remote_node
;
252 while((remote_node
= ll_iter_next(&it
)))
254 memcpy(buf
+ ofs
, remote_node
, 8);
260 memcpy(buf
+ ofs
, cc
->node_id
, 8);
267 static int32_t is_client_au_allowed(struct cc_card
*card
, struct s_client
*cl
)
269 if(!card
|| !card
->origin_reader
)
274 if(!cl
|| !cl
->aureader_list
|| !ll_count(cl
->aureader_list
))
279 struct s_reader
*rdr
= NULL
;
280 LL_ITER itr
= ll_iter_create(cl
->aureader_list
);
281 while((rdr
= ll_iter_next(&itr
)))
283 if(rdr
== card
->origin_reader
)
292 static int32_t send_card_to_client(struct cc_card
*card
, struct s_client
*cl
)
294 uint8_t buf
[CC_MAXMSGSIZE
];
296 if(!card_valid_for_client(cl
, card
))
299 int8_t usr_reshare
= cl
->account
->cccreshare
;
300 if(usr_reshare
== -1)
301 { usr_reshare
= cfg
.cc_reshare
; }
303 int8_t ignorereshare
= cl
->account
->cccignorereshare
;
304 if(ignorereshare
== -1)
305 { ignorereshare
= cfg
.cc_ignore_reshare
; }
307 int8_t reader_reshare
= card
->origin_reader
? card
->rdr_reshare
: usr_reshare
;
308 if(reader_reshare
== -1)
309 { reader_reshare
= cfg
.cc_reshare
; }
311 int8_t reshare
= (reader_reshare
< usr_reshare
) ? reader_reshare
: usr_reshare
;
313 if(card
->card_type
== CT_CARD_BY_SERVICE_USER
)
315 new_reshare
= usr_reshare
;
317 else if(ignorereshare
)
319 new_reshare
= reshare
;
323 new_reshare
= card
->reshare
;
324 if(card
->card_type
== CT_REMOTECARD
)
326 if(new_reshare
> reshare
)
327 { new_reshare
= reshare
; }
333 { card
->id
= cc_share_id
++; }
335 struct cc_data
*cc
= cl
->cc
;
336 int32_t is_ext
= cc
->cccam220
&& can_use_ext(card
);
337 int32_t len
= write_card(cc
, buf
, card
, 1, is_ext
, is_client_au_allowed(card
, cl
), cl
);
338 //buf[10] = card->hop-1;
339 buf
[11] = new_reshare
;
341 struct s_clientmsg
*clientmsg
;
342 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
344 memcpy(clientmsg
->msg
, buf
, len
);
345 clientmsg
->len
= len
;
346 clientmsg
->cmd
= is_ext
? MSG_NEW_CARD_SIDINFO
: MSG_NEW_CARD
;
347 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
352 int32_t hide_card_to_client(struct cc_card
*card
, struct s_client
*cl
)
354 if(!card
|| !card
->id
)
358 buf
[0] = card
->id
>> 24;
359 buf
[1] = card
->id
>> 16;
360 buf
[2] = card
->id
>> 8;
361 buf
[3] = card
->id
& 0xFF;
363 struct s_clientmsg
*clientmsg
;
364 struct cc_data
*cc
= cl
->cc
;
365 if(cc
&& (cl
->typ
== 'c') && !cl
->kill
&& (get_module(cl
)->num
== R_CCCAM
)) //CCCam-Client!
367 if(card_valid_for_client(cl
, card
))
369 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
371 memcpy(clientmsg
->msg
, buf
, sizeof(buf
));
372 clientmsg
->len
= sizeof(buf
);
373 clientmsg
->cmd
= MSG_CARD_REMOVED
;
374 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
382 int32_t unhide_card_to_client(struct cc_card
*card
, struct s_client
*cl
)
384 return send_card_to_client(card
, cl
);
387 int32_t hidecards_card_valid_for_client(struct s_client
*cl
, struct cc_card
*card
)
389 return card_valid_for_client(cl
, card
);
392 int32_t send_card_to_all_clients(struct cc_card
*card
)
396 cs_readlock(__func__
, &clientlist_lock
);
397 for(cl
= first_client
; cl
; cl
= cl
->next
)
399 if(cl
->cc
&& cl
->typ
== 'c' && !cl
->kill
&& get_module(cl
)->num
== R_CCCAM
) // CCCam-Client!
401 count
+= send_card_to_client(card
, cl
);
404 cs_readunlock(__func__
, &clientlist_lock
);
408 void send_remove_card_to_clients(struct cc_card
*card
)
410 if(!card
|| !card
->id
)
414 buf
[0] = card
->id
>> 24;
415 buf
[1] = card
->id
>> 16;
416 buf
[2] = card
->id
>> 8;
417 buf
[3] = card
->id
& 0xFF;
420 struct s_clientmsg
*clientmsg
;
421 cs_readlock(__func__
, &clientlist_lock
);
422 for(cl
= first_client
; cl
; cl
= cl
->next
)
424 struct cc_data
*cc
= cl
->cc
;
425 if(cc
&& cl
->typ
== 'c' && !cl
->kill
&& get_module(cl
)->num
== R_CCCAM
) // CCCam-Client!
427 if(card_valid_for_client(cl
, card
))
429 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
431 memcpy(clientmsg
->msg
, buf
, sizeof(buf
));
432 clientmsg
->len
= sizeof(buf
);
433 clientmsg
->cmd
= MSG_CARD_REMOVED
;
434 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
439 cs_readunlock(__func__
, &clientlist_lock
);
444 * if idents defined on an cccam reader, the cards caid+provider are checked.
445 * return 1 a) if no ident defined b) card is in identlist
446 * 0 if card is not in identlist
448 * a card is in the identlist, if the cards caid is matching and mininum a provider is matching
450 int32_t chk_ident(FTAB
*ftab
, struct cc_card
*card
)
456 if(ftab
&& ftab
->filts
)
458 for(j
= 0; j
< ftab
->nfilts
; j
++)
460 if(ftab
->filts
[j
].caid
)
463 if(ftab
->filts
[j
].caid
== card
->caid
) // caid matches!
466 int32_t nprids
= ftab
->filts
[j
].nprids
;
467 if(!nprids
) // No Provider ->Ok
471 LL_ITER it
= ll_iter_create(card
->providers
);
472 struct cc_provider
*prov
;
474 while((prov
= ll_iter_next(&it
)))
476 for(k
= 0; k
< nprids
; k
++)
478 uint32_t prid
= ftab
->filts
[j
].prids
[k
];
479 if(prid
== prov
->prov
) // Provider matches
492 int32_t cc_clear_reported_carddata(LLIST
*reported_carddatas
, LLIST
*except
, int32_t send_removed
)
495 LL_ITER it
= ll_iter_create(reported_carddatas
);
496 struct cc_card
*card
;
497 while((card
= ll_iter_next(&it
)))
499 struct cc_card
*card2
= NULL
;
502 LL_ITER it2
= ll_iter_create(except
);
503 while((card2
= ll_iter_next(&it2
)))
510 if(!card2
&& ll_iter_remove(&it
)) // check result of ll_iter_remove, because another thread could removed it
514 cs_log_dbg(D_TRACE
, "s-card removed: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
515 card
->id
, card
->remote_id
, card
->caid
, card
->hop
, card
->reshare
, card
->origin_id
, card
->card_type
);
517 send_remove_card_to_clients(card
);
526 int32_t cc_free_reported_carddata(LLIST
*reported_carddatas
, LLIST
*except
, int32_t send_removed
)
529 if(reported_carddatas
)
531 i
= cc_clear_reported_carddata(reported_carddatas
, except
, send_removed
);
532 ll_destroy(&reported_carddatas
);
537 int32_t card_valid_for_client(struct s_client
*cl
, struct cc_card
*card
)
541 if(card
->grp
&& !(card
->grp
& cl
->grp
))
545 if(!chk_ident(&cl
->ftab
, card
))
549 if(!chk_ctab(card
->caid
, &cl
->ctab
))
553 if(card
->card_type
== CT_REMOTECARD
)
555 int8_t ignorereshare
= cl
->account
->cccignorereshare
;
556 if(ignorereshare
== -1) { ignorereshare
= cfg
.cc_ignore_reshare
; }
557 if(!ignorereshare
&& !card
->reshare
)
561 // Check account maxhops:
562 if(cl
->account
->cccmaxhops
< card
->hop
)
565 // Check remote node id, if card is from there, ignore it!
566 LL_ITER it
= ll_iter_create(card
->remote_nodes
);
568 struct cc_data
*cc
= cl
->cc
;
569 while((node
= ll_iter_next(&it
)))
571 if(!memcmp(node
, cc
->peer_node_id
, 8))
578 if(ll_count(card
->providers
))
580 it
= ll_iter_create(card
->providers
);
581 struct cc_provider
*prov
;
583 while((prov
= ll_iter_next(&it
)))
585 uint32_t prid
= prov
->prov
;
586 if(chk_srvid_by_caid_prov(cl
, card
->caid
, prid
))
592 if(!found
) { return 0; }
596 if(!chk_srvid_by_caid_prov(cl
, card
->caid
, 0))
600 // Check Card created by Service:
603 struct s_sidtab
*ptr
;
605 int32_t ok
= !cl
->sidtabs
.ok
&& !cl
->sidtabs
.no
; // default valid if no positive services and no negative services
608 if(!cl
->sidtabs
.ok
) // no positive services, so ok by default if no negative found
611 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
613 if(ptr
== card
->sidtab
)
615 if(cl
->sidtabs
.no
& ((SIDTABBITS
)1 << j
))
617 if(cl
->sidtabs
.ok
& ((SIDTABBITS
)1 << j
))
630 uint32_t get_reader_prid(struct s_reader
*rdr
, int32_t j
)
632 return b2i(3, &rdr
->prid
[j
][1]);
634 //uint32_t get_reader_prid(struct s_reader *rdr, int32_t j) {
636 // if (!is_cascading_reader(rdr)) { // Real cardreaders have 4-byte Providers
637 // prid = b2i(4, &rdr->prid[j][0]);
638 // //prid = (rdr->prid[j][0] << 24) | (rdr->prid[j][1] << 16)
639 // // | (rdr->prid[j][2] << 8) | (rdr->prid[j][3] & 0xFF);
640 // } else { // Cascading/Network-reader 3-bytes Providers
641 // prid = b2i(3, &rdr->prid[j][0]);
642 // //prid = (rdr->prid[j][0] << 16) | (rdr->prid[j][1] << 8)
643 // // | (rdr->prid[j][2] & 0xFF);
649 void copy_good_sids(LLIST
*dst
, LLIST
*src
)
651 LL_ITER it_src
= ll_iter_create(src
);
652 LL_ITER it_dst
= ll_iter_create(dst
);
653 struct cc_srvid
*srvid_src
;
654 struct cc_srvid
*srvid_dst
;
655 while((srvid_src
= ll_iter_next(&it_src
)))
657 ll_iter_reset(&it_dst
);
658 while((srvid_dst
= ll_iter_next(&it_dst
)))
660 if(sid_eq(srvid_src
, srvid_dst
))
665 if(!cs_malloc(&srvid_dst
, sizeof(struct cc_srvid
)))
667 memcpy(srvid_dst
, srvid_src
, sizeof(struct cc_srvid
));
668 ll_iter_insert(&it_dst
, srvid_dst
);
673 void copy_bad_sids(LLIST
*dst
, LLIST
*src
)
675 LL_ITER it_src
= ll_iter_create(src
);
676 LL_ITER it_dst
= ll_iter_create(dst
);
677 struct cc_srvid_block
*srvid_src
;
678 struct cc_srvid_block
*srvid_dst
;
679 while((srvid_src
= ll_iter_next(&it_src
)))
681 ll_iter_reset(&it_dst
);
682 while((srvid_dst
= ll_iter_next(&it_dst
)))
684 if(sid_eq_bb(srvid_src
, srvid_dst
))
689 if(!cs_malloc(&srvid_dst
, sizeof(struct cc_srvid_block
)))
691 memcpy(srvid_dst
, srvid_src
, sizeof(struct cc_srvid_block
));
692 ll_iter_insert(&it_dst
, srvid_dst
);
697 int32_t add_card_providers(struct cc_card
*dest_card
, struct cc_card
*card
, int32_t copy_remote_nodes
)
699 int32_t modified
= 0;
701 // 1. Copy nonexisting providers, ignore double:
702 struct cc_provider
*prov_info
;
703 LL_ITER it_src
= ll_iter_create(card
->providers
);
704 LL_ITER it_dst
= ll_iter_create(dest_card
->providers
);
706 struct cc_provider
*provider
;
707 while((provider
= ll_iter_next(&it_src
)))
709 ll_iter_reset(&it_dst
);
710 while((prov_info
= ll_iter_next(&it_dst
)))
712 if(prov_info
->prov
== provider
->prov
)
717 struct cc_provider
*prov_new
;
718 if(!cs_malloc(&prov_new
, sizeof(struct cc_provider
)))
720 memcpy(prov_new
, provider
, sizeof(struct cc_provider
));
721 ll_iter_insert(&it_dst
, prov_new
);
726 if(copy_remote_nodes
)
728 // 2. Copy nonexisting remote_nodes, ignoring existing:
729 it_src
= ll_iter_create(card
->remote_nodes
);
730 it_dst
= ll_iter_create(dest_card
->remote_nodes
);
731 uint8_t *remote_node
;
732 uint8_t *remote_node2
;
733 while((remote_node
= ll_iter_next(&it_src
)))
735 ll_iter_reset(&it_dst
);
736 while((remote_node2
= ll_iter_next(&it_dst
)))
738 if(memcmp(remote_node
, remote_node2
, 8) == 0)
743 uint8_t *remote_node_new
;
744 if(!cs_malloc(&remote_node_new
, 8))
746 memcpy(remote_node_new
, remote_node
, 8);
747 ll_iter_insert(&it_dst
, remote_node_new
);
755 #define TIMEOUT_SECONDS 3600
757 void set_card_timeout(struct cc_card
*card
)
759 card
->timeout
= time(NULL
) + TIMEOUT_SECONDS
+ ((rand() & 0xff) - 128) * 2;
762 struct cc_card
*create_card(struct cc_card
*card
)
764 struct cc_card
*card2
;
765 if(!cs_malloc(&card2
, sizeof(struct cc_card
)))
768 { memcpy(card2
, card
, sizeof(struct cc_card
)); }
770 { memset(card2
, 0, sizeof(struct cc_card
)); }
771 card2
->providers
= ll_create("providers");
772 card2
->badsids
= ll_create("badsids");
773 card2
->goodsids
= ll_create("goodsids");
774 card2
->remote_nodes
= ll_create("remote_nodes");
778 copy_good_sids(card2
->goodsids
, card
->goodsids
);
779 copy_bad_sids(card2
->badsids
, card
->badsids
);
783 { set_card_timeout(card2
); }
788 struct cc_card
*create_card2(struct s_reader
*rdr
, int32_t j
, uint16_t caid
, uint8_t reshare
)
791 struct cc_card
*card
= create_card(NULL
);
794 card
->remote_id
= (rdr
? (rdr
->cc_id
<< 16) : 0x7F7F8000) | j
;
796 card
->reshare
= reshare
;
797 card
->origin_reader
= rdr
;
800 card
->grp
= rdr
->grp
;
801 card
->rdr_reshare
= rdr
->cc_reshare
> -1 ? rdr
->cc_reshare
: cfg
.cc_reshare
; //copy reshare because reader could go offline
802 card
->sidtabno
= rdr
->sidtabs
.no
;
803 card
->hop
= rdr
->cc_hop
;
805 else { card
->rdr_reshare
= reshare
; }
810 * num_same_providers checks if card1 has exactly the same providers as card2
811 * returns same provider count
813 int32_t num_same_providers(struct cc_card
*card1
, struct cc_card
*card2
)
818 LL_ITER it1
= ll_iter_create(card1
->providers
);
819 LL_ITER it2
= ll_iter_create(card2
->providers
);
821 struct cc_provider
*prov1
, *prov2
;
823 while((prov1
= ll_iter_next(&it1
)))
827 while((prov2
= ll_iter_next(&it2
)))
829 if(prov1
->prov
== prov2
->prov
)
841 * equal_providers checks if card1 has exactly the same providers as card2
842 * returns 1=equal 0=different
844 int32_t equal_providers(struct cc_card
*card1
, struct cc_card
*card2
)
847 if(ll_count(card1
->providers
) != ll_count(card2
->providers
))
849 if(ll_count(card1
->providers
) == 0)
852 LL_ITER it1
= ll_iter_create(card1
->providers
);
853 LL_ITER it2
= ll_iter_create(card2
->providers
);
855 struct cc_provider
*prov1
, *prov2
;
857 while((prov1
= ll_iter_next(&it1
)))
861 while((prov2
= ll_iter_next(&it2
)))
863 if(prov1
->prov
== prov2
->prov
)
869 if(!prov2
) { break; }
871 return (prov1
== NULL
);
874 int32_t is_au_card(struct cc_card
*card
)
876 if(card
&& card
->origin_reader
)
877 { return !card
->origin_reader
->audisabled
&& cc_UA_valid(card
->hexserial
); }
881 void merge_sids(struct cc_card
*carddst
, struct cc_card
*cardsrc
)
884 struct cc_srvid
*srvid
;
885 struct cc_srvid_block
*srvidb
;
887 int32_t goodSidCountSrc
= ll_count(cardsrc
->goodsids
);
888 int32_t goodSidCountDst
= ll_count(carddst
->goodsids
);
890 if(goodSidCountDst
== 0)
892 // remove sid blocks good+notbad from src
893 it
= ll_iter_create(cardsrc
->goodsids
);
894 while((srvid
= ll_iter_next(&it
)))
896 if(!is_sid_blocked(cardsrc
, srvid
))
897 { remove_sid_block(carddst
, srvid
); }
902 if(goodSidCountSrc
== 0)
904 // del goods from dst
905 ll_clear(carddst
->goodsids
);
908 ll_clear(carddst
->badsids
);
911 it
= ll_iter_create(cardsrc
->badsids
);
912 while((srvidb
= ll_iter_next(&it
)))
914 { add_sid_block(carddst
, (struct cc_srvid
*)srvidb
, false); }
919 // add good sid good+notbad from src
920 it
= ll_iter_create(cardsrc
->goodsids
);
921 while((srvid
= ll_iter_next(&it
)))
923 if(!is_sid_blocked(cardsrc
, srvid
))
924 { add_good_sid(carddst
, srvid
); }
932 * Adds a new card to a cardlist.
934 int32_t add_card_to_serverlist(LLIST
*cardlist
, struct cc_card
*card
, int8_t free_card
)
937 int32_t modified
= 0;
941 LL_ITER it
= ll_iter_create(cardlist
);
942 struct cc_card
*card2
;
944 // Minimize all, transmit just CAID, merge providers:
945 if(cfg
.cc_minimize_cards
== MINIMIZE_CAID
&& !cfg
.cc_forward_origin_card
)
947 while((card2
= ll_iter_next(&it
)))
949 // compare caid, hexserial, cardtype and sidtab (if any):
950 if(same_card2(card
, card2
, 0))
952 // Merge cards only if resulting providercount is smaller than CS_MAXPROV
953 int32_t nsame
, ndiff
, nnew
;
955 nsame
= num_same_providers(card
, card2
); // count same cards
956 ndiff
= ll_count(card
->providers
) - nsame
; // cound different cards, this cound will be added
957 nnew
= ndiff
+ ll_count(card2
->providers
); // new card count after add. because its limited to CS_MAXPROV, dont add it
959 if(nnew
<= CS_MAXPROV
)
964 if(!card2
) // Not found->add it:
966 if(free_card
) // Use this card
969 ll_iter_insert(&it
, card
);
973 card2
= create_card(card
); // Copy card
977 ll_iter_insert(&it
, card2
);
978 add_card_providers(card2
, card
, 1); // copy providers to new card. Copy remote nodes to new card
983 else // found, merge providers:
986 card2
->grp
|= card
->grp
; // add group to the card
987 add_card_providers(card2
, card
, 0); // merge all providers
988 ll_clear_data(card2
->remote_nodes
); // clear remote nodes
989 merge_sids(card2
, card
);
993 // Removed duplicate cards, keeping card with lower hop:
994 else if(cfg
.cc_minimize_cards
== MINIMIZE_HOPS
&& !cfg
.cc_forward_origin_card
)
996 while((card2
= ll_iter_next(&it
)))
998 // compare caid, hexserial, cardtype, sidtab (if any), providers:
999 if(same_card2(card
, card2
, 0) && equal_providers(card
, card2
))
1005 if(card2
&& card2
->hop
> card
->hop
) // hop is smaller, drop old card
1007 ll_iter_remove(&it
);
1008 cc_free_card(card2
);
1013 if(!card2
) // Not found->add it:
1015 if(free_card
) // use this card
1018 ll_iter_insert(&it
, card
);
1022 card2
= create_card(card
); // copy card
1024 { return modified
; }
1025 ll_iter_insert(&it
, card2
);
1026 add_card_providers(card2
, card
, 1); // copy providers to new card. Copy remote nodes to new card
1030 else // found, merge cards (providers are same!)
1033 card2
->grp
|= card
->grp
; //add group to the card
1034 add_card_providers(card2
, card
, 0);
1035 merge_sids(card2
, card
);
1040 else // just remove duplicate cards (same ids)
1042 while((card2
= ll_iter_next(&it
)))
1044 // compare remote_id, first_node, caid, hexserial, cardtype, sidtab (if any), providers:
1045 if(same_card(card
, card2
))
1049 if(card2
&& card2
->hop
> card
->hop
) // same card, if hop greater drop card
1051 ll_iter_remove(&it
);
1052 cc_free_card(card2
);
1056 if(!card2
) // Not found, add it:
1061 ll_iter_insert(&it
, card
);
1065 card2
= create_card(card
);
1067 { return modified
; }
1068 ll_iter_insert(&it
, card2
);
1069 add_card_providers(card2
, card
, 1);
1073 else // Found, everything is same (including providers)
1080 { cc_free_card(card
); }
1086 * returns true if timeout-time is reached
1087 * only local cards needs to be renewed after 1h. "O" CCCam throws away cards older than 1,2h
1089 int32_t card_timed_out(struct cc_card
*card
)
1091 //!=CT_REMOTECARD = LOCALCARD (or virtual cards by caid/ident/service)
1092 //timeout is set in future, so if current time is bigger, timeout is reached
1093 int32_t res
= (card
->card_type
!= CT_REMOTECARD
) && (card
->timeout
< time(NULL
)); //local card is older than 1h?
1095 { cs_log_dbg(D_TRACE
, "card %08X timed out! refresh forced", card
->id
? card
->id
: card
->origin_id
); }
1100 * returns true if card1 is already reported.
1101 * "reported" means, we already have this card1 in our sharelist.
1102 * if the card1 is already reported, we throw it away, because we build a new sharelist
1103 * so after finding all reported cards, we have a list of reported cards, which aren't used anymore
1105 int32_t find_reported_card(struct cc_card
*card1
)
1107 LL_ITER it
= ll_iter_create(get_cardlist(card1
->caid
, reported_carddatas_list
));
1108 struct cc_card
*card2
;
1109 while((card2
= ll_iter_next(&it
)))
1111 if(same_card(card1
, card2
) && !card_timed_out(card2
))
1113 card1
->id
= card2
->id
; //Set old id !!
1114 card1
->timeout
= card2
->timeout
;
1115 cc_free_card(card2
);
1116 ll_iter_remove(&it
);
1117 return 1; //Old card and new card are equal!
1120 return 0; //Card not found
1125 * Adds a cccam-carddata buffer to the list of reported carddatas
1127 void cc_add_reported_carddata(LLIST
*reported_carddatas
, struct cc_card
*card
)
1129 ll_append(reported_carddatas
, card
);
1133 * adds the card to the list of the new reported carddatas - this is the new sharelist
1134 * if this card is not already reported, we send them to the clients
1135 * if this card is already reported, find_reported_card throws the "origin" card away
1136 * so the "old" sharelist is reduced
1138 void report_card(struct cc_card
*card
, LLIST
*new_reported_carddatas
, LLIST
*new_cards
)
1140 if(!find_reported_card(card
)) //Add new card:
1143 cs_log_dbg(D_TRACE
, "s-card added: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
1144 card
->id
, card
->remote_id
, card
->caid
, card
->hop
, card
->reshare
, card
->origin_id
, card
->card_type
);
1146 ll_append(new_cards
, card
);
1150 cc_add_reported_carddata(new_reported_carddatas
, card
);
1156 * Reports all caid/providers to the connected clients
1157 * returns 1=ok, 0=error
1158 * cfg.cc_reshare_services =0 CCCAM reader reshares only received cards + defined reader services
1159 * =1 CCCAM reader reshares received cards + defined services
1160 * =2 CCCAM reader reshares only defined reader-services as virtual cards
1161 * =3 CCCAM reader reshares only defined user-services as virtual cards
1162 * =4 CCCAM reader reshares only received cards
1164 void update_card_list(void)
1166 int32_t i
, j
, k
, l
, flt
, card_count
= 0;
1168 LLIST
*server_cards
[CAID_KEY
];
1169 LLIST
*new_reported_carddatas
[CAID_KEY
];
1172 struct cc_card
*card
;
1174 memset(server_cards
, 0, sizeof(server_cards
));
1175 memset(new_reported_carddatas
, 0, sizeof(new_reported_carddatas
));
1177 card_added_count
= 0;
1178 card_removed_count
= 0;
1182 if(cfg
.cc_reshare_services
== 3 && cfg
.sidtab
)
1184 struct s_sidtab
*ptr
;
1185 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
1187 for(k
= 0; k
< ptr
->num_caid
; k
++)
1189 card
= create_card2(NULL
, (j
<< 8) | k
, ptr
->caid
[k
], cfg
.cc_reshare
);
1192 card
->card_type
= CT_CARD_BY_SERVICE_USER
;
1194 for(l
= 0; l
< ptr
->num_provid
; l
++)
1196 struct cc_provider
*prov
;
1197 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1199 prov
->prov
= ptr
->provid
[l
];
1200 ll_append(card
->providers
, prov
);
1203 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 1);
1210 struct s_reader
*rdr
;
1213 cs_readlock(__func__
, &readerlist_lock
);
1215 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1217 //Generate a uniq reader id:
1221 struct s_reader
*rdr2
;
1222 for(rdr2
= first_active_reader
; rdr2
; rdr2
= rdr2
->next
)
1224 if(rdr2
!= rdr
&& rdr2
->cc_id
== rdr
->cc_id
)
1226 rdr2
= first_active_reader
;
1234 int8_t reshare
= rdr
->cc_reshare
> -1 ? rdr
->cc_reshare
: cfg
.cc_reshare
;
1237 if((cfg
.cc_reshare_services
== 1 || cfg
.cc_reshare_services
== 2 || (!rdr
->caid
&& rdr
->typ
!= R_CCCAM
&& cfg
.cc_reshare_services
!= 4)) &&
1238 cfg
.sidtab
&& (rdr
->sidtabs
.no
|| rdr
->sidtabs
.ok
))
1240 struct s_sidtab
*ptr
;
1241 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
1243 if(!(rdr
->sidtabs
.no
& ((SIDTABBITS
)1 << j
)) && (rdr
->sidtabs
.ok
& ((SIDTABBITS
)1 << j
)))
1245 for(k
= 0; k
< ptr
->num_caid
; k
++)
1247 card
= create_card2(rdr
, (j
<< 8) | k
, ptr
->caid
[k
], reshare
);
1250 card
->card_type
= CT_CARD_BY_SERVICE_READER
;
1252 for(l
= 0; l
< ptr
->num_provid
; l
++)
1254 struct cc_provider
*prov
;
1255 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1257 prov
->prov
= ptr
->provid
[l
];
1258 ll_append(card
->providers
, prov
);
1261 if(chk_ident(&rdr
->ftab
, card
) && chk_ctab(card
->caid
, &rdr
->ctab
))
1263 if(!rdr
->audisabled
)
1264 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, card
->caid
); }
1266 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 1);
1270 { cc_free_card(card
); }
1276 //Filts by Hardware readers:
1277 if((rdr
->typ
!= R_CCCAM
) && rdr
->ftab
.filts
&& !flt
)
1279 for(j
= 0; j
< rdr
->ftab
.nfilts
; j
++)
1281 uint16_t caid
= rdr
->ftab
.filts
[j
].caid
;
1284 card
= create_card2(rdr
, j
, caid
, reshare
);
1287 card
->card_type
= CT_LOCALCARD
;
1289 //Setting UA: (Unique Address):
1290 if(!rdr
->audisabled
)
1291 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1292 //cs_log("Ident CCcam card report caid: %04X readr %s subid: %06X", rdr->ftab.filts[j].caid, rdr->label, rdr->cc_id);
1293 for(k
= 0; k
< rdr
->ftab
.filts
[j
].nprids
; k
++)
1295 struct cc_provider
*prov
;
1296 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1298 prov
->prov
= rdr
->ftab
.filts
[j
].prids
[k
];
1300 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1301 if(!rdr
->audisabled
)
1303 for(l
= 0; l
< rdr
->nprov
; l
++)
1305 uint32_t rprid
= get_reader_prid(rdr
, l
);
1306 if(rprid
== prov
->prov
)
1307 { cc_SA_oscam2cccam(&rdr
->sa
[l
][0], prov
->sa
); }
1311 ll_append(card
->providers
, prov
);
1314 add_good_bad_sids_by_rdr(rdr
, card
);
1315 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1321 if((rdr
->typ
!= R_CCCAM
) && !rdr
->caid
&& !flt
)
1323 for(j
= 0; j
< rdr
->ctab
.ctnum
; j
++)
1325 CAIDTAB_DATA
*d
= &rdr
->ctab
.ctdata
[j
];
1326 //cs_log("CAID map CCcam card report caid: %04X cmap: %04X", d->caid, d->cmap);
1327 uint16_t lcaid
= d
->caid
;
1329 if(!lcaid
|| (lcaid
== 0xFFFF))
1330 { lcaid
= d
->cmap
; }
1332 if(lcaid
&& (lcaid
!= 0xFFFF))
1334 card
= create_card2(rdr
, j
, lcaid
, reshare
);
1337 card
->card_type
= CT_CARD_BY_CAID1
;
1338 if(!rdr
->audisabled
)
1339 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, lcaid
); }
1341 add_good_bad_sids_by_rdr(rdr
, card
);
1342 add_card_to_serverlist(get_cardlist(lcaid
, server_cards
), card
, 1);
1348 if((rdr
->typ
!= R_CCCAM
) && rdr
->ctab
.ctnum
&& !flt
)
1350 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1352 if(rdr
->tcp_connected
|| rdr
->card_status
== CARD_INSERTED
)
1354 for(c
= 0; c
< rdr
->ctab
.ctnum
; c
++)
1356 CAIDTAB_DATA
*d
= &rdr
->ctab
.ctdata
[c
];
1357 uint16_t caid
= d
->caid
;
1358 if(!caid
) { break; }
1360 card
= create_card2(rdr
, c
, caid
, reshare
);
1363 card
->card_type
= CT_CARD_BY_CAID2
;
1365 if(!rdr
->audisabled
)
1366 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1367 for(j
= 0; j
< rdr
->nprov
; j
++)
1369 uint32_t prid
= get_reader_prid(rdr
, j
);
1370 struct cc_provider
*prov
;
1371 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1374 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1375 if(!rdr
->audisabled
)
1377 //Setting SA (Shared Addresses):
1378 cc_SA_oscam2cccam(rdr
->sa
[j
], prov
->sa
);
1380 ll_append(card
->providers
, prov
);
1381 //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)]);
1383 add_good_bad_sids_by_rdr(rdr
, card
);
1384 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1391 if((rdr
->typ
!= R_CCCAM
) && rdr
->caid
&& !flt
)
1393 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1394 if(rdr
->tcp_connected
|| rdr
->card_status
== CARD_INSERTED
)
1396 uint16_t caid
= rdr
->caid
;
1397 card
= create_card2(rdr
, 1, caid
, reshare
);
1400 card
->card_type
= CT_CARD_BY_CAID3
;
1402 if(!rdr
->audisabled
)
1403 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1404 for(j
= 0; j
< rdr
->nprov
; j
++)
1406 uint32_t prid
= get_reader_prid(rdr
, j
);
1407 struct cc_provider
*prov
;
1408 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1411 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1412 if(!rdr
->audisabled
)
1414 //Setting SA (Shared Addresses):
1415 cc_SA_oscam2cccam(rdr
->sa
[j
], prov
->sa
);
1417 ll_append(card
->providers
, prov
);
1418 //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)]);
1420 add_good_bad_sids_by_rdr(rdr
, card
);
1421 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1425 if(rdr
->typ
== R_CCCAM
&& rdr
->tcp_connected
&&
1426 (cfg
.cc_reshare_services
< 2 || cfg
.cc_reshare_services
== 4) && rdr
->card_status
!= CARD_FAILURE
)
1429 cs_log_dbg(D_TRACE
, "asking reader %s for cards...", rdr
->label
);
1431 struct s_client
*rc
= rdr
->client
;
1432 struct cc_data
*rcc
= rc
? rc
->cc
: NULL
;
1435 if(rcc
&& rcc
->cards
&& !rc
->kill
)
1437 cs_readlock(__func__
, &rcc
->cards_busy
);
1439 it
= ll_iter_create(rcc
->cards
);
1440 while((card
= ll_iter_next(&it
)))
1442 if(chk_ctab(card
->caid
, &rdr
->ctab
))
1444 int32_t dont_ignore
= ll_count(card
->providers
) ? 0 : 1;
1446 it2
= ll_iter_create(card
->providers
);
1447 struct cc_provider
*prov
;
1448 while((prov
= ll_iter_next(&it2
)))
1450 uint32_t prid
= prov
->prov
;
1451 if(chk_srvid_by_caid_prov(rc
, card
->caid
, prid
))
1458 if(dont_ignore
) //Filtered by service
1460 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 0);
1465 cs_readunlock(__func__
, &rcc
->cards_busy
);
1468 { cs_log_dbg(D_TRACE
, "reader %s not active!", rdr
->label
); }
1469 cs_log_dbg(D_TRACE
, "got %d cards from %s", count
, rdr
->label
);
1472 cs_readunlock(__func__
, &readerlist_lock
);
1475 LLIST
*new_cards
= ll_create("new_cards"); //List of new (added) cards
1477 cs_writelock(__func__
, &cc_shares_lock
);
1479 //report reshare cards:
1480 //cs_log_dbg(D_TRACE, "%s reporting %d cards", getprefix(), ll_count(server_cards));
1481 for(i
= 0; i
< CAID_KEY
; i
++)
1485 it
= ll_iter_create(server_cards
[i
]);
1487 //we compare every card of our new list (server_cards) with the last list.
1488 while((card
= ll_iter_next(&it
)))
1490 //cs_log_dbg(D_TRACE, "%s card %d caid %04X hop %d", getprefix(), card->id, card->caid, card->hop);
1492 if(!new_reported_carddatas
[i
])
1493 { new_reported_carddatas
[i
] = ll_create("new_cardlist"); }
1494 report_card(card
, new_reported_carddatas
[i
], new_cards
);
1495 ll_iter_remove(&it
);
1497 cc_free_cardlist(server_cards
[i
], 1);
1500 //remove unsed, remaining cards:
1501 card_removed_count
+= cc_free_reported_carddata(reported_carddatas_list
[i
], new_reported_carddatas
[i
], 1);
1502 reported_carddatas_list
[i
] = new_reported_carddatas
[i
];
1503 card_count
+= ll_count(reported_carddatas_list
[i
]);
1504 //cs_log_dbg(D_TRACE, "CARDS FOR INDEX %d=%d", i, ll_count(reported_carddatas[i]));
1507 //now send new cards. Always remove first, then add new:
1508 it
= ll_iter_create(new_cards
);
1509 while((card
= ll_iter_next(&it
)))
1511 send_card_to_all_clients(card
);
1513 ll_destroy(&new_cards
);
1516 cs_writeunlock(__func__
, &cc_shares_lock
);
1518 cs_log_dbg(D_TRACE
, "reported/updated +%d/-%d/dup %d of %d cards to sharelist",
1519 card_added_count
, card_removed_count
, card_dup_count
, card_count
);
1522 int32_t cc_srv_report_cards(struct s_client
*cl
)
1525 struct cc_card
*card
;
1526 int32_t i
, count
= 0;
1528 cs_readlock(__func__
, &cc_shares_lock
);
1529 for(i
= 0; i
< CAID_KEY
; i
++)
1531 if(reported_carddatas_list
[i
])
1533 it
= ll_iter_create(reported_carddatas_list
[i
]);
1534 while(cl
->cc
&& !cl
->kill
&& (card
= ll_iter_next(&it
)))
1536 count
+= send_card_to_client(card
, cl
);
1540 cs_readunlock(__func__
, &cc_shares_lock
);
1541 cs_log_dbg(D_TRACE
, "reported %d cards for %s", count
, username(cl
));
1543 return cl
->cc
&& !cl
->kill
;
1546 void refresh_shares(void)
1551 #define DEFAULT_INTERVAL 30
1553 void share_updater(void)
1555 int32_t i
= DEFAULT_INTERVAL
+ cfg
.waitforcards_extra_delay
/ 1000;
1556 uint32_t last_check
= 0;
1557 uint32_t last_check_rdroptions
= 0;
1558 uint32_t cur_check_rdroptions
= 0;
1559 uint32_t last_card_check
= 0;
1560 uint32_t last_sidtab_generation
= 0;
1561 uint32_t card_count
= 0;
1562 while(share_updater_thread_active
)
1564 const uint32_t sleep_step
= 500;
1565 uint32_t sleep_time
;
1567 if(i
> 0 && card_count
< 100) //fast refresh only if we have less cards
1569 cs_log_dbg(D_TRACE
, "share-updater mode=initfast t=1s i=%d", i
);
1575 cs_log_dbg(D_TRACE
, "share-updater mode=initslow t=6s i=%d", i
);
1576 sleep_time
= 6000; //1s later than garbage collector because this list uses much space
1581 if(cfg
.cc_update_interval
<= 10)
1582 { cfg
.cc_update_interval
= DEFAULT_UPDATEINTERVAL
; }
1583 cs_log_dbg(D_TRACE
, "share-updater mode=interval t=%ds", cfg
.cc_update_interval
);
1584 sleep_time
= cfg
.cc_update_interval
* 1000;
1586 for(slept
= 0; slept
< sleep_time
; slept
+= sleep_step
)
1588 if(!share_updater_thread_active
|| share_updater_refresh
)
1590 share_updater_refresh
= 0;
1593 cs_sleepms(sleep_step
);
1595 if(!share_updater_thread_active
)
1598 cs_log_dbg(D_TRACE
, "share-updater check");
1600 uint32_t cur_check
= 0;
1601 uint32_t cur_card_check
= 0;
1602 int8_t rdroptionchange
= 0;
1604 struct s_reader
*rdr
;
1607 cs_readlock(__func__
, &readerlist_lock
);
1609 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1611 struct s_client
*cl
= rdr
->client
;
1612 if(cl
&& (cc
= cl
->cc
)) //check cccam-cardlist:
1614 cur_card_check
+= cc
->card_added_count
;
1615 cur_card_check
+= cc
->card_removed_count
;
1616 card_count
+= ll_count(cc
->cards
);
1618 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->tcp_connected
, sizeof(rdr
->tcp_connected
));
1619 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->card_status
, sizeof(rdr
->card_status
));
1621 //Check hexserial/UA changes only on lokal readers:
1622 if(!is_network_reader(rdr
))
1624 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->hexserial
, 8); //check hexserial
1625 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->prid
, rdr
->nprov
* sizeof(rdr
->prid
[0])); //check providers
1626 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->sa
, rdr
->nprov
* sizeof(rdr
->sa
[0])); //check provider-SA
1629 if(rdr
->changes_since_shareupdate
)
1631 rdr
->changes_since_shareupdate
= 0;
1632 rdroptionchange
= 1;
1637 cur_check_rdroptions
= 0;
1638 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1640 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->ftab
, sizeof(FTAB
)); //check reader
1641 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->ctab
, sizeof(CAIDTAB
)); //check caidtab
1642 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->fchid
, sizeof(FTAB
)); //check chids
1643 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->sidtabs
.ok
, sizeof(rdr
->sidtabs
.ok
)); //check assigned ok services
1644 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->sidtabs
.no
, sizeof(rdr
->sidtabs
.no
)); //check assigned no services
1648 cs_readunlock(__func__
, &readerlist_lock
);
1650 //update cardlist if reader config has changed, also set interval to 1s / 30times
1651 if(cur_check
!= last_check
|| last_sidtab_generation
!= cfg_sidtab_generation
|| last_check_rdroptions
!= cur_check_rdroptions
)
1653 last_sidtab_generation
= cfg_sidtab_generation
;
1654 i
= DEFAULT_INTERVAL
;
1655 cs_log_dbg(D_TRACE
, "share-update [1] %u %u", cur_check
, last_check
);
1657 last_check
= cur_check
;
1658 last_card_check
= cur_card_check
;
1660 //update cardlist if cccam cards has changed:
1661 else if(cur_card_check
!= last_card_check
)
1663 cs_log_dbg(D_TRACE
, "share-update [2] %u %u", cur_card_check
, last_card_check
);
1665 last_card_check
= cur_card_check
;
1667 last_check_rdroptions
= cur_check_rdroptions
;
1669 for(i
= 0; i
< CAID_KEY
; i
++)
1670 { cc_free_reported_carddata(reported_carddatas_list
[i
], NULL
, 0); }
1673 int32_t compare_cards_by_hop(struct cc_card
**pcard1
, struct cc_card
**pcard2
)
1675 struct cc_card
*card1
= (*pcard1
), *card2
= (*pcard2
);
1677 int32_t res
= card1
->hop
- card2
->hop
;
1678 if(res
) { return res
; }
1679 res
= card1
->caid
- card2
->caid
;
1680 if(res
) { return res
; }
1681 res
= card1
->reshare
- card2
->reshare
;
1682 if(res
) { return res
; }
1683 res
= card1
->id
- card2
->id
;
1687 int32_t compare_cards_by_hop_r(struct cc_card
**pcard1
, struct cc_card
**pcard2
)
1689 return -compare_cards_by_hop(pcard1
, pcard2
);
1692 struct cc_card
**get_sorted_card_copy(LLIST
*cards
, int32_t reverse
, int32_t *size
)
1695 { return (struct cc_card
**)ll_sort(cards
, compare_cards_by_hop_r
, size
); }
1697 { return (struct cc_card
**)ll_sort(cards
, compare_cards_by_hop
, size
); }
1700 void cccam_init_share(void)
1702 memset(reported_carddatas_list
, 0, sizeof(reported_carddatas_list
));
1703 cs_lock_create(__func__
, &cc_shares_lock
, "cc_shares_lock", 200000);
1705 share_updater_thread
= 0;
1706 share_updater_thread_active
= 1;
1707 share_updater_refresh
= 0;
1710 int32_t ret
= start_thread("share updater", (void *)&share_updater
, NULL
, &temp
, 1, 1);
1713 share_updater_thread
= temp
;
1717 void cccam_done_share(void)
1719 if(share_updater_thread
)
1721 share_updater_thread_active
= 0;
1722 share_updater_thread
= 0;
1726 void cccam_refresh_share(void)
1728 share_updater_refresh
= 1;