static void *chkcache_process(void)
{
set_thread_name(__func__);
time_t timeout;
struct ecm_request_t *er, *ecm;
uint8_t add_hitcache_er;
struct s_reader *cl_rdr;
struct s_reader *rdr;
struct s_ecm_answer *ea;
struct s_client *cex_src=NULL;
struct s_write_from_cache *wfc=NULL;
while(cacheex_running)
{
cs_readlock(__func__, &ecmcache_lock);
for(er = ecmcwcache; er; er = er->next)
{
timeout = time(NULL)-((cfg.ctimeout+500)/1000+1);
if(er->tps.time < timeout)
{ break; }
if(er->rc<E_UNHANDLED || er->readers_timeout_check) //already answered
{ continue; }
//******** CHECK IF FOUND ECM IN CACHE
ecm = check_cache(er, er->client);
if(ecm) //found in cache
{
//check for add_hitcache
if(ecm->cacheex_src) //cw from cacheex
{
if((er->cacheex_wait_time && !er->cacheex_wait_time_expired) || !er->cacheex_wait_time) //only when no wait_time expires (or not wait_time)
{
//add_hitcache already called, but we check if we have to call it for these (er) caid|prid|srvid
if(ecm->prid!=er->prid || ecm->srvid!=er->srvid)
{
cex_src = ecm->cacheex_src && is_valid_client(ecm->cacheex_src) && !ecm->cacheex_src->kill ? ecm->cacheex_src : NULL; //here we should be sure cex client has not been freed!
if(cex_src){ //add_hitcache only if client is really active
add_hitcache_er=1;
cl_rdr = cex_src->reader;
if(cl_rdr && cl_rdr->cacheex.mode == 2)
{
for(ea = er->matching_rdr; ea; ea = ea->next)
{
rdr = ea->reader;
if(cl_rdr == rdr && ((ea->status & REQUEST_ANSWERED) == REQUEST_ANSWERED))
{
cs_log_dbg(D_CACHEEX|D_CSP|D_LB,"{client %s, caid %04X, prid %06X, srvid %04X} [CACHEEX] skip ADD self request!", (check_client(er->client)?er->client->account->usr:"******"),er->caid, er->prid, er->srvid);
add_hitcache_er=0; //don't add hit cache, reader requested self
}
}
}
if(add_hitcache_er)
{ cacheex_add_hitcache(cex_src, er); } //USE cacheex client (to get correct group) and ecm from requesting client (to get correct caid|prid|srvid)!!!
}
}
}
else
{
//add_hitcache already called, but we have to remove it because cacheex not coming before wait_time
if(ecm->prid==er->prid && ecm->srvid==er->srvid)
{ cacheex_del_hitcache(er->client, ecm); }
}
}
//END check for add_hitcache
if(check_client(er->client))
{
wfc=NULL;
if(!cs_malloc(&wfc, sizeof(struct s_write_from_cache)))
{
NULLFREE(ecm);
continue;
}
wfc->er_new=er;
wfc->er_cache=ecm;
if(!add_job(er->client, ACTION_ECM_ANSWER_CACHE, wfc, sizeof(struct s_write_from_cache))) //write_ecm_answer_fromcache
{
NULLFREE(ecm);
continue;
}
}
else
{ NULLFREE(ecm); }
}
}
cs_readunlock(__func__, &ecmcache_lock);
cs_sleepms(10);
}
return NULL;
}
static int32_t cacheex_add_to_cache_int(struct s_client *cl, ECM_REQUEST *er, int8_t csp)
{
if(er->rc >= E_NOTFOUND) { return 0; }
if(!cl)
{ return 0; }
if(!csp && cl->reader && cl->reader->cacheex.mode != 2) //from reader
{
cs_log_dbg(D_CACHEEX, "CACHEX received, but disabled for %s", username(cl));
return 0;
}
if(!csp && !cl->reader && cl->account && cl->account->cacheex.mode != 3) //from user
{
cs_log_dbg(D_CACHEEX, "CACHEX received, but disabled for %s", username(cl));
return 0;
}
if(!csp && !cl->reader && !cl->account) //not active!
{
cs_log_dbg(D_CACHEEX, "CACHEX received, but invalid client state %s", username(cl));
return 0;
}
uint8_t i, c;
uint8_t null = 0;
for(i = 0; i < 16; i += 4)
{
c = ((er->cw[i] + er->cw[i + 1] + er->cw[i + 2]) & 0xff);
null |= (er->cw[i] | er->cw[i + 1] | er->cw[i + 2]);
if(er->cw[i + 3] != c)
{
cs_log_dump_dbg(D_CACHEEX, er->cw, 16, "push received cw with chksum error from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
}
if(null == 0 || chk_is_null_CW(er->cw))
{
cs_log_dump_dbg(D_CACHEEX, er->cw, 16, "push received null cw from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
if(get_odd_even(er)==0){
cs_log_dbg(D_CACHEEX, "push received ecm with null odd/even byte from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
if(!chk_halfCW(er, er->cw)){
log_cacheex_cw(er, "bad half cw");
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
if((csp && cfg.csp.block_fakecws) || (cl->reader && cl->reader->cacheex.block_fakecws)
|| (!cl->reader && cl->account && cl->account->cacheex.block_fakecws))
{
if(chk_is_fakecw(er->cw))
{
cs_log_dbg(D_CACHEEX, "push received fake cw from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
}
er->grp |= cl->grp; //ok for mode2 reader too: cl->reader->grp
er->rc = E_CACHEEX;
er->cacheex_src = cl;
er->selected_reader = cl->reader;
er->client = NULL; //No Owner! So no fallback!
if(check_client(cl))
{
cl->cwcacheexgot++;
if(cl->account)
{ cl->account->cwcacheexgot++; }
first_client->cwcacheexgot++;
}
cacheex_add_hitcache(cl, er); //we have to call it before add_cache, because in chk_process we could remove it!
add_cache(er);
cacheex_add_stats(cl, er->caid, er->srvid, er->prid, 1);
cs_writelock(__func__, &ecm_pushed_deleted_lock);
er->next = ecm_pushed_deleted;
ecm_pushed_deleted = er;
cs_writeunlock(__func__, &ecm_pushed_deleted_lock);
return 1; //NO free, we have to wait cache push out stuff ends.
}
static int32_t cacheex_add_to_cache_int(struct s_client *cl, ECM_REQUEST *er, int8_t csp)
{
if(er->rc >= E_NOTFOUND) { return 0; }
if(!cl)
{ return 0; }
if(!csp && cl->reader && cl->reader->cacheex.mode != 2) //from reader
{
cs_log_dbg(D_CACHEEX, "CACHEX received, but disabled for %s", username(cl));
return 0;
}
if(!csp && !cl->reader && cl->account && cl->account->cacheex.mode != 3) //from user
{
cs_log_dbg(D_CACHEEX, "CACHEX received, but disabled for %s", username(cl));
return 0;
}
if(!csp && !cl->reader && !cl->account) //not active!
{
cs_log_dbg(D_CACHEEX, "CACHEX received, but invalid client state %s", username(cl));
return 0;
}
if(!cfg.disablecrccws && ((cl->typ == 'c' && !cl->account->disablecrccacheex) || ( cl->typ == 'p' && !cl->reader->disablecrccws)))
{
uint8_t selectedForIgnChecksum = chk_if_ignore_checksum(er, &cfg.disablecrccws_only_for);
if(cl->typ == 'c')
{
selectedForIgnChecksum += chk_if_ignore_checksum(er, &cl->account->disablecrccacheex_only_for);
}
if(cl->typ == 'p')
{
selectedForIgnChecksum += chk_if_ignore_checksum(er, &cl->reader->disablecrccws_only_for);
}
if(!selectedForIgnChecksum)
{
uint8_t i, c;
for(i = 0; i < 16; i += 4)
{
c = ((er->cw[i] + er->cw[i + 1] + er->cw[i + 2]) & 0xff);
if(er->cw[i + 3] != c)
{
cs_log_dump_dbg(D_CACHEEX, er->cw, 16, "push received cw with chksum error from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
}
}
}
// Skip check for BISS1 - cw could be indeed zero
// Skip check for BISS2 - we use the extended cw, so the "simple" cw is always zero
if(chk_is_null_CW(er->cw) && !caid_is_biss(er->caid))
{
cs_log_dump_dbg(D_CACHEEX, er->cw, 16, "push received null cw from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
// Don't check for BISS1 and BISS2 mode 1/E or fake caid (ECM is fake for them)
// Don't check for BISS2 mode CA (ECM table is always 0x80)
if(!caid_is_biss(er->caid) && !caid_is_fake(er->caid) && get_odd_even(er) == 0)
{
cs_log_dbg(D_CACHEEX, "push received ecm with null odd/even byte from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
if(!chk_halfCW(er, er->cw))
{
log_cacheex_cw(er, "bad half cw");
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
if((csp && cfg.csp.block_fakecws) || (cl->reader && cl->reader->cacheex.block_fakecws)
|| (!cl->reader && cl->account && cl->account->cacheex.block_fakecws))
{
if(chk_is_fakecw(er->cw))
{
cs_log_dbg(D_CACHEEX, "push received fake cw from %s", csp ? "csp" : username(cl));
cl->cwcacheexerr++;
if(cl->account)
{ cl->account->cwcacheexerr++; }
return 0;
}
}
er->grp |= cl->grp; // ok for mode2 reader too: cl->reader->grp
er->rc = E_CACHEEX;
er->cacheex_src = cl;
er->selected_reader = cl->reader;
er->client = NULL; // No Owner! So no fallback!
if(check_client(cl))
{
cl->cwcacheexgot++;
if(cl->account)
{ cl->account->cwcacheexgot++; }
first_client->cwcacheexgot++;
}
cacheex_add_hitcache(cl, er); // we have to call it before add_cache, because in chk_process we could remove it!
add_cache(er);
cacheex_add_stats(cl, er->caid, er->srvid, er->prid, 1);
cs_writelock(__func__, &ecm_pushed_deleted_lock);
er->next = ecm_pushed_deleted;
ecm_pushed_deleted = er;
cs_writeunlock(__func__, &ecm_pushed_deleted_lock);
return 1; // NO free, we have to wait cache push out stuff ends.
}