#ifndef GLOBALS_H_ #define GLOBALS_H_ #define _GNU_SOURCE // needed for PTHREAD_MUTEX_RECURSIVE on some plattforms and maybe other things; do not remove #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__OpenBSD__) #include #endif /* * The following hack is taken from Linux: include/linux/kconfig.h * Original comment follows: * Getting something that works in C and CPP for an arg that may or may * not be defined is tricky. Here, if we have "#define CONFIG_BOOGER 1" * we match on the placeholder define, insert the "0," for arg1 and generate * the triplet (0, 1, 0). Then the last step cherry picks the 2nd arg (a one). * When CONFIG_BOOGER is not defined, we generate a (... 1, 0) pair, and when * the last step cherry picks the 2nd arg, we get a zero. */ #define __ARG_PLACEHOLDER_1 0, #define config_enabled(cfg) _config_enabled(cfg) #define _config_enabled(value) __config_enabled(__ARG_PLACEHOLDER_##value) #define __config_enabled(arg1_or_junk) ___config_enabled(arg1_or_junk 1, 0) #define ___config_enabled(__ignored, val, ...) val #include "config.h" #if defined(WITH_SSL) && !defined(WITH_LIBCRYPTO) # define WITH_LIBCRYPTO 1 #endif /* For deprecated but still needed cryptography functions: * 10002 corresponds to OpenSSL version 1.0.2*/ #define OPENSSL_API_COMPAT 10002 #if defined(__CYGWIN__) || defined(__arm__) || defined(__SH4__) || defined(__MIPS__) || defined(__MIPSEL__) || defined(__powerpc__) # define CS_LOGFILE "/dev/tty" #endif #if defined(__AIX__) || defined(__SGI__) || defined(__OSF__) || defined(__HPUX__) || defined(__SOLARIS__) || defined(__APPLE__) # define NEED_DAEMON #endif #if defined(__AIX__) || defined(__SGI__) || defined(__OSF__) || defined(__HPUX__) || defined(__SOLARIS__) || defined(__CYGWIN__) # define NO_ENDIAN_H #endif #if defined(__AIX__) || defined(__SGI__) # define socklen_t unsigned long #endif #if defined(__SOLARIS__) || defined(__FreeBSD__) || defined(__OpenBSD__) # define BSD_COMP #endif #if defined(__HPUX__) # define _XOPEN_SOURCE_EXTENDED #endif #if (defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(s6_addr32) #define s6_addr32 __u6_addr.__u6_addr32 #endif #ifdef __ANDROID__ #ifndef in_port_t #define in_port_t uint16_t #endif #define tcdrain(fd) ioctl(fd, TCSBRK, 1) #endif #ifdef __uClinux__ #define fork() 0 #endif // Prevent warnings about openssl functions. Apple may consider 'openssl' // deprecated but changing perfectly working portable code just because they // introduced some proprietary API is not going to happen. #if defined(__APPLE__) #define __AVAILABILITY_MACROS_USES_AVAILABILITY 0 #define MAC_OS_X_VERSION_MIN_REQUIRED MAC_OS_X_VERSION_10_6 #endif #include "cscrypt/aes.h" #ifdef IPV6SUPPORT #define IN_ADDR_T struct in6_addr #define SOCKADDR sockaddr_storage #define ADDR_ANY in6addr_any #define DEFAULT_AF AF_INET6 #else #define IN_ADDR_T in_addr_t #define SOCKADDR sockaddr_in #define ADDR_ANY INADDR_ANY #define DEFAULT_AF AF_INET #endif #ifndef NO_ENDIAN_H #if defined(__APPLE__) #include #define __BYTE_ORDER __DARWIN_BYTE_ORDER #define __BIG_ENDIAN __DARWIN_BIG_ENDIAN #define __LITTLE_ENDIAN __DARWIN_LITTLE_ENDIAN #elif defined(__FreeBSD__) || defined(__OpenBSD__) #include #define __BYTE_ORDER _BYTE_ORDER #define __BIG_ENDIAN _BIG_ENDIAN #define __LITTLE_ENDIAN _LITTLE_ENDIAN #else #include #include #endif #endif /* =========================== * macros * =========================== */ // Prevent use of unsafe functions (doesn't work for MacOSX) #if !defined(__APPLE__) #define strcpy(a,b) UNSAFE_STRCPY_USE_CS_STRNCPY_INSTEAD() #define sprintf(a,...) UNSAFE_SPRINTF_USE_SNPRINTF_INSTEAD() #define strtok(a,b,c) UNSAFE_STRTOK_USE_STRTOK_R_INSTEAD() #define gmtime(a) UNSAFE_GMTIME_NOT_THREADSAFE_USE_CS_GMTIME_R() #define localtime(a) UNSAFE_LOCALTIME_NOT_THREADSAFE_USE_LOCALTIME_R() #define asctime(a) UNSAFE_ASCTIME_NOT_THREADSAFE_USE_ASCTIME_R() #define ctime(a) UNSAFE_CTIME_NOT_THREADSAFE_USE_CS_CTIME_R() #define gethostbyaddr(a,b,c) UNSAFE_GETHOSTBYADDR_NOT_THREADSAFE_USE_GETADDRINFO() #define gethostent(a) UNSAFE_GETHOSTENT_NOT_THREADSAFE() #define getprotobyname(a) UNSAFE_GETPROTOBYNAME_NOT_THREADSAFE_USE_GETPROTOBYNAME_R() #define getservbyname(a,b) UNSAFE_GETSERVBYNAME_NOT_THREADSAFE_USE_GETSERVBYNAME_R() #define getservbyport(a,b) UNSAFE_GETSERVBYPORT_NOT_THREADSAFE_USE_GETSERVBYPORT_R() #define getservent() UNSAFE_GETSERVENT_NOT_THREADSAFE_USE_GETSERVENT_R() #define getnetbyname(a) UNSAFE_GETNETBYNAME_NOT_THREADSAFE_USE_GETNETBYNAME_R #define getnetbyaddr(a,b) UNSAFE_GETNETBYADDR_NOT_THREADSAFE_USE_GETNETBYADDR_R #define getnetent() UNSAFE_GETNETENT_NOT_THREADSAFE_USE_GETNETENT_R #define getrpcbyname(a) UNSAFE_GETRPCBYNAME_NOT_THREADSAFE_USE_GETRPCBYNAME_R #define getrpcbynumber(a) UNSAFE_GETRPCBYNUMBER_NOT_THREADSAFE_USE_GETRPCBYNUMBER_R #define getrpcent() UNSAFE_GETRPCENT_NOT_THREADSAFE_USE_GETRPCENT_R #define ctermid(a) UNSAFE_CTERMID_NOT_THREADSAFE_USE_CTERMID_R #define tmpnam(a) UNSAFE_TMPNAM_NOT_THREADSAFE #define tempnam(a,b) UNSAFE_TEMPNAM_NOT_THREADSAFE #define getlogin() UNSAFE_GETLOGIN_NOT_THREADSAFE_USE_GETLOGIN_R #define getpwnam(a) UNSAFE_GETPWNAM_NOT_THREADSAFE_USE_GETPWNAM_R #define getpwent() UNSAFE_GETPWENT_NOT_THREADSAFE_USE_GETPWENT_R #define fgetpwent(a) UNSAFE_FGETPWENT_NOT_THREADSAFE_USE_FGETPWENT_R #ifndef __ANDROID__ #define getpwuid(a) UNSAFE_GETPWUID_NOT_THREADSAFE_USE_GETPWUID_R #endif #define getspent() UNSAFE_GETSPENT_NOT_THREADSAFE_USE_GETSPENT_R #define getspnam(a) UNSAFE_GETSPNAM_NOT_THREADSAFE_USE_GETSPNAM_R #define fgetspent(a) UNSAFE_FGETSPENT_NOT_THREADSAFE_USE_FGETSPENT_R #define getgrnam(a) UNSAFE_GETGRNAM_NOT_THREADSAFE_USE_GETGRNAM_R #define getgrent() UNSAFE_GETGRENT_NOT_THREADSAFE_USE_GETGRENT_R #define getgrgid(a) UNSAFE_GETGRGID_NOT_THREADSAFE_USE_GETGRGID_R #define fgetgrent() UNSAFE_FGETGRENT_NOT_THREADSAFE_USE_FGETGRGID_R #define fcvt(a,b,c,d) UNSAFE_FCVT_NOT_THREADSAFE_AND_DEPRECATED #define ecvt(a,b,c,d) UNSAFE_ECVT_NOT_THREADSAFE_AND_DEPRECATED #define gcvt(a,b,c) UNSAFE_GCVT_NOT_THREADSAFE_AND_DEPRECATED #define strptime(a,b,c) STRPTIME_NOT_EXISTS_ON_SOME_DM500_DB2() #define ftime(a) FTIME_DEPRECATED() #define timegm(a) TIMEGM_GNU_SPECIFIC_USE_CS_TIMEGM #endif #ifdef UNUSED #elif __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7) # define UNUSED(x) UNUSED_ ## x __attribute__((unused)) #elif defined(__LCLINT__) # define UNUSED(x) /*@unused@*/ x #else # define UNUSED(x) x #endif #if __GNUC__ >= 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) # define MUST_CHECK_RESULT __attribute__((warn_unused_result)) #endif #ifdef OK #undef OK #endif #ifdef ERROR #undef ERROR #endif #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) #ifdef WITH_DEBUG # define call(arg) \ if(arg) \ { \ cs_log_dbg(D_TRACE, "ERROR, function call %s returns error.",#arg); \ return ERROR; \ } #else # define call(arg) \ if(arg) \ { \ return ERROR; \ } #endif // checking if (X) free(X) unneccessary since freeing a null pointer doesnt do anything #define NULLFREE(X) {void *tmpX=X; X=NULL; free(tmpX); } #ifdef __CYGWIN__ #define cs_recv(a,b,c,d) cygwin_recv(a,b,c,d) #else #define cs_recv(a,b,c,d) recv(a,b,c,d) #endif // safe wrappers to pthread functions #define fprintf_stderr(fmt, params...) fprintf(stderr, fmt, ##params) #define SAFE_PTHREAD_1ARG(a, b, c) { \ int32_t pter = a(b); \ if(pter != 0) \ { \ c("FATAL ERROR: %s() failed in %s with error %d %s\n", #a, __func__, pter, strerror(pter)); \ } } #define SAFE_MUTEX_LOCK(a) SAFE_PTHREAD_1ARG(pthread_mutex_lock, a, cs_log) #define SAFE_MUTEX_UNLOCK(a) SAFE_PTHREAD_1ARG(pthread_mutex_unlock, a, cs_log) #define SAFE_COND_SIGNAL(a) SAFE_PTHREAD_1ARG(pthread_cond_signal, a, cs_log) #define SAFE_COND_BROADCAST(a) SAFE_PTHREAD_1ARG(pthread_cond_broadcast, a, cs_log) #define SAFE_RWLOCK_RDLOCK(a) SAFE_PTHREAD_1ARG(pthread_rwlock_rdlock, a, cs_log) #define SAFE_RWLOCK_WRLOCK(a) SAFE_PTHREAD_1ARG(pthread_rwlock_wrlock, a, cs_log) #define SAFE_RWLOCK_UNLOCK(a) SAFE_PTHREAD_1ARG(pthread_rwlock_unlock, a, cs_log) #define SAFE_ATTR_INIT(a) SAFE_PTHREAD_1ARG(pthread_attr_init, a, cs_log) #define SAFE_MUTEXATTR_INIT(a) SAFE_PTHREAD_1ARG(pthread_mutexattr_init, a, cs_log) #define SAFE_CONDATTR_INIT(a) SAFE_PTHREAD_1ARG(pthread_condattr_init, a, cs_log) #define SAFE_MUTEX_LOCK_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_mutex_lock, a, fprintf_stderr) #define SAFE_MUTEX_UNLOCK_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_mutex_unlock, a, fprintf_stderr) #define SAFE_COND_SIGNAL_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_cond_signal, a, fprintf_stderr) #define SAFE_MUTEX_UNLOCK_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_mutex_unlock, a, fprintf_stderr) #define SAFE_ATTR_INIT_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_attr_init, a, fprintf_stderr) #define SAFE_CONDATTR_INIT_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_condattr_init, a, fprintf_stderr) #define SAFE_PTHREAD_2ARG(a, b, c, d) { \ int32_t pter = a(b, c); \ if(pter != 0) \ { \ d("FATAL ERROR: %s() failed in %s with error %d %s\n", #a, __func__, pter, strerror(pter)); \ } } #define SAFE_COND_WAIT(a,b) SAFE_PTHREAD_2ARG(pthread_cond_wait, a, b, cs_log) #define SAFE_THREAD_JOIN(a,b) SAFE_PTHREAD_2ARG(pthread_join, a, b, cs_log) #define SAFE_SETSPECIFIC(a,b) SAFE_PTHREAD_2ARG(pthread_setspecific, a, b, cs_log) #define SAFE_MUTEXATTR_SETTYPE(a,b) SAFE_PTHREAD_2ARG(pthread_mutexattr_settype, a, b, cs_log) #define SAFE_MUTEX_INIT(a,b) SAFE_PTHREAD_2ARG(pthread_mutex_init, a, b, cs_log) #define SAFE_COND_INIT(a,b) SAFE_PTHREAD_2ARG(pthread_cond_init, a, b, cs_log) #define SAFE_CONDATTR_SETCLOCK(a,b) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, cs_log) #define SAFE_MUTEX_INIT_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_mutex_init, a, b, fprintf_stderr) #define SAFE_COND_INIT_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_cond_init, a, b, fprintf_stderr) #define SAFE_THREAD_JOIN_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_join, a, b, fprintf_stderr) #define SAFE_CONDATTR_SETCLOCK_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, fprintf_stderr) #define SAFE_PTHREAD_1ARG_R(a, b, c, d) { \ int32_t pter = a(b); \ if(pter != 0) \ { \ c("FATAL ERROR: %s() failed in %s (called from %s) with error %d %s\n", #a, __func__, d, pter, strerror(pter)); \ } } #define SAFE_MUTEX_LOCK_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_lock, a, cs_log, b) #define SAFE_MUTEX_UNLOCK_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_unlock, a, cs_log, b) #define SAFE_COND_SIGNAL_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_cond_signal, a, cs_log, b) #define SAFE_COND_BROADCAST_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_cond_broadcast, a, cs_log, b) #define SAFE_CONDATTR_INIT_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_condattr_init, a, cs_log, b) #define SAFE_MUTEX_LOCK_NOLOG_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_lock, a, fprintf_stderr, b) #define SAFE_MUTEX_UNLOCK_NOLOG_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_unlock, a, fprintf_stderr, b) #define SAFE_CONDATTR_INIT_NOLOG_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_condattr_init, a, fprintf_stderr, b) #define SAFE_PTHREAD_2ARG_R(a, b, c, d, e) { \ int32_t pter = a(b, c); \ if(pter != 0) \ { \ d("FATAL ERROR: %s() failed in %s (called from %s) with error %d %s\n", #a, __func__, e, pter, strerror(pter)); \ } } #define SAFE_MUTEX_INIT_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_mutex_init, a, b, cs_log, c) #define SAFE_COND_INIT_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_cond_init, a, b, cs_log, c) #define SAFE_CONDATTR_SETCLOCK_R(a,b,c) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, cs_log, c) #define SAFE_MUTEX_INIT_NOLOG_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_mutex_init, a, b, fprintf_stderr, c) #define SAFE_COND_INIT_NOLOG_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_cond_init, a, b, fprintf_stderr, c) #define SAFE_CONDATTR_SETCLOCK_NOLOG_R(a,b,c) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, fprintf_stderr, c) #define SAFE_COND_TIMEDWAIT(a, b, c) { \ int32_t pter; \ if((c)->tv_nsec < 0) (c)->tv_nsec = 0; \ if((c)->tv_nsec > 999999999) (c)->tv_nsec = 999999999; \ pter = pthread_cond_timedwait(a, b, c); \ if(pter != 0 && pter != ETIMEDOUT) \ { \ cs_log("FATAL ERROR: pthread_cond_timedwait failed in %s with error %d %s\n", __func__, pter, strerror(pter)); \ } } #define SAFE_COND_TIMEDWAIT_R(a, b, c, d) { \ int32_t pter; \ if((c)->tv_nsec < 0) (c)->tv_nsec = 0; \ if((c)->tv_nsec > 999999999) (c)->tv_nsec = 999999999; \ pter = pthread_cond_timedwait(a, b, c); \ if(pter != 0 && pter != ETIMEDOUT) \ { \ cs_log("FATAL ERROR: pthread_cond_timedwait failed in %s (called from %s) with error %d %s\n", __func__, d, pter, strerror(pter)); \ } } #define SAFE_ATTR_SETSTACKSIZE(a,b) { \ int32_t pter = pthread_attr_setstacksize(a, b); \ if(pter != 0) \ { \ cs_log("WARNING: pthread_attr_setstacksize() failed in %s with error %d %s\n", __func__, pter, strerror(pter)); \ } } #define SAFE_ATTR_SETSTACKSIZE_NOLOG(a,b) { \ int32_t pter = pthread_attr_setstacksize(a, b); \ if(pter != 0) \ { \ fprintf_stderr("WARNING: pthread_attr_setstacksize() failed in %s with error %d %s\n", __func__, pter, strerror(pter)); \ } } #ifdef NO_PTHREAD_STACKSIZE #undef SAFE_ATTR_SETSTACKSIZE #undef SAFE_ATTR_SETSTACKSIZE_NOLOG #define SAFE_ATTR_SETSTACKSIZE(a,b) #define SAFE_ATTR_SETSTACKSIZE_NOLOG(a,b) #endif #define CHECK_BIT(var,pos) (((var) & (1<<(pos)))? 1 : 0) // CW VOTING #define MAX_VOTE_CANDIDATES 16 // Zwiększono dla obsługi większej liczby głosów #define MIN_VOTES_REQUIRED 2 #define CW_COMPARE_LEN 14 /* =========================== * constants * =========================== */ #define SCM_URL "https://github.com/oscam-mirror/oscam-emu" #define WIKI_URL "https://git.streamboard.tv/common/oscam/-/wikis" #define BOARD_URL "https://github.com/oscam-mirror/oscam-emu/discussions" #ifndef CS_VERSION #define CS_VERSION "2.26.01-11942" #endif #ifndef CS_GIT_COMMIT #define CS_GIT_COMMIT "a2b4c6d8" #endif #ifdef CS_CACHEEX #ifdef CS_CACHEEX_AIO #define CS_AIO_VERSION CS_VERSION #define CS_AIO_VERSION_LEN (sizeof(CS_AIO_VERSION)) #endif #endif #ifndef CS_TARGET # define CS_TARGET "unknown" #endif #ifndef CS_CONFDIR #define CS_CONFDIR "/usr/local/etc" #endif #ifndef CS_LOGFILE #define CS_LOGFILE "/var/log/oscam.log" #endif #define CS_QLEN 128 // size of request queue #define CS_MAXPROV 32 #define CS_MAXPORTS 32 // max server ports #define CS_CLIENT_HASHBUCKETS 32 #define CS_SERVICENAME_SIZE 32 #define CS_ECMSTORESIZE 16 // use MD5() #define CS_EMMSTORESIZE 16 // use MD5() #define CS_CLIENT_TIMEOUT 5000 #define CS_CLIENT_MAXIDLE 120 #define CS_BIND_TIMEOUT 120 #define CS_DELAY 0 #define CS_ECM_RINGBUFFER_MAX 0x10 // max size for ECM last responsetimes ringbuffer. Keep this set to power of 2 values! // Support for multiple CWs per channel and other encryption algos #define WITH_EXTENDED_CW 1 #define MAX_ECM_SIZE 1024 #define MAX_EMM_SIZE 1024 #define MAX_CMD_SIZE 0xff + 5 // maximum value from length byte + command header #ifdef WITH_EMU #define CS_EMMCACHESIZE 1024 // nr of EMMs that EMU reader will cache #else #define CS_EMMCACHESIZE 512 // nr of EMMs that each reader will cache #endif #define MSGLOGSIZE 64 // size of string buffer for a ecm to return messages #define D_TRACE 0x0001 // Generate very detailed error/trace messages per routine #define D_ATR 0x0002 // Debug ATR parsing, dump of ecm, cw #define D_READER 0x0004 // Debug Reader/Proxy Process #define D_CLIENT 0x0008 // Debug Client Process #define D_IFD 0x0010 // Debug IFD+protocol #define D_DEVICE 0x0020 // Debug Reader I/O #define D_EMM 0x0040 // Dumps EMM #define D_DVBAPI 0x0080 // Debug DVBAPI #define D_LB 0x0100 // Debug Loadbalancer/ECM handler #define D_CACHEEX 0x0200 // Debug CACHEEX #define D_CLIENTECM 0x0400 // Debug Client ECMs #define D_CSP 0x0800 // Debug CSP #define D_CWC 0x1000 // Debug CWC #ifdef CS_CACHEEX_AIO #define D_CW_CACHE 0x2000 // Debug CW Cache #endif #define D_ALL_DUMP 0xFFFF // dumps all #ifdef CS_CACHEEX_AIO #define MAX_DEBUG_LEVELS 14 #else #define MAX_DEBUG_LEVELS 13 #endif /////// phoenix readers which need baudrate setting and timings need to be guarded by OSCam: BEFORE R_MOUSE #define R_DB2COM1 0x1 // Reader Dbox2 @ com1 #define R_DB2COM2 0x2 // Reader Dbox2 @ com1 #define R_SC8in1 0x3 // Reader Sc8in1 or MCR #define R_MP35 0x4 // AD-Teknik Multiprogrammer 3.5 and 3.6 (only usb tested) #define R_MOUSE 0x5 // Reader smartcard mouse /////// internal readers (Dreambox, Coolstream, IPBox) are all R_INTERNAL, they are determined compile-time #define R_INTERNAL 0x6 // Reader smartcard intern #define R_SMART 0x7 // Reader smartcard (generic) /////// readers that do not reed baudrate setting and timings are guarded by reader itself (large buffer built in): AFTER R_SMART #define R_PCSC 0x8 // PCSC #define R_DRECAS 0x9 // Reader DRECAS #define R_EMU 0x17 // Reader EMU /////// proxy readers after R_CS378X #define R_CAMD35 0x20 // Reader cascading camd 3.5x #define R_CAMD33 0x21 // Reader cascading camd 3.3x #define R_NEWCAMD 0x22 // Reader cascading newcamd #define R_RADEGAST 0x23 // Reader cascading radegast #define R_CS378X 0x24 // Reader cascading camd 3.5x TCP #define R_CONSTCW 0x25 // Reader for Constant CW #define R_CSP 0x26 // Cache CSP #define R_GHTTP 0x27 // Reader ghttp #define R_SCAM 0x28 // Reader cascading scam /////// peer to peer proxy readers after R_CCCAM #define R_GBOX 0x30 // Reader cascading gbox #define R_CCCAM 0x35 // Reader cascading cccam #define R_PANDORA 0x36 // Reader cascading pandora #define R_SERIAL 0x80 // Reader serial #define R_IS_NETWORK 0x60 #define R_IS_CASCADING 0xE0 #define is_network_reader(__X) (__X->typ & R_IS_NETWORK) #define is_cascading_reader(__X) (__X->typ & R_IS_CASCADING) #define is_smargo_reader(__X) (__X->crdr && strcmp(__X->crdr->desc, "smargo") == 0) // ECM rc codes: /////// all found #define E_FOUND 0 #define E_CACHE1 1 #define E_CACHE2 2 #define E_CACHEEX 3 /////// all notfound, some error or problem #define E_NOTFOUND 4 // for selection of found, use < E_NOTFOUND #define E_TIMEOUT 5 #define E_SLEEPING 6 #define E_FAKE 7 #define E_INVALID 8 #define E_CORRUPT 9 #define E_NOCARD 10 #define E_EXPDATE 11 #define E_DISABLED 12 #define E_STOPPED 13 // for selection of error, use <= E_STOPPED and exclude selection of found #define E_ALREADY_SENT 101 #define E_WAITING 102 #define E_99 99 // this code is undocumented #define E_UNHANDLED 100 // for selection of unhandled, use >= E_UNHANDLED #define CS_MAX_MOD 20 #define MOD_CONN_TCP 1 #define MOD_CONN_UDP 2 #define MOD_CONN_NET 3 #define MOD_CONN_SERIAL 4 #define MOD_NO_CONN 8 #define EMM_UNIQUE 1 #define EMM_SHARED 2 #define EMM_GLOBAL 4 #define EMM_UNKNOWN 8 // Listener Types #define LIS_CAMD33TCP 1 #define LIS_CAMD35UDP 2 #define LIS_CAMD35TCP 4 #define LIS_NEWCAMD 8 #define LIS_CCCAM 16 #define LIS_GBOX 32 #define LIS_RADEGAST 64 #define LIS_DVBAPI 128 #define LIS_CONSTCW 256 #define LIS_SERIAL 1024 #define LIS_CSPUDP 2048 #define LIS_SCAM 4096 // EMM types: #define UNKNOWN 0 #define UNIQUE 1 #define SHARED 2 #define GLOBAL 3 #define NCD_AUTO 0 #define NCD_524 1 #define NCD_525 2 // moved from reader-common.h #define UNKNOWN 0 #define CARD_NEED_INIT 1 #define CARD_INSERTED 2 #define CARD_FAILURE 3 #define NO_CARD 4 #define READER_DEVICE_ERROR 5 // moved from stats #define DEFAULT_REOPEN_SECONDS 30 #define DEFAULT_MIN_ECM_COUNT 5 #define DEFAULT_MAX_ECM_COUNT 500 #define DEFAULT_NBEST 1 #define DEFAULT_NFB 1 #define DEFAULT_RETRYLIMIT 0 #define DEFAULT_LB_MODE 0 #define DEFAULT_LB_STAT_CLEANUP 336 #define DEFAULT_UPDATEINTERVAL 240 #define DEFAULT_LB_AUTO_BETATUNNEL 1 #define DEFAULT_LB_AUTO_BETATUNNEL_MODE 0 #define DEFAULT_LB_AUTO_BETATUNNEL_PREFER_BETA 50 #define DEFAULT_MAX_CACHE_TIME 15 #define DEFAULT_MAX_HITCACHE_TIME 15 #define DEFAULT_LB_AUTO_TIMEOUT 0 #define DEFAULT_LB_AUTO_TIMEOUT_P 30 #define DEFAULT_LB_AUTO_TIMEOUT_T 300 enum {E1_GLOBAL = 0, E1_USER, E1_READER, E1_SERVER, E1_LSERVER}; // LB blocking events: enum {E2_GLOBAL = 0, E2_GROUP, E2_CAID, E2_IDENT, E2_CLASS, E2_CHID, E2_QUEUE, E2_OFFLINE, E2_SID, E2_CCCAM_NOCARD, // From here only LB nonblocking events: E2_CCCAM_NOK1, E2_CCCAM_NOK2, E2_CCCAM_LOOP, E2_WRONG_CHKSUM, E2_RATELIMIT }; #define LB_NONBLOCK_E2_FIRST E2_CCCAM_NOK1 #define CTA_RES_LEN 512 #define MAX_ATR_LEN 33 // max. ATR length #define MAX_HIST 15 // max. number of historical characters #define MAX_SIDBITS 64 // max services #define SIDTABBITS uint64_t // 64bit type for services, if a system does not support this type, // please use a define and define it as uint32_t / MAX_SIDBITS 32 #define BAN_UNKNOWN 1 // Failban mask for anonymous/ unknown contact #define BAN_DISABLED 2 // Failban mask for Disabled user #define BAN_SLEEPING 4 // Failban mask for sleeping user #define BAN_DUPLICATE 8 // Failban mask for duplicate user #define MAX_HTTP_DYNDNS 3 // maximum allowed Dyndns addresses for webif access #define CHECK_WAKEUP 1 #define CHECK_ANTICASCADER 2 #define CHECK_ECMCACHE 3 #define AVAIL_CHECK_CONNECTED 0 #define AVAIL_CHECK_LOADBALANCE 1 #define ECM_FMT_LEN 109 // 64 #define CXM_FMT_LEN 209 // 160 #define LB_MAX_STAT_TIME 10 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) #define OSCAM_SIGNAL_WAKEUP SIGCONT #else #define OSCAM_SIGNAL_WAKEUP SIGRTMAX-2 #endif #define READER_ACTIVE 0x01 #define READER_FALLBACK 0x02 #define READER_LOCAL 0x04 #define READER_CACHEEX 0x08 #define REQUEST_SENT 0x10 #define REQUEST_ANSWERED 0x20 #define CW_MODE_ONE_CW 0 #define CW_MODE_MULTIPLE_CW 1 #define CW_TYPE_VIDEO 0 #define CW_TYPE_AUDIO 1 #define CW_TYPE_DATA 2 #define CW_ALGO_CSA 0 #define CW_ALGO_DES 1 #define CW_ALGO_AES128 2 #define CW_ALGO_CSA_ALT 3 #define CW_ALGO_MODE_ECB 0 #define CW_ALGO_MODE_CBC 1 #define SIZE_SHORTDAY 8 #define MAXALLOWEDTF 1001 // 10 allowed time frame slots for everyday + all [(3 + 1 + 10*(12) + 1)*8] extern const char *shortDay[SIZE_SHORTDAY]; extern const char *weekdstr; /* =========================== * Default Values * =========================== */ #define DEFAULT_INACTIVITYTIMEOUT 0 #define DEFAULT_TCP_RECONNECT_TIMEOUT 30 #define DEFAULT_NCD_KEEPALIVE 0 #define DEFAULT_CC_MAXHOPS 10 #define DEFAULT_CC_RESHARE -1 // Use global cfg #define DEFAULT_CC_IGNRSHR -1 // Use global cfg #define DEFAULT_CC_STEALTH -1 // Use global cfg #define DEFAULT_CC_KEEPALIVE 0 #define DEFAULT_CC_RECONNECT 12000 #define DEFAULT_CC_RECV_TIMEOUT 2000 #define DEFAULT_AC_USERS -1 // Use global cfg #define DEFAULT_AC_PENALTY -1 // Use global cfg // Return MPEG section length #define SCT_LEN(sct) (3+((sct[1]&0x0f)<<8)+sct[2]) // Used by readers #define MAX_LEN 256 #define NO_CAID_VALUE 0xfffe #define NO_PROVID_VALUE 0xfffffe #define NO_SRVID_VALUE 0xfffe // If NULL return empty string #define ESTR(x) ((x) ? (x) : "") #ifndef MAX #define MAX(a,b) ((a) > (b) ? (a) : (b)) #endif #ifndef MIN #define MIN(a,b) ((a) < (b) ? (a) : (b)) #endif /* See: http://stackoverflow.com/questions/10269685/kernels-container-of-any-way-to-make-it-iso-conforming http://www.kroah.com/log/linux/container_of.html */ #define container_of(ptr, type, member) \ ((type *) ((char *) (ptr) - offsetof(type, member) + \ (&((type *) 0)->member == (ptr)) * 0)) /* =========================== * global structures * =========================== */ struct timeb { time_t time; int64_t millitm; }; typedef struct cs_mutexlock { int32_t timeout; pthread_mutex_t lock; pthread_cond_t writecond, readcond; const char *name; int8_t flag; int16_t writelock, readlock; } CS_MUTEX_LOCK; #include "oscam-llist.h" typedef struct s_caidvaluetab_data { uint16_t caid; uint16_t value; } CAIDVALUETAB_DATA; typedef struct s_caidvaluetab { int32_t cvnum; CAIDVALUETAB_DATA *cvdata; } CAIDVALUETAB; typedef struct s_classtab { uint8_t an; uint8_t bn; uint8_t *aclass; uint8_t *bclass; } CLASSTAB; typedef struct s_caidtab_data { uint16_t caid; uint16_t mask; uint16_t cmap; } CAIDTAB_DATA; typedef struct s_caidtab { int32_t ctnum; CAIDTAB_DATA *ctdata; } CAIDTAB; typedef struct s_tuntab_data { uint16_t bt_caidfrom; uint16_t bt_caidto; uint16_t bt_srvid; } TUNTAB_DATA; typedef struct s_tuntab { int32_t ttnum; TUNTAB_DATA *ttdata; } TUNTAB; typedef struct s_sidtab { char label[64]; #ifdef CS_CACHEEX_AIO uint8_t disablecrccws_only_for_exception; uint8_t no_wait_time; uint8_t lg_only_exception; #endif uint16_t num_caid; uint16_t num_provid; uint16_t num_srvid; uint16_t *caid; uint32_t *provid; uint16_t *srvid; struct s_sidtab *next; } SIDTAB; typedef struct s_filter { uint16_t caid; uint8_t nprids; uint32_t prids[CS_MAXPROV]; } FILTER; typedef struct s_ftab { int32_t nfilts; FILTER *filts; } FTAB; typedef struct s_ncd_ftab { int32_t nfilts; FILTER filts[16]; } NCD_FTAB; struct ncd_port { bool ncd_key_is_set; uint8_t ncd_key[14]; NCD_FTAB ncd_ftab; }; typedef struct s_port { int32_t fd; int32_t s_port; struct ncd_port *ncd; // newcamd specific settings } PORT; typedef struct s_ptab { int32_t nports; PORT ports[CS_MAXPORTS]; } PTAB; typedef struct aes_entry { uint16_t keyid; uint16_t caid; uint32_t ident; uint8_t plainkey[16]; AES_KEY key; struct aes_entry *next; } AES_ENTRY; struct aes_keys { AES_KEY aeskey_encrypt; // encryption key needed by monitor and used by camd33, camd35 AES_KEY aeskey_decrypt; // decryption key needed by monitor and used by camd33, camd35 }; struct s_ecm { uint8_t ecmd5[CS_ECMSTORESIZE]; uint8_t cw[16]; uint16_t caid; uint64_t grp; struct s_reader *reader; int32_t rc; time_t time; }; struct s_emmstat { uint8_t emmd5[CS_EMMSTORESIZE]; uint8_t type; int32_t count; struct timeb firstwritten; struct timeb lastwritten; }; struct s_emmcache { uint8_t emmd5[CS_EMMSTORESIZE]; uint8_t type; uint16_t len; uint8_t emm[MAX_EMM_SIZE]; struct timeb firstseen; struct timeb lastseen; }; struct s_csystem_emm_filter { uint8_t type; uint8_t enabled; uint8_t filter[16]; uint8_t mask[16]; }; typedef struct v_ban // Failban listmember { int32_t v_count; IN_ADDR_T v_ip; int32_t v_port; struct timeb v_time; bool acosc_entry; int32_t acosc_penalty_dur; char *info; } V_BAN; typedef struct s_cacheex_stat_entry // Cacheex stats listmember { int32_t cache_count; time_t cache_last; uint16_t cache_caid; uint16_t cache_srvid; uint32_t cache_prid; int8_t cache_direction; // 0 = push / 1 = got #ifdef CS_CACHEEX_AIO int32_t cache_count_lg; #endif } S_CACHEEX_STAT_ENTRY; typedef struct s_entitlement // contains entitlement Info { uint64_t id; // the element ID uint32_t type; // enumerator for tier,chid whatever // 0="", 1="Package", 2="PPV-Event", 3="chid", 4="tier", 5 = "class", 6 = "PBM". 7 = "seca-admin" uint16_t caid; // the caid of element uint32_t provid; // the provid of element uint32_t class; // the class needed for some systems time_t start; // startdate time_t end; // enddate #ifdef WITH_EMU bool isKey; bool isData; char name[8]; uint8_t *key; uint32_t keyLength; #endif } S_ENTITLEMENT; struct s_client; struct ecm_request_t; struct emm_packet_t; struct cmd_packet_t; struct s_ecm_answer; struct demux_s; #define DEFAULT_MODULE_BUFsize 1024 struct s_module { const char *desc; int8_t type; int8_t large_ecm_support; int16_t listenertype; //int32_t s_port; IN_ADDR_T s_ip; uint16_t bufsize; void *(*s_handler)(struct s_client *, uint8_t *, int32_t); void (*s_init)(struct s_client *); int32_t (*recv)(struct s_client *, uint8_t *, int32_t); void (*send_dcw)(struct s_client *, struct ecm_request_t *); void (*cleanup)(struct s_client *); int32_t (*c_recv_chk)(struct s_client *, uint8_t *, int32_t *, uint8_t *, int32_t); int32_t (*c_init)(struct s_client *); int32_t (*c_send_ecm)(struct s_client *, struct ecm_request_t *); int32_t (*c_send_emm)(struct emm_packet_t *); int32_t (*c_available)(struct s_reader *, int32_t, struct ecm_request_t *); // Schlocke: available check for load-balancing, // params: // rdr (reader to check) // int32_t checktype (0=return connected, 1=return loadbalance-avail) return int void (*c_idle)(void); // Schlocke: called when reader is idle void (*s_idle)(struct s_client *); void (*s_peer_idle)(struct s_client *); void (*c_card_info)(void); // Schlocke: request card infos int32_t (*c_capmt)(struct s_client *, struct demux_s *); #ifdef CS_CACHEEX int32_t (*c_cache_push)(struct s_client *, struct ecm_request_t *); // Cache push int32_t (*c_cache_push_chk)(struct s_client *, struct ecm_request_t *); // Cache push Node Check, 0=no push #endif int32_t c_port; PTAB ptab; int32_t num; }; struct s_ATR; struct s_cardreader_settings { uint32_t ETU; uint32_t EGT; uint8_t P; uint32_t I; uint32_t F; uint32_t Fi; uint8_t Di; uint8_t Ni; uint32_t WWT; uint32_t BGT; uint8_t D; }; struct s_cardreader { const char *desc; int32_t (*reader_init)(struct s_reader *); int32_t (*get_status)(struct s_reader *, int *); int32_t (*activate)(struct s_reader *, struct s_ATR *); int32_t (*transmit)(struct s_reader *, uint8_t *sent, uint32_t size, uint32_t expectedlen, uint32_t delay, uint32_t timeout); int32_t (*receive)(struct s_reader *, uint8_t *data, uint32_t size, uint32_t delay, uint32_t timeout); int32_t (*lock_init)(struct s_reader *); void (*lock)(struct s_reader *); void (*unlock)(struct s_reader *); int32_t (*close)(struct s_reader *); int32_t (*set_parity)(struct s_reader *, uint8_t parity); int32_t (*write_settings)(struct s_reader *, struct s_cardreader_settings *s); int32_t (*set_protocol)(struct s_reader *, uint8_t *params, uint32_t *length, uint32_t len_request); int32_t (*set_baudrate)(struct s_reader *, uint32_t baud); // set only for readers which need baudrate setting and timings need to be guarded by OSCam int32_t (*card_write)(struct s_reader *pcsc_reader, const uint8_t *buf, uint8_t *cta_res, uint16_t *cta_lr, int32_t l); void (*display_msg)(struct s_reader *, char *msg); int32_t (*do_reset)(struct s_reader *, struct s_ATR *, int32_t (*rdr_activate_card)(struct s_reader *, struct s_ATR *, uint16_t deprecated), int32_t (*rdr_get_cardsystem)(struct s_reader *, struct s_ATR *)); bool (*set_DTS_RTS)(struct s_reader *, int32_t *dtr, int32_t *rts); int32_t typ; // fixme: workaround, remove when all old code is converted int8_t max_clock_speed; // 1 for reader->typ > R_MOUSE int8_t need_inverse; // 0 = reader does inversing; 1 = inversing done by oscam //io_serial config int8_t flush; int8_t read_written; // 1 = written bytes has to read from device bool skip_extra_atr_parsing; bool skip_t1_command_retries; bool skip_setting_ifsc; }; struct s_cardsystem { const char *desc; const uint16_t *caids; int32_t (*card_init)(struct s_reader *reader, struct s_ATR *); void (*card_done)(struct s_reader *reader); int32_t (*card_info)(struct s_reader *); void (*poll_status)(struct s_reader *); int32_t (*do_ecm)(struct s_reader *, const struct ecm_request_t *, struct s_ecm_answer *); int32_t (*do_emm_reassembly)(struct s_reader *, struct s_client *, struct emm_packet_t *); // Returns 1/true if the EMM is ready to be written in the card int32_t (*do_emm)(struct s_reader *, struct emm_packet_t *); int32_t (*do_rawcmd)(struct s_reader *, struct cmd_packet_t *); void (*post_process)(struct s_reader *); int32_t (*get_emm_type)(struct emm_packet_t *, struct s_reader *); int32_t (*get_emm_filter)(struct s_reader *, struct s_csystem_emm_filter **, uint32_t *); int32_t (*get_emm_filter_adv)(struct s_reader *, struct s_csystem_emm_filter **, uint32_t *, uint16_t, uint32_t, uint16_t, uint16_t, uint16_t, uint32_t); int32_t (*get_tunemm_filter)(struct s_reader *, struct s_csystem_emm_filter **, uint32_t *); }; typedef struct cw_extendted_t { #ifdef WITH_EXTENDED_CW uint8_t mode; uint8_t audio[4][16]; // 4 x odd/even pairs of 8 byte CWs uint8_t data[16]; // odd/even pair of 8 byte CW or 16 byte IV uint8_t session_word[32]; // odd/even pair of 16 byte CW uint8_t algo; // CSA, DES or AES128 uint8_t algo_mode; // ECB or CBC #else uint8_t disabled; #endif } EXTENDED_CW; typedef struct s_cw_vote { uint8_t cw[16]; uint8_t votes; uint8_t local_votes; struct s_reader *voters[MAX_VOTE_CANDIDATES]; } s_cw_vote; // CW Vote settings typedef struct s_cw_vote_caid_data { uint16_t caid; } CW_VOTE_CAID_DATA; typedef struct s_cw_vote_caid_tab { int32_t cvcnum; CW_VOTE_CAID_DATA *cvcdata; } CW_VOTE_CAID_TAB; typedef struct ecm_request_t { uint8_t ecm[MAX_ECM_SIZE]; uint8_t cw[16]; EXTENDED_CW cw_ex; uint8_t ecmd5[CS_ECMSTORESIZE]; int16_t ecmlen; uint16_t caid; uint16_t ocaid; // original caid, used for betatunneling uint16_t srvid; uint16_t onid; uint16_t tsid; uint16_t pmtpid; uint32_t ens; // enigma namespace uint32_t vpid; // videopid uint16_t chid; uint16_t pid; uint16_t idx; uint32_t prid; struct s_reader *selected_reader; struct s_ecm_answer *matching_rdr; // list of matching readers const struct s_reader *fallback; // fallback is the first fallback reader in the list matching_rdr struct s_client *client; // contains pointer to 'c' client while running in 'r' client uint64_t grp; int32_t msgid; // client pending table index uint8_t stage; // processing stage in server module int8_t rc; uint8_t rcEx; struct timeb tps; // incoming time stamp int8_t btun; // mark er as betatunneled uint16_t reader_avail; // count of available readers for ecm uint16_t readers; // count of available used readers for ecm uint16_t reader_requested; // count of real requested readers uint16_t localreader_count; // count of selected local readers uint16_t cacheex_reader_count; // count of selected cacheex mode-1 readers uint16_t fallback_reader_count; // count of selected fb readers uint16_t reader_count; // count of selected not fb readers int8_t preferlocalcards; int8_t checked; // for doublecheck uint8_t cw_checked[16]; // for doublecheck int8_t readers_timeout_check; // set to 1 after ctimeout occurs and readers not answered are checked uint32_t client_timeout; // clienttimeout per CAID struct s_reader *origin_reader; #if defined MODULE_CCCAM void *origin_card; // CCcam preferred card! #endif #if defined MODULE_GBOX uint32_t gbox_crc; // rcrc for gbox, used to identify ECM task in peer responses uint16_t gbox_cw_src_peer; uint16_t gbox_ecm_src_peer; uint8_t gbox_ecm_dist; uint8_t gbox_ecm_status; LLIST *gbox_cards_pending; // type gbox_card_pending #endif void *src_data; uint32_t csp_hash; // csp has its own hash struct s_client *cacheex_src; // Cacheex origin #ifdef CS_CACHEEX int8_t cacheex_pushed; // to avoid duplicate pushs uint8_t csp_answered; // =1 if er get answer by csp LLIST *csp_lastnodes; // last 10 Cacheex nodes atm cc-proto-only uint32_t cacheex_wait_time; // cacheex wait time in ms uint8_t cacheex_wait_time_expired; // =1 if cacheex wait_time expires uint16_t cacheex_mode1_delay; // cacheex mode 1 delay uint8_t cacheex_hitcache; // =1 if wait_time due hitcache void *cw_cache; // pointer to cw stored in cache #endif #ifdef CS_CACHEEX_AIO int32_t ecm_time; // ecm-time in ms uint8_t localgenerated; // flag for local generated CW #endif uint32_t cw_count; uint8_t from_csp; // =1 if er from csp cache uint8_t from_cacheex; // =1 if er from cacheex client pushing cache uint8_t from_cacheex1_client; // =1 if er from cacheex-1 client char msglog[MSGLOGSIZE]; uint8_t cwc_cycletime; uint8_t cwc_next_cw_cycle; #ifdef CW_CYCLE_CHECK char cwc_msg_log[MSGLOGSIZE]; #endif #ifdef WITH_STAPI5 char dev_name[20]; #endif struct ecm_request_t *parent; struct ecm_request_t *next; #ifdef HAVE_DVBAPI uint8_t adapter_index; #endif uint32_t vote_pool_session; // sesja dla vote_pool - zapobiega wielokrotnemu czyszczeniu struct s_cw_vote vote_pool[MAX_VOTE_CANDIDATES]; } ECM_REQUEST; struct s_ecm_answer { uint8_t status; struct s_reader *reader; ECM_REQUEST *er; int8_t rc; uint8_t rcEx; uint8_t cw[16]; EXTENDED_CW cw_ex; char msglog[MSGLOGSIZE]; struct timeb time_request_sent; // using for evaluate ecm_time int32_t ecm_time; uint16_t tier; // only filled by local videoguard reader atm #ifdef WITH_LB int32_t value; int32_t time; #endif struct s_ecm_answer *next; CS_MUTEX_LOCK ecmanswer_lock; struct s_ecm_answer *pending; struct s_ecm_answer *pending_next; bool is_pending; }; struct s_acasc_shm { uint16_t ac_count : 15; uint16_t ac_deny : 1; }; struct s_acasc { uint16_t stat[10]; uint8_t idx; // current active index in stat[] }; struct s_cwresponse { int32_t duration; time_t timestamp; int32_t rc; }; struct s_cascadeuser { uint16_t caid; uint32_t prid; uint16_t srvid; time_t time; int8_t cwrate; }; typedef struct sidtabs { SIDTABBITS ok; // positive services SIDTABBITS no; // negative services } SIDTABS; struct s_zap_list { uint16_t caid; uint32_t provid; uint16_t chid; uint16_t sid; int8_t request_stage; time_t lasttime; }; // EMM reassemply struct emm_rass { int16_t emmlen; int32_t provid; uint8_t emm[MAX_EMM_SIZE]; }; struct s_client { uint32_t tid; int8_t init_done; pthread_mutex_t thread_lock; int8_t thread_active; int8_t kill; int8_t kill_started; LLIST *joblist; IN_ADDR_T ip; in_port_t port; time_t login; // connection time_t logout; // disconnection time_t last; time_t lastswitch; time_t lastemm; time_t lastecm; time_t expirationdate; uint32_t allowedtimeframe[SIZE_SHORTDAY][24][2]; // day[0-sun to 6-sat, 7-ALL],hours,minutes use as binary flags to reduce mem usage uint8_t allowedtimeframe_set; // flag for internal use to mention if allowed time frame is used int8_t c35_suppresscmd08; uint8_t c35_sleepsend; int8_t ncd_keepalive; int8_t disabled; uint64_t grp; int8_t crypted; int8_t dup; LLIST *aureader_list; int8_t autoau; LLIST *ra_buf; // EMM reassembly buffer for viaccess struct emm_rass *cw_rass; // EMM reassembly buffer for cryptoworks int8_t monlvl; CAIDTAB ctab; TUNTAB ttab; SIDTABS sidtabs; SIDTABS lb_sidtabs; int8_t typ; // first s_client is type s=starting (master) thread; type r = physical reader, type p = proxy reader both always have 1 s_reader struct allocated; type c = client (user logging in into oscam) type m = monitor type h = http server a = anticascader uint8_t module_idx; uint16_t last_srvid; uint32_t last_provid; uint16_t last_caid; struct s_provid *last_providptr; struct s_srvid *last_srvidptr; uint32_t last_srvidptr_search_provid; int32_t tosleep; struct s_auth *account; int32_t udp_fd; struct SOCKADDR udp_sa; socklen_t udp_sa_len; int8_t tcp_nodelay; int8_t log; int32_t logcounter; int32_t cwfound; // count found ECMs per client int32_t cwcache; // count ECMs from cache1/2 per client int32_t cwnot; // count not found ECMs per client int32_t cwtun; // count betatunneled ECMs per client int32_t cwignored; // count ignored ECMs per client int32_t cwtout; // count timeouted ECMs per client int32_t cwlastresptime; // last Responsetime (ms) #ifdef CW_CYCLE_CHECK int32_t cwcycledchecked; // count checked cwcycles per client int32_t cwcycledok; // count pos checked cwcycles per client int32_t cwcyclednok; // count neg checked cwcycles per client int32_t cwcycledign; // count ign cwcycles per client #endif int32_t emmok; // count EMM ok int32_t emmnok; // count EMM nok int8_t pending; // number of ECMs pending #ifdef CS_CACHEEX int32_t cwcacheexpush; // count pushed ecms/cws int32_t cwcacheexgot; // count got ecms/cws int32_t cwcacheexhit; // count hit ecms/cws LLIST *ll_cacheex_stats; // list for Cacheex statistics int8_t cacheex_maxhop; int32_t cwcacheexerr; // cw=00 or chksum wrong int32_t cwcacheexerrcw; // same Hex, different CW int16_t cwcacheexping; // peer ping in ms, only used by csp int32_t cwc_info; // count of in/out comming cacheex ecms with CWCinfo uint8_t cxnodeid_last[9]; // save previous nodeid uint8_t cxnodeid_changer_detected; // save node-changer detection status #ifdef CS_CACHEEX_AIO int32_t cwcacheexgotlg; // count got localgenerated-flagged CWs int32_t cwcacheexpushlg; // count pushed localgenerated-flagged CWs #endif uint8_t cacheex_needfilter; // flag for cachex mode 3 used with camd35 #ifdef CS_CACHEEX_AIO uint8_t cacheex_aio_checked; // flag for cacheex aio detection done #endif #endif #ifdef CS_ANTICASC struct s_zap_list client_zap_list[15]; // 15 last zappings from client used for ACoSC #endif #ifdef WEBIF struct s_cwresponse cwlastresptimes[CS_ECM_RINGBUFFER_MAX]; // ringbuffer for last 20 times int32_t cwlastresptimes_last; // ringbuffer pointer int8_t wihidden; // hidden in webinterface status char lastreader[64]; // last cw got from this reader #endif uint8_t ucrc[4]; // needed by monitor and used by camd35 uint32_t pcrc; // password crc struct aes_keys *aes_keys; // used by camd33 and camd35 uint16_t ncd_msgid; uint16_t ncd_client_id; uint8_t ncd_skey[16]; // Also used for camd35 Cacheex to store remote node id #ifdef MODULE_CCCAM void *cc; #endif #ifdef CS_CACHEEX_AIO #if defined(MODULE_CAMD35) || defined(MODULE_CAMD35_TCP) uint8_t c35_extmode; #endif #endif #ifdef MODULE_GBOX void *gbox; uint16_t gbox_peer_id; #endif #ifdef MODULE_GHTTP void *ghttp; #endif int32_t port_idx; // index in server ptab int32_t ncd_server; // newcamd server #ifdef CS_ANTICASC int32_t ac_fakedelay; // When this is -1, the global ac_fakedelay is used uint16_t ac_limit; int8_t ac_penalty; struct s_acasc_shm acasc; #endif FTAB fchid; FTAB ftab; // user [caid] and ident filter CLASSTAB cltab; int32_t pfd; // Primary FD, must be closed on exit struct s_reader *reader; // points to s_reader when cl->typ='r' ECM_REQUEST *ecmtask; pthread_t thread; #ifdef MODULE_SERIAL struct s_serial_client *serialdata; #endif // reader common int32_t last_idx; uint16_t idx; int8_t ncd_proto; uint8_t ncd_header[12]; // camd35 uint8_t upwd[64]; int8_t is_udp; int8_t stopped; uint16_t lastcaid; uint16_t lastsrvid; int32_t lastpid; int8_t disable_counter; uint8_t lastserial[8]; // Failban value set bitwise - compared with BAN_ int32_t failban; LLIST *cascadeusers; // s_cascadeuser int32_t n_request[2]; // count for number of request per minute by client void *work_mbuf; // Points to local data allocated in work_thread when the thread is running void *work_job_data; // Points to current job_data when work_thread is running #ifdef MODULE_PANDORA int32_t pand_autodelay; uint8_t pand_send_ecm; uint8_t pand_ignore_ecm; uint8_t pand_md5_key[16]; #endif #ifdef MODULE_SCAM void *scam; #endif void *module_data; // private module data struct s_client *next; // make client a linked list struct s_client *nexthashed; int8_t start_hidecards; }; typedef struct s_ecm_whitelist_data { uint16_t len; uint16_t caid; uint32_t ident; } ECM_WHITELIST_DATA; typedef struct s_ecm_whitelist { int32_t ewnum; ECM_WHITELIST_DATA *ewdata; } ECM_WHITELIST; typedef struct s_ecm_hdr_whitelist_data { uint16_t len; uint16_t caid; uint32_t provid; uint8_t header[20]; } ECM_HDR_WHITELIST_DATA; typedef struct s_ecm_hdr_whitelist { int32_t ehnum; ECM_HDR_WHITELIST_DATA *ehdata; } ECM_HDR_WHITELIST; // ratelimit struct ecmrl { struct timeb last; uint8_t kindecm; bool once; uint8_t ecmd5[CS_ECMSTORESIZE]; uint16_t caid; uint32_t provid; uint16_t srvid; uint16_t chid; int32_t ratelimitecm; int32_t ratelimittime; int32_t srvidholdtime; }; #define MAXECMRATELIMIT 20 // maxparallel service tracking struct s_parallel_slot { uint16_t srvid; // service ID struct timeb last_ecm; // time of last ECM for this service int32_t ecm_interval; // measured interval between ECMs in ms struct s_client *client; // client using this slot }; // maxparallel blocked client tracking struct s_blocked_client { struct s_client *client; // client pointer uint16_t srvid; // blocked service ID }; #ifdef MODULE_SERIAL struct ecmtw { uint16_t caid; uint32_t provid; uint16_t srvid; uint16_t deg; uint16_t freq; }; #endif typedef struct ce_csp_tab_data { int32_t caid; int32_t cmask; int32_t prid; int32_t srvid; int16_t awtime; int16_t dwtime; } CECSPVALUETAB_DATA; typedef struct ce_csp_tab { int32_t cevnum; CECSPVALUETAB_DATA *cevdata; } CECSPVALUETAB; typedef struct cacheex_check_cw_tab_data { int32_t caid; int32_t cmask; int32_t prid; int32_t srvid; int8_t mode; uint32_t counter; } CWCHECKTAB_DATA; typedef struct cacheex_check_cw_tab { int32_t cwchecknum; CWCHECKTAB_DATA *cwcheckdata; } CWCHECKTAB; typedef struct cacheex_check_cw { int8_t mode; uint32_t counter; } CWCHECK; typedef struct ce_csp_t { int8_t mode; int8_t maxhop; #ifdef CS_CACHEEX_AIO int8_t maxhop_lg; #endif CECSPVALUETAB filter_caidtab; CAIDVALUETAB cacheex_nopushafter_tab; uint8_t allow_request; uint8_t allow_reforward; uint8_t drop_csp; uint8_t allow_filter; #ifdef CS_CACHEEX_AIO uint8_t allow_maxhop; #endif uint8_t block_fakecws; #ifdef CS_CACHEEX_AIO uint8_t cw_check_for_push; uint8_t localgenerated_only; CAIDTAB localgenerated_only_caidtab; FTAB lg_only_tab; uint8_t localgenerated_only_in; CAIDTAB localgenerated_only_in_caidtab; FTAB lg_only_in_tab; uint8_t lg_only_in_aio_only; uint8_t lg_only_remote_settings; int32_t feature_bitfield; char aio_version[CS_AIO_VERSION_LEN]; #endif } CECSP; struct s_emmlen_range { int16_t min; int16_t max; }; typedef struct emm_packet_t { uint8_t emm[MAX_EMM_SIZE]; int16_t emmlen; uint8_t caid[2]; uint8_t provid[4]; uint8_t hexserial[8]; // contains hexserial or SA of EMM uint8_t type; uint8_t skip_filter_check; struct s_client *client; } EMM_PACKET; typedef struct cmd_packet_t { uint8_t cmd[MAX_CMD_SIZE]; int16_t cmdlen; struct s_client *client; } CMD_PACKET; struct s_reader // contains device info, reader info and card info { uint8_t keepalive; uint8_t changes_since_shareupdate; int32_t resetcycle; // ECM until reset int32_t resetcounter; // actual count uint32_t auprovid; // AU only for this provid int8_t audisabled; // exclude reader from auto AU struct timeb emm_last; // time of last successfully written emm struct s_client *client; // pointer to 'r'client this reader is running in LLIST *ll_entitlements; // entitlements int8_t enable; int8_t active; int8_t dropbadcws; // Schlocke: 1=drops cw if checksum is wrong. 0=fix checksum (default) int8_t disablecrccws; // 1=disable cw checksum test. 0=enable checksum check uint64_t grp; int8_t fallback; FTAB fallback_percaid; FTAB localcards; FTAB disablecrccws_only_for; // ignore checksum for selected caid provid #ifdef READER_CRYPTOWORKS int8_t needsglobalfirst; // 0:Write one Global EMM for SHARED EMM disabled 1:Write one Global EMM for SHARED EMM enabled #endif #if defined(READER_NAGRA) uint8_t cak63nuid[4]; uint8_t cak63nuid_length; uint8_t cak63cwekey[16]; uint8_t cak63cwekey_length; #endif #ifdef READER_NAGRA_MERLIN uint8_t mod1[112]; uint8_t mod1_length; uint8_t cmd0eprov[2]; uint8_t cmd0eprov_length; uint8_t mod2[112]; uint8_t mod2_length; uint8_t tmprsa[112]; uint8_t data50[80]; uint8_t data50_length; uint8_t mod50[80]; uint8_t mod50_length; uint8_t key3588[136]; uint8_t key3588_length; uint8_t key60[96]; uint8_t exp60[96]; uint8_t key68[104]; uint8_t exp68[104]; uint8_t key3des[16]; uint8_t klucz68[24]; uint8_t pairtype; uint8_t hasunique; uint8_t key3460[96]; uint8_t key3460_length; uint8_t key3310[16]; uint8_t key3310_length; uint8_t cwekey[17][16]; uint8_t cwekey_length[17]; uint8_t idird[4]; uint8_t idird_length; uint8_t kdt05_00[216]; uint8_t kdt05_10[208]; uint8_t edata[255]; uint8_t dt5num; uint8_t out[255]; uint8_t ideakey1[16]; uint8_t block3[8]; uint8_t v[8]; uint8_t iout[8]; uint32_t dword_83DBC; uint8_t data2[4]; uint8_t ecmheader[4]; uint8_t timestmp1[4]; uint8_t timestmp2[4]; uint8_t cak7expo[0x11]; uint8_t data[0x80]; uint8_t step1[0x60]; uint8_t step2[0x68]; uint8_t step3[0x6c]; uint8_t encrypted[0x68]; uint8_t result[104]; uint8_t stillencrypted[0x50]; uint8_t resultrsa[0x50]; uint32_t cak7_seq; uint32_t needrestart; uint8_t otpcsc[2]; uint8_t otpcsc_length; uint8_t otacsc[2]; uint8_t otacsc_length; uint8_t forcepair[1]; uint8_t forcepair_length; uint8_t cak7_camstate; uint8_t cak7_aes_key[32]; uint8_t cak7_aes_iv[16]; int8_t forcecwswap; int8_t evensa; int8_t forceemmg; int8_t cwpkota; int8_t headermode; struct timeb last_refresh; #endif #if defined(READER_DGCRYPT) || defined(READER_NAGRA_MERLIN) uint8_t cardid[8]; #endif #ifdef CS_CACHEEX CECSP cacheex; // CacheEx Settings uint8_t cxnodeid_last[9]; // save previous nodeid uint8_t cxnodeid_changer_detected; // save node-changer detection status #endif int32_t typ; char label[64]; #ifdef WEBIF char *description; #endif char device[128]; #ifdef WITH_CARDREADER uint16_t slot; // in case of multiple slots like sc8in1; first slot = 1 int32_t handle; // device handle int64_t handle_nr; // device handle_nr for mutiple readers same driver int32_t fdmc; // device handle for multicam int32_t detect; int32_t mhz; // actual clock rate of reader in 10khz steps int32_t cardmhz; // standard clock speed your card should have in 10khz steps; normally 357 but for Irdeto cards 600 int32_t divider; // PLL divider for internal readers #endif int32_t r_port; char r_usr[64]; char r_pwd[64]; // Max length 63 + null terminator int32_t l_port; CAIDTAB ctab; uint32_t boxid; #ifdef READER_TONGFANG uint32_t tongfang_version; uint8_t tongfang3_commkey[8]; uint32_t tongfang3_calibsn; uint32_t tongfang_boxid; uint8_t tongfang3_deskey[8]; uint8_t tongfang3_deskey_length; uint8_t stbid[8]; uint8_t stbid_length; #endif #ifdef READER_NAGRA_MERLIN int8_t cak7_mode; uint8_t cak7type; uint8_t cwpkcaid[2]; uint8_t cwpkcaid_length; uint8_t nuid[4]; uint8_t nuid_length; #endif #ifdef READER_NAGRA int8_t nagra_read; // read nagra ncmed records: 0 Disabled (default), 1 read all records, 2 read valid records only int8_t detect_seca_nagra_tunneled_card; #endif #ifdef READER_IRDETO int8_t force_irdeto; #endif #ifdef WITH_CARDREADER uint8_t boxkey[16]; // n3 boxkey 8 bytes, seca sessionkey 16 bytes, viaccess camid 4 bytes uint8_t boxkey_length; uint8_t rsa_mod[120]; // rsa modulus for nagra cards. uint8_t rsa_mod_length; uint8_t cwpk_mod[16]; // cwpk modulus for conax cards. uint8_t cwpk_mod_length; uint8_t des_key[128]; // 3des key for Viaccess 16 bytes, des key for Dre 128 bytes uint8_t des_key_length; #endif uint8_t card_atr[64]; // ATR readed from card int8_t card_atr_length; // length of ATR #ifdef WITH_CARDREADER uint8_t atr[64]; int32_t atrlen; int8_t seca_nagra_card; // seca nagra card #endif SIDTABS sidtabs; SIDTABS lb_sidtabs; uint8_t hexserial[8]; int32_t nprov; uint8_t prid[CS_MAXPROV][8]; uint8_t sa[CS_MAXPROV][4]; // viaccess & seca #if defined(READER_NAGRA) || defined(READER_NAGRA_MERLIN) int32_t nsa; int32_t nemm82u; int32_t nemm84; int32_t nemm84s; int32_t nemm83u; int32_t nemm83s; int32_t nemm87; uint8_t emm82u[CS_MAXPROV][7]; uint8_t emm84[CS_MAXPROV][3]; uint8_t emm84s[CS_MAXPROV][6]; uint8_t emm83; uint8_t emm83u[CS_MAXPROV][6]; uint8_t emm83s[CS_MAXPROV][6]; uint8_t emm87[CS_MAXPROV][6]; uint8_t emm82; #endif uint8_t read_old_classes; // viaccess uint8_t maturity; // viaccess & seca maturity level uint16_t caid; uint16_t cak7_emm_caid; uint16_t b_nano; uint16_t s_nano; int8_t ecmcommand; // used for filtering nagra bad ecm commands uint8_t ecmcommandcache[5]; // cachebuff for ecm commands int32_t blockemm; int32_t saveemm; LLIST *blockemmbylen; char *emmfile; char pincode[5]; int8_t logemm; int8_t cachemm; int16_t rewritemm; int16_t deviceemm; // catch device specific emms (so far only used for viaccess) int8_t card_status; #ifdef WITH_CARDREADER int8_t deprecated; // if 0 ATR obeyed, if 1 default speed (9600) is chosen; for devices that cannot switch baudrate #endif int8_t resetalways; // send reset after each commands (for pscs) struct s_module ph; const struct s_cardreader *crdr; void *crdr_data; // Private card reader data bool crdr_flush; // sci readers may disable flush per reader const struct s_cardsystem *csystem; void *csystem_data; // Private card system data bool csystem_active; uint8_t ncd_key[14]; uint8_t ncd_skey[16]; int8_t ncd_connect_on_init; int8_t ncd_disable_server_filt; int8_t ncd_proto; int8_t currenthops; // number of hops (cccam & gbox) #ifdef MODULE_CCCAM char cc_version[7]; // cccam version char cc_build[7]; // cccam build number int8_t cc_maxhops; // cccam max distance int8_t cc_mindown; // cccam min downhops int8_t cc_want_emu; // Schlocke: Client want to have EMUs, 0 - NO; 1 - YES uint32_t cc_id; int8_t cc_keepalive; int8_t cc_hop; // For non-cccam reader: hop for virtual cards int8_t cc_reshare; int32_t cc_reconnect; // reconnect on ecm-request timeout #endif int8_t tcp_connected; int32_t tcp_ito; // inactivity timeout int32_t tcp_rto; // reconnect timeout int32_t tcp_reconnect_delay; // max tcp connection block delay uint8_t ipv4force; uint8_t ipv6_connect_failed; struct timeb tcp_block_connect_till; // time tcp connect ist blocked int32_t tcp_block_delay; // incrementing block time time_t last_g; // get (if last_s-last_g>tcp_rto - reconnect ) time_t last_s; // send time_t last_check; // last checked time_t last_poll; // last poll FTAB fchid; FTAB ftab; CLASSTAB cltab; ECM_WHITELIST ecm_whitelist; ECM_HDR_WHITELIST ecm_hdr_whitelist; int32_t brk_pos; int32_t msg_idx; int32_t secatype; // 0=not determined, 2=seca2, 3=nagra(~seca3) this is only valid for localreaders! uint32_t maxreadtimeout; // in us uint32_t minreadtimeout; // in us uint32_t maxwritetimeout; // in us uint32_t minwritetimeout; // in us #if defined(WEBIF) || defined(LCDSUPPORT) int32_t emmwritten[4]; // count written EMM int32_t emmskipped[4]; // count skipped EMM int32_t emmerror[4]; // count error EMM int32_t emmblocked[4]; // count blocked EMM int32_t webif_emmwritten[4]; // count written EMM for webif reader info int32_t webif_emmskipped[4]; // count skipped EMM for webif reader info int32_t webif_emmerror[4]; // count error EMM for reader webif info int32_t webif_emmblocked[4]; // count blocked EMM for reader webif info int32_t lbvalue; // loadbalance Value #endif #ifdef WITH_AZBOX int32_t azbox_mode; #endif #ifdef WITH_CARDREADER int32_t use_gpio; // Should this reader use GPIO functions int gpio_outen; // fd of opened /dev/gpio/outen int gpio_out; // fd of opened /dev/gpio/out int gpio_in; // fd of opened /dev/gpio/in uint32_t gpio; // gpio addr // variables from icc_async.h start int32_t convention; // Convention of this ICC uint8_t protocol_type; // Type of protocol uint32_t current_baudrate; // (for overclocking uncorrected) baudrate to prevent unnecessary conversions from/to termios structure double worketu; // in us for internal and external readers calculated (1/D)*(F/cardclock)*1000000 uint32_t read_timeout; // Max timeout (ETU) to receive characters uint32_t char_delay; // Delay (ETU) after transmiting each successive char uint32_t block_delay; // Delay (ms) after starting to transmit uint32_t BWT, CWT; // (for overclocking uncorrected) block waiting time, character waiting time, in ETU // variables from io_serial.h int32_t written; // keep score of how much bytes are written to serial port, since they are echoed back they have to be read // variables from protocol_t1.h uint16_t ifsc; // Information field size for the ICC uint8_t ns; // Send sequence number int16_t smartdev_found; int16_t smart_type; uint16_t statuscnt; uint16_t modemstat; #endif #ifdef READER_CRYPTOWORKS EMM_PACKET *last_g_emm; // last global EMM bool last_g_emm_valid; // status of last global EMM #endif uint8_t rom[15]; uint8_t irdId[4]; #ifdef READER_VIDEOGUARD uint8_t payload4C[15]; uint16_t VgCredit; uint16_t VgPin; uint8_t VgFuse; uint8_t VgCountryC[3]; uint8_t VgRegionC[8]; uint8_t VgLastPayload[6]; int32_t card_startdate_basemonth; int32_t card_startdate_baseyear; int32_t card_expiredate_basemonth; int32_t card_expiredate_baseyear; #endif #ifdef WITH_LB int32_t lb_weight; // loadbalance weight factor, if unset, weight=100. The higher the value, the higher the usage-possibility int8_t lb_force_fallback; // force this reader as fallback if fallback or fallback_percaid paramters set int32_t lb_usagelevel; // usagelevel for loadbalancer int32_t lb_usagelevel_ecmcount; struct timeb lb_usagelevel_time; // time for counting ecms, this creates usagelevel struct timeb lb_last; // time for oldest reader LLIST *lb_stat; // loadbalancer reader statistics CS_MUTEX_LOCK lb_stat_lock; int32_t lb_stat_busy; // do not add while saving #endif time_t card_valid_to; // ratelimit int32_t ratelimitecm; int32_t ratelimittime; // ratelimit time in ms (everything below 60 ms is converted to ms by applying *1000) int8_t ecmunique; // check for matching ecm hash in ratelimitslot int32_t srvidholdtime; // time in ms to keep srvid in ratelimitslot (during this time not checked for ecmunique!) // (everything below 60 ms is converted to ms by applying *1000) struct timeb lastdvbapirateoverride; uint32_t ecmsok; #ifdef CS_CACHEEX_AIO uint32_t ecmsoklg; #endif uint32_t webif_ecmsok; uint32_t ecmsnok; uint32_t webif_ecmsnok; uint32_t ecmstout; uint32_t webif_ecmstout; uint32_t ecmnotfoundlimit; // config setting. restart reader if ecmsnok >= ecmnotfoundlimit int32_t ecmsfilteredhead; // count filtered ECM's by ECM Headerwhitelist int32_t ecmsfilteredlen; // count filtered ECM's by ECM Whitelist int32_t webif_ecmsfilteredhead; // count filtered ECM's by ECM Headerwhitelist to readers ecminfo int32_t webif_ecmsfilteredlen; // count filtered ECM's by ECM Whitelist to readers ecm info float ecmshealthok; #ifdef CS_CACHEEX_AIO float ecmshealthoklg; #endif float ecmshealthnok; float ecmshealthtout; int32_t cooldown[2]; int32_t maxparallel; // max parallel active services, 0 = unlimited (default) float parallelfactor; // zapping tolerance multiplier (default: 2.0) int32_t paralleltimeout; // timeout buffer in ms after expected ECM (default: 1000) struct s_parallel_slot *parallel_slots; // regular service tracking (size: maxparallel) struct s_parallel_slot *parallel_slots_prov; // pending service tracking (size: maxparallel * parallelfactor, rounded) LLIST *blocked_services; // list of s_blocked_client for dropped services CS_MUTEX_LOCK parallel_lock; // lock for parallel_slots access int8_t parallel_full; // flag: 1 if reader is at capacity limit int8_t cooldownstate; struct timeb cooldowntime; struct ecmrl rlecmh[MAXECMRATELIMIT]; #ifdef READER_VIDEOGUARD int8_t ndsversion; // 0 auto (default), 1 NDS1, 12 NDS1+, 2 NDS2 int8_t fix_07; int8_t fix_9993; int8_t readtiers; // method to get videoguard tiers uint8_t ins7E[0x1A + 1]; uint8_t ins7E11[0x01 + 1]; uint8_t ins42[0x25 + 1]; uint8_t ins2e06[0x04 + 1]; uint8_t k1_generic[0x10 + 1]; // k1 for generic pairing mode uint8_t k1_unique[0x10 + 1]; // k1 for unique pairing mode #endif #ifdef WITH_CARDREADER int8_t smargopatch; int8_t autospeed; // 1 clockspeed set according to atr f max int8_t ins7e11_fast_reset; uint8_t sc8in1_dtrrts_patch; // fix for kernel commit 6a1a82df91fa0eb1cc76069a9efe5714d087eccd #endif #ifdef READER_VIACCESS AES_ENTRY *aes_list; // multi AES linked list uint8_t initCA28; // To set when CA28 succeed uint32_t key_schedule1[32]; uint32_t key_schedule2[32]; #endif #if defined(READER_DRE) || defined(READER_DRECAS) char *userscript; uint32_t force_ua; #endif #ifdef READER_DRECAS char *stmkeys; #endif #ifdef MODULE_GBOX uint8_t gbox_maxdist; uint8_t gbox_maxecmsend; uint8_t gbox_reshare; int8_t gbox_cccam_reshare; char last_gsms[128]; uint16_t gbox_remm_peer; uint16_t gbox_gsms_peer; uint8_t gbox_force_remm; uint16_t gbox_cw_src_peer; uint8_t gbox_crd_slot_lev; FTAB ccc_gbx_reshare_ident; uint8_t send_offline_cmd; uint16_t nb_send_crds; #endif #ifdef MODULE_PANDORA uint8_t pand_send_ecm; #endif #ifdef MODULE_GHTTP uint8_t ghttp_use_ssl; #endif #ifdef WITH_EMU FTAB emu_auproviders; // AU providers for Emu reader int8_t emu_datecodedenabled; // date-coded keys for BISS LLIST *ll_biss2_rsa_keys; // BISS2 RSA keys - Read from external PEM files #endif #ifdef READER_CONAX uint8_t cnxlastecm; // == 0 - last ecm has not been paired ecm, > 0 last ecm has been paired ecm #endif LLIST *emmstat; // emm stats CS_MUTEX_LOCK emmstat_lock; struct s_reader *next; }; struct s_cpmap { uint16_t caid; uint32_t provid; uint16_t sid; uint16_t chid; uint16_t dwtime; struct s_cpmap *next; }; struct s_auth { char usr[64]; char *pwd; #ifdef WEBIF char *description; #endif int8_t uniq; #ifdef CS_CACHEEX CECSP cacheex; // CacheEx Settings uint8_t no_wait_time; uint8_t disablecrccacheex; FTAB disablecrccacheex_only_for; #endif int16_t allowedprotocols; LLIST *aureader_list; int8_t autoau; uint8_t emm_reassembly; // 0 = OFF; 1 = OFF / DVBAPI = ON; 2 = ON (default) int8_t monlvl; uint64_t grp; int32_t tosleep; int32_t umaxidle; CAIDTAB ctab; SIDTABS sidtabs; FTAB fchid; FTAB ftab; // user [caid] and ident filter CLASSTAB cltab; TUNTAB ttab; int8_t preferlocalcards; uint32_t max_connections; #ifdef CS_ANTICASC int32_t ac_fakedelay; // When this is -1, the global ac_fakedelay is used int32_t ac_users; // 0 - unlimited int8_t ac_penalty; // 0 - log, >0 - fake dw struct s_acasc ac_stat; int8_t acosc_max_ecms_per_minute; // user value 0 - unlimited int8_t acosc_max_active_sids; // user value 0 - unlimited int8_t acosc_zap_limit; // user value 0 - unlimited int8_t acosc_penalty; // user value penalty int32_t acosc_penalty_duration; // user value how long is penalty activ in sek. time_t acosc_penalty_until; int8_t acosc_penalty_active; // 0-deaktiv 1-max_active_sids 2-zap_limit 3-max_ecms_per_minute 4-penaly_duration int32_t acosc_delay; // user value int8_t acosc_user_zap_count; time_t acosc_user_zap_count_start_time; #endif #ifdef WITH_LB int32_t lb_nbest_readers; // When this is -1, the global lb_nbest_readers is used int32_t lb_nfb_readers; // When this is -1, the global lb_nfb_readers is used CAIDVALUETAB lb_nbest_readers_tab; // like nbest_readers, but for special caids #endif IN_ADDR_T dynip; char *dyndns; time_t expirationdate; time_t firstlogin; uint32_t allowedtimeframe[SIZE_SHORTDAY][24][2]; // day[0-sun to 6-sat, 7-ALL],hours,minutes use as binary flags to reduce mem usage uint8_t allowedtimeframe_set; // flag for internal use to mention if allowed time frame is used int8_t c35_suppresscmd08; uint8_t c35_sleepsend; int8_t ncd_keepalive; #ifdef MODULE_CCCAM int32_t cccmaxhops; int8_t cccreshare; int8_t cccignorereshare; int8_t cccstealth; #endif int8_t disabled; int32_t failban; int32_t cwfound; int32_t cwcache; int32_t cwnot; int32_t cwtun; int32_t cwignored; int32_t cwtout; #ifdef CW_CYCLE_CHECK int32_t cwcycledchecked; // count checked cwcycles per client int32_t cwcycledok; // count pos checked cwcycles per client int32_t cwcyclednok; // count neg checked cwcycles per client int32_t cwcycledign; // count ign cwcycles per client int8_t cwc_disable; // disable cwc checking for this Client #endif int32_t emmok; int32_t emmnok; #ifdef CS_CACHEEX int32_t cwcacheexpush; // count pushed ecms/cws int32_t cwcacheexgot; // count got ecms/cws int32_t cwcacheexhit; // count hit ecms/cws int32_t cwcacheexerr; // cw=00 or chksum wrong int32_t cwcacheexerrcw; // Same Hex, different CW int32_t cwc_info; // count of in/out comming cacheex ecms with CWCinfo #ifdef CS_CACHEEX_AIO int32_t cwcacheexgotlg; // count got localgenerated-flagged CWs int32_t cwcacheexpushlg; // count pushed localgenerated-flagged CWs #endif #endif struct s_auth *next; }; struct s_srvid_caid { uint16_t caid; uint16_t nprovid; uint32_t *provid; }; struct s_srvid { uint16_t srvid; int8_t ncaid; struct s_srvid_caid *caid; char *data; const char *prov; const char *name; const char *type; const char *desc; struct s_srvid *next; }; struct s_rlimit { struct ecmrl rl; struct s_rlimit *next; }; struct s_cw { uint8_t cw[16]; }; struct s_fakecws { uint32_t count; struct s_cw *data; }; #ifdef MODULE_SERIAL struct s_twin { struct ecmtw tw; struct s_twin *next; }; #endif struct s_tierid { uint16_t tierid; int8_t ncaid; uint16_t caid[10]; char name[33]; struct s_tierid *next; }; struct s_provid { uint16_t caid; uint16_t nprovid; uint32_t *provid; char prov[33]; char sat[33]; char lang[33]; struct s_provid *next; }; struct s_ip { IN_ADDR_T ip[2]; struct s_ip *next; }; struct s_global_whitelist { uint32_t line; // linenr of oscam.whitelist file, starting with 1 char type; // w or i or l uint16_t caid; uint32_t provid; uint16_t srvid; uint16_t chid; uint16_t pid; uint16_t ecmlen; uint16_t mapcaid; uint32_t mapprovid; struct s_global_whitelist *next; }; struct s_cacheex_matcher { uint32_t line; // linenr of oscam.Cacheex file, starting with 1 char type; // m uint16_t caid; uint32_t provid; uint16_t srvid; uint16_t chid; uint16_t pid; uint16_t ecmlen; uint16_t to_caid; uint32_t to_provid; uint16_t to_srvid; uint16_t to_chid; uint16_t to_pid; uint16_t to_ecmlen; int32_t valid_from; int32_t valid_to; struct s_cacheex_matcher *next; }; struct s_config { int32_t nice; uint32_t netprio; uint32_t ctimeout; uint32_t ftimeout; CAIDVALUETAB ftimeouttab; CAIDVALUETAB ctimeouttab; // ← clienttimeout_percaid uint32_t cmaxidle; int32_t ulparent; uint32_t delay; int32_t bindwait; int32_t tosleep; IN_ADDR_T srvip; char *usrfile; char *cwlogdir; char *emmlogdir; char *logfile; char *mailfile; int8_t disablecrccws; // 1=disable cw checksum test. 0=enable checksum check FTAB disablecrccws_only_for; // ignore checksum for selected caid provid #ifdef CS_CACHEEX_AIO uint8_t cacheex_srcname_webif; // show cacheex-srcname not cache3 in log #endif uint8_t logtostdout; uint8_t logtosyslog; int8_t logduplicatelines; int32_t initial_debuglevel; char *sysloghost; int32_t syslogport; #if defined(WEBIF) || defined(MODULE_MONITOR) uint32_t loghistorylines; #endif int8_t disablelog; int8_t disablemail; int8_t disableuserfile; int8_t usrfileflag; struct s_auth *account; struct s_srvid *srvid[16]; struct s_tierid *tierid; struct s_provid *provid; struct s_sidtab *sidtab; #ifdef MODULE_MONITOR int32_t mon_port; IN_ADDR_T mon_srvip; struct s_ip *mon_allowed; uint8_t mon_level; #endif int32_t aulow; int32_t hideclient_to; #ifdef WEBIF int32_t http_port; IN_ADDR_T http_srvip; char *http_user; char *http_pwd; char *http_css; int8_t http_prepend_embedded_css; char *http_jscript; char *http_tpl; char *http_piconpath; char *http_script; #ifndef WEBIF_JQUERY char *http_extern_jquery; #endif int32_t http_refresh; int32_t poll_refresh; int8_t http_hide_idle_clients; char *http_hide_type; int8_t http_showpicons; int8_t http_picon_size; int8_t http_status_log; int8_t http_showmeminfo; int8_t http_showecminfo; int8_t http_showloadinfo; int8_t http_showuserinfo; int8_t http_showreaderinfo; int8_t http_showcacheexinfo; struct s_ip *http_allowed; int8_t http_readonly; IN_ADDR_T http_dynip[MAX_HTTP_DYNDNS]; uint8_t http_dyndns[MAX_HTTP_DYNDNS][64]; int8_t http_use_ssl; int8_t https_force_secure_mode; int8_t https_auto_create_cert; char *http_cert; char *http_help_lang; char *http_locale; char *http_oscam_label; int32_t http_emmu_clean; int32_t http_emms_clean; int32_t http_emmg_clean; #endif int8_t http_full_cfg; int8_t http_overwrite_bak_file; int32_t failbantime; int32_t failbancount; LLIST *v_list; // Failban list #ifdef MODULE_CAMD33 int32_t c33_port; IN_ADDR_T c33_srvip; uint8_t c33_key[16]; int32_t c33_crypted; int32_t c33_passive; struct s_ip *c33_plain; #endif #if defined(MODULE_CAMD35) || defined(MODULE_CAMD35_TCP) int32_t c35_port; IN_ADDR_T c35_srvip; int8_t c35_tcp_suppresscmd08; int8_t c35_udp_suppresscmd08; PTAB c35_tcp_ptab; IN_ADDR_T c35_tcp_srvip; #endif int8_t c35_suppresscmd08; // used in cccam module int8_t getblockemmauprovid; int32_t umaxidle; //User max Idle #ifdef MODULE_NEWCAMD PTAB ncd_ptab; IN_ADDR_T ncd_srvip; uint8_t ncd_key[14]; int8_t ncd_keepalive; int8_t ncd_mgclient; struct s_ip *ncd_allowed; #endif #ifdef MODULE_RADEGAST int32_t rad_port; IN_ADDR_T rad_srvip; struct s_ip *rad_allowed; char *rad_usr; #endif #ifdef MODULE_CCCAM uint16_t cc_port[CS_MAXPORTS]; int8_t cc_reshare; int8_t cc_ignore_reshare; int32_t cc_update_interval; IN_ADDR_T cc_srvip; char cc_version[7]; int8_t cc_minimize_cards; int8_t cc_keep_connected; int8_t cc_stealth; int8_t cc_reshare_services; int8_t cc_forward_origin_card; uint8_t cc_fixed_nodeid[8]; uint32_t cc_recv_timeout; // The poll() timeout parameter in ms. Default: DEFAULT_CC_RECV_TIMEOUT (2000 ms). #endif #ifdef MODULE_GBOX #define GBOX_MY_VERS_DEF 0x2A #define GBOX_MY_CPU_API_DEF 0x61 #define GBOX_MAX_PROXY_CARDS 32 #define GBOX_MAX_IGNORED_PEERS 16 #define GBOX_MAX_BLOCKED_ECM 16 #define GBOX_MAX_REMM_PEERS 8 #define GBOX_MAX_DEST_PEERS 16 #define GBOX_MAX_MSG_TXT 127 uint16_t gbox_port[CS_MAXPORTS]; char *gbox_hostname; uint32_t gbox_reconnect; uint32_t gbox_password; unsigned long gbox_proxy_card[GBOX_MAX_PROXY_CARDS]; int8_t gbox_proxy_cards_num; uint32_t gbox_my_vers; uint8_t gbox_my_cpu_api; uint8_t gsms_dis; uint8_t log_hello; uint8_t dis_attack_txt; char *gbox_tmp_dir; uint8_t cc_gbx_reshare_en; uint16_t gbox_ignored_peer[GBOX_MAX_IGNORED_PEERS]; uint8_t gbox_ignored_peer_num; uint16_t accept_remm_peer[GBOX_MAX_REMM_PEERS]; uint8_t accept_remm_peer_num; uint16_t gbox_block_ecm[GBOX_MAX_BLOCKED_ECM]; uint8_t gbox_block_ecm_num; uint8_t gbox_save_gsms; uint8_t gbox_msg_type; uint16_t gbox_dest_peers[GBOX_MAX_DEST_PEERS]; uint8_t gbox_dest_peers_num; char gbox_msg_txt[GBOX_MAX_MSG_TXT+1]; #endif #ifdef MODULE_SERIAL char *ser_device; #endif int32_t max_log_size; int8_t waitforcards; int32_t waitforcards_extra_delay; int8_t preferlocalcards; int32_t reader_restart_seconds; // schlocke: reader restart auf x seconds, disable = 0 int8_t dropdups; // drop duplicate logins // Loadbalancer-Config: int32_t lb_mode; // schlocke: reader loadbalancing mode int32_t lb_auto_betatunnel; // automatic selection of betatunnel convertion based on learned data int32_t lb_auto_betatunnel_mode; // automatic selection of betatunnel direction #ifdef WITH_LB int32_t lb_save; // schlocke: load/save statistics to file, save every x ecms int32_t lb_nbest_readers; // count of best readers int32_t lb_nfb_readers; // count of fallback readers int32_t lb_min_ecmcount; // minimal ecm count to evaluate lbvalues int32_t lb_max_ecmcount; // maximum ecm count before reseting lbvalues int32_t lb_reopen_seconds; // time between retrying failed readers/caids/prov/srv int8_t lb_reopen_invalid; // default=1; if 0, rc=E_INVALID will be blocked until stats cleaned int8_t lb_force_reopen_always; // force reopening immediately all failing readers if no matching reader found int32_t lb_retrylimit; // reopen only happens if reader response time > retrylimit CAIDVALUETAB lb_retrylimittab; CAIDVALUETAB lb_nbest_readers_tab; // like nbest_readers, but for special caids CAIDTAB lb_noproviderforcaid; // do not store loadbalancer stats with providers for this caid char *lb_savepath; // path where the stat file is save. Empty=default=/tmp/.oscam/stat int32_t lb_stat_cleanup; // duration in hours for cleaning old statistics int32_t lb_max_readers; // limit the amount of readers during learning int32_t lb_auto_betatunnel_prefer_beta; // prefer-beta-over-nagra factor int32_t lb_auto_timeout; // Automatic timeout by loadbalancer statistics int32_t lb_auto_timeout_p; // percent added to avg time as timeout time int32_t lb_auto_timeout_t; // minimal time added to avg time as timeout time #endif int32_t resolve_gethostbyname; int8_t double_check; // schlocke: Double checks each ecm+dcw from two (or more) readers FTAB double_check_caid; // do not store loadbalancer stats with providers for this caid // CW Vote settings int8_t cwvote_enabled; int8_t cwvote_log_enabled; int32_t cwvote_timeout; // w milisekundach, 0 = wyłączony int32_t cwvote_min_votes; float cwvote_local_weight; // waga local readera (np. 2.0) int32_t cwvote_max_candidates; int32_t cwvote_compare_len; // 8 lub 16 int32_t cwvote_fallback; // 0=wait, 1=best anyway, 2=first CW CW_VOTE_CAID_TAB cwvote_caids; #ifdef HAVE_DVBAPI int8_t dvbapi_enabled; int8_t dvbapi_au; char *dvbapi_usr; int8_t dvbapi_boxtype; int8_t dvbapi_pmtmode; int8_t dvbapi_requestmode; int32_t dvbapi_listenport; // TCP port to listen instead of camd.socket (network mode, default=0 -> disabled) IN_ADDR_T dvbapi_srvip; SIDTABS dvbapi_sidtabs; int32_t dvbapi_delayer; // delayer ms, minimum time to write cw int8_t dvbapi_ecminfo_file; // Enable or disable ecm.info file creation int8_t dvbapi_ecminfo_type; int8_t dvbapi_read_sdt; int8_t dvbapi_write_sdt_prov; int8_t dvbapi_extended_cw_api; #ifdef MODULE_STREAMRELAY int8_t dvbapi_demuxer_fix; #endif #endif #ifdef CS_ANTICASC int8_t ac_enabled; int32_t ac_users; // num of users for account (0 - default) int32_t ac_stime; // time to collect AC statistics (3 min - default) int32_t ac_samples; // qty of samples int8_t ac_penalty; // 0 - write to log int32_t ac_fakedelay; // 100-1000 ms int32_t ac_denysamples; char *ac_logfile; struct s_cpmap *cpmap; int8_t acosc_enabled; int8_t acosc_max_ecms_per_minute; // global value 0 - unlimited int8_t acosc_max_active_sids; // global value 0 - unlimited int8_t acosc_zap_limit; // global value 0 - unlimited int32_t acosc_penalty_duration; // global value how long is penalty activ in sek. int8_t acosc_penalty; // global value int32_t acosc_delay; // global value #endif #ifdef LEDSUPPORT int8_t enableled; // 0=disabled led, 1=enable led for routers, 2=enable qboxhd led #endif #ifdef LCDSUPPORT int8_t enablelcd; char *lcd_output_path; int32_t lcd_hide_idle; int32_t lcd_write_intervall; #endif #ifdef MODULE_PANDORA int8_t pand_skip_send_dw; struct s_ip *pand_allowed; char *pand_usr; char *pand_pass; int8_t pand_ecm; int32_t pand_port; IN_ADDR_T pand_srvip; #endif #ifdef MODULE_SCAM int32_t scam_port; IN_ADDR_T scam_srvip; struct s_ip *scam_allowed; #endif #ifdef MODULE_STREAMRELAY int8_t stream_relay_enabled; int32_t stream_relay_port; char *stream_relay_user; CAIDTAB stream_relay_ctab; // use the stream server for these caids char *stream_source_host; int8_t stream_client_source_host; int32_t stream_source_port; char *stream_source_auth_user; char *stream_source_auth_password; uint32_t stream_relay_buffer_time; int8_t stream_relay_reconnect_count; int8_t stream_display_client; int8_t stream_reuse_client; #ifdef WEBIF int8_t stream_hide_client; #endif #ifdef WITH_NEUTRINO #define DEFAULT_STREAM_SOURCE_PORT 31339 //Neutrino #else #define DEFAULT_STREAM_SOURCE_PORT 8001 //Enigma2 #endif #endif #ifdef WITH_EMU uint32_t emu_stream_ecm_delay; int8_t emu_stream_emm_enabled; #endif int32_t max_cache_time; // seconds ecms are stored in ecmcwcache int32_t max_hitcache_time; // seconds hits are stored in cspec_hitcache (to detect dyn wait_time) int8_t reload_useraccounts; int8_t reload_readers; int8_t reload_provid; int8_t reload_services_ids; int8_t reload_tier_ids; int8_t reload_fakecws; int8_t reload_ac_stat; int8_t reload_log; int8_t block_same_ip; // 0=allow all, 1=block client requests to reader with same ip (default=1) int8_t block_same_name; // 0=allow all, 1=block client requests to reader with same name (default=1) #ifdef CS_CACHEEX #ifdef CS_CACHEEX_AIO uint32_t cw_cache_size; uint32_t cw_cache_memory; CWCHECKTAB cw_cache_settings; uint32_t ecm_cache_size; uint32_t ecm_cache_memory; int32_t ecm_cache_droptime; #endif uint8_t wait_until_ctimeout; CWCHECKTAB cacheex_cwcheck_tab; IN_ADDR_T csp_srvip; int32_t csp_port; CECSPVALUETAB cacheex_wait_timetab; CAIDVALUETAB cacheex_mode1_delay_tab; #ifdef CS_CACHEEX_AIO uint8_t waittime_block_start; uint16_t waittime_block_time; #endif CECSP csp; // CSP Settings uint8_t cacheex_enable_stats; // enable stats struct s_cacheex_matcher *cacheex_matcher; #ifdef CS_CACHEEX_AIO uint8_t cacheex_dropdiffs; uint8_t cacheex_lg_only_remote_settings; uint8_t cacheex_localgenerated_only; CAIDTAB cacheex_localgenerated_only_caidtab; FTAB lg_only_tab; uint8_t localgenerated_only_in; CAIDTAB localgenerated_only_in_caidtab; FTAB lg_only_in_tab; uint8_t lg_only_in_aio_only; uint8_t lg_only_remote_settings; int32_t feature_bitfield; char aio_version[CS_AIO_VERSION_LEN]; #endif CAIDVALUETAB cacheex_nopushafter_tab; uint8_t cacheex_localgenerated_only_in; CAIDTAB cacheex_localgenerated_only_in_caidtab; FTAB cacheex_lg_only_in_tab; uint8_t cacheex_lg_only_in_aio_only; CECSPVALUETAB cacheex_filter_caidtab; CECSPVALUETAB cacheex_filter_caidtab_aio; uint32_t cacheex_push_lg_groups; FTAB cacheex_lg_only_tab; #endif #ifdef CW_CYCLE_CHECK int8_t cwcycle_check_enable; // on or off CAIDTAB cwcycle_check_caidtab; // Caid for CW Cycle Check int32_t keepcycletime; // how long stay the learned Cycletime in Memory int32_t maxcyclelist; // max size of cwcyclelist int8_t onbadcycle; // what to do on bad cwcycle int8_t cwcycle_dropold; // what to do on old ecmd5/cw int8_t cwcycle_sensitive; int8_t cwcycle_allowbadfromffb; // allow Bad cycles from Fixed Fallbackreader int8_t cwcycle_usecwcfromce; // Use CWC Info from Cacheex Sources for CWC Checking #endif // Global whitelist: struct s_global_whitelist *global_whitelist; int8_t global_whitelist_use_l; int8_t global_whitelist_use_m; char *ecmfmt; char *pidfile; int32_t max_pending; // Ratelimit list struct s_rlimit *ratelimit_list; // fake cws struct s_fakecws fakecws[0x100]; #ifdef MODULE_SERIAL struct s_twin *twin_list; #endif }; struct s_clientinit { void *(*handler)(struct s_client *); struct s_client *client; }; struct s_clientmsg { uint8_t msg[1024]; int32_t len; int32_t cmd; }; typedef struct reader_stat_t { int32_t rc; uint16_t caid; uint32_t prid; uint16_t srvid; uint32_t chid; int16_t ecmlen; struct timeb last_received; int32_t ecm_count; int32_t time_avg; int32_t time_stat[LB_MAX_STAT_TIME]; int32_t time_idx; int32_t fail_factor; } READER_STAT; typedef struct cs_stat_query { uint16_t caid; uint32_t prid; uint16_t srvid; uint32_t chid; int16_t ecmlen; } STAT_QUERY; struct s_write_from_cache { ECM_REQUEST *er_new; ECM_REQUEST *er_cache; }; /* =========================== * global variables * =========================== */ extern pthread_key_t getclient; extern struct s_client *first_client; extern CS_MUTEX_LOCK config_lock; extern CS_MUTEX_LOCK clientlist_lock; extern CS_MUTEX_LOCK readerlist_lock; extern struct s_reader *first_active_reader; // points to list of _active_ readers (enable = 1, deleted = 0) extern LLIST *configured_readers; // These are used pretty much everywhere extern struct s_config cfg; extern uint16_t cs_dblevel; #include "oscam-log.h" #include "oscam-log-reader.h" // Add here *only* funcs that are implemented in oscam.c and are called in other places void cs_exit(int32_t sig); void cs_exit_oscam(void); void cs_restart_oscam(void); int32_t cs_get_restartmode(void); void set_thread_name(const char *thread_name); int32_t start_thread(char *nameroutine, void *startroutine, void *arg, pthread_t *pthread, int8_t detach, int8_t modify_stacksize); int32_t start_thread_nolog(char *nameroutine, void *startroutine, void *arg, pthread_t *pthread, int8_t detach, int8_t modify_stacksize); void kill_thread(struct s_client *cl); struct s_module *get_module(struct s_client *cl); void module_reader_set(struct s_reader *rdr); // Until we find a better place for these (they are implemented in oscam-simples.h) char *get_servicename(struct s_client *cl, uint16_t srvid, uint32_t provid, uint16_t caid, char *buf, uint32_t buflen); char *get_servicename_or_null(struct s_client *cl, uint16_t srvid, uint32_t provid, uint16_t caid, char *buf, uint32_t buflen); char *get_picon_servicename_or_null(struct s_client *cl, uint16_t srvid, uint32_t provid, uint16_t caid, char *buf, uint32_t buflen); int32_t picon_servicename_remve_hd(char *buf, uint32_t buflen); char *get_tiername(uint16_t tierid, uint16_t caid, char *buf); char *get_tiername_defaultid(uint16_t tierid, uint16_t caid, char *buf); char *get_provider(uint32_t provid, uint16_t caid, char *buf, uint32_t buflen); char *get_providername(uint32_t provid, uint16_t caid, char *buf, uint32_t buflen); char *get_providername_or_null(uint32_t provid, uint16_t caid, char *buf, uint32_t buflen); void add_provider(uint16_t caid, uint32_t provid, const char *name, const char *sat, const char *lang); const char *get_cl_lastprovidername(struct s_client *cl); bool boxtype_is(const char *boxtype); bool boxname_is(const char *boxname); const char *boxtype_get(void); const char *boxname_get(void); static inline bool caid_is_fake(uint16_t caid) { return caid == 0xffff; } static inline bool caid_is_biss(uint16_t caid) { return caid >> 8 == 0x26; } static inline bool caid_is_biss_fixed(uint16_t caid) { return caid == 0x2600 || caid == 0x2602; } // fixed cw, fake ecm static inline bool caid_is_biss_dynamic(uint16_t caid) { return caid == 0x2610; } // dynamic cw, real ecm and emm static inline bool caid_is_seca(uint16_t caid) { return caid >> 8 == 0x01; } static inline bool caid_is_viaccess(uint16_t caid) { return caid >> 8 == 0x05; } static inline bool caid_is_irdeto(uint16_t caid) { return caid >> 8 == 0x06; } static inline bool caid_is_videoguard(uint16_t caid) { return caid >> 8 == 0x09; } static inline bool caid_is_conax(uint16_t caid) { return caid >> 8 == 0x0B; } static inline bool caid_is_cryptoworks(uint16_t caid) { return caid >> 8 == 0x0D; } static inline bool caid_is_powervu(uint16_t caid) { return caid >> 8 == 0x0E; } static inline bool caid_is_director(uint16_t caid) { return caid >> 8 == 0x10; } static inline bool caid_is_betacrypt(uint16_t caid) { return caid >> 8 == 0x17; } static inline bool caid_is_nagra(uint16_t caid) { return caid >> 8 == 0x18; } static inline bool caid_is_bulcrypt(uint16_t caid) { return caid == 0x5581 || caid == 0x4AEE; } static inline bool caid_is_dre(uint16_t caid) { return caid == 0x4AE0 || caid == 0x4AE1 || caid == 0x2710;} static inline bool caid_is_tongfang(uint16_t caid) { return caid == 0x4A02; } #if defined(WITH_EXTENDED_CW) || defined(MODULE_STREAMRELAY) static inline bool select_csa_alt(const ECM_REQUEST *er) { return (caid_is_videoguard(er->caid) && er->ecm[4] != 0 && (er->ecm[2] - er->ecm[4]) == 4); } #endif #ifdef MODULE_STREAMRELAY static inline uint8_t get_ecm_mode(const ECM_REQUEST *er) { return (caid_is_videoguard(er->caid) && er->ecmlen >= 4) ? (er->ecm[er->ecmlen - 1] & 0x0F) : 0; } #endif const char *get_cardsystem_desc_by_caid(uint16_t caid); #ifdef WITH_EMU FILTER *get_emu_prids_for_caid(struct s_reader *rdr, uint16_t caid); #endif #endif