int32_t coolapi_open_device(int32_t demux_index, int32_t demux_id)
{
dmx_t *dmx;
SAFE_MUTEX_LOCK(&demux_lock);
dmx = find_demux(0, demux_index);
if(!dmx)
{
SAFE_MUTEX_UNLOCK(&demux_lock);
cs_log("no free demux found");
return 0;
}
if(!ll_cool_filter)
{ ll_cool_filter = ll_create("ll_cool_filter"); }
if(!ll_cool_chanhandle)
{ ll_cool_chanhandle = ll_create("ll_cool_chanhandle"); }
dmx->demux_id = demux_id;
dmx->pid = -1;
//dmx->device = dmx_handles[demux_index].handle;
dmx->opened = 1;
pthread_mutexattr_t attr;
SAFE_MUTEXATTR_INIT(&attr);
SAFE_MUTEXATTR_SETTYPE(&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
SAFE_MUTEX_INIT(&dmx->mutex, &attr);
SAFE_MUTEX_UNLOCK(&demux_lock);
return dmx->fd;
}
static void * card_poll(void) {
struct s_client *cl;
struct s_reader *rdr;
pthread_mutex_t card_poll_sleep_cond_mutex;
SAFE_MUTEX_INIT(&card_poll_sleep_cond_mutex, NULL);
SAFE_COND_INIT(&card_poll_sleep_cond, NULL);
set_thread_name(__func__);
while (!exit_oscam) {
cs_readlock(__func__, &readerlist_lock);
for (rdr=first_active_reader; rdr; rdr=rdr->next) {
if (rdr->enable && rdr->card_status == CARD_INSERTED) {
cl = rdr->client;
if (cl && !cl->kill)
{ add_job(cl, ACTION_READER_POLL_STATUS, 0, 0); }
}
}
cs_readunlock(__func__, &readerlist_lock);
struct timespec ts;
struct timeval tv;
gettimeofday(&tv, NULL);
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000;
ts.tv_sec += 1;
SAFE_MUTEX_LOCK(&card_poll_sleep_cond_mutex);
SAFE_COND_TIMEDWAIT(&card_poll_sleep_cond, &card_poll_sleep_cond_mutex, &ts); // sleep on card_poll_sleep_cond
SAFE_MUTEX_UNLOCK(&card_poll_sleep_cond_mutex);
}
return NULL;
}
/**
* called by signal SIGHUP
*
* reloads configs:
* - useraccounts (oscam.user)
* - readers (oscam.server)
* - services ids (oscam.srvid)
* - tier ids (oscam.tiers)
* Also clears anticascading stats.
**/
static void cs_reload_config(void)
{
static pthread_mutex_t mutex;
static int8_t mutex_init = 0;
if(!mutex_init)
{
SAFE_MUTEX_INIT(&mutex, NULL);
mutex_init = 1;
}
if(pthread_mutex_trylock(&mutex))
{
return;
}
cs_accounts_chk();
reload_readerdb();
init_provid();
init_srvid();
init_tierid();
init_fakecws();
ac_init_stat();
cs_reopen_log(); // FIXME: aclog.log, emm logs, cw logs (?)
SAFE_MUTEX_UNLOCK(&mutex);
}
struct s_client *create_client(IN_ADDR_T ip)
{
struct s_client *cl;
if(!cs_malloc(&cl, sizeof(struct s_client)))
{
cs_log("max connections reached (out of memory) -> reject client %s", IP_ISSET(ip) ? cs_inet_ntoa(ip) : "with null address");
return NULL;
}
//client part
IP_ASSIGN(cl->ip, ip);
cl->account = first_client->account;
//master part
SAFE_MUTEX_INIT(&cl->thread_lock, NULL);
cl->login = cl->last = time(NULL);
cl->tid = (uint32_t)rand();
//Now add new client to the list:
struct s_client *last;
cs_writelock(__func__, &clientlist_lock);
for(last = first_client; last && last->next; last = last->next)
{ ; } //ends with cl on last client
if (last)
last->next = cl;
int32_t bucket = (uintptr_t)cl / 16 % CS_CLIENT_HASHBUCKETS;
cl->nexthashed = first_client_hashed[bucket];
first_client_hashed[bucket] = cl;
cs_writeunlock(__func__, &clientlist_lock);
return cl;
}
int32_t stapi_open(void)
{
uint32_t ErrorCode;
DIR *dirp;
struct dirent entry, *dp = NULL;
struct stat buf;
int32_t i;
char pfad[80];
stapi_on = 1;
int32_t stapi_priority = 0;
dirp = opendir(PROCDIR);
if(!dirp)
{
cs_log("opendir failed (errno=%d %s)", errno, strerror(errno));
return 0;
}
memset(dev_list, 0, sizeof(struct STDEVICE)*PTINUM);
if(dvbapi_priority)
{
struct s_dvbapi_priority *p;
for(p = dvbapi_priority; p != NULL; p = p->next)
{
if(p->type == 's')
{
stapi_priority = 1;
break;
}
}
}
if(!stapi_priority)
{
cs_log("WARNING: no PTI devices defined, stapi disabled");
return 0;
}
oscam_stapi5_GetRevision();
oscam_sttkd_GetRevision();
i = 0;
while(!cs_readdir_r(dirp, &entry, &dp))
{
if(!dp) {
break;
}
snprintf(pfad, sizeof(pfad), "%s%s", PROCDIR, dp->d_name);
if(stat(pfad, &buf) != 0)
{
continue;
}
if(!(buf.st_mode & S_IFDIR && strncmp(dp->d_name, ".", 1) != 0))
{
continue;
}
int32_t do_open = 0;
struct s_dvbapi_priority *p;
for(p = dvbapi_priority; p != NULL; p = p->next)
{
if(p->type != 's') {
continue;
}
if(strcmp(dp->d_name, p->devname) == 0)
{
do_open = 1;
break;
}
}
if(!do_open)
{
cs_log("PTI: %s skipped", dp->d_name);
continue;
}
ErrorCode = oscam_stapi5_Open(dp->d_name, &dev_list[i].SessionHandle);
if(ErrorCode != 0)
{
cs_log("STPTI_Open ErrorCode: %d", ErrorCode);
continue;
}
//debug
//oscam_stapi_Capability(dp->d_name);
cs_strncpy(dev_list[i].name, dp->d_name, sizeof(dev_list[i].name));
cs_log("PTI: %s open %d", dp->d_name, i);
ErrorCode = oscam_stapi5_SignalAllocate(dev_list[i].SessionHandle, &dev_list[i].SignalHandle);
if(ErrorCode != 0)
{
cs_log("SignalAllocate: ErrorCode: %d SignalHandle: %x", ErrorCode, dev_list[i].SignalHandle);
}
i++;
if(i >= PTINUM) {
break;
}
}
closedir(dirp);
if(i == 0) {
return 0;
}
uint8_t TKD_InstanceID = 0;
memset(&tkd_desc_info, 0, sizeof(tkd_desc_info[0]) * MAX_DESCRAMBLER);
for(TKD_InstanceID = 0; TKD_InstanceID < TKD_MAX_NUMBER; TKD_InstanceID++)
{
/* Generate the device name dynamically based upon the Instance ID */
snprintf(TKD_DeviceName[TKD_InstanceID], sizeof(TKD_DeviceName), "TKD_%02d", TKD_InstanceID);
ErrorCode = oscam_sttkd_Open(TKD_DeviceName[TKD_InstanceID], &TKDHandle[TKD_InstanceID]);
if(ErrorCode != 0)
cs_log("oscam_sttkd_Open: DeviceName: %s, TKDHandle: 0x%08X, ErrorCode: %d", TKD_DeviceName[TKD_InstanceID], TKDHandle[TKD_InstanceID], ErrorCode);
}
SAFE_MUTEX_INIT(&filter_lock, NULL);
for(i = 0; i < PTINUM; i++)
{
if(dev_list[i].SessionHandle == 0)
{
continue;
}
struct read_thread_param *para;
if(!cs_malloc(¶, sizeof(struct read_thread_param)))
{
return 0;
}
para->id = i;
para->cli = cur_client();
int32_t ret = start_thread("stapi read", stapi_read_thread, (void *)para, &dev_list[i].thread, 1, 0);
if(ret)
{
return 0;
}
}
atexit(stapi_off);
cs_log("liboscam_stapi5 v.%s initialized", oscam_stapi5_LibVersion());
return 1;
}
