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"); }
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
); }
115 int32_t can_use_ext(struct cc_card
*card
)
117 if(card
->card_type
== CT_REMOTECARD
)
118 { return card
->is_ext
; }
121 { return (card
->sidtab
->num_srvid
> 0); }
123 { return ll_count(card
->goodsids
) || ll_count(card
->badsids
); }
127 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
)
129 memset(buf
, 0, CC_MAXMSGSIZE
);
130 buf
[0] = card
->id
>> 24;
131 buf
[1] = card
->id
>> 16;
132 buf
[2] = card
->id
>> 8;
133 buf
[3] = card
->id
& 0xff;
134 buf
[4] = card
->remote_id
>> 24;
135 buf
[5] = card
->remote_id
>> 16;
136 buf
[6] = card
->remote_id
>> 8;
137 buf
[7] = card
->remote_id
& 0xFF;
138 buf
[8] = card
->caid
>> 8;
139 buf
[9] = card
->caid
& 0xff;
141 buf
[11] = card
->reshare
;
143 { memcpy(buf
+ 12, card
->hexserial
, 8); }
145 //with cccam 2.2.0 we have assigned and rejected sids:
146 int32_t ofs
= ext
? 23 : 21;
149 LL_ITER it
= ll_iter_create(card
->providers
);
150 struct cc_provider
*prov
;
151 while((prov
= ll_iter_next(&it
)))
153 uint32_t prid
= prov
->prov
;
154 buf
[ofs
+ 0] = prid
>> 16;
155 buf
[ofs
+ 1] = prid
>> 8;
156 buf
[ofs
+ 2] = prid
& 0xFF;
158 { memcpy(buf
+ ofs
+ 3, prov
->sa
, 4); }
163 //write sids only if cccam 2.2.x:
169 struct s_sidtab
*ptr
= card
->sidtab
;
171 for(l
= 0; l
< ptr
->num_srvid
; l
++)
173 buf
[ofs
+ 0] = ptr
->srvid
[l
] >> 8;
174 buf
[ofs
+ 1] = ptr
->srvid
[l
] & 0xFF;
183 for(n
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, n
++)
185 if((cl
->sidtabs
.no
& ((SIDTABBITS
)1 << n
)) || (card
->sidtabno
& ((SIDTABBITS
)1 << n
)))
189 for(m
= 0; m
< ptr
->num_caid
; m
++) //search bad sids for this caid:
191 if(ptr
->caid
[m
] == card
->caid
)
199 for(l
= 0; l
< ptr
->num_srvid
; l
++)
201 buf
[ofs
+ 0] = ptr
->srvid
[l
] >> 8;
202 buf
[ofs
+ 1] = ptr
->srvid
[l
] & 0xFF;
218 it
= ll_iter_create(card
->goodsids
);
219 struct cc_srvid
*srvid
;
220 struct cc_srvid_block
*srvidblock
;
221 while((srvid
= ll_iter_next(&it
)))
223 buf
[ofs
+ 0] = srvid
->sid
>> 8;
224 buf
[ofs
+ 1] = srvid
->sid
& 0xFF;
232 it
= ll_iter_create(card
->badsids
);
233 while((srvidblock
= ll_iter_next(&it
)))
235 if(srvidblock
->blocked_till
> 0)
239 buf
[ofs
+ 0] = srvidblock
->sid
>> 8;
240 buf
[ofs
+ 1] = srvidblock
->sid
& 0xFF;
250 int32_t nremote_ofs
= ofs
;
252 it
= ll_iter_create(card
->remote_nodes
);
253 uint8_t *remote_node
;
254 while((remote_node
= ll_iter_next(&it
)))
256 memcpy(buf
+ ofs
, remote_node
, 8);
262 memcpy(buf
+ ofs
, cc
->node_id
, 8);
269 static int32_t is_client_au_allowed(struct cc_card
*card
, struct s_client
*cl
)
271 if(!card
|| !card
->origin_reader
)
276 if(!cl
|| !cl
->aureader_list
|| !ll_count(cl
->aureader_list
))
281 struct s_reader
*rdr
= NULL
;
282 LL_ITER itr
= ll_iter_create(cl
->aureader_list
);
283 while((rdr
= ll_iter_next(&itr
)))
285 if(rdr
== card
->origin_reader
)
294 static int32_t send_card_to_client(struct cc_card
*card
, struct s_client
*cl
)
296 uint8_t buf
[CC_MAXMSGSIZE
];
298 if(!card_valid_for_client(cl
, card
))
301 int8_t usr_reshare
= cl
->account
->cccreshare
;
302 if(usr_reshare
== -1)
303 { usr_reshare
= cfg
.cc_reshare
; }
305 int8_t ignorereshare
= cl
->account
->cccignorereshare
;
306 if(ignorereshare
== -1)
307 { ignorereshare
= cfg
.cc_ignore_reshare
; }
309 int8_t reader_reshare
= card
->origin_reader
? card
->rdr_reshare
: usr_reshare
;
310 if(reader_reshare
== -1)
311 { reader_reshare
= cfg
.cc_reshare
; }
313 int8_t reshare
= (reader_reshare
< usr_reshare
) ? reader_reshare
: usr_reshare
;
315 if(card
->card_type
== CT_CARD_BY_SERVICE_USER
)
317 new_reshare
= usr_reshare
;
319 else if(ignorereshare
)
321 new_reshare
= reshare
;
325 new_reshare
= card
->reshare
;
326 if(card
->card_type
== CT_REMOTECARD
)
328 if(new_reshare
> reshare
)
329 { new_reshare
= reshare
; }
335 { card
->id
= cc_share_id
++; }
337 struct cc_data
*cc
= cl
->cc
;
338 int32_t is_ext
= cc
->cccam220
&& can_use_ext(card
);
339 int32_t len
= write_card(cc
, buf
, card
, 1, is_ext
, is_client_au_allowed(card
, cl
), cl
);
340 //buf[10] = card->hop-1;
341 buf
[11] = new_reshare
;
343 struct s_clientmsg
*clientmsg
;
344 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
346 memcpy(clientmsg
->msg
, buf
, len
);
347 clientmsg
->len
= len
;
348 clientmsg
->cmd
= is_ext
? MSG_NEW_CARD_SIDINFO
: MSG_NEW_CARD
;
349 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
354 int32_t send_card_to_all_clients(struct cc_card
*card
)
358 cs_readlock(__func__
, &clientlist_lock
);
359 for(cl
= first_client
; cl
; cl
= cl
->next
)
361 if(cl
->cc
&& cl
->typ
== 'c' && !cl
->kill
&& get_module(cl
)->num
== R_CCCAM
) //CCCam-Client!
363 count
+= send_card_to_client(card
, cl
);
366 cs_readunlock(__func__
, &clientlist_lock
);
370 void send_remove_card_to_clients(struct cc_card
*card
)
372 if(!card
|| !card
->id
)
376 buf
[0] = card
->id
>> 24;
377 buf
[1] = card
->id
>> 16;
378 buf
[2] = card
->id
>> 8;
379 buf
[3] = card
->id
& 0xFF;
382 struct s_clientmsg
*clientmsg
;
383 cs_readlock(__func__
, &clientlist_lock
);
384 for(cl
= first_client
; cl
; cl
= cl
->next
)
386 struct cc_data
*cc
= cl
->cc
;
387 if(cc
&& cl
->typ
== 'c' && !cl
->kill
&& get_module(cl
)->num
== R_CCCAM
) //CCCam-Client!
389 if(card_valid_for_client(cl
, card
))
391 if(cs_malloc(&clientmsg
, sizeof(struct s_clientmsg
)))
393 memcpy(clientmsg
->msg
, buf
, sizeof(buf
));
394 clientmsg
->len
= sizeof(buf
);
395 clientmsg
->cmd
= MSG_CARD_REMOVED
;
396 add_job(cl
, ACTION_CLIENT_SEND_MSG
, clientmsg
, sizeof(struct s_clientmsg
));
401 cs_readunlock(__func__
, &clientlist_lock
);
406 * if idents defined on an cccam reader, the cards caid+provider are checked.
407 * return 1 a) if no ident defined b) card is in identlist
408 * 0 if card is not in identlist
410 * a card is in the identlist, if the cards caid is matching and mininum a provider is matching
412 int32_t chk_ident(FTAB
*ftab
, struct cc_card
*card
)
418 if(ftab
&& ftab
->filts
)
420 for(j
= 0; j
< ftab
->nfilts
; j
++)
422 if(ftab
->filts
[j
].caid
)
425 if(ftab
->filts
[j
].caid
== card
->caid
) //caid matches!
428 int32_t nprids
= ftab
->filts
[j
].nprids
;
429 if(!nprids
) // No Provider ->Ok
433 LL_ITER it
= ll_iter_create(card
->providers
);
434 struct cc_provider
*prov
;
436 while((prov
= ll_iter_next(&it
)))
438 for(k
= 0; k
< nprids
; k
++)
440 uint32_t prid
= ftab
->filts
[j
].prids
[k
];
441 if(prid
== prov
->prov
) //Provider matches
454 int32_t cc_clear_reported_carddata(LLIST
*reported_carddatas
, LLIST
*except
,
455 int32_t send_removed
)
458 LL_ITER it
= ll_iter_create(reported_carddatas
);
459 struct cc_card
*card
;
460 while((card
= ll_iter_next(&it
)))
462 struct cc_card
*card2
= NULL
;
465 LL_ITER it2
= ll_iter_create(except
);
466 while((card2
= ll_iter_next(&it2
)))
473 if(!card2
&& ll_iter_remove(&it
)) //check result of ll_iter_remove, because another thread could removed it
477 cs_log_dbg(D_TRACE
, "s-card removed: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
478 card
->id
, card
->remote_id
, card
->caid
, card
->hop
, card
->reshare
, card
->origin_id
, card
->card_type
);
480 send_remove_card_to_clients(card
);
489 int32_t cc_free_reported_carddata(LLIST
*reported_carddatas
, LLIST
*except
,
490 int32_t send_removed
)
493 if(reported_carddatas
)
495 i
= cc_clear_reported_carddata(reported_carddatas
, except
, send_removed
);
496 ll_destroy(&reported_carddatas
);
501 int32_t card_valid_for_client(struct s_client
*cl
, struct cc_card
*card
)
505 if(card
->grp
&& !(card
->grp
& cl
->grp
))
509 if(!chk_ident(&cl
->ftab
, card
))
513 if(!chk_ctab(card
->caid
, &cl
->ctab
))
517 if(card
->card_type
== CT_REMOTECARD
)
519 int8_t ignorereshare
= cl
->account
->cccignorereshare
;
520 if(ignorereshare
== -1) { ignorereshare
= cfg
.cc_ignore_reshare
; }
521 if(!ignorereshare
&& !card
->reshare
)
525 //Check account maxhops:
526 if(cl
->account
->cccmaxhops
< card
->hop
)
529 //Check remote node id, if card is from there, ignore it!
530 LL_ITER it
= ll_iter_create(card
->remote_nodes
);
532 struct cc_data
*cc
= cl
->cc
;
533 while((node
= ll_iter_next(&it
)))
535 if(!memcmp(node
, cc
->peer_node_id
, 8))
542 if(ll_count(card
->providers
))
544 it
= ll_iter_create(card
->providers
);
545 struct cc_provider
*prov
;
547 while((prov
= ll_iter_next(&it
)))
549 uint32_t prid
= prov
->prov
;
550 if(chk_srvid_by_caid_prov(cl
, card
->caid
, prid
))
556 if(!found
) { return 0; }
560 if(!chk_srvid_by_caid_prov(cl
, card
->caid
, 0))
564 //Check Card created by Service:
567 struct s_sidtab
*ptr
;
569 int32_t ok
= !cl
->sidtabs
.ok
&& !cl
->sidtabs
.no
; //default valid if no positive services and no negative services
572 if(!cl
->sidtabs
.ok
) // no positive services, so ok by default if no negative found
575 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
577 if(ptr
== card
->sidtab
)
579 if(cl
->sidtabs
.no
& ((SIDTABBITS
)1 << j
))
581 if(cl
->sidtabs
.ok
& ((SIDTABBITS
)1 << j
))
594 uint32_t get_reader_prid(struct s_reader
*rdr
, int32_t j
)
596 return b2i(3, &rdr
->prid
[j
][1]);
598 //uint32_t get_reader_prid(struct s_reader *rdr, int32_t j) {
600 // if (!is_cascading_reader(rdr)) { // Real cardreaders have 4-byte Providers
601 // prid = b2i(4, &rdr->prid[j][0]);
602 // //prid = (rdr->prid[j][0] << 24) | (rdr->prid[j][1] << 16)
603 // // | (rdr->prid[j][2] << 8) | (rdr->prid[j][3] & 0xFF);
604 // } else { // Cascading/Network-reader 3-bytes Providers
605 // prid = b2i(3, &rdr->prid[j][0]);
606 // //prid = (rdr->prid[j][0] << 16) | (rdr->prid[j][1] << 8)
607 // // | (rdr->prid[j][2] & 0xFF);
613 void copy_good_sids(LLIST
*dst
, LLIST
*src
)
615 LL_ITER it_src
= ll_iter_create(src
);
616 LL_ITER it_dst
= ll_iter_create(dst
);
617 struct cc_srvid
*srvid_src
;
618 struct cc_srvid
*srvid_dst
;
619 while((srvid_src
= ll_iter_next(&it_src
)))
621 ll_iter_reset(&it_dst
);
622 while((srvid_dst
= ll_iter_next(&it_dst
)))
624 if(sid_eq(srvid_src
, srvid_dst
))
629 if(!cs_malloc(&srvid_dst
, sizeof(struct cc_srvid
)))
631 memcpy(srvid_dst
, srvid_src
, sizeof(struct cc_srvid
));
632 ll_iter_insert(&it_dst
, srvid_dst
);
637 void copy_bad_sids(LLIST
*dst
, LLIST
*src
)
639 LL_ITER it_src
= ll_iter_create(src
);
640 LL_ITER it_dst
= ll_iter_create(dst
);
641 struct cc_srvid_block
*srvid_src
;
642 struct cc_srvid_block
*srvid_dst
;
643 while((srvid_src
= ll_iter_next(&it_src
)))
645 ll_iter_reset(&it_dst
);
646 while((srvid_dst
= ll_iter_next(&it_dst
)))
648 if(sid_eq_bb(srvid_src
, srvid_dst
))
653 if(!cs_malloc(&srvid_dst
, sizeof(struct cc_srvid_block
)))
655 memcpy(srvid_dst
, srvid_src
, sizeof(struct cc_srvid_block
));
656 ll_iter_insert(&it_dst
, srvid_dst
);
661 int32_t add_card_providers(struct cc_card
*dest_card
, struct cc_card
*card
,
662 int32_t copy_remote_nodes
)
664 int32_t modified
= 0;
666 //1. Copy nonexisting providers, ignore double:
667 struct cc_provider
*prov_info
;
668 LL_ITER it_src
= ll_iter_create(card
->providers
);
669 LL_ITER it_dst
= ll_iter_create(dest_card
->providers
);
671 struct cc_provider
*provider
;
672 while((provider
= ll_iter_next(&it_src
)))
674 ll_iter_reset(&it_dst
);
675 while((prov_info
= ll_iter_next(&it_dst
)))
677 if(prov_info
->prov
== provider
->prov
)
682 struct cc_provider
*prov_new
;
683 if(!cs_malloc(&prov_new
, sizeof(struct cc_provider
)))
685 memcpy(prov_new
, provider
, sizeof(struct cc_provider
));
686 ll_iter_insert(&it_dst
, prov_new
);
691 if(copy_remote_nodes
)
693 //2. Copy nonexisting remote_nodes, ignoring existing:
694 it_src
= ll_iter_create(card
->remote_nodes
);
695 it_dst
= ll_iter_create(dest_card
->remote_nodes
);
696 uint8_t *remote_node
;
697 uint8_t *remote_node2
;
698 while((remote_node
= ll_iter_next(&it_src
)))
700 ll_iter_reset(&it_dst
);
701 while((remote_node2
= ll_iter_next(&it_dst
)))
703 if(memcmp(remote_node
, remote_node2
, 8) == 0)
708 uint8_t *remote_node_new
;
709 if(!cs_malloc(&remote_node_new
, 8))
711 memcpy(remote_node_new
, remote_node
, 8);
712 ll_iter_insert(&it_dst
, remote_node_new
);
720 #define TIMEOUT_SECONDS 3600
722 void set_card_timeout(struct cc_card
*card
)
724 card
->timeout
= time(NULL
) + TIMEOUT_SECONDS
+ ((rand() & 0xff) - 128) * 2;
727 struct cc_card
*create_card(struct cc_card
*card
)
729 struct cc_card
*card2
;
730 if(!cs_malloc(&card2
, sizeof(struct cc_card
)))
733 { memcpy(card2
, card
, sizeof(struct cc_card
)); }
735 { memset(card2
, 0, sizeof(struct cc_card
)); }
736 card2
->providers
= ll_create("providers");
737 card2
->badsids
= ll_create("badsids");
738 card2
->goodsids
= ll_create("goodsids");
739 card2
->remote_nodes
= ll_create("remote_nodes");
743 copy_good_sids(card2
->goodsids
, card
->goodsids
);
744 copy_bad_sids(card2
->badsids
, card
->badsids
);
748 { set_card_timeout(card2
); }
753 struct cc_card
*create_card2(struct s_reader
*rdr
, int32_t j
, uint16_t caid
, uint8_t reshare
)
756 struct cc_card
*card
= create_card(NULL
);
759 card
->remote_id
= (rdr
? (rdr
->cc_id
<< 16) : 0x7F7F8000) | j
;
761 card
->reshare
= reshare
;
762 card
->origin_reader
= rdr
;
765 card
->grp
= rdr
->grp
;
766 card
->rdr_reshare
= rdr
->cc_reshare
> -1 ? rdr
->cc_reshare
: cfg
.cc_reshare
; //copy reshare because reader could go offline
767 card
->sidtabno
= rdr
->sidtabs
.no
;
768 card
->hop
= rdr
->cc_hop
;
770 else { card
->rdr_reshare
= reshare
; }
775 * num_same_providers checks if card1 has exactly the same providers as card2
776 * returns same provider count
778 int32_t num_same_providers(struct cc_card
*card1
, struct cc_card
*card2
)
783 LL_ITER it1
= ll_iter_create(card1
->providers
);
784 LL_ITER it2
= ll_iter_create(card2
->providers
);
786 struct cc_provider
*prov1
, *prov2
;
788 while((prov1
= ll_iter_next(&it1
)))
792 while((prov2
= ll_iter_next(&it2
)))
794 if(prov1
->prov
== prov2
->prov
)
806 * equal_providers checks if card1 has exactly the same providers as card2
807 * returns 1=equal 0=different
809 int32_t equal_providers(struct cc_card
*card1
, struct cc_card
*card2
)
812 if(ll_count(card1
->providers
) != ll_count(card2
->providers
))
814 if(ll_count(card1
->providers
) == 0)
817 LL_ITER it1
= ll_iter_create(card1
->providers
);
818 LL_ITER it2
= ll_iter_create(card2
->providers
);
820 struct cc_provider
*prov1
, *prov2
;
822 while((prov1
= ll_iter_next(&it1
)))
826 while((prov2
= ll_iter_next(&it2
)))
828 if(prov1
->prov
== prov2
->prov
)
834 if(!prov2
) { break; }
836 return (prov1
== NULL
);
839 int32_t is_au_card(struct cc_card
*card
)
841 if(card
&& card
->origin_reader
)
842 { return !card
->origin_reader
->audisabled
&& cc_UA_valid(card
->hexserial
); }
846 void merge_sids(struct cc_card
*carddst
, struct cc_card
*cardsrc
)
849 struct cc_srvid
*srvid
;
850 struct cc_srvid_block
*srvidb
;
852 int32_t goodSidCountSrc
= ll_count(cardsrc
->goodsids
);
853 int32_t goodSidCountDst
= ll_count(carddst
->goodsids
);
855 if(goodSidCountDst
== 0)
857 // remove sid blocks good+notbad from src
858 it
= ll_iter_create(cardsrc
->goodsids
);
859 while((srvid
= ll_iter_next(&it
)))
861 if(!is_sid_blocked(cardsrc
, srvid
))
862 { remove_sid_block(carddst
, srvid
); }
867 if(goodSidCountSrc
== 0)
869 // del goods from dst
870 ll_clear(carddst
->goodsids
);
873 ll_clear(carddst
->badsids
);
876 it
= ll_iter_create(cardsrc
->badsids
);
877 while((srvidb
= ll_iter_next(&it
)))
879 { add_sid_block(carddst
, (struct cc_srvid
*)srvidb
, false); }
884 // add good sid good+notbad from src
885 it
= ll_iter_create(cardsrc
->goodsids
);
886 while((srvid
= ll_iter_next(&it
)))
888 if(!is_sid_blocked(cardsrc
, srvid
))
889 { add_good_sid(carddst
, srvid
); }
897 * Adds a new card to a cardlist.
899 int32_t add_card_to_serverlist(LLIST
*cardlist
, struct cc_card
*card
, int8_t free_card
)
902 int32_t modified
= 0;
906 LL_ITER it
= ll_iter_create(cardlist
);
907 struct cc_card
*card2
;
909 //Minimize all, transmit just CAID, merge providers:
910 if(cfg
.cc_minimize_cards
== MINIMIZE_CAID
&& !cfg
.cc_forward_origin_card
)
912 while((card2
= ll_iter_next(&it
)))
914 //compare caid, hexserial, cardtype and sidtab (if any):
915 if(same_card2(card
, card2
, 0))
917 //Merge cards only if resulting providercount is smaller than CS_MAXPROV
918 int32_t nsame
, ndiff
, nnew
;
920 nsame
= num_same_providers(card
, card2
); //count same cards
921 ndiff
= ll_count(card
->providers
) - nsame
; //cound different cards, this cound will be added
922 nnew
= ndiff
+ ll_count(card2
->providers
); //new card count after add. because its limited to CS_MAXPROV, dont add it
924 if(nnew
<= CS_MAXPROV
)
929 if(!card2
) //Not found->add it:
931 if(free_card
) //Use this card
934 ll_iter_insert(&it
, card
);
938 card2
= create_card(card
); //Copy card
942 ll_iter_insert(&it
, card2
);
943 add_card_providers(card2
, card
, 1); //copy providers to new card. Copy remote nodes to new card
948 else //found, merge providers:
951 card2
->grp
|= card
->grp
; //add group to the card
952 add_card_providers(card2
, card
, 0); //merge all providers
953 ll_clear_data(card2
->remote_nodes
); //clear remote nodes
954 merge_sids(card2
, card
);
958 //Removed duplicate cards, keeping card with lower hop:
959 else if(cfg
.cc_minimize_cards
== MINIMIZE_HOPS
&& !cfg
.cc_forward_origin_card
)
961 while((card2
= ll_iter_next(&it
)))
963 //compare caid, hexserial, cardtype, sidtab (if any), providers:
964 if(same_card2(card
, card2
, 0) && equal_providers(card
, card2
))
970 if(card2
&& card2
->hop
> card
->hop
) //hop is smaller, drop old card
978 if(!card2
) //Not found->add it:
980 if(free_card
) //use this card
983 ll_iter_insert(&it
, card
);
987 card2
= create_card(card
); //copy card
990 ll_iter_insert(&it
, card2
);
991 add_card_providers(card2
, card
, 1); //copy providers to new card. Copy remote nodes to new card
995 else //found, merge cards (providers are same!)
998 card2
->grp
|= card
->grp
; //add group to the card
999 add_card_providers(card2
, card
, 0);
1000 merge_sids(card2
, card
);
1005 else //just remove duplicate cards (same ids)
1007 while((card2
= ll_iter_next(&it
)))
1009 //compare remote_id, first_node, caid, hexserial, cardtype, sidtab (if any), providers:
1010 if(same_card(card
, card2
))
1014 if(card2
&& card2
->hop
> card
->hop
) //same card, if hop greater drop card
1016 ll_iter_remove(&it
);
1017 cc_free_card(card2
);
1021 if(!card2
) //Not found, add it:
1026 ll_iter_insert(&it
, card
);
1030 card2
= create_card(card
);
1032 { return modified
; }
1033 ll_iter_insert(&it
, card2
);
1034 add_card_providers(card2
, card
, 1);
1038 else //Found, everything is same (including providers)
1045 { cc_free_card(card
); }
1051 * returns true if timeout-time is reached
1052 * only local cards needs to be renewed after 1h. "O" CCCam throws away cards older than 1,2h
1054 int32_t card_timed_out(struct cc_card
*card
)
1056 //!=CT_REMOTECARD = LOCALCARD (or virtual cards by caid/ident/service)
1057 //timeout is set in future, so if current time is bigger, timeout is reached
1058 int32_t res
= (card
->card_type
!= CT_REMOTECARD
) && (card
->timeout
< time(NULL
)); //local card is older than 1h?
1060 { cs_log_dbg(D_TRACE
, "card %08X timed out! refresh forced", card
->id
? card
->id
: card
->origin_id
); }
1065 * returns true if card1 is already reported.
1066 * "reported" means, we already have this card1 in our sharelist.
1067 * if the card1 is already reported, we throw it away, because we build a new sharelist
1068 * so after finding all reported cards, we have a list of reported cards, which aren't used anymore
1070 int32_t find_reported_card(struct cc_card
*card1
)
1072 LL_ITER it
= ll_iter_create(get_cardlist(card1
->caid
, reported_carddatas_list
));
1073 struct cc_card
*card2
;
1074 while((card2
= ll_iter_next(&it
)))
1076 if(same_card(card1
, card2
) && !card_timed_out(card2
))
1078 card1
->id
= card2
->id
; //Set old id !!
1079 card1
->timeout
= card2
->timeout
;
1080 cc_free_card(card2
);
1081 ll_iter_remove(&it
);
1082 return 1; //Old card and new card are equal!
1085 return 0; //Card not found
1090 * Adds a cccam-carddata buffer to the list of reported carddatas
1092 void cc_add_reported_carddata(LLIST
*reported_carddatas
, struct cc_card
*card
)
1094 ll_append(reported_carddatas
, card
);
1098 * adds the card to the list of the new reported carddatas - this is the new sharelist
1099 * if this card is not already reported, we send them to the clients
1100 * if this card is already reported, find_reported_card throws the "origin" card away
1101 * so the "old" sharelist is reduced
1103 void report_card(struct cc_card
*card
, LLIST
*new_reported_carddatas
, LLIST
*new_cards
)
1105 if(!find_reported_card(card
)) //Add new card:
1108 cs_log_dbg(D_TRACE
, "s-card added: id %8X remoteid %8X caid %4X hop %d reshare %d originid %8X cardtype %d",
1109 card
->id
, card
->remote_id
, card
->caid
, card
->hop
, card
->reshare
, card
->origin_id
, card
->card_type
);
1111 ll_append(new_cards
, card
);
1115 cc_add_reported_carddata(new_reported_carddatas
, card
);
1121 * Reports all caid/providers to the connected clients
1122 * returns 1=ok, 0=error
1123 * cfg.cc_reshare_services =0 CCCAM reader reshares only received cards + defined reader services
1124 * =1 CCCAM reader reshares received cards + defined services
1125 * =2 CCCAM reader reshares only defined reader-services as virtual cards
1126 * =3 CCCAM reader reshares only defined user-services as virtual cards
1127 * =4 CCCAM reader reshares only received cards
1129 void update_card_list(void)
1131 int32_t i
, j
, k
, l
, flt
, card_count
= 0;
1133 LLIST
*server_cards
[CAID_KEY
];
1134 LLIST
*new_reported_carddatas
[CAID_KEY
];
1137 struct cc_card
*card
;
1139 memset(server_cards
, 0, sizeof(server_cards
));
1140 memset(new_reported_carddatas
, 0, sizeof(new_reported_carddatas
));
1142 card_added_count
= 0;
1143 card_removed_count
= 0;
1147 if(cfg
.cc_reshare_services
== 3 && cfg
.sidtab
)
1149 struct s_sidtab
*ptr
;
1150 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
1152 for(k
= 0; k
< ptr
->num_caid
; k
++)
1154 card
= create_card2(NULL
, (j
<< 8) | k
, ptr
->caid
[k
], cfg
.cc_reshare
);
1157 card
->card_type
= CT_CARD_BY_SERVICE_USER
;
1159 for(l
= 0; l
< ptr
->num_provid
; l
++)
1161 struct cc_provider
*prov
;
1162 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1164 prov
->prov
= ptr
->provid
[l
];
1165 ll_append(card
->providers
, prov
);
1168 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 1);
1175 struct s_reader
*rdr
;
1178 cs_readlock(__func__
, &readerlist_lock
);
1180 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1182 //Generate a uniq reader id:
1186 struct s_reader
*rdr2
;
1187 for(rdr2
= first_active_reader
; rdr2
; rdr2
= rdr2
->next
)
1189 if(rdr2
!= rdr
&& rdr2
->cc_id
== rdr
->cc_id
)
1191 rdr2
= first_active_reader
;
1199 int8_t reshare
= rdr
->cc_reshare
> -1 ? rdr
->cc_reshare
: cfg
.cc_reshare
;
1202 if((cfg
.cc_reshare_services
== 1 || cfg
.cc_reshare_services
== 2 || (!rdr
->caid
&& rdr
->typ
!= R_CCCAM
&& cfg
.cc_reshare_services
!= 4)) &&
1203 cfg
.sidtab
&& (rdr
->sidtabs
.no
|| rdr
->sidtabs
.ok
))
1205 struct s_sidtab
*ptr
;
1206 for(j
= 0, ptr
= cfg
.sidtab
; ptr
; ptr
= ptr
->next
, j
++)
1208 if(!(rdr
->sidtabs
.no
& ((SIDTABBITS
)1 << j
)) && (rdr
->sidtabs
.ok
& ((SIDTABBITS
)1 << j
)))
1210 for(k
= 0; k
< ptr
->num_caid
; k
++)
1212 card
= create_card2(rdr
, (j
<< 8) | k
, ptr
->caid
[k
], reshare
);
1215 card
->card_type
= CT_CARD_BY_SERVICE_READER
;
1217 for(l
= 0; l
< ptr
->num_provid
; l
++)
1219 struct cc_provider
*prov
;
1220 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1222 prov
->prov
= ptr
->provid
[l
];
1223 ll_append(card
->providers
, prov
);
1226 if(chk_ident(&rdr
->ftab
, card
) && chk_ctab(card
->caid
, &rdr
->ctab
))
1228 if(!rdr
->audisabled
)
1229 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, card
->caid
); }
1231 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 1);
1235 { cc_free_card(card
); }
1241 //Filts by Hardware readers:
1242 if((rdr
->typ
!= R_CCCAM
) && rdr
->ftab
.filts
&& !flt
)
1244 for(j
= 0; j
< rdr
->ftab
.nfilts
; j
++)
1246 uint16_t caid
= rdr
->ftab
.filts
[j
].caid
;
1249 card
= create_card2(rdr
, j
, caid
, reshare
);
1252 card
->card_type
= CT_LOCALCARD
;
1254 //Setting UA: (Unique Address):
1255 if(!rdr
->audisabled
)
1256 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1257 //cs_log("Ident CCcam card report caid: %04X readr %s subid: %06X", rdr->ftab.filts[j].caid, rdr->label, rdr->cc_id);
1258 for(k
= 0; k
< rdr
->ftab
.filts
[j
].nprids
; k
++)
1260 struct cc_provider
*prov
;
1261 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1263 prov
->prov
= rdr
->ftab
.filts
[j
].prids
[k
];
1265 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1266 if(!rdr
->audisabled
)
1268 for(l
= 0; l
< rdr
->nprov
; l
++)
1270 uint32_t rprid
= get_reader_prid(rdr
, l
);
1271 if(rprid
== prov
->prov
)
1272 { cc_SA_oscam2cccam(&rdr
->sa
[l
][0], prov
->sa
); }
1276 ll_append(card
->providers
, prov
);
1279 add_good_bad_sids_by_rdr(rdr
, card
);
1280 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1286 if((rdr
->typ
!= R_CCCAM
) && !rdr
->caid
&& !flt
)
1288 for(j
= 0; j
< rdr
->ctab
.ctnum
; j
++)
1290 CAIDTAB_DATA
*d
= &rdr
->ctab
.ctdata
[j
];
1291 //cs_log("CAID map CCcam card report caid: %04X cmap: %04X", d->caid, d->cmap);
1292 uint16_t lcaid
= d
->caid
;
1294 if(!lcaid
|| (lcaid
== 0xFFFF))
1295 { lcaid
= d
->cmap
; }
1297 if(lcaid
&& (lcaid
!= 0xFFFF))
1299 card
= create_card2(rdr
, j
, lcaid
, reshare
);
1302 card
->card_type
= CT_CARD_BY_CAID1
;
1303 if(!rdr
->audisabled
)
1304 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, lcaid
); }
1306 add_good_bad_sids_by_rdr(rdr
, card
);
1307 add_card_to_serverlist(get_cardlist(lcaid
, server_cards
), card
, 1);
1313 if((rdr
->typ
!= R_CCCAM
) && rdr
->ctab
.ctnum
&& !flt
)
1315 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1317 if(rdr
->tcp_connected
|| rdr
->card_status
== CARD_INSERTED
)
1319 for(c
= 0; c
< rdr
->ctab
.ctnum
; c
++)
1321 CAIDTAB_DATA
*d
= &rdr
->ctab
.ctdata
[c
];
1322 uint16_t caid
= d
->caid
;
1323 if(!caid
) { break; }
1325 card
= create_card2(rdr
, c
, caid
, reshare
);
1328 card
->card_type
= CT_CARD_BY_CAID2
;
1330 if(!rdr
->audisabled
)
1331 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1332 for(j
= 0; j
< rdr
->nprov
; j
++)
1334 uint32_t prid
= get_reader_prid(rdr
, j
);
1335 struct cc_provider
*prov
;
1336 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1339 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1340 if(!rdr
->audisabled
)
1342 //Setting SA (Shared Addresses):
1343 cc_SA_oscam2cccam(rdr
->sa
[j
], prov
->sa
);
1345 ll_append(card
->providers
, prov
);
1346 //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)]);
1348 add_good_bad_sids_by_rdr(rdr
, card
);
1349 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1356 if((rdr
->typ
!= R_CCCAM
) && rdr
->caid
&& !flt
)
1358 //cs_log("tcp_connected: %d card_status: %d ", rdr->tcp_connected, rdr->card_status);
1359 if(rdr
->tcp_connected
|| rdr
->card_status
== CARD_INSERTED
)
1361 uint16_t caid
= rdr
->caid
;
1362 card
= create_card2(rdr
, 1, caid
, reshare
);
1365 card
->card_type
= CT_CARD_BY_CAID3
;
1367 if(!rdr
->audisabled
)
1368 { cc_UA_oscam2cccam(rdr
->hexserial
, card
->hexserial
, caid
); }
1369 for(j
= 0; j
< rdr
->nprov
; j
++)
1371 uint32_t prid
= get_reader_prid(rdr
, j
);
1372 struct cc_provider
*prov
;
1373 if(!cs_malloc(&prov
, sizeof(struct cc_provider
)))
1376 //cs_log("Ident CCcam card report provider: %02X%02X%02X", buf[21 + (k*7)]<<16, buf[22 + (k*7)], buf[23 + (k*7)]);
1377 if(!rdr
->audisabled
)
1379 //Setting SA (Shared Addresses):
1380 cc_SA_oscam2cccam(rdr
->sa
[j
], prov
->sa
);
1382 ll_append(card
->providers
, prov
);
1383 //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)]);
1385 add_good_bad_sids_by_rdr(rdr
, card
);
1386 add_card_to_serverlist(get_cardlist(caid
, server_cards
), card
, 1);
1390 if(rdr
->typ
== R_CCCAM
&& rdr
->tcp_connected
&&
1391 (cfg
.cc_reshare_services
< 2 || cfg
.cc_reshare_services
== 4) && rdr
->card_status
!= CARD_FAILURE
)
1394 cs_log_dbg(D_TRACE
, "asking reader %s for cards...", rdr
->label
);
1396 struct s_client
*rc
= rdr
->client
;
1397 struct cc_data
*rcc
= rc
? rc
->cc
: NULL
;
1400 if(rcc
&& rcc
->cards
&& !rc
->kill
)
1402 cs_readlock(__func__
, &rcc
->cards_busy
);
1404 it
= ll_iter_create(rcc
->cards
);
1405 while((card
= ll_iter_next(&it
)))
1407 if(chk_ctab(card
->caid
, &rdr
->ctab
))
1409 int32_t dont_ignore
= ll_count(card
->providers
) ? 0 : 1;
1411 it2
= ll_iter_create(card
->providers
);
1412 struct cc_provider
*prov
;
1413 while((prov
= ll_iter_next(&it2
)))
1415 uint32_t prid
= prov
->prov
;
1416 if(chk_srvid_by_caid_prov(rc
, card
->caid
, prid
))
1423 if(dont_ignore
) //Filtered by service
1425 add_card_to_serverlist(get_cardlist(card
->caid
, server_cards
), card
, 0);
1430 cs_readunlock(__func__
, &rcc
->cards_busy
);
1433 { cs_log_dbg(D_TRACE
, "reader %s not active!", rdr
->label
); }
1434 cs_log_dbg(D_TRACE
, "got %d cards from %s", count
, rdr
->label
);
1437 cs_readunlock(__func__
, &readerlist_lock
);
1440 LLIST
*new_cards
= ll_create("new_cards"); //List of new (added) cards
1442 cs_writelock(__func__
, &cc_shares_lock
);
1444 //report reshare cards:
1445 //cs_log_dbg(D_TRACE, "%s reporting %d cards", getprefix(), ll_count(server_cards));
1446 for(i
= 0; i
< CAID_KEY
; i
++)
1450 it
= ll_iter_create(server_cards
[i
]);
1452 //we compare every card of our new list (server_cards) with the last list.
1453 while((card
= ll_iter_next(&it
)))
1455 //cs_log_dbg(D_TRACE, "%s card %d caid %04X hop %d", getprefix(), card->id, card->caid, card->hop);
1457 if(!new_reported_carddatas
[i
])
1458 { new_reported_carddatas
[i
] = ll_create("new_cardlist"); }
1459 report_card(card
, new_reported_carddatas
[i
], new_cards
);
1460 ll_iter_remove(&it
);
1462 cc_free_cardlist(server_cards
[i
], 1);
1465 //remove unsed, remaining cards:
1466 card_removed_count
+= cc_free_reported_carddata(reported_carddatas_list
[i
], new_reported_carddatas
[i
], 1);
1467 reported_carddatas_list
[i
] = new_reported_carddatas
[i
];
1468 card_count
+= ll_count(reported_carddatas_list
[i
]);
1469 //cs_log_dbg(D_TRACE, "CARDS FOR INDEX %d=%d", i, ll_count(reported_carddatas[i]));
1472 //now send new cards. Always remove first, then add new:
1473 it
= ll_iter_create(new_cards
);
1474 while((card
= ll_iter_next(&it
)))
1476 send_card_to_all_clients(card
);
1478 ll_destroy(&new_cards
);
1481 cs_writeunlock(__func__
, &cc_shares_lock
);
1483 cs_log_dbg(D_TRACE
, "reported/updated +%d/-%d/dup %d of %d cards to sharelist",
1484 card_added_count
, card_removed_count
, card_dup_count
, card_count
);
1487 int32_t cc_srv_report_cards(struct s_client
*cl
)
1490 struct cc_card
*card
;
1491 int32_t i
, count
= 0;
1493 cs_readlock(__func__
, &cc_shares_lock
);
1494 for(i
= 0; i
< CAID_KEY
; i
++)
1496 if(reported_carddatas_list
[i
])
1498 it
= ll_iter_create(reported_carddatas_list
[i
]);
1499 while(cl
->cc
&& !cl
->kill
&& (card
= ll_iter_next(&it
)))
1501 count
+= send_card_to_client(card
, cl
);
1505 cs_readunlock(__func__
, &cc_shares_lock
);
1506 cs_log_dbg(D_TRACE
, "reported %d cards for %s", count
, username(cl
));
1508 return cl
->cc
&& !cl
->kill
;
1511 void refresh_shares(void)
1516 #define DEFAULT_INTERVAL 30
1518 void share_updater(void)
1520 int32_t i
= DEFAULT_INTERVAL
+ cfg
.waitforcards_extra_delay
/ 1000;
1521 uint32_t last_check
= 0;
1522 uint32_t last_check_rdroptions
= 0;
1523 uint32_t cur_check_rdroptions
= 0;
1524 uint32_t last_card_check
= 0;
1525 uint32_t last_sidtab_generation
= 0;
1526 uint32_t card_count
= 0;
1527 while(share_updater_thread_active
)
1529 const uint32_t sleep_step
= 500;
1530 uint32_t sleep_time
;
1532 if(i
> 0 && card_count
< 100) //fast refresh only if we have less cards
1534 cs_log_dbg(D_TRACE
, "share-updater mode=initfast t=1s i=%d", i
);
1540 cs_log_dbg(D_TRACE
, "share-updater mode=initslow t=6s i=%d", i
);
1541 sleep_time
= 6000; //1s later than garbage collector because this list uses much space
1546 if(cfg
.cc_update_interval
<= 10)
1547 { cfg
.cc_update_interval
= DEFAULT_UPDATEINTERVAL
; }
1548 cs_log_dbg(D_TRACE
, "share-updater mode=interval t=%ds", cfg
.cc_update_interval
);
1549 sleep_time
= cfg
.cc_update_interval
* 1000;
1551 for(slept
= 0; slept
< sleep_time
; slept
+= sleep_step
)
1553 if(!share_updater_thread_active
|| share_updater_refresh
)
1555 share_updater_refresh
= 0;
1558 cs_sleepms(sleep_step
);
1560 if(!share_updater_thread_active
)
1563 cs_log_dbg(D_TRACE
, "share-updater check");
1565 uint32_t cur_check
= 0;
1566 uint32_t cur_card_check
= 0;
1567 int8_t rdroptionchange
= 0;
1569 struct s_reader
*rdr
;
1572 cs_readlock(__func__
, &readerlist_lock
);
1574 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1576 struct s_client
*cl
= rdr
->client
;
1577 if(cl
&& (cc
= cl
->cc
)) //check cccam-cardlist:
1579 cur_card_check
+= cc
->card_added_count
;
1580 cur_card_check
+= cc
->card_removed_count
;
1581 card_count
+= ll_count(cc
->cards
);
1583 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->tcp_connected
, sizeof(rdr
->tcp_connected
));
1584 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->card_status
, sizeof(rdr
->card_status
));
1586 //Check hexserial/UA changes only on lokal readers:
1587 if(!is_network_reader(rdr
))
1589 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->hexserial
, 8); //check hexserial
1590 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->prid
, rdr
->nprov
* sizeof(rdr
->prid
[0])); //check providers
1591 cur_check
= crc32(cur_check
, (uint8_t *)&rdr
->sa
, rdr
->nprov
* sizeof(rdr
->sa
[0])); //check provider-SA
1594 if(rdr
->changes_since_shareupdate
)
1596 rdr
->changes_since_shareupdate
= 0;
1597 rdroptionchange
= 1;
1602 cur_check_rdroptions
= 0;
1603 for(rdr
= first_active_reader
; rdr
; rdr
= rdr
->next
)
1605 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->ftab
, sizeof(FTAB
)); //check reader
1606 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->ctab
, sizeof(CAIDTAB
)); //check caidtab
1607 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->fchid
, sizeof(FTAB
)); //check chids
1608 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->sidtabs
.ok
, sizeof(rdr
->sidtabs
.ok
)); //check assigned ok services
1609 cur_check_rdroptions
= crc32(cur_check_rdroptions
, (uint8_t *)&rdr
->sidtabs
.no
, sizeof(rdr
->sidtabs
.no
)); //check assigned no services
1613 cs_readunlock(__func__
, &readerlist_lock
);
1615 //update cardlist if reader config has changed, also set interval to 1s / 30times
1616 if(cur_check
!= last_check
|| last_sidtab_generation
!= cfg_sidtab_generation
|| last_check_rdroptions
!= cur_check_rdroptions
)
1618 last_sidtab_generation
= cfg_sidtab_generation
;
1619 i
= DEFAULT_INTERVAL
;
1620 cs_log_dbg(D_TRACE
, "share-update [1] %u %u", cur_check
, last_check
);
1622 last_check
= cur_check
;
1623 last_card_check
= cur_card_check
;
1625 //update cardlist if cccam cards has changed:
1626 else if(cur_card_check
!= last_card_check
)
1628 cs_log_dbg(D_TRACE
, "share-update [2] %u %u", cur_card_check
, last_card_check
);
1630 last_card_check
= cur_card_check
;
1632 last_check_rdroptions
= cur_check_rdroptions
;
1634 for(i
= 0; i
< CAID_KEY
; i
++)
1635 { cc_free_reported_carddata(reported_carddatas_list
[i
], NULL
, 0); }
1638 int32_t compare_cards_by_hop(struct cc_card
**pcard1
, struct cc_card
**pcard2
)
1640 struct cc_card
*card1
= (*pcard1
), *card2
= (*pcard2
);
1642 int32_t res
= card1
->hop
- card2
->hop
;
1643 if(res
) { return res
; }
1644 res
= card1
->caid
- card2
->caid
;
1645 if(res
) { return res
; }
1646 res
= card1
->reshare
- card2
->reshare
;
1647 if(res
) { return res
; }
1648 res
= card1
->id
- card2
->id
;
1652 int32_t compare_cards_by_hop_r(struct cc_card
**pcard1
, struct cc_card
**pcard2
)
1654 return -compare_cards_by_hop(pcard1
, pcard2
);
1657 struct cc_card
**get_sorted_card_copy(LLIST
*cards
, int32_t reverse
, int32_t *size
)
1660 { return (struct cc_card
**)ll_sort(cards
, compare_cards_by_hop_r
, size
); }
1662 { return (struct cc_card
**)ll_sort(cards
, compare_cards_by_hop
, size
); }
1665 void cccam_init_share(void)
1667 memset(reported_carddatas_list
, 0, sizeof(reported_carddatas_list
));
1668 cs_lock_create(__func__
, &cc_shares_lock
, "cc_shares_lock", 200000);
1670 share_updater_thread
= 0;
1671 share_updater_thread_active
= 1;
1672 share_updater_refresh
= 0;
1675 int32_t ret
= start_thread("share updater", (void *)&share_updater
, NULL
, &temp
, 1, 1);
1678 share_updater_thread
= temp
;
1682 void cccam_done_share(void)
1684 if(share_updater_thread
)
1686 share_updater_thread_active
= 0;
1687 share_updater_thread
= 0;
1691 void cccam_refresh_share(void)
1693 share_updater_refresh
= 1;