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