?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert breaks some stupid old compilers
[oscam.git] / globals.h
blob28a8055964868085bb18e5d0cbd0b277999ee14f
1 #ifndef GLOBALS_H_
2 #define GLOBALS_H_
3
4 #define _GNU_SOURCE //needed for PTHREAD_MUTEX_RECURSIVE on some plattforms and maybe other things; do not remove
5 #include <stdlib.h>
6 #include <stdio.h>
7 #include <stdbool.h>
8 #include <stdint.h>
9 #include <stddef.h>
10 #include <assert.h>
11 #include <fcntl.h>
12 #include <sys/ioctl.h>
13 #include <poll.h>
14 #include <ctype.h>
15 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <sys/wait.h>
18 #include <unistd.h>
19 #include <sys/mman.h>
20 #include <stdarg.h>
21 #include <time.h>
22 #include <sys/time.h>
23 #include <limits.h>
24 #include <pwd.h>
25 #include <netinet/tcp.h>
26 #include <sys/socket.h>
27 #include <netinet/in.h>
28 #include <arpa/inet.h>
29 #include <netdb.h>
30 #include <string.h>
31 #include <strings.h>
32 #include <signal.h>
33 #include <errno.h>
34 #include <pthread.h>
35 #include <dirent.h>
36 #include <termios.h>
37 #include <inttypes.h>
38 #include <sys/utsname.h>
39
40 /*
41 * The following hack is taken from Linux: include/linux/kconfig.h
42 * Original comment follows:
43 * Getting something that works in C and CPP for an arg that may or may
44 * not be defined is tricky. Here, if we have "#define CONFIG_BOOGER 1"
45 * we match on the placeholder define, insert the "0," for arg1 and generate
46 * the triplet (0, 1, 0). Then the last step cherry picks the 2nd arg (a one).
47 * When CONFIG_BOOGER is not defined, we generate a (... 1, 0) pair, and when
48 * the last step cherry picks the 2nd arg, we get a zero.
49 */
50 #define __ARG_PLACEHOLDER_1 0,
51 #define config_enabled(cfg) _config_enabled(cfg)
52 #define _config_enabled(value) __config_enabled(__ARG_PLACEHOLDER_##value)
53 #define __config_enabled(arg1_or_junk) ___config_enabled(arg1_or_junk 1, 0)
54 #define ___config_enabled(__ignored, val, ...) val
55
56 #include "config.h"
57
58 #if defined(WITH_SSL) && !defined(WITH_LIBCRYPTO)
59 # define WITH_LIBCRYPTO 1
60 #endif
61
62 #if defined(__CYGWIN__) || defined(__arm__) || defined(__SH4__) || defined(__MIPS__) || defined(__MIPSEL__) || defined(__powerpc__)
63 # define CS_LOGFILE "/dev/tty"
64 #endif
65
66 #if defined(__AIX__) || defined(__SGI__) || defined(__OSF__) || defined(__HPUX__) || defined(__SOLARIS__) || defined(__APPLE__)
67 # define NEED_DAEMON
68 #endif
69
70 #if defined(__AIX__) || defined(__SGI__) || defined(__OSF__) || defined(__HPUX__) || defined(__SOLARIS__) || defined(__CYGWIN__)
71 # define NO_ENDIAN_H
72 #endif
73
74 #if defined(__AIX__) || defined(__SGI__)
75 # define socklen_t unsigned long
76 #endif
77
78 #if defined(__SOLARIS__) || defined(__FreeBSD__) || defined(__OpenBSD__)
79 # define BSD_COMP
80 #endif
81
82 #if defined(__HPUX__)
83 # define _XOPEN_SOURCE_EXTENDED
84 #endif
85
86 #if (defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(s6_addr32)
87 #define s6_addr32 __u6_addr.__u6_addr32
88 #endif
89
90 #ifdef __ANDROID__
91 #ifndef in_port_t
92 #define in_port_t uint16_t
93 #endif
94 #define tcdrain(fd) ioctl(fd, TCSBRK, 1)
95 #endif
96
97 #ifdef __uClinux__
98 #define fork() 0
99 #endif
100
101 // Prevent warnings about openssl functions. Apple may consider 'openssl'
102 // deprecated but changing perfectly working portable code just because they
103 // introduced some proprietary API is not going to happen.
104 #if defined(__APPLE__)
105 #define __AVAILABILITY_MACROS_USES_AVAILABILITY 0
106 #define MAC_OS_X_VERSION_MIN_REQUIRED MAC_OS_X_VERSION_10_6
107 #endif
108
109 #include "cscrypt/aes.h"
110
111 #ifndef uchar
112 typedef unsigned char uchar;
113 #endif
114
115 #ifdef IPV6SUPPORT
116 #define IN_ADDR_T struct in6_addr
117 #define SOCKADDR sockaddr_storage
118 #define ADDR_ANY in6addr_any
119 #define DEFAULT_AF AF_INET6
120 #else
121 #define IN_ADDR_T in_addr_t
122 #define SOCKADDR sockaddr_in
123 #define ADDR_ANY INADDR_ANY
124 #define DEFAULT_AF AF_INET
125 #endif
126
127 #ifndef NO_ENDIAN_H
128 #if defined(__APPLE__)
129 #include <machine/endian.h>
130 #define __BYTE_ORDER __DARWIN_BYTE_ORDER
131 #define __BIG_ENDIAN __DARWIN_BIG_ENDIAN
132 #define __LITTLE_ENDIAN __DARWIN_LITTLE_ENDIAN
133 #elif defined(__FreeBSD__) || defined(__OpenBSD__)
134 #include <sys/endian.h>
135 #define __BYTE_ORDER _BYTE_ORDER
136 #define __BIG_ENDIAN _BIG_ENDIAN
137 #define __LITTLE_ENDIAN _LITTLE_ENDIAN
138 #else
139 #include <endian.h>
140 #include <byteswap.h>
141 #endif
142 #endif
143
144 /* ===========================
145 * macros
146 * =========================== */
147 // Prevent use of unsafe functions (doesn't work for MacOSX)
148 #if !defined(__APPLE__)
149 #define strcpy(a,b) UNSAFE_STRCPY_USE_CS_STRNCPY_INSTEAD()
150 #define sprintf(a,...) UNSAFE_SPRINTF_USE_SNPRINTF_INSTEAD()
151 #define strtok(a,b,c) UNSAFE_STRTOK_USE_STRTOK_R_INSTEAD()
152 #define gmtime(a) UNSAFE_GMTIME_NOT_THREADSAFE_USE_CS_GMTIME_R()
153 #define localtime(a) UNSAFE_LOCALTIME_NOT_THREADSAFE_USE_LOCALTIME_R()
154 #define asctime(a) UNSAFE_ASCTIME_NOT_THREADSAFE_USE_ASCTIME_R()
155 #define ctime(a) UNSAFE_CTIME_NOT_THREADSAFE_USE_CS_CTIME_R()
156 #define gethostbyaddr(a,b,c) UNSAFE_GETHOSTBYADDR_NOT_THREADSAFE_USE_GETADDRINFO()
157 #define gethostent(a) UNSAFE_GETHOSTENT_NOT_THREADSAFE()
158 #define getprotobyname(a) UNSAFE_GETPROTOBYNAME_NOT_THREADSAFE_USE_GETPROTOBYNAME_R()
159 #define getservbyname(a,b) UNSAFE_GETSERVBYNAME_NOT_THREADSAFE_USE_GETSERVBYNAME_R()
160 #define getservbyport(a,b) UNSAFE_GETSERVBYPORT_NOT_THREADSAFE_USE_GETSERVBYPORT_R()
161 #define getservent() UNSAFE_GETSERVENT_NOT_THREADSAFE_USE_GETSERVENT_R()
162 #define getnetbyname(a) UNSAFE_GETNETBYNAME_NOT_THREADSAFE_USE_GETNETBYNAME_R
163 #define getnetbyaddr(a,b) UNSAFE_GETNETBYADDR_NOT_THREADSAFE_USE_GETNETBYADDR_R
164 #define getnetent() UNSAFE_GETNETENT_NOT_THREADSAFE_USE_GETNETENT_R
165 #define getrpcbyname(a) UNSAFE_GETRPCBYNAME_NOT_THREADSAFE_USE_GETRPCBYNAME_R
166 #define getrpcbynumber(a) UNSAFE_GETRPCBYNUMBER_NOT_THREADSAFE_USE_GETRPCBYNUMBER_R
167 #define getrpcent() UNSAFE_GETRPCENT_NOT_THREADSAFE_USE_GETRPCENT_R
168 #define ctermid(a) UNSAFE_CTERMID_NOT_THREADSAFE_USE_CTERMID_R
169 #define tmpnam(a) UNSAFE_TMPNAM_NOT_THREADSAFE
170 #define tempnam(a,b) UNSAFE_TEMPNAM_NOT_THREADSAFE
171 #define getlogin() UNSAFE_GETLOGIN_NOT_THREADSAFE_USE_GETLOGIN_R
172 #define getpwnam(a) UNSAFE_GETPWNAM_NOT_THREADSAFE_USE_GETPWNAM_R
173 #define getpwent() UNSAFE_GETPWENT_NOT_THREADSAFE_USE_GETPWENT_R
174 #define fgetpwent(a) UNSAFE_FGETPWENT_NOT_THREADSAFE_USE_FGETPWENT_R
175 #ifndef __ANDROID__
176 #define getpwuid(a) UNSAFE_GETPWUID_NOT_THREADSAFE_USE_GETPWUID_R
177 #endif
178 #define getspent() UNSAFE_GETSPENT_NOT_THREADSAFE_USE_GETSPENT_R
179 #define getspnam(a) UNSAFE_GETSPNAM_NOT_THREADSAFE_USE_GETSPNAM_R
180 #define fgetspent(a) UNSAFE_FGETSPENT_NOT_THREADSAFE_USE_FGETSPENT_R
181 #define getgrnam(a) UNSAFE_GETGRNAM_NOT_THREADSAFE_USE_GETGRNAM_R
182 #define getgrent() UNSAFE_GETGRENT_NOT_THREADSAFE_USE_GETGRENT_R
183 #define getgrgid(a) UNSAFE_GETGRGID_NOT_THREADSAFE_USE_GETGRGID_R
184 #define fgetgrent() UNSAFE_FGETGRENT_NOT_THREADSAFE_USE_FGETGRGID_R
185 #define fcvt(a,b,c,d) UNSAFE_FCVT_NOT_THREADSAFE_AND_DEPRECATED
186 #define ecvt(a,b,c,d) UNSAFE_ECVT_NOT_THREADSAFE_AND_DEPRECATED
187 #define gcvt(a,b,c) UNSAFE_GCVT_NOT_THREADSAFE_AND_DEPRECATED
188 #define strptime(a,b,c) STRPTIME_NOT_EXISTS_ON_SOME_DM500_DB2()
189 #define ftime(a) FTIME_DEPRECATED()
190 #define timegm(a) TIMEGM_GNU_SPECIFIC_USE_CS_TIMEGM
191 #endif
192
193 #ifdef UNUSED
194 #elif __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
195 # define UNUSED(x) UNUSED_ ## x __attribute__((unused))
196 #elif defined(__LCLINT__)
197 # define UNUSED(x) /*@unused@*/ x
198 #else
199 # define UNUSED(x) x
200 #endif
201
202 #if __GNUC__ >= 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
203 # define MUST_CHECK_RESULT __attribute__((warn_unused_result))
204 #endif
205
206 #ifdef OK
207 #undef OK
208 #endif
209
210 #ifdef ERROR
211 #undef ERROR
212 #endif
213
214 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
215
216 #ifdef WITH_DEBUG
217 # define call(arg) \
218 if (arg) { \
219 cs_log_dbg(D_TRACE, "ERROR, function call %s returns error.",#arg); \
220 return ERROR; \
221 }
222 #else
223 # define call(arg) \
224 if (arg) { \
225 return ERROR; \
226 }
227 #endif
228
229 //checking if (X) free(X) unneccessary since freeing a null pointer doesnt do anything
230 #define NULLFREE(X) {if (X) {void *tmpX=X; X=NULL; free(tmpX); }}
231
232 #ifdef __CYGWIN__
233 #define cs_recv(a,b,c,d) cygwin_recv(a,b,c,d)
234 #else
235 #define cs_recv(a,b,c,d) recv(a,b,c,d)
236 #endif
237
238 //safe wrappers to pthread functions
239 #define fprintf_stderr(fmt, params...) fprintf(stderr, fmt, ##params)
240
241 #define SAFE_PTHREAD_1ARG(a, b, c) { \
242 int32_t pter = a(b); \
243 if(pter != 0) \
244 { \
245 c("FATAL ERROR: %s() failed in %s with error %d %s\n", #a, __func__, pter, strerror(pter)); \
246 } }
247
248 #define SAFE_MUTEX_LOCK(a) SAFE_PTHREAD_1ARG(pthread_mutex_lock, a, cs_log)
249 #define SAFE_MUTEX_UNLOCK(a) SAFE_PTHREAD_1ARG(pthread_mutex_unlock, a, cs_log)
250 #define SAFE_COND_SIGNAL(a) SAFE_PTHREAD_1ARG(pthread_cond_signal, a, cs_log)
251 #define SAFE_COND_BROADCAST(a) SAFE_PTHREAD_1ARG(pthread_cond_broadcast, a, cs_log)
252 #define SAFE_RWLOCK_RDLOCK(a) SAFE_PTHREAD_1ARG(pthread_rwlock_rdlock, a, cs_log)
253 #define SAFE_RWLOCK_WRLOCK(a) SAFE_PTHREAD_1ARG(pthread_rwlock_wrlock, a, cs_log)
254 #define SAFE_RWLOCK_UNLOCK(a) SAFE_PTHREAD_1ARG(pthread_rwlock_unlock, a, cs_log)
255 #define SAFE_ATTR_INIT(a) SAFE_PTHREAD_1ARG(pthread_attr_init, a, cs_log)
256 #define SAFE_MUTEXATTR_INIT(a) SAFE_PTHREAD_1ARG(pthread_mutexattr_init, a, cs_log)
257 #define SAFE_CONDATTR_INIT(a) SAFE_PTHREAD_1ARG(pthread_condattr_init, a, cs_log)
258
259 #define SAFE_MUTEX_LOCK_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_mutex_lock, a, fprintf_stderr)
260 #define SAFE_MUTEX_UNLOCK_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_mutex_unlock, a, fprintf_stderr)
261 #define SAFE_COND_SIGNAL_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_cond_signal, a, fprintf_stderr)
262 #define SAFE_MUTEX_UNLOCK_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_mutex_unlock, a, fprintf_stderr)
263 #define SAFE_ATTR_INIT_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_attr_init, a, fprintf_stderr)
264 #define SAFE_CONDATTR_INIT_NOLOG(a) SAFE_PTHREAD_1ARG(pthread_condattr_init, a, fprintf_stderr)
265
266 #define SAFE_PTHREAD_2ARG(a, b, c, d) { \
267 int32_t pter = a(b, c); \
268 if(pter != 0) \
269 { \
270 d("FATAL ERROR: %s() failed in %s with error %d %s\n", #a, __func__, pter, strerror(pter)); \
271 } }
272
273 #define SAFE_COND_WAIT(a,b) SAFE_PTHREAD_2ARG(pthread_cond_wait, a, b, cs_log)
274 #define SAFE_THREAD_JOIN(a,b) SAFE_PTHREAD_2ARG(pthread_join, a, b, cs_log)
275 #define SAFE_SETSPECIFIC(a,b) SAFE_PTHREAD_2ARG(pthread_setspecific, a, b, cs_log)
276 #define SAFE_MUTEXATTR_SETTYPE(a,b) SAFE_PTHREAD_2ARG(pthread_mutexattr_settype, a, b, cs_log)
277 #define SAFE_MUTEX_INIT(a,b) SAFE_PTHREAD_2ARG(pthread_mutex_init, a, b, cs_log)
278 #define SAFE_COND_INIT(a,b) SAFE_PTHREAD_2ARG(pthread_cond_init, a, b, cs_log)
279 #define SAFE_CONDATTR_SETCLOCK(a,b) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, cs_log)
280
281 #define SAFE_MUTEX_INIT_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_mutex_init, a, b, fprintf_stderr)
282 #define SAFE_COND_INIT_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_cond_init, a, b, fprintf_stderr)
283 #define SAFE_THREAD_JOIN_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_join, a, b, fprintf_stderr)
284 #define SAFE_CONDATTR_SETCLOCK_NOLOG(a,b) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, fprintf_stderr)
285
286 #define SAFE_PTHREAD_1ARG_R(a, b, c, d) { \
287 int32_t pter = a(b); \
288 if(pter != 0) \
289 { \
290 c("FATAL ERROR: %s() failed in %s (called from %s) with error %d %s\n", #a, __func__, d, pter, strerror(pter)); \
291 } }
292
293 #define SAFE_MUTEX_LOCK_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_lock, a, cs_log, b)
294 #define SAFE_MUTEX_UNLOCK_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_unlock, a, cs_log, b)
295 #define SAFE_COND_SIGNAL_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_cond_signal, a, cs_log, b)
296 #define SAFE_COND_BROADCAST_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_cond_broadcast, a, cs_log, b)
297 #define SAFE_CONDATTR_INIT_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_condattr_init, a, cs_log, b)
298
299 #define SAFE_MUTEX_LOCK_NOLOG_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_lock, a, fprintf_stderr, b)
300 #define SAFE_MUTEX_UNLOCK_NOLOG_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_mutex_unlock, a, fprintf_stderr, b)
301 #define SAFE_CONDATTR_INIT_NOLOG_R(a, b) SAFE_PTHREAD_1ARG_R(pthread_condattr_init, a, fprintf_stderr, b)
302
303 #define SAFE_PTHREAD_2ARG_R(a, b, c, d, e) { \
304 int32_t pter = a(b, c); \
305 if(pter != 0) \
306 { \
307 d("FATAL ERROR: %s() failed in %s (called from %s) with error %d %s\n", #a, __func__, e, pter, strerror(pter)); \
308 } }
309
310 #define SAFE_MUTEX_INIT_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_mutex_init, a, b, cs_log, c)
311 #define SAFE_COND_INIT_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_cond_init, a, b, cs_log, c)
312 #define SAFE_CONDATTR_SETCLOCK_R(a,b,c) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, cs_log, c)
313
314 #define SAFE_MUTEX_INIT_NOLOG_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_mutex_init, a, b, fprintf_stderr, c)
315 #define SAFE_COND_INIT_NOLOG_R(a,b,c) SAFE_PTHREAD_2ARG_R(pthread_cond_init, a, b, fprintf_stderr, c)
316 #define SAFE_CONDATTR_SETCLOCK_NOLOG_R(a,b,c) SAFE_PTHREAD_2ARG(pthread_condattr_setclock, a, b, fprintf_stderr, c)
317
318 #define SAFE_COND_TIMEDWAIT(a, b, c) { \
319 int32_t pter; \
320 if((c)->tv_nsec < 0) (c)->tv_nsec = 0; \
321 if((c)->tv_nsec > 999999999) (c)->tv_nsec = 999999999; \
322 pter = pthread_cond_timedwait(a, b, c); \
323 if(pter != 0 && pter != ETIMEDOUT) \
324 { \
325 cs_log("FATAL ERROR: pthread_cond_timedwait failed in %s with error %d %s\n", __func__, pter, strerror(pter)); \
326 } }
327
328 #define SAFE_COND_TIMEDWAIT_R(a, b, c, d) { \
329 int32_t pter; \
330 if((c)->tv_nsec < 0) (c)->tv_nsec = 0; \
331 if((c)->tv_nsec > 999999999) (c)->tv_nsec = 999999999; \
332 pter = pthread_cond_timedwait(a, b, c); \
333 if(pter != 0 && pter != ETIMEDOUT) \
334 { \
335 cs_log("FATAL ERROR: pthread_cond_timedwait failed in %s (called from %s) with error %d %s\n", __func__, d, pter, strerror(pter)); \
336 } }
337
338 #define SAFE_ATTR_SETSTACKSIZE(a,b) { \
339 int32_t pter = pthread_attr_setstacksize(a, b); \
340 if(pter != 0) \
341 { \
342 cs_log("WARNING: pthread_attr_setstacksize() failed in %s with error %d %s\n", __func__, pter, strerror(pter)); \
343 } }
344
345 #define SAFE_ATTR_SETSTACKSIZE_NOLOG(a,b) { \
346 int32_t pter = pthread_attr_setstacksize(a, b); \
347 if(pter != 0) \
348 { \
349 fprintf_stderr("WARNING: pthread_attr_setstacksize() failed in %s with error %d %s\n", __func__, pter, strerror(pter)); \
350 } }
351
352 #ifdef NO_PTHREAD_STACKSIZE
353 #undef SAFE_ATTR_SETSTACKSIZE
354 #undef SAFE_ATTR_SETSTACKSIZE_NOLOG
355 #define SAFE_ATTR_SETSTACKSIZE(a,b)
356 #define SAFE_ATTR_SETSTACKSIZE_NOLOG(a,b)
357 #endif
358
359 #define CHECK_BIT(var,pos) (((var) & (1<<(pos)))? 1 : 0)
360
361 /* ===========================
362 * constants
363 * =========================== */
364 #define CS_VERSION "1.20-unstable_svn"
365 #ifndef CS_SVN_VERSION
366 # define CS_SVN_VERSION "test"
367 #endif
368 #ifndef CS_TARGET
369 # define CS_TARGET "unknown"
370 #endif
371 #ifndef CS_CONFDIR
372 #define CS_CONFDIR "/usr/local/etc"
373 #endif
374 #ifndef CS_LOGFILE
375 #define CS_LOGFILE "/var/log/oscam.log"
376 #endif
377 #define CS_QLEN 128 // size of request queue
378 #define CS_MAXPROV 32
379 #define CS_MAXPORTS 32 // max server ports
380 #define CS_CLIENT_HASHBUCKETS 32
381 #define CS_SERVICENAME_SIZE 32
382
383 #define CS_ECMSTORESIZE 16 // use MD5()
384 #define CS_EMMSTORESIZE 16 // use MD5()
385 #define CS_CLIENT_TIMEOUT 5000
386 #define CS_CLIENT_MAXIDLE 120
387 #define CS_BIND_TIMEOUT 120
388 #define CS_DELAY 0
389 #define CS_ECM_RINGBUFFER_MAX 0x10 // max size for ECM last responsetimes ringbuffer. Keep this set to power of 2 values!
390
391 // Support for multiple CWs per channel and other encryption algos
392 //#define WITH_EXTENDED_CW 1
393
394 #if defined(READER_DRE) || defined(READER_DRECAS) || defined(READER_VIACCESS)
395 #define MAX_ECM_SIZE 1024
396 #define MAX_EMM_SIZE 1024
397 #else
398 #define MAX_ECM_SIZE 596
399 #define MAX_EMM_SIZE 512
400 #endif
401
402 #define CS_EMMCACHESIZE 512 //nr of EMMs that each reader will cache
403 #define MSGLOGSIZE 64 //size of string buffer for a ecm to return messages
404
405 #define D_TRACE 0x0001 // Generate very detailed error/trace messages per routine
406 #define D_ATR 0x0002 // Debug ATR parsing, dump of ecm, cw
407 #define D_READER 0x0004 // Debug Reader/Proxy Process
408 #define D_CLIENT 0x0008 // Debug Client Process
409 #define D_IFD 0x0010 // Debug IFD+protocol
410 #define D_DEVICE 0x0020 // Debug Reader I/O
411 #define D_EMM 0x0040 // Dumps EMM
412 #define D_DVBAPI 0x0080 // Debug DVBAPI
413 #define D_LB 0x0100 // Debug Loadbalancer/ECM handler
414 #define D_CACHEEX 0x0200 // Debug CACHEEX
415 #define D_CLIENTECM 0x0400 // Debug Client ECMs
416 #define D_CSP 0x0800 // Debug CSP
417 #define D_CWC 0x1000 // Debug CWC
418 #define D_ALL_DUMP 0xFFFF // dumps all
419
420 #define MAX_DEBUG_LEVELS 13
421
422 #define R_DB2COM1 0x1 // Reader Dbox2 @ com1
423 #define R_DB2COM2 0x2 // Reader Dbox2 @ com1
424 #define R_SC8in1 0x3 // Reader Sc8in1 or MCR
425 #define R_MP35 0x4 // AD-Teknik Multiprogrammer 3.5 and 3.6 (only usb tested)
426 #define R_MOUSE 0x5 // Reader smartcard mouse
427 /////////////////// phoenix readers which need baudrate setting and timings need to be guarded by OSCam: BEFORE R_MOUSE
428 #define R_INTERNAL 0x6 // Reader smartcard intern
429 /////////////////// internal readers (Dreambox, Coolstream, IPBox) are all R_INTERNAL, they are determined compile-time
430 /////////////////// readers that do not reed baudrate setting and timings are guarded by reader itself (large buffer built in): AFTER R_SMART
431 #define R_SMART 0x7 // Smartreader+
432 #define R_PCSC 0x8 // PCSC
433 #define R_DRECAS 0x9 // Reader DRECAS
434 /////////////////// proxy readers after R_CS378X
435 #define R_CAMD35 0x20 // Reader cascading camd 3.5x
436 #define R_CAMD33 0x21 // Reader cascading camd 3.3x
437 #define R_NEWCAMD 0x22 // Reader cascading newcamd
438 #define R_RADEGAST 0x23 // Reader cascading radegast
439 #define R_CS378X 0x24 // Reader cascading camd 3.5x TCP
440 #define R_CONSTCW 0x25 // Reader for Constant CW
441 #define R_CSP 0x26 // Cache CSP
442 #define R_GHTTP 0x27 // Reader ghttp
443 #define R_SCAM 0x28 // Reader cascading scam
444 /////////////////// peer to peer proxy readers after R_CCCAM
445 #define R_GBOX 0x30 // Reader cascading gbox
446 #define R_CCCAM 0x35 // Reader cascading cccam
447 #define R_PANDORA 0x36 // Reader cascading pandora
448 #define R_SERIAL 0x80 // Reader serial
449 #define R_IS_NETWORK 0x60
450 #define R_IS_CASCADING 0xE0
451
452 #define is_network_reader(__X) (__X->typ & R_IS_NETWORK)
453 #define is_cascading_reader(__X) (__X->typ & R_IS_CASCADING)
454 #define is_smargo_reader(__X) (__X->crdr && strcmp(__X->crdr->desc, "smargo") == 0)
455
456 //ECM rc codes:
457 #define E_FOUND 0
458 #define E_CACHE1 1
459 #define E_CACHE2 2
460 #define E_CACHEEX 3
461 ///////above is all found
462 #define E_NOTFOUND 4 //for selection of found, use < E_NOTFOUND
463 #define E_TIMEOUT 5
464 #define E_SLEEPING 6
465 #define E_FAKE 7
466 #define E_INVALID 8
467 #define E_CORRUPT 9
468 #define E_NOCARD 10
469 #define E_EXPDATE 11
470 #define E_DISABLED 12
471 #define E_STOPPED 13 //for selection of error, use <= E_STOPPED and exclude selection of found
472 ///////above is all notfound, some error or problem
473 #define E_ALREADY_SENT 101
474 #define E_WAITING 102
475 #define E_99 99 //this code is undocumented
476 #define E_UNHANDLED 100 //for selection of unhandled, use >= E_UNHANDLED
477
478 #define CS_MAX_MOD 20
479 #define MOD_CONN_TCP 1
480 #define MOD_CONN_UDP 2
481 #define MOD_CONN_NET 3
482 #define MOD_CONN_SERIAL 4
483 #define MOD_NO_CONN 8
484
485 #define EMM_UNIQUE 1
486 #define EMM_SHARED 2
487 #define EMM_GLOBAL 4
488 #define EMM_UNKNOWN 8
489
490 //Listener Types
491 #define LIS_CAMD33TCP 1
492 #define LIS_CAMD35UDP 2
493 #define LIS_CAMD35TCP 4
494 #define LIS_NEWCAMD 8
495 #define LIS_CCCAM 16
496 #define LIS_GBOX 32
497 #define LIS_RADEGAST 64
498 #define LIS_DVBAPI 128
499 #define LIS_CONSTCW 256
500 #define LIS_SERIAL 1024
501 #define LIS_CSPUDP 2048
502 #define LIS_SCAM 4096
503
504 //EMM types:
505 #define UNKNOWN 0
506 #define UNIQUE 1
507 #define SHARED 2
508 #define GLOBAL 3
509
510 #define NCD_AUTO 0
511 #define NCD_524 1
512 #define NCD_525 2
513
514 // moved from reader-common.h
515 #define UNKNOWN 0
516 #define CARD_NEED_INIT 1
517 #define CARD_INSERTED 2
518 #define CARD_FAILURE 3
519 #define NO_CARD 4
520 #define READER_DEVICE_ERROR 5
521
522 // moved from stats
523 #define DEFAULT_REOPEN_SECONDS 30
524 #define DEFAULT_MIN_ECM_COUNT 5
525 #define DEFAULT_MAX_ECM_COUNT 500
526 #define DEFAULT_NBEST 1
527 #define DEFAULT_NFB 1
528 #define DEFAULT_RETRYLIMIT 0
529 #define DEFAULT_LB_MODE 0
530 #define DEFAULT_LB_STAT_CLEANUP 336
531 #define DEFAULT_UPDATEINTERVAL 240
532 #define DEFAULT_LB_AUTO_BETATUNNEL 1
533 #define DEFAULT_LB_AUTO_BETATUNNEL_MODE 0
534 #define DEFAULT_LB_AUTO_BETATUNNEL_PREFER_BETA 50
535
536 #define DEFAULT_MAX_CACHE_TIME 15
537 #define DEFAULT_MAX_HITCACHE_TIME 15
538
539 #define DEFAULT_LB_AUTO_TIMEOUT 0
540 #define DEFAULT_LB_AUTO_TIMEOUT_P 30
541 #define DEFAULT_LB_AUTO_TIMEOUT_T 300
542
543 enum {E1_GLOBAL = 0, E1_USER, E1_READER, E1_SERVER, E1_LSERVER};
544
545 //LB blocking events:
546 enum {E2_GLOBAL = 0, E2_GROUP, E2_CAID, E2_IDENT, E2_CLASS, E2_CHID, E2_QUEUE, E2_OFFLINE,
547 E2_SID, E2_CCCAM_NOCARD,
548 //From here only LB nonblocking events:
549 E2_CCCAM_NOK1, E2_CCCAM_NOK2, E2_CCCAM_LOOP, E2_WRONG_CHKSUM, E2_RATELIMIT
550 };
551
552 #define LB_NONBLOCK_E2_FIRST E2_CCCAM_NOK1
553
554 #define CTA_RES_LEN 512
555
556 #define MAX_ATR_LEN 33 // max. ATR length
557 #define MAX_HIST 15 // max. number of historical characters
558
559 #define MAX_SIDBITS 64 // max services
560 #define SIDTABBITS uint64_t // 64bit type for services, if a system does not support this type,
561 // please use a define and define it as uint32_t / MAX_SIDBITS 32
562
563 #define BAN_UNKNOWN 1 // Failban mask for anonymous/ unknown contact
564 #define BAN_DISABLED 2 // Failban mask for Disabled user
565 #define BAN_SLEEPING 4 // Failban mask for sleeping user
566 #define BAN_DUPLICATE 8 // Failban mask for duplicate user
567
568 #define MAX_HTTP_DYNDNS 3 // maximum allowed Dyndns addresses for webif access
569
570 #define CHECK_WAKEUP 1
571 #define CHECK_ANTICASCADER 2
572 #define CHECK_ECMCACHE 3
573
574 #define AVAIL_CHECK_CONNECTED 0
575 #define AVAIL_CHECK_LOADBALANCE 1
576
577 #define ECM_FMT_LEN 109 //64
578 #define CXM_FMT_LEN 209 // 160
579
580 #define LB_MAX_STAT_TIME 10
581
582 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__)
583 #define OSCAM_SIGNAL_WAKEUP SIGCONT
584 #else
585 #define OSCAM_SIGNAL_WAKEUP SIGRTMAX-2
586 #endif
587
588 #define READER_ACTIVE 0x01
589 #define READER_FALLBACK 0x02
590 #define READER_LOCAL 0x04
591 #define READER_CACHEEX 0x08
592
593 #define REQUEST_SENT 0x10
594 #define REQUEST_ANSWERED 0x20
595
596 #define CW_MODE_ONE_CW 0
597 #define CW_MODE_MULTIPLE_CW 1
598 #define CW_TYPE_VIDEO 0
599 #define CW_TYPE_AUDIO 1
600 #define CW_TYPE_DATA 2
601 #define CW_ALGO_CSA 0
602 #define CW_ALGO_DES 1
603 #define CW_ALGO_AES128 2
604 #define CW_ALGO_MODE_ECB 0
605 #define CW_ALGO_MODE_CBC 1
606
607 #define SIZE_SHORTDAY 8
608 #define MAXALLOWEDTF 1001 // 10 allowed time frame slots for everyday + all [(3 + 1 + 10*(12) + 1)*8]
609 extern const char *shortDay[SIZE_SHORTDAY];
610 extern const char *weekdstr;
611
612 /* ===========================
613 * Default Values
614 * =========================== */
615 #define DEFAULT_INACTIVITYTIMEOUT 0
616 #define DEFAULT_TCP_RECONNECT_TIMEOUT 30
617 #define DEFAULT_NCD_KEEPALIVE 0
618
619 #define DEFAULT_CC_MAXHOPS 10
620 #define DEFAULT_CC_RESHARE -1 // Use global cfg
621 #define DEFAULT_CC_IGNRSHR -1 // Use global cfg
622 #define DEFAULT_CC_STEALTH -1 // Use global cfg
623 #define DEFAULT_CC_KEEPALIVE 0
624 #define DEFAULT_CC_RECONNECT 12000
625 #define DEFAULT_CC_RECV_TIMEOUT 2000
626
627 #define DEFAULT_AC_USERS -1 // Use global cfg
628 #define DEFAULT_AC_PENALTY -1 // Use global cfg
629
630 // Return MPEG section length
631 #define SCT_LEN(sct) (3+((sct[1]&0x0f)<<8)+sct[2])
632 // Used by readers
633 #define MAX_LEN 256
634
635 #define NO_CAID_VALUE 0xfffe
636 #define NO_PROVID_VALUE 0xfffffe
637 #define NO_SRVID_VALUE 0xfffe
638
639 // If NULL return empty string
640 #define ESTR(x) ((x) ? (x) : "")
641
642 #ifndef MAX
643 #define MAX(a,b) ((a) > (b) ? (a) : (b))
644 #endif
645
646 #ifndef MIN
647 #define MIN(a,b) ((a) < (b) ? (a) : (b))
648 #endif
649
650 /*
651 See: http://stackoverflow.com/questions/10269685/kernels-container-of-any-way-to-make-it-iso-conforming
652 http://www.kroah.com/log/linux/container_of.html
653 */
654 #define container_of(ptr, type, member) \
655 ((type *) ((char *) (ptr) - offsetof(type, member) + \
656 (&((type *) 0)->member == (ptr)) * 0))
657
658 /* ===========================
659 * global structures
660 * =========================== */
661 struct timeb
662 {
663 time_t time;
664 int64_t millitm;
665 };
666
667 typedef struct cs_mutexlock
668 {
669 int32_t timeout;
670 pthread_mutex_t lock;
671 pthread_cond_t writecond, readcond;
672 const char *name;
673 int8_t flag;
674 int16_t writelock, readlock;
675 } CS_MUTEX_LOCK;
676
677 #include "oscam-llist.h"
678
679 typedef struct s_caidvaluetab_data
680 {
681 uint16_t caid;
682 uint16_t value;
683 } CAIDVALUETAB_DATA;
684
685 typedef struct s_caidvaluetab
686 {
687 int32_t cvnum;
688 CAIDVALUETAB_DATA *cvdata;
689 } CAIDVALUETAB;
690
691 typedef struct s_classtab
692 {
693 uchar an;
694 uchar bn;
695 uchar *aclass;
696 uchar *bclass;
697 } CLASSTAB;
698
699 typedef struct s_caidtab_data
700 {
701 uint16_t caid;
702 uint16_t mask;
703 uint16_t cmap;
704 } CAIDTAB_DATA;
705
706 typedef struct s_caidtab
707 {
708 int32_t ctnum;
709 CAIDTAB_DATA *ctdata;
710 } CAIDTAB;
711
712 typedef struct s_tuntab_data
713 {
714 uint16_t bt_caidfrom;
715 uint16_t bt_caidto;
716 uint16_t bt_srvid;
717 } TUNTAB_DATA;
718
719 typedef struct s_tuntab
720 {
721 int32_t ttnum;
722 TUNTAB_DATA *ttdata;
723 } TUNTAB;
724
725 typedef struct s_sidtab
726 {
727 char label[64];
728 uint16_t num_caid;
729 uint16_t num_provid;
730 uint16_t num_srvid;
731 uint16_t *caid;
732 uint32_t *provid;
733 uint16_t *srvid;
734 struct s_sidtab *next;
735 } SIDTAB;
736
737 typedef struct s_filter
738 {
739 uint16_t caid;
740 uchar nprids;
741 uint32_t prids[CS_MAXPROV];
742 } FILTER;
743
744 typedef struct s_ftab
745 {
746 int32_t nfilts;
747 FILTER *filts;
748 } FTAB;
749
750 typedef struct s_ncd_ftab
751 {
752 int32_t nfilts;
753 FILTER filts[16];
754 } NCD_FTAB;
755
756 struct ncd_port
757 {
758 bool ncd_key_is_set;
759 uint8_t ncd_key[14];
760 NCD_FTAB ncd_ftab;
761 };
762
763 typedef struct s_port
764 {
765 int32_t fd;
766 int32_t s_port;
767 struct ncd_port *ncd; // newcamd specific settings
768 } PORT;
769
770 typedef struct s_ptab
771 {
772 int32_t nports;
773 PORT ports[CS_MAXPORTS];
774 } PTAB;
775
776 typedef struct aes_entry
777 {
778 uint16_t keyid;
779 uint16_t caid;
780 uint32_t ident;
781 uchar plainkey[16];
782 AES_KEY key;
783 struct aes_entry *next;
784 } AES_ENTRY;
785
786 struct aes_keys
787 {
788 AES_KEY aeskey_encrypt; // encryption key needed by monitor and used by camd33, camd35
789 AES_KEY aeskey_decrypt; // decryption key needed by monitor and used by camd33, camd35
790 };
791
792 struct s_ecm
793 {
794 uchar ecmd5[CS_ECMSTORESIZE];
795 uchar cw[16];
796 uint16_t caid;
797 uint64_t grp;
798 struct s_reader *reader;
799 int32_t rc;
800 time_t time;
801 };
802
803 struct s_emmstat
804 {
805 uchar emmd5[CS_EMMSTORESIZE];
806 uchar type;
807 int32_t count;
808 struct timeb firstwritten;
809 struct timeb lastwritten;
810 };
811
812 struct s_emmcache
813 {
814 uchar emmd5[CS_EMMSTORESIZE];
815 uchar type;
816 uint16_t len;
817 uchar emm[MAX_EMM_SIZE];
818 struct timeb firstseen;
819 struct timeb lastseen;
820 };
821
822 struct s_csystem_emm_filter
823 {
824 uint8_t type;
825 uint8_t enabled;
826 uint8_t filter[16];
827 uint8_t mask[16];
828 };
829
830 typedef struct v_ban // Failban listmember
831 {
832 int32_t v_count;
833 IN_ADDR_T v_ip;
834 int32_t v_port;
835 struct timeb v_time;
836 bool acosc_entry;
837 int32_t acosc_penalty_dur;
838 char *info;
839 } V_BAN;
840
841 typedef struct s_cacheex_stat_entry // Cacheex stats listmember
842 {
843 int32_t cache_count;
844 time_t cache_last;
845 uint16_t cache_caid;
846 uint16_t cache_srvid;
847 uint32_t cache_prid;
848 int8_t cache_direction; // 0 = push / 1 = got
849 } S_CACHEEX_STAT_ENTRY;
850
851 typedef struct s_entitlement // contains entitlement Info
852 {
853 uint64_t id; // the element ID
854 uint32_t type; // enumerator for tier,chid whatever
855 // 0="", 1="Package", 2="PPV-Event", 3="chid", 4="tier", 5 = "class", 6 = "PBM". 7 = "seca-admin"
856 uint16_t caid; // the caid of element
857 uint32_t provid; // the provid of element
858 uint32_t class; // the class needed for some systems
859 time_t start; // startdate
860 time_t end; // enddate
861 } S_ENTITLEMENT;
862
863 struct s_client ;
864 struct ecm_request_t ;
865 struct emm_packet_t ;
866 struct s_ecm_answer ;
867 struct demux_s ;
868
869 #define DEFAULT_MODULE_BUFSIZE 1024
870
871 struct s_module
872 {
873 const char *desc;
874 int8_t type;
875 int8_t large_ecm_support;
876 int16_t listenertype;
877 //int32_t s_port;
878 IN_ADDR_T s_ip;
879 uint16_t bufsize;
880 void *(*s_handler)(struct s_client *, uchar *, int32_t);
881 void (*s_init)(struct s_client *);
882 int32_t (*recv)(struct s_client *, uchar *, int32_t);
883 void (*send_dcw)(struct s_client *, struct ecm_request_t *);
884 void (*cleanup)(struct s_client *);
885 int32_t (*c_recv_chk)(struct s_client *, uchar *, int32_t *, uchar *, int32_t);
886 int32_t (*c_init)(struct s_client *);
887 int32_t (*c_send_ecm)(struct s_client *, struct ecm_request_t *);
888 int32_t (*c_send_emm)(struct emm_packet_t *);
889 int32_t (*c_available)(struct s_reader *, int32_t, struct ecm_request_t *); //Schlocke: available check for load-balancing,
890 // params:
891 // rdr (reader to check)
892 // int32_t checktype (0=return connected, 1=return loadbalance-avail) return int
893 void (*c_idle)(void); // Schlocke: called when reader is idle
894 void (*s_idle)(struct s_client *);
895 void (*s_peer_idle)(struct s_client *);
896 void (*c_card_info)(void); // Schlocke: request card infos
897
898 int32_t (*c_capmt)(struct s_client *, struct demux_s *);
899
900 #ifdef CS_CACHEEX
901 int32_t (*c_cache_push)(struct s_client *, struct ecm_request_t *); //Cache push
902 int32_t (*c_cache_push_chk)(struct s_client *, struct ecm_request_t *); //Cache push Node Check, 0=no push
903 #endif
904 int32_t c_port;
905 PTAB ptab;
906 int32_t num;
907 };
908
909 struct s_ATR ;
910
911 struct s_cardreader_settings
912 {
913 uint32_t ETU;
914 uint32_t EGT;
915 unsigned char P;
916 uint32_t I;
917 uint32_t F;
918 uint32_t Fi;
919 unsigned char Di;
920 unsigned char Ni;
921 uint32_t WWT;
922 uint32_t BGT;
923 uint8_t D;
924 };
925
926 struct s_cardreader
927 {
928 const char *desc;
929 int32_t (*reader_init)(struct s_reader *);
930 int32_t (*get_status)(struct s_reader *, int *);
931 int32_t (*activate)(struct s_reader *, struct s_ATR *);
932 int32_t (*transmit)(struct s_reader *, unsigned char *sent, uint32_t size, uint32_t expectedlen, uint32_t delay, uint32_t timeout);
933 int32_t (*receive)(struct s_reader *, unsigned char *data, uint32_t size, uint32_t delay, uint32_t timeout);
934 int32_t (*lock_init)(struct s_reader *);
935 void (*lock)(struct s_reader *);
936 void (*unlock)(struct s_reader *);
937 int32_t (*close)(struct s_reader *);
938 int32_t (*set_parity)(struct s_reader *, uchar parity);
939 int32_t (*write_settings)(struct s_reader *, struct s_cardreader_settings *s);
940 int32_t (*set_protocol)(struct s_reader *,
941 unsigned char *params,
942 uint32_t *length,
943 uint32_t len_request);
944 int32_t (*set_baudrate)(struct s_reader *,
945 uint32_t baud); //set only for readers which need baudrate setting and timings need to be guarded by OSCam
946 int32_t (*card_write)(struct s_reader *pcsc_reader,
947 const uchar *buf,
948 unsigned char *cta_res,
949 uint16_t *cta_lr,
950 int32_t l);
951 void (*display_msg)(struct s_reader *, char *msg);
952
953 int32_t (*do_reset)(struct s_reader *, struct s_ATR *,
954 int32_t (*rdr_activate_card)(struct s_reader *, struct s_ATR *, uint16_t deprecated),
955 int32_t (*rdr_get_cardsystem)(struct s_reader *, struct s_ATR *));
956
957 bool (*set_DTS_RTS)(struct s_reader *, int32_t *dtr, int32_t *rts);
958
959 int32_t typ; // fixme: workaround, remove when all old code is converted
960
961 int8_t max_clock_speed; // 1 for reader->typ > R_MOUSE
962 int8_t need_inverse; // 0 = reader does inversing; 1 = inversing done by oscam
963 //io_serial config
964 int8_t flush;
965 int8_t read_written; // 1 = written bytes has to read from device
966 bool skip_extra_atr_parsing;
967 bool skip_t1_command_retries;
968 bool skip_setting_ifsc;
969 };
970
971 struct s_cardsystem
972 {
973 const char *desc;
974 const uint16_t *caids;
975 int32_t (*card_init)(struct s_reader *reader, struct s_ATR *);
976 void (*card_done)(struct s_reader *reader);
977 int32_t (*card_info)(struct s_reader *);
978 void (*poll_status)(struct s_reader *);
979 int32_t (*do_ecm)(struct s_reader *, const struct ecm_request_t *, struct s_ecm_answer *);
980 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
981 int32_t (*do_emm)(struct s_reader *, struct emm_packet_t *);
982 void (*post_process)(struct s_reader *);
983 int32_t (*get_emm_type)(struct emm_packet_t *, struct s_reader *);
984 int32_t (*get_emm_filter)(struct s_reader *, struct s_csystem_emm_filter **, unsigned int *);
985 int32_t (*get_tunemm_filter)(struct s_reader *, struct s_csystem_emm_filter **, unsigned int *);
986 };
987
988 #ifdef WITH_EXTENDED_CW
989 typedef struct cw_extendted_t
990 {
991 uchar mode;
992 uchar audio[4][16];
993 uchar data[16];
994 uchar algo;
995 uchar algo_mode;
996 } EXTENDED_CW;
997 #else
998 typedef struct cw_extendted_t
999 {
1000 uchar disabled;
1001 } EXTENDED_CW;
1002 #endif
1003
1004 typedef struct ecm_request_t
1005 {
1006 uchar ecm[MAX_ECM_SIZE];
1007 uchar cw[16];
1008 EXTENDED_CW cw_ex;
1009 uchar ecmd5[CS_ECMSTORESIZE];
1010 int16_t ecmlen;
1011 uint16_t caid;
1012 uint16_t ocaid; //original caid, used for betatunneling
1013 uint16_t srvid;
1014 uint16_t onid;
1015 uint16_t tsid;
1016 uint16_t pmtpid;
1017 uint32_t ens; // enigma namespace
1018 uint32_t vpid; // videopid
1019 uint16_t chid;
1020 uint16_t pid;
1021 uint16_t idx;
1022 uint32_t prid;
1023 struct s_reader *selected_reader;
1024 struct s_ecm_answer *matching_rdr; //list of matching readers
1025 const struct s_reader *fallback; //fallback is the first fallback reader in the list matching_rdr
1026 struct s_client *client; //contains pointer to 'c' client while running in 'r' client
1027 uint64_t grp;
1028 int32_t msgid; // client pending table index
1029 uint8_t stage; // processing stage in server module
1030 int8_t rc;
1031 uint8_t rcEx;
1032 struct timeb tps; // incoming time stamp
1033 int8_t btun; // mark er as betatunneled
1034 uint16_t reader_avail; // count of available readers for ecm
1035 uint16_t readers; // count of available used readers for ecm
1036 uint16_t reader_requested; // count of real requested readers
1037 uint16_t localreader_count; // count of selected local readers
1038 uint16_t cacheex_reader_count; // count of selected cacheex mode-1 readers
1039 uint16_t fallback_reader_count; // count of selected fb readers
1040 uint16_t reader_count; // count of selected not fb readers
1041 int8_t preferlocalcards;
1042 int8_t checked; //for doublecheck
1043 uchar cw_checked[16]; //for doublecheck
1044 int8_t readers_timeout_check; // set to 1 after ctimeout occurs and readers not answered are checked
1045 struct s_reader *origin_reader;
1046
1047 #if defined MODULE_CCCAM
1048 void *origin_card; // CCcam preferred card!
1049 #endif
1050
1051 #if defined MODULE_GBOX
1052 uint32_t gbox_crc; // rcrc for gbox, used to identify ECM task in peer responses
1053 uint16_t gbox_ecm_id;
1054 uint8_t gbox_ecm_status;
1055 LLIST *gbox_cards_pending; //type gbox_card_pending
1056 #endif
1057
1058 void *src_data;
1059 uint32_t csp_hash; // csp has its own hash
1060
1061 struct s_client *cacheex_src; // Cacheex origin
1062 #ifdef CS_CACHEEX
1063 int8_t cacheex_pushed; // to avoid duplicate pushs
1064 uint8_t csp_answered; // =1 if er get answer by csp
1065 LLIST *csp_lastnodes; // last 10 Cacheex nodes atm cc-proto-only
1066 uint32_t cacheex_wait_time; // cacheex wait time in ms
1067 uint8_t cacheex_wait_time_expired; // =1 if cacheex wait_time expires
1068 uint16_t cacheex_mode1_delay; // cacheex mode 1 delay
1069 uint8_t cacheex_hitcache; // =1 if wait_time due hitcache
1070 void *cw_cache; //pointer to cw stored in cache
1071 #endif
1072 uint32_t cw_count;
1073 uint8_t from_csp; // =1 if er from csp cache
1074 uint8_t from_cacheex; // =1 if er from cacheex client pushing cache
1075 uint8_t from_cacheex1_client; // =1 if er from cacheex-1 client
1076 char msglog[MSGLOGSIZE];
1077 uint8_t cwc_cycletime;
1078 uint8_t cwc_next_cw_cycle;
1079 #ifdef CW_CYCLE_CHECK
1080 char cwc_msg_log[MSGLOGSIZE];
1081 #endif
1082 #ifdef WITH_STAPI5
1083 char dev_name[20];
1084 #endif
1085 struct ecm_request_t *parent;
1086 struct ecm_request_t *next;
1087 #ifdef HAVE_DVBAPI
1088 uint8_t adapter_index;
1089 #endif
1090 } ECM_REQUEST;
1091
1092
1093 struct s_ecm_answer
1094 {
1095 uint8_t status;
1096 struct s_reader *reader;
1097 ECM_REQUEST *er;
1098 int8_t rc;
1099 uint8_t rcEx;
1100 uchar cw[16];
1101 EXTENDED_CW cw_ex;
1102 char msglog[MSGLOGSIZE];
1103 struct timeb time_request_sent; //using for evaluate ecm_time
1104 int32_t ecm_time;
1105 uint16_t tier; //only filled by local videoguard reader atm
1106 #ifdef WITH_LB
1107 int32_t value;
1108 int32_t time;
1109 #endif
1110 struct s_ecm_answer *next;
1111 CS_MUTEX_LOCK ecmanswer_lock;
1112 struct s_ecm_answer *pending;
1113 struct s_ecm_answer *pending_next;
1114 bool is_pending;
1115 };
1116
1117 struct s_acasc_shm
1118 {
1119 uint16_t ac_count : 15;
1120 uint16_t ac_deny : 1;
1121 };
1122
1123 struct s_acasc
1124 {
1125 uint16_t stat[10];
1126 uchar idx; // current active index in stat[]
1127 };
1128
1129 struct s_cwresponse
1130 {
1131 int32_t duration;
1132 time_t timestamp;
1133 int32_t rc;
1134 };
1135
1136 struct s_cascadeuser
1137 {
1138 uint16_t caid;
1139 uint32_t prid;
1140 uint16_t srvid;
1141 time_t time;
1142 int8_t cwrate;
1143 };
1144
1145 typedef struct sidtabs
1146 {
1147 SIDTABBITS ok; // positive services
1148 SIDTABBITS no; // negative services
1149 } SIDTABS;
1150
1151 struct s_zap_list
1152 {
1153 uint16_t caid;
1154 uint32_t provid;
1155 uint16_t chid;
1156 uint16_t sid;
1157 int8_t request_stage;
1158 time_t lasttime;
1159 };
1160
1161 // EMM reassemply
1162 struct emm_rass
1163 {
1164 int16_t emmlen;
1165 int32_t provid;
1166 uint8_t emm[MAX_EMM_SIZE];
1167 };
1168
1169 struct s_client
1170 {
1171 uint32_t tid;
1172 int8_t init_done;
1173 pthread_mutex_t thread_lock;
1174 int8_t thread_active;
1175 int8_t kill;
1176 int8_t kill_started;
1177 LLIST *joblist;
1178 IN_ADDR_T ip;
1179 in_port_t port;
1180 time_t login; // connection
1181 time_t logout; // disconnection
1182 time_t last;
1183 time_t lastswitch;
1184 time_t lastemm;
1185 time_t lastecm;
1186 time_t expirationdate;
1187 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
1188 uint8_t allowedtimeframe_set; //flag for internal use to mention if allowed time frame is used
1189 int8_t c35_suppresscmd08;
1190 uint8_t c35_sleepsend;
1191 int8_t ncd_keepalive;
1192 int8_t disabled;
1193 uint64_t grp;
1194 int8_t crypted;
1195 int8_t dup;
1196 LLIST *aureader_list;
1197 int8_t autoau;
1198 LLIST *ra_buf; // EMM reassembly buffer for viaccess
1199 struct emm_rass *cw_rass; // EMM reassembly buffer for cryptoworks
1200 int8_t monlvl;
1201 CAIDTAB ctab;
1202 TUNTAB ttab;
1203 SIDTABS sidtabs;
1204 SIDTABS lb_sidtabs;
1205 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
1206 uint8_t module_idx;
1207 uint16_t last_srvid;
1208 uint32_t last_provid;
1209 uint16_t last_caid;
1210 struct s_provid *last_providptr;
1211 struct s_srvid *last_srvidptr;
1212 uint32_t last_srvidptr_search_provid;
1213 int32_t tosleep;
1214 struct s_auth *account;
1215 int32_t udp_fd;
1216 struct SOCKADDR udp_sa;
1217 socklen_t udp_sa_len;
1218 int8_t tcp_nodelay;
1219 int8_t log;
1220 int32_t logcounter;
1221 int32_t cwfound; // count found ECMs per client
1222 int32_t cwcache; // count ECMs from cache1/2 per client
1223 int32_t cwnot; // count not found ECMs per client
1224 int32_t cwtun; // count betatunneled ECMs per client
1225 int32_t cwignored; // count ignored ECMs per client
1226 int32_t cwtout; // count timeouted ECMs per client
1227 int32_t cwlastresptime; // last Responsetime (ms)
1228 #ifdef CW_CYCLE_CHECK
1229 int32_t cwcycledchecked; // count checked cwcycles per client
1230 int32_t cwcycledok; // count pos checked cwcycles per client
1231 int32_t cwcyclednok; // count neg checked cwcycles per client
1232 int32_t cwcycledign; // count ign cwcycles per client
1233 #endif
1234 int32_t emmok; // count EMM ok
1235 int32_t emmnok; // count EMM nok
1236 int8_t pending; // number of ECMs pending
1237 #ifdef CS_CACHEEX
1238 int32_t cwcacheexpush; // count pushed ecms/cws
1239 int32_t cwcacheexgot; // count got ecms/cws
1240 int32_t cwcacheexhit; // count hit ecms/cws
1241 LLIST *ll_cacheex_stats; // list for Cacheex statistics
1242 int8_t cacheex_maxhop;
1243 int32_t cwcacheexerr; // cw=00 or chksum wrong
1244 int32_t cwcacheexerrcw; // same Hex, different CW
1245 int16_t cwcacheexping; // peer ping in ms, only used by csp
1246 int32_t cwc_info; // count of in/out comming cacheex ecms with CWCinfo
1247 uint8_t cacheex_needfilter; // flag for cachex mode 3 used with camd35
1248 #endif
1249 #ifdef CS_ANTICASC
1250 struct s_zap_list client_zap_list[15]; //15 last zappings from client used for ACoSC
1251 #endif
1252 #ifdef WEBIF
1253 struct s_cwresponse cwlastresptimes[CS_ECM_RINGBUFFER_MAX]; //ringbuffer for last 20 times
1254 int32_t cwlastresptimes_last; // ringbuffer pointer
1255 int8_t wihidden; // hidden in webinterface status
1256 char lastreader[64]; // last cw got from this reader
1257 #endif
1258
1259 uchar ucrc[4]; // needed by monitor and used by camd35
1260 uint32_t pcrc; // password crc
1261 struct aes_keys *aes_keys; // used by camd33 and camd35
1262 uint16_t ncd_msgid;
1263 uint16_t ncd_client_id;
1264 uchar ncd_skey[16]; //Also used for camd35 Cacheex to store remote node id
1265
1266 #ifdef MODULE_CCCAM
1267 void *cc;
1268 #endif
1269
1270 #ifdef MODULE_GBOX
1271 void *gbox;
1272 uint16_t gbox_peer_id;
1273 #endif
1274
1275 #ifdef MODULE_GHTTP
1276 void *ghttp;
1277 #endif
1278
1279 int32_t port_idx; // index in server ptab
1280 int32_t ncd_server; // newcamd server
1281
1282 #ifdef CS_ANTICASC
1283 int32_t ac_fakedelay; // When this is -1, the global ac_fakedelay is used
1284 uint16_t ac_limit;
1285 int8_t ac_penalty;
1286 struct s_acasc_shm acasc;
1287 #endif
1288
1289 FTAB fchid;
1290 FTAB ftab; // user [caid] and ident filter
1291 CLASSTAB cltab;
1292
1293 int32_t pfd; // Primary FD, must be closed on exit
1294 struct s_reader *reader; // points to s_reader when cl->typ='r'
1295
1296 ECM_REQUEST *ecmtask;
1297
1298 pthread_t thread;
1299
1300 #ifdef MODULE_SERIAL
1301 struct s_serial_client *serialdata;
1302 #endif
1303 //reader common
1304 int32_t last_idx;
1305 uint16_t idx;
1306
1307 int8_t ncd_proto;
1308 uint8_t ncd_header[12];
1309
1310 //camd35
1311 uchar upwd[64];
1312 int8_t is_udp;
1313 int8_t stopped;
1314 uint16_t lastcaid;
1315 uint16_t lastsrvid;
1316 int32_t lastpid;
1317 int8_t disable_counter;
1318 uchar lastserial[8];
1319
1320 // Failban value set bitwise - compared with BAN_
1321 int32_t failban;
1322
1323 LLIST *cascadeusers; //s_cascadeuser
1324
1325 int32_t n_request[2]; //count for number of request per minute by client
1326
1327 void *work_mbuf; // Points to local data allocated in work_thread when the thread is running
1328 void *work_job_data; // Points to current job_data when work_thread is running
1329
1330 #ifdef MODULE_PANDORA
1331 int32_t pand_autodelay;
1332 uint8_t pand_send_ecm;
1333 uchar pand_ignore_ecm;
1334 uchar pand_md5_key[16];
1335 #endif
1336
1337 #ifdef MODULE_SCAM
1338 void *scam;
1339 #endif
1340 void *module_data; // private module data
1341
1342 struct s_client *next; //make client a linked list
1343 struct s_client *nexthashed;
1344 };
1345
1346 typedef struct s_ecm_whitelist_data
1347 {
1348 uint16_t len;
1349 uint16_t caid;
1350 uint32_t ident;
1351 } ECM_WHITELIST_DATA;
1352
1353 typedef struct s_ecm_whitelist
1354 {
1355 int32_t ewnum;
1356 ECM_WHITELIST_DATA *ewdata;
1357 } ECM_WHITELIST;
1358
1359 typedef struct s_ecm_hdr_whitelist_data
1360 {
1361 uint16_t len;
1362 uint16_t caid;
1363 uint32_t provid;
1364 uint8_t header[20];
1365 } ECM_HDR_WHITELIST_DATA;
1366
1367 typedef struct s_ecm_hdr_whitelist
1368 {
1369 int32_t ehnum;
1370 ECM_HDR_WHITELIST_DATA *ehdata;
1371 } ECM_HDR_WHITELIST;
1372
1373 //ratelimit
1374 struct ecmrl
1375 {
1376 struct timeb last;
1377 uchar kindecm;
1378 bool once;
1379 uchar ecmd5[CS_ECMSTORESIZE];
1380 uint16_t caid;
1381 uint32_t provid;
1382 uint16_t srvid;
1383 uint16_t chid;
1384 int32_t ratelimitecm;
1385 int32_t ratelimittime;
1386 int32_t srvidholdtime;
1387 };
1388 #define MAXECMRATELIMIT 20
1389
1390 #ifdef MODULE_SERIAL
1391 struct ecmtw
1392 {
1393 uint16_t caid;
1394 uint32_t provid;
1395 uint16_t srvid;
1396 uint16_t deg;
1397 uint16_t freq;
1398 };
1399 #endif
1400
1401 typedef struct ce_csp_tab_data
1402 {
1403 int32_t caid;
1404 int32_t cmask;
1405 int32_t prid;
1406 int32_t srvid;
1407 int16_t awtime;
1408 int16_t dwtime;
1409 } CECSPVALUETAB_DATA;
1410
1411 typedef struct ce_csp_tab
1412 {
1413 int32_t cevnum;
1414 CECSPVALUETAB_DATA *cevdata;
1415 } CECSPVALUETAB;
1416
1417 typedef struct cacheex_check_cw_tab_data
1418 {
1419 int32_t caid;
1420 int32_t cmask;
1421 int32_t prid;
1422 int32_t srvid;
1423 int8_t mode;
1424 uint32_t counter;
1425 } CWCHECKTAB_DATA;
1426
1427 typedef struct cacheex_check_cw_tab
1428 {
1429 int32_t cwchecknum;
1430 CWCHECKTAB_DATA *cwcheckdata;
1431
1432 } CWCHECKTAB;
1433
1434 typedef struct cacheex_check_cw
1435 {
1436 int8_t mode;
1437 uint32_t counter;
1438 } CWCHECK;
1439
1440 typedef struct ce_csp_t
1441 {
1442 int8_t mode;
1443 int8_t maxhop;
1444 CECSPVALUETAB filter_caidtab;
1445 uint8_t allow_request;
1446 uint8_t allow_reforward;
1447 uint8_t drop_csp;
1448 uint8_t allow_filter;
1449 uint8_t block_fakecws;
1450 } CECSP;
1451
1452 struct s_emmlen_range
1453 {
1454 int16_t min;
1455 int16_t max;
1456 };
1457
1458 struct s_reader //contains device info, reader info and card info
1459 {
1460 uint8_t keepalive;
1461 uint8_t changes_since_shareupdate;
1462 int32_t resetcycle; // ECM until reset
1463 int32_t resetcounter; // actual count
1464 uint32_t auprovid; // AU only for this provid
1465 int8_t audisabled; // exclude reader from auto AU
1466 int8_t needsemmfirst; // 0: reader descrambles without emm first, 1: reader needs emms before it can descramble
1467 struct timeb emm_last; // time of last successfully written emm
1468 int8_t smargopatch;
1469 int8_t autospeed; // 1 clockspeed set according to atr f max
1470 struct s_client *client; // pointer to 'r'client this reader is running in
1471 LLIST *ll_entitlements; // entitlements
1472 int8_t enable;
1473 int8_t active;
1474 int8_t dropbadcws; // Schlocke: 1=drops cw if checksum is wrong. 0=fix checksum (default)
1475 int8_t disablecrccws; // 1=disable cw checksum test. 0=enable checksum check
1476 uint64_t grp;
1477 int8_t fallback;
1478 FTAB fallback_percaid;
1479 FTAB localcards;
1480 FTAB disablecrccws_only_for; // ignore checksum for selected caid provid
1481 #ifdef CS_CACHEEX
1482 CECSP cacheex; //CacheEx Settings
1483 #endif
1484 int32_t typ;
1485 char label[64];
1486 #ifdef WEBIF
1487 char *description;
1488 #endif
1489 char device[128];
1490 uint16_t slot; // in case of multiple slots like sc8in1; first slot = 1
1491 int32_t handle; // device handle
1492 int64_t handle_nr; // device handle_nr for mutiple readers same driver
1493 int32_t fdmc; // device handle for multicam
1494 int32_t detect;
1495 int32_t mhz; // actual clock rate of reader in 10khz steps
1496 int32_t cardmhz; // standard clock speed your card should have in 10khz steps; normally 357 but for Irdeto cards 600
1497 int32_t divider; // PLL divider for internal readers
1498 int32_t r_port;
1499 char r_usr[64];
1500 char r_pwd[64];
1501 int32_t l_port;
1502 CAIDTAB ctab;
1503 uint32_t boxid;
1504 int8_t nagra_read; // read nagra ncmed records: 0 Disabled (default), 1 read all records, 2 read valid records only
1505 int8_t detect_seca_nagra_tunneled_card;
1506 int8_t force_irdeto;
1507 uint8_t boxkey[16]; // n3 boxkey 8 bytes, seca sessionkey 16 bytes, viaccess camid 4 bytes
1508 uint8_t boxkey_length;
1509 uint8_t rsa_mod[120]; // rsa modulus for nagra cards.
1510 uint8_t rsa_mod_length;
1511 uint8_t des_key[128]; // 3des key for Viaccess 16 bytes, des key for Dre 128 bytes
1512 uint8_t des_key_length;
1513 uchar atr[64];
1514 uchar card_atr[64]; // ATR readed from card
1515 int8_t card_atr_length; // length of ATR
1516 int8_t seca_nagra_card; // seca nagra card
1517 int32_t atrlen;
1518 SIDTABS sidtabs;
1519 SIDTABS lb_sidtabs;
1520 uchar hexserial[8];
1521 int32_t nprov;
1522 uchar prid[CS_MAXPROV][8];
1523 uchar sa[CS_MAXPROV][4]; // viaccess & seca
1524 uint8_t read_old_classes; // viaccess
1525 uint8_t maturity; // viaccess & seca maturity level
1526 uint16_t caid;
1527 uint16_t b_nano;
1528 uint16_t s_nano;
1529 int8_t ecmcommand; // used for filtering nagra bad ecm commands
1530 uchar ecmcommandcache[5]; // cachebuff for ecm commands
1531 int32_t blockemm;
1532 int32_t saveemm;
1533 LLIST *blockemmbylen;
1534 char *emmfile;
1535 char pincode[5];
1536 int8_t logemm;
1537 int8_t cachemm;
1538 int16_t rewritemm;
1539 int16_t deviceemm; // catch device specific emms (so far only used for viaccess)
1540 int8_t card_status;
1541 int8_t deprecated; //if 0 ATR obeyed, if 1 default speed (9600) is chosen; for devices that cannot switch baudrate
1542 struct s_module ph;
1543 const struct s_cardreader *crdr;
1544 void *crdr_data; // Private card reader data
1545 bool crdr_flush; // sci readers may disable flush per reader
1546 const struct s_cardsystem *csystem;
1547 void *csystem_data; // Private card system data
1548 bool csystem_active;
1549 uint8_t ncd_key[14];
1550 uchar ncd_skey[16];
1551 int8_t ncd_connect_on_init;
1552 int8_t ncd_disable_server_filt;
1553 int8_t ncd_proto;
1554 int8_t currenthops; // number of hops (cccam & gbox)
1555 int8_t sh4_stb; // to set sh4 type box used to identify sci type.
1556 #ifdef MODULE_CCCAM
1557 char cc_version[7]; // cccam version
1558 char cc_build[7]; // cccam build number
1559 int8_t cc_maxhops; // cccam max distance
1560 int8_t cc_mindown; // cccam min downhops
1561 int8_t cc_want_emu; // Schlocke: Client want to have EMUs, 0 - NO; 1 - YES
1562 uint32_t cc_id;
1563 int8_t cc_keepalive;
1564 int8_t cc_hop; // For non-cccam reader: hop for virtual cards
1565 int8_t cc_reshare;
1566 int32_t cc_reconnect; //reconnect on ecm-request timeout
1567 #endif
1568 int8_t tcp_connected;
1569 int32_t tcp_ito; // inactivity timeout
1570 int32_t tcp_rto; // reconnect timeout
1571 int32_t tcp_reconnect_delay; // max tcp connection block delay
1572
1573 struct timeb tcp_block_connect_till; //time tcp connect ist blocked
1574 int32_t tcp_block_delay; //incrementing block time
1575 time_t last_g; // get (if last_s-last_g>tcp_rto - reconnect )
1576 time_t last_s; // send
1577 time_t last_check; // last checked
1578 time_t last_poll; // last poll
1579 FTAB fchid;
1580 FTAB ftab;
1581 CLASSTAB cltab;
1582 ECM_WHITELIST ecm_whitelist;
1583 ECM_HDR_WHITELIST ecm_hdr_whitelist;
1584 int32_t brk_pos;
1585 int32_t msg_idx;
1586 int32_t secatype; // 0=not determined, 2=seca2, 3=nagra(~seca3) this is only valid for localreaders!
1587 uint32_t maxreadtimeout; // in us
1588 uint32_t minreadtimeout; // in us
1589 uint32_t maxwritetimeout; // in us
1590 uint32_t minwritetimeout; // in us
1591 #if defined(WEBIF) || defined(LCDSUPPORT)
1592 int32_t emmwritten[4]; // count written EMM
1593 int32_t emmskipped[4]; // count skipped EMM
1594 int32_t emmerror[4]; // count error EMM
1595 int32_t emmblocked[4]; // count blocked EMM
1596 int32_t webif_emmwritten[4]; // count written EMM for webif reader info
1597 int32_t webif_emmskipped[4]; // count skipped EMM for webif reader info
1598 int32_t webif_emmerror[4]; // count error EMM for reader webif info
1599 int32_t webif_emmblocked[4]; // count blocked EMM for reader webif info
1600 int32_t lbvalue; // loadbalance Value
1601 #endif
1602 #ifdef WITH_AZBOX
1603 int32_t azbox_mode;
1604 #endif
1605 int32_t use_gpio; // Should this reader use GPIO functions
1606 int gpio_outen; // fd of opened /dev/gpio/outen
1607 int gpio_out; // fd of opened /dev/gpio/out
1608 int gpio_in; // fd of opened /dev/gpio/in
1609 uint32_t gpio; // gpio addr
1610 ////variables from icc_async.h start
1611 #ifdef WITH_CARDREADER
1612 int32_t convention; // Convention of this ICC
1613 unsigned char protocol_type; // Type of protocol
1614 uint32_t current_baudrate; // (for overclocking uncorrected) baudrate to prevent unnecessary conversions from/to termios structure
1615 double worketu; // in us for internal and external readers calculated (1/D)*(F/cardclock)*1000000
1616 uint32_t read_timeout; // Max timeout (ETU) to receive characters
1617 uint32_t char_delay; // Delay (ETU) after transmiting each successive char
1618 uint32_t block_delay; // Delay (ms) after starting to transmit
1619 uint32_t BWT, CWT; // (for overclocking uncorrected) block waiting time, character waiting time, in ETU
1620 ////variables from io_serial.h
1621 int32_t written; // keep score of how much bytes are written to serial port, since they are echoed back they have to be read
1622 ////variables from protocol_t1.h
1623 uint16_t ifsc; // Information field size for the ICC
1624 unsigned char ns; // Send sequence number
1625 int16_t smartdev_found;
1626 int16_t smart_type;
1627 uint16_t statuscnt;
1628 uint16_t modemstat;
1629 #endif
1630 unsigned char rom[15];
1631 unsigned char irdId[4];
1632 unsigned char payload4C[15];
1633 uint16_t VgCredit;
1634 uint16_t VgPin;
1635 unsigned char VgFuse;
1636 unsigned char VgCountryC[3];
1637 unsigned char VgRegionC[8];
1638 unsigned char VgLastPayload[6];
1639 #ifdef WITH_LB
1640 int32_t lb_weight; //loadbalance weight factor, if unset, weight=100. The higher the value, the higher the usage-possibility
1641 int8_t lb_force_fallback; //force this reader as fallback if fallback or fallback_percaid paramters set
1642 int32_t lb_usagelevel; //usagelevel for loadbalancer
1643 int32_t lb_usagelevel_ecmcount;
1644 struct timeb lb_usagelevel_time; //time for counting ecms, this creates usagelevel
1645 struct timeb lb_last; //time for oldest reader
1646 LLIST *lb_stat; //loadbalancer reader statistics
1647 CS_MUTEX_LOCK lb_stat_lock;
1648 int32_t lb_stat_busy; //do not add while saving
1649 #endif
1650
1651 AES_ENTRY *aes_list; // multi AES linked list
1652 int8_t ndsversion; // 0 auto (default), 1 NDS1, 12 NDS1+, 2 NDS2
1653 time_t card_valid_to;
1654 //ratelimit
1655 int32_t ratelimitecm;
1656 int32_t ratelimittime; // ratelimit time in ms (everything below 60 ms is converted to ms by applying *1000)
1657 int8_t ecmunique; // check for matching ecm hash in ratelimitslot
1658 int32_t srvidholdtime; // time in ms to keep srvid in ratelimitslot (during this time not checked for ecmunique!)
1659 // (everything below 60 ms is converted to ms by applying *1000)
1660 struct timeb lastdvbapirateoverride;
1661 uint32_t ecmsok;
1662 uint32_t webif_ecmsok;
1663 uint32_t ecmsnok;
1664 uint32_t webif_ecmsnok;
1665 uint32_t ecmstout;
1666 uint32_t webif_ecmstout;
1667 uint32_t ecmnotfoundlimit; // config setting. restart reader if ecmsnok >= ecmnotfoundlimit
1668 int32_t ecmsfilteredhead; // count filtered ECM's by ECM Headerwhitelist
1669 int32_t ecmsfilteredlen; // count filtered ECM's by ECM Whitelist
1670 int32_t webif_ecmsfilteredhead; // count filtered ECM's by ECM Headerwhitelist to readers ecminfo
1671 int32_t webif_ecmsfilteredlen; // count filtered ECM's by ECM Whitelist to readers ecm info
1672 float ecmshealthok;
1673 float ecmshealthnok;
1674 float ecmshealthtout;
1675 int32_t cooldown[2];
1676 int8_t cooldownstate;
1677 struct timeb cooldowntime;
1678 struct ecmrl rlecmh[MAXECMRATELIMIT];
1679 int8_t fix_07;
1680 int8_t fix_9993;
1681 int8_t readtiers; // method to get videoguard tiers
1682 uint8_t ins7E[0x1A + 1];
1683 uint8_t ins7E11[0x01 + 1];
1684 uint8_t ins2e06[0x04 + 1];
1685 int8_t ins7e11_fast_reset;
1686 uint8_t sc8in1_dtrrts_patch; // fix for kernel commit 6a1a82df91fa0eb1cc76069a9efe5714d087eccd
1687
1688 #ifdef READER_VIACCESS
1689 unsigned char initCA28; // To set when CA28 succeed
1690 uint32_t key_schedule1[32];
1691 uint32_t key_schedule2[32];
1692 #endif
1693
1694 #if defined(READER_DRE) || defined(READER_DRECAS)
1695 char *userscript;
1696 uint32_t force_ua;
1697 #endif
1698
1699 #ifdef READER_DRECAS
1700 char *stmkeys;
1701 #endif
1702
1703 #ifdef MODULE_GBOX
1704 uint8_t gbox_maxdist;
1705 uint8_t gbox_maxecmsend;
1706 uint8_t gbox_reshare;
1707 uint8_t gbox_cccam_reshare;
1708 char last_gsms[128];
1709 #endif
1710
1711 #ifdef MODULE_PANDORA
1712 uint8_t pand_send_ecm;
1713 #endif
1714 #ifdef MODULE_GHTTP
1715 uint8_t ghttp_use_ssl;
1716 #endif
1717 uint8_t cnxlastecm; // == 0 - las ecm has not been paired ecm, > 0 last ecm has been paired ecm
1718 LLIST *emmstat; //emm stats
1719 CS_MUTEX_LOCK emmstat_lock;
1720 struct s_reader *next;
1721 };
1722
1723 struct s_cpmap
1724 {
1725 uint16_t caid;
1726 uint32_t provid;
1727 uint16_t sid;
1728 uint16_t chid;
1729 uint16_t dwtime;
1730 struct s_cpmap *next;
1731 };
1732
1733 struct s_auth
1734 {
1735 char usr[64];
1736 char *pwd;
1737 #ifdef WEBIF
1738 char *description;
1739 #endif
1740 int8_t uniq;
1741 #ifdef CS_CACHEEX
1742 CECSP cacheex; //CacheEx Settings
1743 uint8_t no_wait_time;
1744 uint8_t disablecrccacheex;
1745 FTAB disablecrccacheex_only_for;
1746 #endif
1747 int16_t allowedprotocols;
1748 LLIST *aureader_list;
1749 int8_t autoau;
1750 uint8_t emm_reassembly; // 0 = OFF; 1 = OFF / DVBAPI = ON; 2 = ON (default)
1751 int8_t monlvl;
1752 uint64_t grp;
1753 int32_t tosleep;
1754 int32_t umaxidle;
1755 CAIDTAB ctab;
1756 SIDTABS sidtabs;
1757 FTAB fchid;
1758 FTAB ftab; // user [caid] and ident filter
1759 CLASSTAB cltab;
1760 TUNTAB ttab;
1761 int8_t preferlocalcards;
1762 uint32_t max_connections;
1763 #ifdef CS_ANTICASC
1764 int32_t ac_fakedelay; // When this is -1, the global ac_fakedelay is used
1765 int32_t ac_users; // 0 - unlimited
1766 int8_t ac_penalty; // 0 - log, >0 - fake dw
1767 struct s_acasc ac_stat;
1768 int8_t acosc_max_active_sids; // user value 0 - unlimited
1769 int8_t acosc_zap_limit; // user value 0 - unlimited
1770 int8_t acosc_penalty; //user value penalty
1771 int32_t acosc_penalty_duration; // user value how long is penalty activ in sek.
1772 time_t acosc_penalty_until;
1773 int8_t acosc_penalty_active; // 0-deaktiv 1-max_active_sids 2-zap_limit 3-penaly_duration
1774 int32_t acosc_delay; //user value
1775 int8_t acosc_user_zap_count;
1776 time_t acosc_user_zap_count_start_time;
1777 #endif
1778 #ifdef WITH_LB
1779 int32_t lb_nbest_readers; // When this is -1, the global lb_nbest_readers is used
1780 int32_t lb_nfb_readers; // When this is -1, the global lb_nfb_readers is used
1781 CAIDVALUETAB lb_nbest_readers_tab; // like nbest_readers, but for special caids
1782 #endif
1783 IN_ADDR_T dynip;
1784 char *dyndns;
1785 time_t expirationdate;
1786 time_t firstlogin;
1787 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
1788 uint8_t allowedtimeframe_set; //flag for internal use to mention if allowed time frame is used
1789 int8_t c35_suppresscmd08;
1790 uint8_t c35_sleepsend;
1791 int8_t ncd_keepalive;
1792 #ifdef MODULE_CCCAM
1793 int32_t cccmaxhops;
1794 int8_t cccreshare;
1795 int8_t cccignorereshare;
1796 int8_t cccstealth;
1797 #endif
1798 int8_t disabled;
1799 int32_t failban;
1800
1801 int32_t cwfound;
1802 int32_t cwcache;
1803 int32_t cwnot;
1804 int32_t cwtun;
1805 int32_t cwignored;
1806 int32_t cwtout;
1807 #ifdef CW_CYCLE_CHECK
1808 int32_t cwcycledchecked; // count checked cwcycles per client
1809 int32_t cwcycledok; // count pos checked cwcycles per client
1810 int32_t cwcyclednok; // count neg checked cwcycles per client
1811 int32_t cwcycledign; // count ign cwcycles per client
1812 int8_t cwc_disable; // disable cwc checking for this Client
1813 #endif
1814 int32_t emmok;
1815 int32_t emmnok;
1816 #ifdef CS_CACHEEX
1817 int32_t cwcacheexpush; // count pushed ecms/cws
1818 int32_t cwcacheexgot; // count got ecms/cws
1819 int32_t cwcacheexhit; // count hit ecms/cws
1820 int32_t cwcacheexerr; //cw=00 or chksum wrong
1821 int32_t cwcacheexerrcw; //Same Hex, different CW
1822 int32_t cwc_info; // count of in/out comming cacheex ecms with CWCinfo
1823 #endif
1824 struct s_auth *next;
1825 };
1826
1827
1828 struct s_srvid_caid
1829 {
1830 uint16_t caid;
1831 uint16_t nprovid;
1832 uint32_t *provid;
1833 };
1834
1835 struct s_srvid
1836 {
1837 uint16_t srvid;
1838 int8_t ncaid;
1839 struct s_srvid_caid *caid;
1840 char *data;
1841 const char *prov;
1842 const char *name;
1843 const char *type;
1844 const char *desc;
1845 struct s_srvid *next;
1846 };
1847
1848 struct s_rlimit
1849 {
1850 struct ecmrl rl;
1851 struct s_rlimit *next;
1852 };
1853
1854 struct s_cw
1855 {
1856 uint8_t cw[16];
1857 };
1858
1859 struct s_fakecws
1860 {
1861 uint32_t count;
1862 struct s_cw *data;
1863 };
1864
1865 #ifdef MODULE_SERIAL
1866 struct s_twin
1867 {
1868 struct ecmtw tw;
1869 struct s_twin *next;
1870 };
1871 #endif
1872
1873 struct s_tierid
1874 {
1875 uint16_t tierid;
1876 int8_t ncaid;
1877 uint16_t caid[10];
1878 char name[33];
1879 struct s_tierid *next;
1880 };
1881
1882 struct s_provid
1883 {
1884 uint16_t caid;
1885 uint16_t nprovid;
1886 uint32_t *provid;
1887 char prov[33];
1888 char sat[33];
1889 char lang[33];
1890 struct s_provid *next;
1891 };
1892
1893 struct s_ip
1894 {
1895 IN_ADDR_T ip[2];
1896 struct s_ip *next;
1897 };
1898
1899 struct s_global_whitelist
1900 {
1901 uint32_t line; //linenr of oscam.whitelist file, starting with 1
1902 char type; // w or i or l
1903 uint16_t caid;
1904 uint32_t provid;
1905 uint16_t srvid;
1906 uint16_t chid;
1907 uint16_t pid;
1908 uint16_t ecmlen;
1909 uint16_t mapcaid;
1910 uint32_t mapprovid;
1911 struct s_global_whitelist *next;
1912 };
1913
1914 struct s_cacheex_matcher
1915 {
1916 uint32_t line; //linenr of oscam.Cacheex file, starting with 1
1917 char type; // m
1918 uint16_t caid;
1919 uint32_t provid;
1920 uint16_t srvid;
1921 uint16_t chid;
1922 uint16_t pid;
1923 uint16_t ecmlen;
1924
1925 uint16_t to_caid;
1926 uint32_t to_provid;
1927 uint16_t to_srvid;
1928 uint16_t to_chid;
1929 uint16_t to_pid;
1930 uint16_t to_ecmlen;
1931
1932 int32_t valid_from;
1933 int32_t valid_to;
1934
1935 struct s_cacheex_matcher *next;
1936 };
1937
1938 struct s_config
1939 {
1940 int32_t nice;
1941 uint32_t netprio;
1942 uint32_t ctimeout;
1943 uint32_t ftimeout;
1944 CAIDVALUETAB ftimeouttab;
1945 uint32_t cmaxidle;
1946 int32_t ulparent;
1947 uint32_t delay;
1948 int32_t bindwait;
1949 int32_t tosleep;
1950 IN_ADDR_T srvip;
1951 char *usrfile;
1952 char *cwlogdir;
1953 char *emmlogdir;
1954 char *logfile;
1955 char *mailfile;
1956 int8_t disablecrccws; // 1=disable cw checksum test. 0=enable checksum check
1957 FTAB disablecrccws_only_for; // ignore checksum for selected caid provid
1958 uint8_t logtostdout;
1959 uint8_t logtosyslog;
1960 int8_t logduplicatelines;
1961 int32_t initial_debuglevel;
1962 char *sysloghost;
1963 int32_t syslogport;
1964 #if defined(WEBIF) || defined(MODULE_MONITOR)
1965 uint32_t loghistorylines;
1966 #endif
1967 int8_t disablelog;
1968 int8_t disablemail;
1969 int8_t disableuserfile;
1970 int8_t usrfileflag;
1971 struct s_auth *account;
1972 struct s_srvid *srvid[16];
1973 struct s_tierid *tierid;
1974 struct s_provid *provid;
1975 struct s_sidtab *sidtab;
1976 #ifdef MODULE_MONITOR
1977 int32_t mon_port;
1978 IN_ADDR_T mon_srvip;
1979 struct s_ip *mon_allowed;
1980 uint8_t mon_level;
1981 #endif
1982 int32_t aulow;
1983 int32_t hideclient_to;
1984 #ifdef WEBIF
1985 int32_t http_port;
1986 IN_ADDR_T http_srvip;
1987 char *http_user;
1988 char *http_pwd;
1989 char *http_css;
1990 int8_t http_prepend_embedded_css;
1991 char *http_jscript;
1992 char *http_tpl;
1993 char *http_piconpath;
1994 char *http_script;
1995 #ifndef WEBIF_JQUERY
1996 char *http_extern_jquery;
1997 #endif
1998 int32_t http_refresh;
1999 int32_t poll_refresh;
2000 int8_t http_hide_idle_clients;
2001 char *http_hide_type;
2002 int8_t http_showpicons;
2003 int8_t http_picon_size;
2004 int8_t http_status_log;
2005 int8_t http_showmeminfo;
2006 int8_t http_showecminfo;
2007 int8_t http_showloadinfo;
2008 int8_t http_showuserinfo;
2009 int8_t http_showreaderinfo;
2010 int8_t http_showcacheexinfo;
2011 struct s_ip *http_allowed;
2012 int8_t http_readonly;
2013 IN_ADDR_T http_dynip[MAX_HTTP_DYNDNS];
2014 uchar http_dyndns[MAX_HTTP_DYNDNS][64];
2015 int8_t http_use_ssl;
2016 int8_t https_force_secure_mode;
2017 char *http_cert;
2018 char *http_help_lang;
2019 char *http_locale;
2020 char *http_oscam_label;
2021 int32_t http_emmu_clean;
2022 int32_t http_emms_clean;
2023 int32_t http_emmg_clean;
2024 #endif
2025 int8_t http_full_cfg;
2026 int8_t http_overwrite_bak_file;
2027 int32_t failbantime;
2028 int32_t failbancount;
2029 LLIST *v_list; // Failban list
2030 #ifdef MODULE_CAMD33
2031 int32_t c33_port;
2032 IN_ADDR_T c33_srvip;
2033 uint8_t c33_key[16];
2034 int32_t c33_crypted;
2035 int32_t c33_passive;
2036 struct s_ip *c33_plain;
2037 #endif
2038 #if defined(MODULE_CAMD35) || defined(MODULE_CAMD35_TCP)
2039 int32_t c35_port;
2040 IN_ADDR_T c35_srvip;
2041 int8_t c35_tcp_suppresscmd08;
2042 int8_t c35_udp_suppresscmd08;
2043 PTAB c35_tcp_ptab;
2044 IN_ADDR_T c35_tcp_srvip;
2045 #endif
2046 int8_t c35_suppresscmd08; // used in cccam module
2047 int8_t getblockemmauprovid;
2048 int32_t umaxidle; //User max Idle
2049 #ifdef MODULE_NEWCAMD
2050 PTAB ncd_ptab;
2051 IN_ADDR_T ncd_srvip;
2052 uint8_t ncd_key[14];
2053 int8_t ncd_keepalive;
2054 int8_t ncd_mgclient;
2055 struct s_ip *ncd_allowed;
2056 #endif
2057 #ifdef MODULE_RADEGAST
2058 int32_t rad_port;
2059 IN_ADDR_T rad_srvip;
2060 struct s_ip *rad_allowed;
2061 char *rad_usr;
2062 #endif
2063 #ifdef MODULE_CCCAM
2064 uint16_t cc_port[CS_MAXPORTS];
2065 int8_t cc_reshare;
2066 int8_t cc_ignore_reshare;
2067 int32_t cc_update_interval;
2068 IN_ADDR_T cc_srvip;
2069 char cc_version[7];
2070 int8_t cc_minimize_cards;
2071 int8_t cc_keep_connected;
2072 int8_t cc_stealth;
2073 int8_t cc_reshare_services;
2074 int8_t cc_forward_origin_card;
2075 uint8_t cc_fixed_nodeid[8];
2076 uint32_t cc_recv_timeout; // The poll() timeout parameter in ms. Default: DEFAULT_CC_RECV_TIMEOUT (2000 ms).
2077 #endif
2078 #ifdef MODULE_GBOX
2079 #define GBOX_MY_VERS_DEF 0x2A
2080 #define GBOX_MY_CPU_API_DEF 0x40
2081 #define GBOX_MAX_PROXY_CARDS 32
2082 #define GBOX_MAX_IGNORED_PEERS 16
2083 #define GBOX_MAX_BLOCKED_ECM 16
2084 #define GBOX_MAX_REMM_PEERS 8
2085 #define GBOX_MAX_DEST_PEERS 16
2086 #define GBOX_MAX_MSG_TXT 127
2087
2088 uint16_t gbox_port[CS_MAXPORTS];
2089 char *gbox_hostname;
2090 uint32_t gbox_reconnect;
2091 uint32_t gbox_password;
2092 unsigned long gbox_proxy_card[GBOX_MAX_PROXY_CARDS];
2093 int8_t gbox_proxy_cards_num;
2094 uint32_t gbox_my_vers;
2095 uint8_t gbox_my_cpu_api;
2096 uint8_t gsms_dis;
2097 uint8_t log_hello;
2098 uint8_t dis_attack_txt;
2099 char *gbox_tmp_dir;
2100 uint8_t ccc_reshare;
2101 uint16_t gbox_ignored_peer[GBOX_MAX_IGNORED_PEERS];
2102 uint8_t gbox_ignored_peer_num;
2103 uint16_t accept_remm_peer[GBOX_MAX_REMM_PEERS];
2104 uint8_t accept_remm_peer_num;
2105 uint16_t gbox_block_ecm[GBOX_MAX_BLOCKED_ECM];
2106 uint8_t gbox_block_ecm_num;
2107 uint8_t gbox_save_gsms;
2108 uint8_t gbox_msg_type;
2109 uint16_t gbox_dest_peers[GBOX_MAX_DEST_PEERS];
2110 uint8_t gbox_dest_peers_num;
2111 char gbox_msg_txt[GBOX_MAX_MSG_TXT+1];
2112 #endif
2113 #ifdef MODULE_SERIAL
2114 char *ser_device;
2115 #endif
2116 int32_t max_log_size;
2117 int8_t waitforcards;
2118 int32_t waitforcards_extra_delay;
2119 int8_t preferlocalcards;
2120 int32_t reader_restart_seconds; // schlocke: reader restart auf x seconds, disable = 0
2121 int8_t dropdups; // drop duplicate logins
2122
2123
2124 //Loadbalancer-Config:
2125 int32_t lb_mode; // schlocke: reader loadbalancing mode
2126 int32_t lb_auto_betatunnel; // automatic selection of betatunnel convertion based on learned data
2127 int32_t lb_auto_betatunnel_mode; // automatic selection of betatunnel direction
2128 #ifdef WITH_LB
2129 int32_t lb_save; // schlocke: load/save statistics to file, save every x ecms
2130 int32_t lb_nbest_readers; // count of best readers
2131 int32_t lb_nfb_readers; // count of fallback readers
2132 int32_t lb_min_ecmcount; // minimal ecm count to evaluate lbvalues
2133 int32_t lb_max_ecmcount; // maximum ecm count before reseting lbvalues
2134 int32_t lb_reopen_seconds; // time between retrying failed readers/caids/prov/srv
2135 int8_t lb_reopen_invalid; // default=1; if 0, rc=E_INVALID will be blocked until stats cleaned
2136 int8_t lb_force_reopen_always; // force reopening immediately all failing readers if no matching reader found
2137 int32_t lb_retrylimit; // reopen only happens if reader response time > retrylimit
2138 CAIDVALUETAB lb_retrylimittab;
2139 CAIDVALUETAB lb_nbest_readers_tab; // like nbest_readers, but for special caids
2140 CAIDTAB lb_noproviderforcaid; // do not store loadbalancer stats with providers for this caid
2141 char *lb_savepath; // path where the stat file is save. Empty=default=/tmp/.oscam/stat
2142 int32_t lb_stat_cleanup; // duration in hours for cleaning old statistics
2143 int32_t lb_max_readers; // limit the amount of readers during learning
2144 int32_t lb_auto_betatunnel_prefer_beta; // prefer-beta-over-nagra factor
2145 int32_t lb_auto_timeout; // Automatic timeout by loadbalancer statistics
2146 int32_t lb_auto_timeout_p; // percent added to avg time as timeout time
2147 int32_t lb_auto_timeout_t; // minimal time added to avg time as timeout time
2148 #endif
2149 int32_t resolve_gethostbyname;
2150 int8_t double_check; // schlocke: Double checks each ecm+dcw from two (or more) readers
2151 CAIDTAB double_check_caid; // do not store loadbalancer stats with providers for this caid
2152
2153 #ifdef HAVE_DVBAPI
2154 int8_t dvbapi_enabled;
2155 int8_t dvbapi_au;
2156 char *dvbapi_usr;
2157 int8_t dvbapi_boxtype;
2158 int8_t dvbapi_pmtmode;
2159 int8_t dvbapi_requestmode;
2160 int32_t dvbapi_listenport; // TCP port to listen instead of camd.socket (network mode, default=0 -> disabled)
2161 SIDTABS dvbapi_sidtabs;
2162 int32_t dvbapi_delayer; // delayer ms, minimum time to write cw
2163 int8_t dvbapi_ecminfo_type;
2164 int8_t dvbapi_read_sdt;
2165 int8_t dvbapi_write_sdt_prov;
2166 int8_t dvbapi_extended_cw_api;
2167 #endif
2168
2169 #ifdef CS_ANTICASC
2170 int8_t ac_enabled;
2171 int32_t ac_users; // num of users for account (0 - default)
2172 int32_t ac_stime; // time to collect AC statistics (3 min - default)
2173 int32_t ac_samples; // qty of samples
2174 int8_t ac_penalty; // 0 - write to log
2175 int32_t ac_fakedelay; // 100-1000 ms
2176 int32_t ac_denysamples;
2177 char *ac_logfile;
2178 struct s_cpmap *cpmap;
2179 int8_t acosc_enabled;
2180 int8_t acosc_max_active_sids;// global value 0 - unlimited
2181 int8_t acosc_zap_limit;// global value 0 - unlimited
2182 int32_t acosc_penalty_duration;// global value how long is penalty activ in sek.
2183 int8_t acosc_penalty;//global value
2184 int32_t acosc_delay;//global value
2185 #endif
2186
2187 #ifdef LEDSUPPORT
2188 int8_t enableled; // 0=disabled led, 1=enable led for routers, 2=enable qboxhd led
2189 #endif
2190
2191 #ifdef LCDSUPPORT
2192 int8_t enablelcd;
2193 char *lcd_output_path;
2194 int32_t lcd_hide_idle;
2195 int32_t lcd_write_intervall;
2196 #endif
2197
2198 #ifdef MODULE_PANDORA
2199 int8_t pand_skip_send_dw;
2200 struct s_ip *pand_allowed;
2201 char *pand_usr;
2202 char *pand_pass;
2203 int8_t pand_ecm;
2204 int32_t pand_port;
2205 IN_ADDR_T pand_srvip;
2206 #endif
2207
2208 #ifdef MODULE_SCAM
2209 int32_t scam_port;
2210 IN_ADDR_T scam_srvip;
2211 struct s_ip *scam_allowed;
2212 #endif
2213 int32_t max_cache_time; //seconds ecms are stored in ecmcwcache
2214 int32_t max_hitcache_time; //seconds hits are stored in cspec_hitcache (to detect dyn wait_time)
2215
2216 int8_t reload_useraccounts;
2217 int8_t reload_readers;
2218 int8_t reload_provid;
2219 int8_t reload_services_ids;
2220 int8_t reload_tier_ids;
2221 int8_t reload_fakecws;
2222 int8_t reload_ac_stat;
2223 int8_t reload_log;
2224
2225 int8_t block_same_ip; //0=allow all, 1=block client requests to reader with same ip (default=1)
2226 int8_t block_same_name; //0=allow all, 1=block client requests to reader with same name (default=1)
2227
2228 #ifdef CS_CACHEEX
2229 uint8_t wait_until_ctimeout;
2230 CWCHECKTAB cacheex_cwcheck_tab;
2231 IN_ADDR_T csp_srvip;
2232 int32_t csp_port;
2233 CECSPVALUETAB cacheex_wait_timetab;
2234 CAIDVALUETAB cacheex_mode1_delay_tab;
2235 CECSP csp; //CSP Settings
2236 uint8_t cacheex_enable_stats; //enable stats
2237 struct s_cacheex_matcher *cacheex_matcher;
2238 #endif
2239
2240 #ifdef CW_CYCLE_CHECK
2241 int8_t cwcycle_check_enable; // on or off
2242 CAIDTAB cwcycle_check_caidtab; // Caid for CW Cycle Check
2243 int32_t keepcycletime; // how long stay the learned Cycletime in Memory
2244 int32_t maxcyclelist; // max size of cwcyclelist
2245 int8_t onbadcycle; // what to do on bad cwcycle
2246 int8_t cwcycle_dropold; // what to do on old ecmd5/cw
2247 int8_t cwcycle_sensitive;
2248 int8_t cwcycle_allowbadfromffb; //allow Bad cycles from Fixed Fallbackreader
2249 int8_t cwcycle_usecwcfromce; //Use CWC Info from Cacheex Sources for CWC Checking
2250 #endif
2251
2252 //Global whitelist:
2253 struct s_global_whitelist *global_whitelist;
2254 int8_t global_whitelist_use_l;
2255 int8_t global_whitelist_use_m;
2256
2257 char *ecmfmt;
2258 char *pidfile;
2259
2260 int32_t max_pending;
2261
2262 //Ratelimit list
2263 struct s_rlimit *ratelimit_list;
2264
2265 // fake cws
2266 struct s_fakecws fakecws[0x100];
2267
2268 #ifdef MODULE_SERIAL
2269 struct s_twin *twin_list;
2270 #endif
2271 };
2272
2273 struct s_clientinit
2274 {
2275 void *(*handler)(struct s_client *);
2276 struct s_client *client;
2277 };
2278
2279 struct s_clientmsg
2280 {
2281 uint8_t msg[1024];
2282 int32_t len;
2283 int32_t cmd;
2284 };
2285
2286 typedef struct reader_stat_t
2287 {
2288 int32_t rc;
2289 uint16_t caid;
2290 uint32_t prid;
2291 uint16_t srvid;
2292 uint32_t chid;
2293 int16_t ecmlen;
2294
2295 struct timeb last_received;
2296
2297 int32_t ecm_count;
2298 int32_t time_avg;
2299 int32_t time_stat[LB_MAX_STAT_TIME];
2300 int32_t time_idx;
2301
2302 int32_t fail_factor;
2303 } READER_STAT;
2304
2305 typedef struct cs_stat_query
2306 {
2307 uint16_t caid;
2308 uint32_t prid;
2309 uint16_t srvid;
2310 uint32_t chid;
2311 int16_t ecmlen;
2312 } STAT_QUERY;
2313
2314 typedef struct emm_packet_t
2315 {
2316 uchar emm[MAX_EMM_SIZE];
2317 int16_t emmlen;
2318 uchar caid[2];
2319 uchar provid[4];
2320 uchar hexserial[8]; //contains hexserial or SA of EMM
2321 uchar type;
2322 uint8_t skip_filter_check;
2323 struct s_client *client;
2324 } EMM_PACKET;
2325
2326
2327 struct s_write_from_cache
2328 {
2329 ECM_REQUEST *er_new;
2330 ECM_REQUEST *er_cache;
2331 };
2332
2333 /* ===========================
2334 * global variables
2335 * =========================== */
2336 extern pthread_key_t getclient;
2337 extern struct s_client *first_client;
2338 extern CS_MUTEX_LOCK config_lock;
2339 extern CS_MUTEX_LOCK clientlist_lock;
2340 extern CS_MUTEX_LOCK readerlist_lock;
2341 extern struct s_reader *first_active_reader; //points to list of _active_ readers (enable = 1, deleted = 0)
2342 extern LLIST *configured_readers;
2343
2344 // These are used pretty much everywhere
2345 extern struct s_config cfg;
2346 extern uint16_t cs_dblevel;
2347
2348 #include "oscam-log.h"
2349 #include "oscam-log-reader.h"
2350
2351 // Add here *only* funcs that are implemented in oscam.c and are called in other places
2352 void cs_exit(int32_t sig);
2353 void cs_exit_oscam(void);
2354 void cs_restart_oscam(void);
2355 int32_t cs_get_restartmode(void);
2356
2357 void set_thread_name(const char *thread_name);
2358 int32_t start_thread(char *nameroutine, void *startroutine, void *arg, pthread_t *pthread, int8_t detach, int8_t modify_stacksize);
2359 int32_t start_thread_nolog(char *nameroutine, void *startroutine, void *arg, pthread_t *pthread, int8_t detach, int8_t modify_stacksize);
2360 void kill_thread(struct s_client *cl);
2361
2362 struct s_module *get_module(struct s_client *cl);
2363 void module_reader_set(struct s_reader *rdr);
2364
2365 // Until we find a better place for these (they are implemented in oscam-simples.h)
2366 char *get_servicename(struct s_client *cl, uint16_t srvid, uint32_t provid, uint16_t caid, char *buf, uint32_t buflen);
2367 char *get_servicename_or_null(struct s_client *cl, uint16_t srvid, uint32_t provid, uint16_t caid, char *buf, uint32_t buflen);
2368 char *get_picon_servicename_or_null(struct s_client *cl, uint16_t srvid, uint32_t provid, uint16_t caid, char *buf, uint32_t buflen);
2369 int32_t picon_servicename_remve_hd(char *buf, uint32_t buflen);
2370 char *get_tiername(uint16_t tierid, uint16_t caid, char *buf);
2371 char *get_tiername_defaultid(uint16_t tierid, uint16_t caid, char *buf);
2372 char *get_provider(uint32_t provid, uint16_t caid, char *buf, uint32_t buflen);
2373 char *get_providername(uint32_t provid, uint16_t caid, char *buf, uint32_t buflen);
2374 char *get_providername_or_null(uint32_t provid, uint16_t caid, char *buf, uint32_t buflen);
2375 void add_provider(uint16_t caid, uint32_t provid, const char *name, const char *sat, const char *lang);
2376 const char *get_cl_lastprovidername(struct s_client *cl);
2377 bool boxtype_is(const char *boxtype);
2378 bool boxname_is(const char *boxname);
2379 const char *boxtype_get(void);
2380 const char *boxname_get(void);
2381 static inline bool caid_is_fake(uint16_t caid) { return caid == 0xffff; }
2382 static inline bool caid_is_biss(uint16_t caid) { return caid >> 8 == 0x26; }
2383 static inline bool caid_is_seca(uint16_t caid) { return caid >> 8 == 0x01; }
2384 static inline bool caid_is_viaccess(uint16_t caid) { return caid >> 8 == 0x05; }
2385 static inline bool caid_is_irdeto(uint16_t caid) { return caid >> 8 == 0x06; }
2386 static inline bool caid_is_videoguard(uint16_t caid) { return caid >> 8 == 0x09; }
2387 static inline bool caid_is_cryptoworks(uint16_t caid) { return caid >> 8 == 0x0D; }
2388 static inline bool caid_is_betacrypt(uint16_t caid) { return caid >> 8 == 0x17; }
2389 static inline bool caid_is_nagra(uint16_t caid) { return caid >> 8 == 0x18; }
2390 static inline bool caid_is_bulcrypt(uint16_t caid) { return caid == 0x5581 || caid == 0x4AEE; }
2391 static inline bool caid_is_dre(uint16_t caid) { return caid == 0x4AE0 || caid == 0x4AE1 || caid == 0x2710;}
2392 const char *get_cardsystem_desc_by_caid(uint16_t caid);
2393
2394 #endif
Open Source Conditional Access Modul