source: trunk/globals.h@ 8454

Last change on this file since 8454 was 8454, checked in by gf, 9 years ago

Add emmreassembly reader setting.

Unfortunately r8441 causes too many errors for clients that do not
try to be smart (like dvbapi, see ticket #3204) so this commit reverts
r8441.

I can't see how to make non assembled and assembled emms to work both,
so I'm forced to introduce reader setting that turns off emm reassembly.

For the documentation:

emmreassembly = [0|1], Default: 1 (EMM reassembly is enabled).

emmreassembly = 0 (disable) should be set for viaccess and cryptoworks
readers if the client that you are using to send EMMs is reassembling
them instead of just sending them to OSCam for processing.

Two such clients are mgcamd and ACamd (over newcamd).

  • Property svn:eol-style set to LF
File size: 55.4 KB
Line 
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 <stddef.h>
9#include <assert.h>
10#include <fcntl.h>
11#include <sys/ioctl.h>
12#include <sys/poll.h>
13#include <ctype.h>
14#include <sys/types.h>
15#include <sys/stat.h>
16#include <sys/wait.h>
17#include <unistd.h>
18#include <sys/mman.h>
19#include <stdarg.h>
20#include <time.h>
21#include <sys/time.h>
22#include <limits.h>
23#include <pwd.h>
24#include <netinet/tcp.h>
25#include <sys/socket.h>
26#include <netinet/in.h>
27#include <arpa/inet.h>
28#include <netdb.h>
29#include <string.h>
30#include <signal.h>
31#include <errno.h>
32#include <pthread.h>
33#include <dirent.h>
34#include <termios.h>
35#include <inttypes.h>
36
37//for reader-nagra variables in s_reader:
38#include "cscrypt/idea.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__)
79# define BSD_COMP
80#endif
81
82#if defined(__HPUX__)
83# define _XOPEN_SOURCE_EXTENDED
84#endif
85
86#if defined(__APPLE__) && !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#include "cscrypt/aes.h"
102#include "cscrypt/bn.h"
103
104#ifndef uchar
105typedef unsigned char uchar;
106#endif
107
108#ifdef IPV6SUPPORT
109#define IN_ADDR_T struct in6_addr
110#define SOCKADDR sockaddr_storage
111#else
112#define IN_ADDR_T in_addr_t
113#define SOCKADDR sockaddr_in
114#endif
115
116#ifndef NO_ENDIAN_H
117 #if defined(__APPLE__)
118 #include <machine/endian.h>
119 #define __BYTE_ORDER __DARWIN_BYTE_ORDER
120 #define __BIG_ENDIAN __DARWIN_BIG_ENDIAN
121 #define __LITTLE_ENDIAN __DARWIN_LITTLE_ENDIAN
122 #elif defined(__FreeBSD__)
123 #include <sys/endian.h>
124 #define __BYTE_ORDER _BYTE_ORDER
125 #define __BIG_ENDIAN _BIG_ENDIAN
126 #define __LITTLE_ENDIAN _LITTLE_ENDIAN
127 #else
128 #include <endian.h>
129 #include <byteswap.h>
130 #endif
131#endif
132
133#ifdef CARDREADER_PCSC
134 #if defined(__CYGWIN__)
135 #define __reserved
136 #define __nullnullterminated
137 #include <specstrings.h>
138 #include "extapi/cygwin/WinSCard.h"
139 #else
140 #include <PCSC/pcsclite.h>
141 #if defined(__APPLE__)
142 #include <PCSC/wintypes.h>
143 #else
144 #include <PCSC/reader.h>
145 #endif
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#ifdef WITH_DEBUG
220# define call(arg) \
221 if (arg) { \
222 cs_debug_mask(D_TRACE, "ERROR, function call %s returns error.",#arg); \
223 return ERROR; \
224 }
225#else
226# define call(arg) \
227 if (arg) { \
228 return ERROR; \
229 }
230#endif
231
232//checking if (X) free(X) unneccessary since freeing a null pointer doesnt do anything
233#define NULLFREE(X) {if (X) {void *tmpX=X; X=NULL; free(tmpX); }}
234
235/* ===========================
236 * constants
237 * =========================== */
238#define CS_VERSION "1.20-unstable_svn"
239#ifndef CS_SVN_VERSION
240# define CS_SVN_VERSION "test"
241#endif
242#ifndef CS_TARGET
243# define CS_TARGET "unknown"
244#endif
245#ifndef CS_CONFDIR
246#define CS_CONFDIR "/usr/local/etc"
247#endif
248#ifndef CS_LOGFILE
249#define CS_LOGFILE "/var/log/oscam.log"
250#endif
251#define CS_QLEN 128 // size of request queue
252#define CS_MAXCAIDTAB 32 // max. caid-defs/user
253#define CS_MAXTUNTAB 50 // max. betatunnel mappings
254#define CS_MAXPROV 32
255#define CS_MAXPORTS 32 // max server ports
256#define CS_MAXFILTERS 16
257#define CS_MAX_CAIDVALUETAB 16
258#define CS_CLIENT_HASHBUCKETS 32
259
260#define CS_ECMSTORESIZE 16 // use MD5()
261#define CS_EMMSTORESIZE 16 // use MD5()
262#define CS_CLIENT_TIMEOUT 5000
263#define CS_CLIENT_MAXIDLE 120
264#define CS_BIND_TIMEOUT 120
265#define CS_DELAY 0
266#define CS_ECM_RINGBUFFER_MAX 0x10 // max size for ECM last responsetimes ringbuffer. Keep this set to power of 2 values!
267
268#ifndef PTHREAD_STACK_MIN
269#define PTHREAD_STACK_MIN 64000
270#endif
271#define PTHREAD_STACK_SIZE PTHREAD_STACK_MIN+32768
272
273#define CS_MAXEMMBLOCKBYLEN 10
274
275#define CS_EMMCACHESIZE 127 //nr of EMMs that each client will cache; cache is per client, so memory-expensive...
276#define MSGLOGSIZE 64 //size of string buffer for a ecm to return messages
277
278#define D_TRACE 0x0001 // Generate very detailed error/trace messages per routine
279#define D_ATR 0x0002 // Debug ATR parsing, dump of ecm, cw
280#define D_READER 0x0004 // Debug Reader/Proxy Process
281#define D_CLIENT 0x0008 // Debug Client Process
282#define D_IFD 0x0010 // Debug IFD+protocol
283#define D_DEVICE 0x0020 // Debug Reader I/O
284#define D_EMM 0x0040 // Dumps EMM
285#define D_DVBAPI 0x0080 // Debug DVBAPI
286#define D_LB 0x0100 // Debug Loadbalancer
287#define D_CACHEEX 0x0200 // Debug CACHEEX
288#define D_CLIENTECM 0x0400 // Debug Client ECMs
289#define D_CSPCWC 0x0800 // Debug CSP/CWC
290#define D_CSPCWCFUL 0x1000 // Debug CSP/CWC FULL
291#define D_ALL_DUMP 0xFFFF // dumps all
292
293#define MAX_DEBUG_LEVELS 11
294
295#define R_DB2COM1 0x1 // Reader Dbox2 @ com1
296#define R_DB2COM2 0x2 // Reader Dbox2 @ com1
297#define R_SC8in1 0x3 // Reader Sc8in1 or MCR
298#define R_MP35 0x4 // AD-Teknik Multiprogrammer 3.5 and 3.6 (only usb tested)
299#define R_MOUSE 0x5 // Reader smartcard mouse
300/////////////////// phoenix readers which need baudrate setting and timings need to be guarded by OSCam: BEFORE R_MOUSE
301#define R_INTERNAL 0x6 // Reader smartcard intern
302/////////////////// internal readers (Dreambox, Coolstream, IPBox) are all R_INTERNAL, they are determined compile-time
303/////////////////// readers that do not reed baudrate setting and timings are guarded by reader itself (large buffer built in): AFTER R_SMART
304#define R_SMART 0x7 // Smartreader+
305#define R_PCSC 0x8 // PCSC
306/////////////////// proxy readers after R_CS378X
307#define R_CAMD35 0x20 // Reader cascading camd 3.5x
308#define R_CAMD33 0x21 // Reader cascading camd 3.3x
309#define R_NEWCAMD 0x22 // Reader cascading newcamd
310#define R_RADEGAST 0x23 // Reader cascading radegast
311#define R_CS378X 0x24 // Reader cascading camd 3.5x TCP
312#define R_CONSTCW 0x25 // Reader for Constant CW
313#define R_CSP 0x26 // Cache CSP
314#define R_GHTTP 0x27 // Reader ghttp
315/////////////////// peer to peer proxy readers after R_CCCAM
316#define R_GBOX 0x30 // Reader cascading gbox
317#define R_CCCAM 0x35 // Reader cascading cccam
318#define R_PANDORA 0x36 // Reader cascading pandora
319#define R_SERIAL 0x80 // Reader serial
320#define R_IS_NETWORK 0x60
321#define R_IS_CASCADING 0xE0
322
323#define is_network_reader(__X) (__X->typ & R_IS_NETWORK)
324#define is_cascading_reader(__X) (__X->typ & R_IS_CASCADING)
325
326//ECM rc codes:
327#define E_FOUND 0
328#define E_CACHE1 1
329#define E_CACHE2 2
330#define E_CACHEEX 3
331///////above is all found
332#define E_NOTFOUND 4 //for selection of found, use < E_NOTFOUND
333#define E_TIMEOUT 5
334#define E_SLEEPING 6
335#define E_FAKE 7
336#define E_INVALID 8
337#define E_CORRUPT 9
338#define E_NOCARD 10
339#define E_EXPDATE 11
340#define E_DISABLED 12
341#define E_STOPPED 13 //for selection of error, use <= E_STOPPED and exclude selection of found
342///////above is all notfound, some error or problem
343#define E_99 99 //this code is undocumented
344#define E_UNHANDLED 100 //for selection of unhandled, use >= E_UNHANDLED
345
346#define CS_MAX_MOD 20
347#define MOD_CONN_TCP 1
348#define MOD_CONN_UDP 2
349#define MOD_CONN_NET 3
350#define MOD_CONN_SERIAL 4
351#define MOD_NO_CONN 8
352
353#define MOD_CARDSYSTEM 16
354#define MOD_ADDON 32
355
356#define EMM_UNIQUE 1
357#define EMM_SHARED 2
358#define EMM_GLOBAL 4
359#define EMM_UNKNOWN 8
360
361//Listener Types
362#define LIS_CAMD33TCP 1
363#define LIS_CAMD35UDP 2
364#define LIS_CAMD35TCP 4
365#define LIS_NEWCAMD 8
366#define LIS_CCCAM 16
367#define LIS_GBOX 32
368#define LIS_RADEGAST 64
369#define LIS_DVBAPI 128
370#define LIS_CONSTCW 256
371#define LIS_SERIAL 1024
372#define LIS_CSPUDP 2048
373
374//EMM types:
375#define UNKNOWN 0
376#define UNIQUE 1
377#define SHARED 2
378#define GLOBAL 3
379
380#define PIP_ID_ECM 0
381#define PIP_ID_EMM 1
382#define PIP_ID_CIN 2 // CARD_INFO
383#define PIP_ID_UDP 3
384#define PIP_ID_MAX PIP_ID_UDP
385#define PIP_ID_ERR (-1)
386#define PIP_ID_NUL (-2)
387
388#define cdiff *c_start
389
390#define NCD_AUTO 0
391#define NCD_524 1
392#define NCD_525 2
393
394// moved from reader-common.h
395#define UNKNOWN 0
396#define CARD_NEED_INIT 1
397#define CARD_INSERTED 2
398#define CARD_FAILURE 3
399#define NO_CARD 4
400
401// moved from stats
402#define DEFAULT_REOPEN_SECONDS 900
403#define DEFAULT_MIN_ECM_COUNT 5
404#define DEFAULT_MAX_ECM_COUNT 500
405#define DEFAULT_NBEST 1
406#define DEFAULT_NFB 1
407#define DEFAULT_RETRYLIMIT 800
408#define DEFAULT_LB_MODE 0
409#define DEFAULT_LB_STAT_CLEANUP 336
410#define DEFAULT_LB_REOPEN_MODE 0
411#define DEFAULT_UPDATEINTERVAL 240
412#define DEFAULT_LB_AUTO_BETATUNNEL 1
413#define DEFAULT_LB_AUTO_BETATUNNEL_MODE 0
414#define DEFAULT_LB_AUTO_BETATUNNEL_PREFER_BETA 50
415
416#define DEFAULT_MAX_CACHE_TIME 15
417#define DEFAULT_MAX_CACHE_COUNT 1000
418
419#define DEFAULT_LB_AUTO_TIMEOUT 0
420#define DEFAULT_LB_AUTO_TIMEOUT_P 30
421#define DEFAULT_LB_AUTO_TIMEOUT_T 300
422
423#define DEFAULT_GBOX_MAX_DIST 2
424#define DEFAULT_GBOX_MAX_ECM_SEND 3
425#define DEFAULT_GBOX_RECONNECT 300
426#define CS_GBOX_MAX_LOCAL_CARDS 16
427
428enum {E1_GLOBAL=0, E1_USER, E1_READER, E1_SERVER, E1_LSERVER};
429
430//LB blocking events:
431enum {E2_GLOBAL=0, E2_GROUP, E2_CAID, E2_IDENT, E2_CLASS, E2_CHID, E2_QUEUE, E2_OFFLINE,
432 E2_SID, E2_CCCAM_NOCARD,
433 //From here only LB nonblocking events:
434 E2_CCCAM_NOK1, E2_CCCAM_NOK2, E2_CCCAM_LOOP, E2_WRONG_CHKSUM, E2_RATELIMIT};
435
436#define LB_NONBLOCK_E2_FIRST E2_CCCAM_NOK1
437
438#define CTA_RES_LEN 512
439
440#define MAX_ATR_LEN 33 // max. ATR length
441#define MAX_HIST 15 // max. number of historical characters
442
443#define MAX_SIDBITS 64 // max services
444#define SIDTABBITS uint64_t // 64bit type for services, if a system does not support this type,
445 // please use a define and define it as uint32_t / MAX_SIDBITS 32
446
447#define BAN_UNKNOWN 1 // Failban mask for anonymous/ unknown contact
448#define BAN_DISABLED 2 // Failban mask for Disabled user
449#define BAN_SLEEPING 4 // Failban mask for sleeping user
450#define BAN_DUPLICATE 8 // Failban mask for duplicate user
451
452#define MAX_HTTP_DYNDNS 3 // maximum allowed Dyndns addresses for webif access
453
454#define CHECK_WAKEUP 1
455#define CHECK_ANTICASCADER 2
456#define CHECK_ECMCACHE 3
457
458#define AVAIL_CHECK_CONNECTED 0
459#define AVAIL_CHECK_LOADBALANCE 1
460
461#define ECM_FMT_LEN 109 //64
462#define CXM_FMT_LEN 209 // 160
463
464#define LB_MAX_STAT_TIME 10
465
466#if defined(__APPLE__) || defined(__FreeBSD__)
467#define OSCAM_SIGNAL_WAKEUP SIGCONT
468#else
469#define OSCAM_SIGNAL_WAKEUP SIGRTMAX-2
470#endif
471
472#define READER_ACTIVE 0x01
473#define READER_FALLBACK 0x02
474#define READER_LOCAL 0x04
475#define READER_CACHEEX 0x08
476
477#define REQUEST_SENT 0x10
478#define REQUEST_ANSWERED 0x20
479
480/* ===========================
481 * Default Values
482 * =========================== */
483#define DEFAULT_INACTIVITYTIMEOUT 0
484#define DEFAULT_TCP_RECONNECT_TIMEOUT 30
485#define DEFAULT_NCD_KEEPALIVE 0
486
487#define DEFAULT_CC_MAXHOPS 10
488#define DEFAULT_CC_RESHARE -1 // Use global cfg
489#define DEFAULT_CC_IGNRSHR -1 // Use global cfg
490#define DEFAULT_CC_STEALTH -1 // Use global cfg
491#define DEFAULT_CC_KEEPALIVE 0
492#define DEFAULT_CC_RECONNECT 12000
493#define DEFAULT_CC_RECV_TIMEOUT 2000
494
495#define DEFAULT_AC_USERS -1 // Use global cfg
496#define DEFAULT_AC_PENALTY -1 // Use global cfg
497
498// Return MPEG section length
499#define SCT_LEN(sct) (3+((sct[1]&0x0f)<<8)+sct[2])
500// Used by readers
501#define MAX_LEN 256
502
503#define NO_CAID_VALUE 0xfffe
504#define NO_SRVID_VALUE 0xfffe
505
506// If NULL return empty string
507#define ESTR(x) ((x) ? (x) : "")
508
509#ifndef MAX
510#define MAX(a,b) ((a) > (b) ? (a) : (b))
511#endif
512
513#ifndef MIN
514#define MIN(a,b) ((a) < (b) ? (a) : (b))
515#endif
516
517/*
518 See: http://stackoverflow.com/questions/10269685/kernels-container-of-any-way-to-make-it-iso-conforming
519 http://www.kroah.com/log/linux/container_of.html
520*/
521#define container_of(ptr, type, member) \
522 ((type *) ((char *) (ptr) - offsetof(type, member) + \
523 (&((type *) 0)->member == (ptr)) * 0))
524
525/* ===========================
526 * global structures
527 * =========================== */
528struct timeb {
529 time_t time;
530 uint16_t millitm;
531};
532
533typedef struct cs_mutexlock {
534 int32_t timeout;
535 pthread_mutex_t lock;
536 pthread_cond_t writecond, readcond;
537 const char *name;
538 int8_t flag;
539 int16_t writelock, readlock;
540} CS_MUTEX_LOCK;
541
542#include "oscam-llist.h"
543
544typedef struct s_caidvaluetab {
545 uint16_t n;
546 uint16_t caid[CS_MAX_CAIDVALUETAB];
547 uint16_t value[CS_MAX_CAIDVALUETAB];
548} CAIDVALUETAB;
549
550typedef struct s_classtab {
551 uchar an;
552 uchar bn;
553 uchar aclass[31];
554 uchar bclass[31];
555} CLASSTAB;
556
557typedef struct s_caidtab {
558 uint16_t caid[CS_MAXCAIDTAB];
559 uint16_t mask[CS_MAXCAIDTAB];
560 uint16_t cmap[CS_MAXCAIDTAB];
561} CAIDTAB;
562
563typedef struct s_tuntab {
564 uint16_t n;
565 uint16_t bt_caidfrom[CS_MAXTUNTAB];
566 uint16_t bt_caidto[CS_MAXTUNTAB];
567 uint16_t bt_srvid[CS_MAXTUNTAB];
568} TUNTAB;
569
570typedef struct s_sidtab {
571 char label[64];
572 uint16_t num_caid;
573 uint16_t num_provid;
574 uint16_t num_srvid;
575 uint16_t *caid;
576 uint32_t *provid;
577 uint16_t *srvid;
578 struct s_sidtab *next;
579} SIDTAB;
580
581typedef struct s_filter {
582 uint16_t caid;
583 uchar nprids;
584 uint32_t prids[CS_MAXPROV];
585} FILTER;
586
587typedef struct s_ftab {
588 int32_t nfilts;
589 FILTER filts[CS_MAXFILTERS];
590} FTAB;
591
592typedef struct s_port {
593 int32_t fd;
594 int32_t s_port;
595 int32_t ncd_key_is_set; //0 or 1
596 uint8_t ncd_key[14];
597 FTAB ftab;
598} PORT;
599
600typedef struct s_ptab {
601 int32_t nports;
602 PORT ports[CS_MAXPORTS];
603} PTAB;
604
605typedef struct aes_entry {
606 uint16_t keyid;
607 uint16_t caid;
608 uint32_t ident;
609 uchar plainkey[16];
610 AES_KEY key;
611 struct aes_entry *next;
612} AES_ENTRY;
613
614struct s_ecm {
615 uchar ecmd5[CS_ECMSTORESIZE];
616 uchar cw[16];
617 uint16_t caid;
618 uint64_t grp;
619 struct s_reader *reader;
620 int32_t rc;
621 time_t time;
622};
623
624struct s_emm {
625 uchar emmd5[CS_EMMSTORESIZE];
626 uchar type;
627 int32_t count;
628};
629
630typedef struct v_ban { // Failban listmember
631 int32_t v_count;
632 IN_ADDR_T v_ip;
633 int32_t v_port;
634 time_t v_time;
635 char *info;
636} V_BAN;
637
638typedef struct s_cacheex_stat_entry { // Cacheex stats listmember
639 int32_t cache_count;
640 time_t cache_last;
641 uint16_t cache_caid;
642 uint16_t cache_srvid;
643 uint32_t cache_prid;
644 int8_t cache_direction; // 0 = push / 1 = got
645} S_CACHEEX_STAT_ENTRY;
646
647typedef struct s_entitlement { // contains entitlement Info
648 uint64_t id; // the element ID
649 uint32_t type; // enumerator for tier,chid whatever
650 // 0="", 1="Package", 2="PPV-Event", 3="chid", 4="tier", 5 = "class", 6 = "PBM". 7 = "seca-admin"
651 uint16_t caid; // the caid of element
652 uint32_t provid; // the provid of element
653 uint32_t class; // the class needed for some systems
654 time_t start; // startdate
655 time_t end; // enddate
656} S_ENTITLEMENT;
657
658struct s_client ;
659struct ecm_request_t ;
660struct emm_packet_t ;
661struct s_ecm_answer ;
662
663struct s_module {
664 int8_t active;
665 int8_t type;
666 int8_t large_ecm_support;
667 int16_t listenertype;
668 char *desc;
669 //int32_t s_port;
670 IN_ADDR_T s_ip;
671 uint16_t bufsize;
672 void *(*s_handler)(struct s_client *, uchar *, int32_t);
673 void (*s_init)(struct s_client *);
674 int32_t (*recv)(struct s_client *, uchar *, int32_t);
675 void (*send_dcw)(struct s_client*, struct ecm_request_t *);
676 void (*cleanup)(struct s_client*);
677 int32_t (*c_recv_chk)(struct s_client*, uchar *, int32_t *, uchar *, int32_t);
678 int32_t (*c_init)(struct s_client*);
679 int32_t (*c_send_ecm)(struct s_client *, struct ecm_request_t *, uchar *);
680 int32_t (*c_send_emm)(struct emm_packet_t *);
681 int32_t (*c_available)(struct s_reader *, int32_t, struct ecm_request_t *); //Schlocke: available check for load-balancing,
682 // params:
683 // rdr (reader to check)
684 // int32_t checktype (0=return connected, 1=return loadbalance-avail) return int
685 void (*c_idle)(void); // Schlocke: called when reader is idle
686 void (*s_idle)(struct s_client*);
687 void (*c_card_info)(void); // Schlocke: request card infos
688#ifdef CS_CACHEEX
689 int32_t (*c_cache_push)(struct s_client*, struct ecm_request_t *); //Cache push
690 int32_t (*c_cache_push_chk)(struct s_client*, struct ecm_request_t *); //Cache push Node Check, 0=no push
691#endif
692 int32_t c_port;
693 PTAB *ptab;
694 int32_t num;
695};
696
697struct s_ATR ;
698
699struct s_cardreader
700{
701 char *desc;
702 int32_t (*reader_init)(struct s_reader*);
703 int32_t (*get_status)(struct s_reader*, int*);
704 int32_t (*activate)(struct s_reader*, struct s_ATR *);
705 int32_t (*transmit)(struct s_reader*, unsigned char *sent, uint32_t size, uint32_t delay, uint32_t timeout);
706 int32_t (*receive)(struct s_reader*, unsigned char *data, uint32_t size, uint32_t delay, uint32_t timeout);
707 int32_t (*lock_init)(struct s_reader *);
708 void (*lock)(struct s_reader *);
709 void (*unlock)(struct s_reader *);
710 int32_t (*close)(struct s_reader*);
711 int32_t (*set_parity)(struct s_reader*, uchar parity);
712 // FIXME: All parameters passed to write_settingsX should be put in a struct
713 int32_t (*write_settings)(struct s_reader*,
714 uint32_t ETU,
715 uint32_t EGT,
716 unsigned char P,
717 unsigned char I,
718 uint16_t Fi,
719 unsigned char Di,
720 unsigned char Ni);
721 // FIXME: write_settings2 is used by coolstream reader
722 int32_t (*write_settings2)(struct s_reader *, uint32_t EGT, uint32_t BGT);
723 // FIXME: write_settings3 is used by sci reader
724 int32_t (*write_settings3)(struct s_reader *, uint32_t ETU, uint32_t WWT, uint32_t I);
725 int32_t (*set_protocol)(struct s_reader*,
726 unsigned char * params,
727 uint32_t *length,
728 uint32_t len_request);
729 int32_t (*set_baudrate)(struct s_reader*,
730 uint32_t baud); //set only for readers which need baudrate setting and timings need to be guarded by OSCam
731 int32_t (*card_write)(struct s_reader *pcsc_reader,
732 const uchar *buf,
733 unsigned char *cta_res,
734 uint16_t *cta_lr,
735 int32_t l);
736 void (*display_msg)(struct s_reader *, char *msg);
737 void (*set_transmit_timeout)(struct s_reader *);
738
739 int32_t (*do_reset)(struct s_reader *, struct s_ATR *,
740 int32_t (*rdr_activate_card)(struct s_reader *, struct s_ATR *, uint16_t deprecated),
741 int32_t (*rdr_get_cardsystem)(struct s_reader *, struct s_ATR *));
742
743 bool (*set_DTS_RTS)(struct s_reader *, int32_t *dtr, int32_t *rts);
744
745 int32_t typ; // fixme: workaround, remove when all old code is converted
746
747 int8_t max_clock_speed; // 1 for reader->typ > R_MOUSE
748 int8_t need_inverse; // 0 = reader does inversing; 1 = inversing done by oscam
749 //io_serial config
750 int8_t flush;
751 int8_t read_written; // 1 = written bytes has to read from device
752 int8_t timings_in_etu; // timings in ETU instead of us
753 bool skip_extra_atr_parsing;
754 bool skip_t1_command_retries;
755 bool skip_setting_ifsc;
756};
757
758struct s_cardsystem {
759 int8_t active;
760 char *desc;
761 int32_t (*card_init)(struct s_reader *reader, struct s_ATR *);
762 int32_t (*card_info)(struct s_reader *);
763 int32_t (*do_ecm)(struct s_reader *, const struct ecm_request_t *, struct s_ecm_answer *);
764 bool (*do_emm_reassembly)(struct s_reader *, struct emm_packet_t *); // Returns 1/true if the EMM is ready to be written in the card
765 int32_t (*do_emm)(struct s_reader *, struct emm_packet_t *);
766 void (*post_process)(struct s_reader *);
767 int32_t (*get_emm_type)(struct emm_packet_t *, struct s_reader *);
768 void (*get_emm_filter)(struct s_reader * rdr, uchar *filter);
769 uint16_t caids[2];
770};
771
772struct s_irdeto_quess {
773 int32_t b47;
774 uint16_t caid;
775 uint16_t sid;
776 struct s_irdeto_quess *next;
777};
778
779#define MAX_ECM_SIZE 512
780
781typedef struct ecm_request_t {
782 uchar ecm[MAX_ECM_SIZE];
783 uchar cw[16];
784 uchar ecmd5[CS_ECMSTORESIZE];
785 int16_t ecmlen;
786 uint16_t caid;
787 uint16_t ocaid; //original caid, used for betatunneling
788 uint16_t srvid;
789 uint16_t onid;
790 uint16_t tsid;
791 uint32_t ens;
792 uint16_t chid;
793 uint16_t pid;
794 uint16_t idx;
795 uint32_t prid;
796 struct s_reader *selected_reader;
797 struct s_ecm_answer *matching_rdr; //list of matching readers
798 const struct s_reader *fallback; //fallback is the first fallback reader in the list matching_rdr
799 struct s_client *client; //contains pointer to 'c' client while running in 'r' client
800 uint64_t grp;
801 int32_t msgid; // client pending table index
802 uint8_t stage; // processing stage in server module
803 int8_t rc;
804 uint8_t rcEx;
805 struct timeb tps; // incoming time stamp
806 uchar locals_done;
807 int8_t btun; // mark er as betatunneled
808 uint16_t reader_avail; // count of available readers
809 uint16_t reader_count; // count of contacted readers
810 uint16_t reader_requested; // count of real requested readers
811 int8_t checked; //for doublecheck
812 uchar cw_checked[16]; //for doublecheck
813 struct s_reader *origin_reader;
814
815#if defined MODULE_CCCAM
816 void *origin_card; // CCcam preferred card!
817#endif
818
819#if defined MODULE_GBOX
820 uint32_t gbox_crc; // rcrc for gbox, used to identify ECM task in peer responses
821 uint16_t gbox_ecm_id;
822 uint8_t gbox_ecm_ok;
823#endif
824
825 void *src_data;
826 struct ecm_request_t *ecmcacheptr; // Pointer to ecm-cw-rc-cache!
827#ifdef CS_CACHEEX
828 uchar cacheex_done;
829 struct s_client *cacheex_src; // Cacheex origin
830 int8_t cacheex_pushed; // to avoid duplicate pushs
831 int32_t csp_hash; // csp has its own hash
832 LLIST *csp_lastnodes; // last 10 Cacheex nodes atm cc-proto-only
833 uint32_t cacheex_wait_time; // cacheex wait time in ms
834 struct timeb cacheex_wait; // incoming time stamp (tps) + cacheex wait time
835#endif
836 char msglog[MSGLOGSIZE];
837 struct ecm_request_t *parent;
838 struct ecm_request_t *next;
839} ECM_REQUEST;
840
841
842struct s_ecm_answer {
843 uint8_t status;
844 struct s_reader *reader;
845 ECM_REQUEST *er;
846 int8_t rc;
847 uint8_t rcEx;
848 uchar cw[16];
849 char msglog[MSGLOGSIZE];
850#ifdef WITH_LB
851 int32_t value;
852 int32_t time;
853#endif
854 struct s_ecm_answer *next;
855};
856
857struct s_acasc_shm {
858 uint16_t ac_count : 15;
859 uint16_t ac_deny : 1;
860};
861
862struct s_acasc {
863 uint16_t stat[10];
864 uchar idx; // current active index in stat[]
865};
866
867struct s_cwresponse {
868 int32_t duration;
869 time_t timestamp;
870 int32_t rc;
871};
872
873struct s_cascadeuser {
874 uint16_t caid;
875 uint32_t prid;
876 uint16_t srvid;
877 time_t time;
878 int8_t cwrate;
879};
880
881typedef struct sidtabs {
882 SIDTABBITS ok; // positive services
883 SIDTABBITS no; // negative services
884} SIDTABS;
885
886struct s_client {
887 uint32_t tid;
888 int8_t init_done;
889 pthread_mutex_t thread_lock;
890 int8_t thread_active;
891 int8_t kill;
892 LLIST *joblist;
893 IN_ADDR_T ip;
894 in_port_t port;
895 time_t login; // connection
896 time_t logout; // disconnection
897 time_t last;
898 time_t lastswitch;
899 time_t lastemm;
900 time_t lastecm;
901 time_t expirationdate;
902 int32_t allowedtimeframe[2];
903 int8_t c35_suppresscmd08;
904 uint8_t c35_sleepsend;
905 int8_t ncd_keepalive;
906 int8_t disabled;
907 uint64_t grp;
908 int8_t crypted;
909 int8_t dup;
910 LLIST *aureader_list;
911 int8_t autoau;
912 int8_t monlvl;
913 CAIDTAB ctab;
914 TUNTAB ttab;
915 SIDTABS sidtabs;
916 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
917 uint8_t module_idx;
918 uint16_t last_srvid;
919 uint16_t last_caid;
920 struct s_srvid *last_srvidptr;
921 int32_t tosleep;
922 struct s_auth *account;
923 int32_t udp_fd;
924 struct SOCKADDR udp_sa;
925 socklen_t udp_sa_len;
926 int8_t log;
927 int32_t logcounter;
928 int32_t cwfound; // count found ECMs per client
929 int32_t cwcache; // count ECMs from cache1/2 per client
930 int32_t cwnot; // count not found ECMs per client
931 int32_t cwtun; // count betatunneled ECMs per client
932 int32_t cwignored; // count ignored ECMs per client
933 int32_t cwtout; // count timeouted ECMs per client
934 int32_t cwlastresptime; //last Responsetime (ms)
935#ifdef CW_CYCLE_CHECK
936 int32_t cwcycledchecked; // count checked cwcycles per client
937 int32_t cwcycledok; // count pos checked cwcycles per client
938 int32_t cwcyclednok; // count neg checked cwcycles per client
939 int32_t cwcycledign; // count ign cwcycles per client
940#endif
941 int32_t emmok; // count EMM ok
942 int32_t emmnok; // count EMM nok
943 int8_t pending; // number of ECMs pending
944#ifdef CS_CACHEEX
945 int32_t cwcacheexpush; // count pushed ecms/cws
946 int32_t cwcacheexgot; // count got ecms/cws
947 int32_t cwcacheexhit; // count hit ecms/cws
948 LLIST *ll_cacheex_stats; // List for Cacheex statistics
949 int8_t cacheex_maxhop;
950 int32_t cwcacheexerr; //cw=00 or chksum wrong
951 int32_t cwcacheexerrcw; //Same Hex, different CW
952#endif
953
954#ifdef WEBIF
955 struct s_cwresponse cwlastresptimes[CS_ECM_RINGBUFFER_MAX]; //ringbuffer for last 20 times
956 int32_t cwlastresptimes_last; // ringbuffer pointer
957 int8_t wihidden; // hidden in webinterface status
958 char lastreader[64]; // last cw got from this reader
959#endif
960
961 uchar ucrc[4]; // needed by monitor and used by camd35
962 uint32_t pcrc; // password crc
963 AES_KEY aeskey; // encryption key needed by monitor and used by camd33, camd35
964 AES_KEY aeskey_decrypt; // decryption key needed by monitor and used by camd33, camd35
965 uint16_t ncd_msgid;
966 uint16_t ncd_client_id;
967 uchar ncd_skey[16]; //Also used for camd35 Cacheex to store remote node id
968
969#ifdef MODULE_CCCAM
970 void *cc;
971#endif
972
973#ifdef MODULE_GBOX
974 void *gbox;
975 uint8_t gbox_cw_id[2];
976 uint8_t gbox_peer_id[2];
977 uint8_t gbox_ver;
978#endif
979
980#ifdef MODULE_GHTTP
981 void *ghttp;
982#endif
983
984 int32_t port_idx; // index in server ptab
985 int32_t ncd_server; // newcamd server
986
987#ifdef CS_ANTICASC
988 int32_t ac_fakedelay; // When this is -1, the global ac_fakedelay is used
989 uint16_t ac_limit;
990 int8_t ac_penalty;
991 struct s_acasc_shm acasc;
992#endif
993
994 FTAB fchid;
995 FTAB ftab; // user [caid] and ident filter
996 CLASSTAB cltab;
997
998 int32_t pfd; // Primary FD, must be closed on exit
999 struct s_reader *reader; // points to s_reader when cl->typ='r'
1000
1001 ECM_REQUEST *ecmtask;
1002 struct s_emm *emmcache;
1003
1004 pthread_t thread;
1005
1006#ifdef MODULE_SERIAL
1007 struct s_serial_client *serialdata;
1008#endif
1009 //reader common
1010 int32_t last_idx;
1011 uint16_t idx;
1012 int8_t rotate;
1013
1014 int8_t ncd_proto;
1015 uint8_t ncd_header[12];
1016
1017 //camd35
1018 uchar upwd[64];
1019 int8_t is_udp;
1020 int8_t stopped;
1021 uint16_t lastcaid;
1022 uint16_t lastsrvid;
1023 int32_t lastpid;
1024 time_t emm_last;
1025 int8_t disable_counter;
1026 uchar lastserial[8];
1027
1028 //monitor
1029 int8_t auth;
1030
1031 //oscam.c
1032 struct timeval tv;
1033
1034 // Failban value set bitwise - compared with BAN_
1035 int32_t failban;
1036 int8_t cleaned;
1037
1038 LLIST *cascadeusers; //s_cascadeuser
1039
1040#ifdef MODULE_PANDORA
1041 int32_t pand_autodelay;
1042 uint8_t pand_send_ecm;
1043 uchar pand_ignore_ecm;
1044 uchar pand_md5_key[16];
1045#endif
1046
1047 struct s_client *next; //make client a linked list
1048 struct s_client *nexthashed;
1049};
1050
1051struct geo_cache { //for viaccess var in s_reader:
1052 uint32_t provid;
1053 uchar geo[256];
1054 uchar geo_len;
1055 int32_t number_ecm;
1056};
1057
1058struct s_CmdTabEntry { // for videoguard in s_reader
1059 unsigned char cla;
1060 unsigned char cmd;
1061 unsigned char len;
1062 unsigned char mode;
1063};
1064
1065struct s_CmdTab {
1066 unsigned char index;
1067 unsigned char size;
1068 unsigned char Nentries;
1069 unsigned char dummy;
1070 struct s_CmdTabEntry e[1];
1071};
1072
1073struct s_ecmWhitelist {
1074 uint16_t caid;
1075 struct s_ecmWhitelistIdent *idents;
1076 struct s_ecmWhitelist *next;
1077};
1078
1079struct s_ecmWhitelistIdent {
1080 uint32_t ident;
1081 struct s_ecmWhitelistLen *lengths;
1082 struct s_ecmWhitelistIdent *next;
1083};
1084
1085struct s_ecmWhitelistLen {
1086 int16_t len;
1087 struct s_ecmWhitelistLen *next;
1088};
1089
1090struct s_ecmHeaderwhitelist {
1091 uint16_t caid;
1092 uint32_t provid;
1093 uchar header[20];
1094 int16_t len;
1095 struct s_ecmHeaderwhitelist *next;
1096};
1097
1098//ratelimit
1099struct ecmrl {
1100 uint16_t srvid;
1101 time_t last;
1102 uchar ecmd5[CS_ECMSTORESIZE];
1103
1104};
1105#define MAXECMRATELIMIT 20
1106
1107struct s_sc8in1_display {
1108 char *text;
1109 uint16_t text_length;
1110 uint16_t char_change_time;
1111 uint16_t last_char;
1112 uint8_t blocking;
1113 struct s_sc8in1_display *next;
1114};
1115struct s_sc8in1_config {
1116 struct termios stored_termio[8];
1117 uint16_t current_slot;
1118 uint32_t current_baudrate;
1119 struct s_reader *current_reader;
1120 unsigned char cardstatus;
1121 unsigned char mcr_type;
1122 CS_MUTEX_LOCK sc8in1_lock;
1123 struct s_sc8in1_display *display;
1124 CS_MUTEX_LOCK sc8in1_display_lock;
1125 unsigned char display_running;
1126 pthread_t display_thread;
1127};
1128
1129#ifdef CS_CACHEEX
1130typedef struct ce_csp_tab {
1131 uint16_t n;
1132 int32_t caid[CS_MAXCAIDTAB];
1133 int32_t cmask[CS_MAXCAIDTAB];
1134 int32_t prid[CS_MAXCAIDTAB];
1135 int32_t srvid[CS_MAXCAIDTAB];
1136 int16_t awtime[CS_MAXCAIDTAB];
1137 int16_t dwtime[CS_MAXCAIDTAB];
1138} CECSPVALUETAB;
1139
1140typedef struct ce_csp_t {
1141 int8_t mode;
1142 int8_t maxhop;
1143 CECSPVALUETAB filter_caidtab;
1144 uint8_t allow_request;
1145 uint8_t drop_csp;
1146} CECSP;
1147#endif
1148
1149struct s_reader //contains device info, reader info and card info
1150{
1151 uint8_t changes_since_shareupdate;
1152 int32_t resetcycle; // ECM until reset
1153 int32_t resetcounter; // actual count
1154 uint32_t auprovid; // AU only for this provid
1155 int8_t audisabled; // exclude reader from auto AU
1156 int8_t smargopatch;
1157 struct s_client *client; // pointer to 'r'client this reader is running in
1158 LLIST *ll_entitlements; // entitlements
1159 int8_t enable;
1160 int8_t active;
1161 int8_t dropbadcws; // Schlocke: 1=drops cw if checksum is wrong. 0=fix checksum (default)
1162 int8_t disablecrccws; // 1=disable cw checksum test. 0=enable checksum check
1163 int8_t fd_error;
1164 uint64_t grp;
1165 int8_t fallback;
1166#ifdef CS_CACHEEX
1167 CECSP cacheex; //CacheEx Settings
1168#endif
1169 int32_t typ;
1170#ifdef WITH_COOLAPI
1171 int32_t cool_timeout_init; // read/transmit timeout while init for coolstream internal reader
1172 int32_t cool_timeout_after_init; // read/transmit timeout after init for coolstream internal reader
1173#endif
1174 char label[64];
1175#ifdef WEBIF
1176 char *description;
1177#endif
1178 char device[128];
1179 void *spec_dev; // pointer to structure that contains specific device data
1180 uint16_t slot; // in case of multiple slots like sc8in1; first slot = 1
1181 int32_t handle; // device handle
1182 int32_t fdmc; // device handle for multicam
1183#ifdef WITH_STAPI
1184 uint32_t stsmart_handle; // device handle for stsmart driver
1185#endif
1186 char pcsc_name[128];
1187 int8_t pcsc_has_card;
1188 int32_t detect;
1189 int32_t mhz; // actual clock rate of reader in 10khz steps
1190 int32_t cardmhz; // standard clock speed your card should have in 10khz steps; normally 357 but for Irdeto cards 600
1191 int32_t divider; // PLL divider for internal readers
1192 int32_t r_port;
1193 char r_usr[64];
1194 char r_pwd[64];
1195 char l_pwd[64];
1196 int32_t l_port;
1197 CAIDTAB ctab;
1198 uint32_t boxid;
1199 int8_t nagra_read; // read nagra ncmed records: 0 Disabled (default), 1 read all records, 2 read valid records only
1200 uint8_t boxkey[8]; // n3 boxkey 8byte
1201 char country_code[3]; // irdeto country code.
1202 int8_t force_irdeto;
1203 uchar rsa_mod[120]; // rsa modulus for nagra cards.
1204 uchar atr[64];
1205 uchar card_atr[64]; // ATR readed from card
1206 int8_t card_atr_length; // length of ATR
1207 int32_t atrlen;
1208 SIDTABS sidtabs;
1209 uchar hexserial[8];
1210 int32_t nprov;
1211 uchar prid[CS_MAXPROV][8];
1212 uchar availkeys[CS_MAXPROV][16]; // viaccess; misused in seca, if availkeys[PROV][0]=0 then expired, 1 then valid.
1213 uchar sa[CS_MAXPROV][4]; // viaccess & seca
1214 uint16_t acs; // irdeto
1215 uint16_t caid;
1216 uint16_t b_nano;
1217 uint16_t s_nano;
1218 int8_t ecmcommand; // used for filtering nagra bad ecm commands
1219 uchar ecmcommandcache[4]; // cachebuff for ecm commands
1220 int32_t blockemm;
1221 int32_t saveemm;
1222 int16_t blockemmbylen[CS_MAXEMMBLOCKBYLEN];
1223 char *emmfile;
1224 char pincode[5];
1225 int32_t ucpk_valid;
1226 int8_t logemm;
1227 int8_t cachemm;
1228 int16_t rewritemm;
1229 int8_t card_status;
1230 int8_t deprecated; //if 0 ATR obeyed, if 1 default speed (9600) is chosen; for devices that cannot switch baudrate
1231 int32_t reassemble_emm_len;
1232 uint8_t reassemble_emm[512];
1233 struct s_module ph;
1234 struct s_cardreader crdr;
1235 struct s_cardsystem csystem;
1236 uint8_t ncd_key[14];
1237 uchar ncd_skey[16];
1238 int8_t ncd_connect_on_init;
1239 int8_t ncd_disable_server_filt;
1240 int8_t ncd_proto;
1241 int8_t currenthops; // number of hops (cccam & gbox)
1242#ifdef MODULE_CCCAM
1243 char cc_version[7]; // cccam version
1244 char cc_build[7]; // cccam build number
1245 int8_t cc_maxhops; // cccam max distance
1246 int8_t cc_mindown; // cccam min downhops
1247 int8_t cc_want_emu; // Schlocke: Client want to have EMUs, 0 - NO; 1 - YES
1248 uint32_t cc_id;
1249 int8_t cc_keepalive;
1250 int8_t cc_hop; // For non-cccam reader: hop for virtual cards
1251 int8_t cc_reshare;
1252 int32_t cc_reconnect; //reconnect on ecm-request timeout
1253#endif
1254 int8_t tcp_connected;
1255 int32_t tcp_ito; // inactivity timeout
1256 int32_t tcp_rto; // reconnect timeout
1257 struct timeb tcp_block_connect_till; //time tcp connect ist blocked
1258 int32_t tcp_block_delay; //incrementing block time
1259 time_t last_g; // get (if last_s-last_g>tcp_rto - reconnect )
1260 time_t last_s; // send
1261 time_t last_check; // last checked
1262 FTAB fchid;
1263 FTAB ftab;
1264 CLASSTAB cltab;
1265 struct s_ecmWhitelist *ecmWhitelist;
1266 struct s_ecmHeaderwhitelist *ecmHeaderwhitelist; // ECM Header Whitelist
1267 int32_t brk_pos;
1268 int32_t msg_idx;
1269 int32_t secatype; // 0=not determined, 2=seca2, 3=nagra(~seca3) this is only valid for localreaders!
1270 double worketu; // in us for internal and external readers calculated (1/D)*(F/cardclock)*1000000
1271 uint32_t maxreadtimeout; // in us
1272 uint32_t minreadtimeout; // in us
1273 uint32_t maxwritetimeout; // in us
1274 uint32_t minwritetimeout; // in us
1275#if defined(WEBIF) || defined(LCDSUPPORT)
1276 int32_t emmwritten[4]; // count written EMM
1277 int32_t emmskipped[4]; // count skipped EMM
1278 int32_t emmerror[4]; // count error EMM
1279 int32_t emmblocked[4]; // count blocked EMM
1280 int32_t lbvalue; // loadbalance Value
1281#endif
1282#ifdef CARDREADER_PCSC
1283 SCARDCONTEXT hContext;
1284 SCARDHANDLE hCard;
1285 DWORD dwActiveProtocol;
1286#endif
1287#ifdef CARDREADER_SMART
1288 struct s_sr_config *sr_config;
1289#endif
1290#ifdef WITH_AZBOX
1291 int32_t azbox_mode;
1292#endif
1293 int32_t use_gpio; // Should this reader use GPIO functions
1294 int gpio_outen; // fd of opened /dev/gpio/outen
1295 int gpio_out; // fd of opened /dev/gpio/out
1296 int gpio_in; // fd of opened /dev/gpio/in
1297 uint32_t gpio; // gpio addr
1298 ////variables from icc_async.h start
1299#ifdef WITH_CARDREADER
1300 int32_t convention; // Convention of this ICC
1301 unsigned char protocol_type; // Type of protocol
1302 uint32_t current_baudrate; // (for overclocking uncorrected) baudrate to prevent unnecessary conversions from/to termios structure
1303 uint32_t read_timeout; // Max timeout (ms) to receive characters
1304 uint32_t block_delay; // Delay (ms) after starting to transmit
1305 uint32_t char_delay; // Delay (ms) after transmiting each sucesive char
1306 ////variables from io_serial.h
1307 int32_t written; // keep score of how much bytes are written to serial port, since they are echoed back they have to be read
1308#endif
1309 uint32_t BWT,CWT; // (for overclocking uncorrected) block waiting time, character waiting time, in ETU
1310 ////variables from protocol_t1.h
1311 uint16_t ifsc; // Information field size for the ICC
1312 unsigned char ns; // Send sequence number
1313 ////variables from reader-dre.c
1314 unsigned char provider;
1315 ////variables from reader-nagra.c
1316 IDEA_KEY_SCHEDULE ksSession;
1317 int8_t is_pure_nagra;
1318 int8_t is_tiger;
1319 int8_t is_n3_na;
1320 int8_t has_dt08;
1321 int8_t swapCW;
1322 uint8_t ExpiryDate[2];
1323 uint8_t ActivationDate[2];
1324 unsigned char rom[15];
1325 unsigned char plainDT08RSA[64];
1326 unsigned char IdeaCamKey[16];
1327 unsigned char irdId[4];
1328 unsigned char sessi[16];
1329 unsigned char signature[8];
1330 unsigned char cam_state[3];
1331 ////variables from reader-irdeto.c
1332 int32_t acs57; // A flag for the ACS57 ITA DVB-T
1333 ////variables from reader-cryptoworks.c
1334 BIGNUM exp;
1335 BIGNUM ucpk;
1336 ////variables from reader-viaccess.c
1337 struct geo_cache last_geo;
1338#ifdef WITH_LB
1339 int32_t lb_weight; //loadbalance weight factor, if unset, weight=100. The higher the value, the higher the usage-possibility
1340 int32_t lb_usagelevel; //usagelevel for loadbalancer
1341 int32_t lb_usagelevel_ecmcount;
1342 time_t lb_usagelevel_time; //time for counting ecms, this creates usagelevel
1343 struct timeb lb_last; //time for oldest reader
1344 LLIST *lb_stat; //loadbalancer reader statistics
1345 CS_MUTEX_LOCK lb_stat_lock;
1346#endif
1347
1348 AES_ENTRY *aes_list; // multi AES linked list
1349 // variables from reader-videoguard*
1350 int8_t ndsversion; // 0 auto (default), 1 NDS1, 12 NDS1+, 2 NDS2
1351 const char *card_desc;
1352 int32_t card_baseyear;
1353 int32_t card_tierstart;
1354 int32_t card_system_version;
1355 time_t card_valid_to;
1356 struct s_CmdTab *cmd_table;
1357 uint16_t cardkeys[3][32];
1358 unsigned char stateD3A[16];
1359 AES_KEY ekey;
1360 AES_KEY astrokey;
1361 //ratelimit
1362 int32_t ratelimitecm;
1363 int32_t ratelimitseconds;
1364 int8_t ecmunique; // check for matching ecm hash in ratelimitslot
1365 int32_t srvidholdseconds; // seconds to keep srvid in ratelimitslot (during this time not checked for ecmunique!)
1366 time_t lastdvbapirateoverride;
1367 uint32_t ecmsok;
1368 uint32_t ecmsnok;
1369 uint32_t ecmnotfoundlimit; // config setting. restart reader if ecmsnok >= ecmnotfoundlimit
1370 int32_t ecmsfilteredhead; // count filtered ECM's by ECM Headerwhitelist
1371 int32_t ecmsfilteredlen; // count filtered ECM's by ECM Whitelist
1372 float ecmshealthok;
1373 float ecmshealthnok;
1374 int32_t cooldown[2];
1375 int8_t cooldownstate;
1376 time_t cooldowntime;
1377 struct ecmrl rlecmh[MAXECMRATELIMIT];
1378 int8_t fix_9993;
1379 uint8_t ins7E[0x1A+1];
1380 uint8_t ins7E11[0x01+1];
1381 int8_t ins7e11_fast_reset;
1382 struct s_sc8in1_config *sc8in1_config;
1383 uint8_t sc8in1_dtrrts_patch; // fix for kernel commit 6a1a82df91fa0eb1cc76069a9efe5714d087eccd
1384#ifdef MODULE_GBOX
1385 char gbox_my_password[9];
1386 int8_t gbox_maxdist;
1387 int8_t gbox_maxecmsend;
1388 int8_t gbox_reshare;
1389 uint16_t gbox_peer_id;
1390 uint64_t gbox_grp;
1391#endif
1392
1393#ifdef MODULE_PANDORA
1394 uint8_t pand_send_ecm;
1395#endif
1396 uint8_t cnxlastecm; // == 0 - las ecm has not been paired ecm, > 0 last ecm has been paired ecm
1397
1398 uint8_t bulcrypt_version;
1399 uint8_t griffin_cmd_base; // Griffin command base, depends on the card
1400 uint8_t emm_reassembly;
1401
1402 struct s_reader *next;
1403};
1404
1405struct s_cpmap
1406{
1407 uint16_t caid;
1408 uint32_t provid;
1409 uint16_t sid;
1410 uint16_t chid;
1411 uint16_t dwtime;
1412 struct s_cpmap *next;
1413};
1414
1415struct s_auth
1416{
1417 char usr[64];
1418 char *pwd;
1419#ifdef WEBIF
1420 char *description;
1421#endif
1422 int8_t uniq;
1423#ifdef CS_CACHEEX
1424 CECSP cacheex; //CacheEx Settings
1425#endif
1426 int16_t allowedprotocols;
1427 LLIST *aureader_list;
1428 int8_t autoau;
1429 int8_t monlvl;
1430 uint64_t grp;
1431 int32_t tosleep;
1432 CAIDTAB ctab;
1433 SIDTABS sidtabs;
1434 FTAB fchid;
1435 FTAB ftab; // user [caid] and ident filter
1436 CLASSTAB cltab;
1437 TUNTAB ttab;
1438#ifdef CS_ANTICASC
1439 int32_t ac_fakedelay; // When this is -1, the global ac_fakedelay is used
1440 int32_t ac_users; // 0 - unlimited
1441 int8_t ac_penalty; // 0 - log, >0 - fake dw
1442 struct s_acasc ac_stat;
1443#endif
1444 IN_ADDR_T dynip;
1445 char *dyndns;
1446 time_t expirationdate;
1447 time_t firstlogin;
1448 int32_t allowedtimeframe[2];
1449 int8_t c35_suppresscmd08;
1450 uint8_t c35_sleepsend;
1451 int8_t ncd_keepalive;
1452#ifdef MODULE_CCCAM
1453 int32_t cccmaxhops;
1454 int8_t cccreshare;
1455 int8_t cccignorereshare;
1456 int8_t cccstealth;
1457#endif
1458 int8_t disabled;
1459 int32_t failban;
1460
1461 int32_t cwfound;
1462 int32_t cwcache;
1463 int32_t cwnot;
1464 int32_t cwtun;
1465 int32_t cwignored;
1466 int32_t cwtout;
1467#ifdef CW_CYCLE_CHECK
1468 int32_t cwcycledchecked; // count checked cwcycles per client
1469 int32_t cwcycledok; // count pos checked cwcycles per client
1470 int32_t cwcyclednok; // count neg checked cwcycles per client
1471 int32_t cwcycledign; // count ign cwcycles per client
1472#endif
1473 int32_t emmok;
1474 int32_t emmnok;
1475#ifdef CS_CACHEEX
1476 int32_t cwcacheexpush; // count pushed ecms/cws
1477 int32_t cwcacheexgot; // count got ecms/cws
1478 int32_t cwcacheexhit; // count hit ecms/cws
1479 int32_t cwcacheexerr; //cw=00 or chksum wrong
1480 int32_t cwcacheexerrcw; //Same Hex, different CW
1481#endif
1482 struct s_auth *next;
1483};
1484
1485struct s_srvid
1486{
1487 uint16_t srvid;
1488 int8_t ncaid;
1489 uint16_t caid[10];
1490 char *data;
1491 char *prov;
1492 char *name;
1493 char *type;
1494 char *desc;
1495 struct s_srvid *next;
1496};
1497
1498struct s_tierid
1499{
1500 uint16_t tierid;
1501 int8_t ncaid;
1502 uint16_t caid[10];
1503 char name[33];
1504 struct s_tierid *next;
1505};
1506
1507struct s_provid
1508{
1509 uint16_t caid;
1510 uint32_t provid;
1511 char prov[33];
1512 char sat[33];
1513 char lang[33];
1514 struct s_provid *next;
1515};
1516
1517struct s_ip
1518{
1519 IN_ADDR_T ip[2];
1520 struct s_ip *next;
1521};
1522
1523struct s_global_whitelist
1524{
1525 uint32_t line; //linenr of oscam.whitelist file, starting with 1
1526 char type; // w or i or l
1527 uint16_t caid;
1528 uint32_t provid;
1529 uint16_t srvid;
1530 uint16_t chid;
1531 uint16_t pid;
1532 uint16_t ecmlen;
1533 uint16_t mapcaid;
1534 uint32_t mapprovid;
1535 struct s_global_whitelist *next;
1536};
1537
1538struct s_cacheex_matcher
1539{
1540 uint32_t line; //linenr of oscam.Cacheex file, starting with 1
1541 char type; // m
1542 uint16_t caid;
1543 uint32_t provid;
1544 uint16_t srvid;
1545 uint16_t chid;
1546 uint16_t pid;
1547 uint16_t ecmlen;
1548
1549 uint16_t to_caid;
1550 uint32_t to_provid;
1551 uint16_t to_srvid;
1552 uint16_t to_chid;
1553 uint16_t to_pid;
1554 uint16_t to_ecmlen;
1555
1556 int32_t valid_from;
1557 int32_t valid_to;
1558
1559 struct s_cacheex_matcher *next;
1560};
1561
1562typedef struct csp_ce_hit_t {
1563 time_t time;
1564 int16_t ecmlen;
1565 uint16_t caid;
1566 uint32_t prid;
1567 uint16_t srvid;
1568 uint64_t grp;
1569 struct csp_ce_hit_t *prev;
1570 struct csp_ce_hit_t *next;
1571} CSPCEHIT;
1572
1573struct s_config
1574{
1575 int32_t nice;
1576 uint32_t netprio;
1577 uint32_t ctimeout;
1578 uint32_t ftimeout;
1579 uint32_t cmaxidle;
1580 int32_t ulparent;
1581 uint32_t delay;
1582 int32_t bindwait;
1583 int32_t tosleep;
1584 IN_ADDR_T srvip;
1585 char *usrfile;
1586 char *cwlogdir;
1587 char *emmlogdir;
1588 char *logfile;
1589 char *mailfile;
1590 uint8_t logtostdout;
1591 uint8_t logtosyslog;
1592 int8_t logduplicatelines;
1593#if defined(WEBIF) || defined(MODULE_MONITOR)
1594 uint32_t loghistorysize;
1595#endif
1596 int8_t disablelog;
1597 int8_t disablemail;
1598 int8_t disableuserfile;
1599 int8_t usrfileflag;
1600 struct s_auth *account;
1601 struct s_srvid *srvid[16];
1602 struct s_tierid *tierid;
1603 //Todo #ifdef CCCAM
1604 struct s_provid *provid;
1605 struct s_sidtab *sidtab;
1606#ifdef MODULE_MONITOR
1607 int32_t mon_port;
1608 IN_ADDR_T mon_srvip;
1609 struct s_ip *mon_allowed;
1610 uint8_t mon_level;
1611#endif
1612 int32_t aulow;
1613 int32_t hideclient_to;
1614 int8_t appendchaninfo;
1615#ifdef WEBIF
1616 int32_t http_port;
1617 char *http_user;
1618 char *http_pwd;
1619 char *http_css;
1620 int32_t http_prepend_embedded_css;
1621 char *http_jscript;
1622 char *http_tpl;
1623 char *http_script;
1624 int32_t http_refresh;
1625 int8_t http_hide_idle_clients;
1626 char *http_hide_type;
1627 int8_t http_showpicons;
1628 struct s_ip *http_allowed;
1629 int8_t http_readonly;
1630 IN_ADDR_T http_dynip[MAX_HTTP_DYNDNS];
1631 uchar http_dyndns[MAX_HTTP_DYNDNS][64];
1632 int8_t http_use_ssl;
1633 int8_t http_force_sslv3;
1634 char *http_cert;
1635 char *http_help_lang;
1636#endif
1637 int8_t http_full_cfg;
1638 int32_t failbantime;
1639 int32_t failbancount;
1640 LLIST *v_list; // Failban list
1641 int32_t c33_port;
1642 IN_ADDR_T c33_srvip;
1643 uint8_t c33_key[16];
1644 int32_t c33_crypted;
1645 int32_t c33_passive;
1646 struct s_ip *c33_plain;
1647 int32_t c35_port;
1648 IN_ADDR_T c35_srvip;
1649 int8_t c35_suppresscmd08;
1650 int8_t c35_tcp_suppresscmd08;
1651 int8_t c35_udp_suppresscmd08;
1652 PTAB c35_tcp_ptab;
1653 IN_ADDR_T c35_tcp_srvip;
1654 PTAB ncd_ptab;
1655 IN_ADDR_T ncd_srvip;
1656 uint8_t ncd_key[14];
1657 int8_t ncd_keepalive;
1658 int8_t ncd_mgclient;
1659 struct s_ip *ncd_allowed;
1660 int32_t rad_port;
1661 IN_ADDR_T rad_srvip;
1662#ifdef MODULE_CCCAM
1663 uint16_t cc_port[CS_MAXPORTS];
1664 int8_t cc_reshare;
1665 int8_t cc_ignore_reshare;
1666 int32_t cc_update_interval;
1667 IN_ADDR_T cc_srvip;
1668 char cc_version[7];
1669 int8_t cc_minimize_cards;
1670 int8_t cc_keep_connected;
1671 int8_t cc_stealth;
1672 int8_t cc_reshare_services;
1673 int8_t cc_forward_origin_card;
1674 uint8_t cc_fixed_nodeid[8];
1675 uint32_t cc_recv_timeout; // The poll() timeout parameter in ms. Default: DEFAULT_CC_RECV_TIMEOUT (2000 ms).
1676#endif
1677#ifdef MODULE_GBOX
1678 char *gbox_hostname;
1679 unsigned long gbox_card[CS_GBOX_MAX_LOCAL_CARDS]; // gbox list of local cards
1680 int32_t gbox_local_cards_num; // number of local card gbox cards
1681 int32_t gbox_reconnect;
1682#endif
1683 struct s_ip *rad_allowed;
1684 char *rad_usr;
1685 char *ser_device;
1686 uint32_t srtimeout; // SerialReaderTimeount in millisec
1687 int32_t max_log_size;
1688 int8_t waitforcards;
1689 int32_t waitforcards_extra_delay;
1690 int8_t preferlocalcards;
1691 int32_t reader_restart_seconds; // schlocke: reader restart auf x seconds, disable = 0
1692 int8_t dropdups; // drop duplicate logins
1693
1694
1695//Loadbalancer-Config:
1696#ifdef WITH_LB
1697 int32_t lb_mode; // schlocke: reader loadbalancing mode
1698 int32_t lb_save; // schlocke: load/save statistics to file, save every x ecms
1699 int32_t lb_nbest_readers; // count of best readers
1700 int32_t lb_nfb_readers; // count of fallback readers
1701 int32_t lb_min_ecmcount; // minimal ecm count to evaluate lbvalues
1702 int32_t lb_max_ecmcount; // maximum ecm count before reseting lbvalues
1703 int32_t lb_reopen_seconds; // time between retrying failed readers/caids/prov/srv
1704 int32_t lb_retrylimit; // reopen only happens if reader response time > retrylimit
1705 CAIDVALUETAB lb_retrylimittab;
1706 CAIDVALUETAB lb_nbest_readers_tab; // like nbest_readers, but for special caids
1707 CAIDTAB lb_noproviderforcaid; // do not store loadbalancer stats with providers for this caid
1708 char *lb_savepath; // path where the stat file is save. Empty=default=/tmp/.oscam/stat
1709 int32_t lb_stat_cleanup; // duration in hours for cleaning old statistics
1710 int32_t lb_reopen_mode; // reopen readers mode
1711 int32_t lb_max_readers; // limit the amount of readers during learning
1712 int32_t lb_auto_betatunnel; // automatic selection of betatunnel convertion based on learned data
1713 int32_t lb_auto_betatunnel_mode; // automatic selection of betatunnel direction
1714 int32_t lb_auto_betatunnel_prefer_beta; // prefer-beta-over-nagra factor
1715 int32_t lb_auto_timeout; // Automatic timeout by loadbalancer statistics
1716 int32_t lb_auto_timeout_p; // percent added to avg time as timeout time
1717 int32_t lb_auto_timeout_t; // minimal time added to avg time as timeout time
1718#endif
1719 int32_t resolve_gethostbyname;
1720 int8_t double_check; // schlocke: Double checks each ecm+dcw from two (or more) readers
1721 CAIDTAB double_check_caid; // do not store loadbalancer stats with providers for this caid
1722
1723#ifdef IRDETO_GUESSING
1724 struct s_irdeto_quess *itab[0xff];
1725#endif
1726
1727#ifdef HAVE_DVBAPI
1728 int8_t dvbapi_enabled;
1729 int8_t dvbapi_au;
1730 char *dvbapi_usr;
1731 int8_t dvbapi_boxtype;
1732 int8_t dvbapi_pmtmode;
1733 int8_t dvbapi_requestmode;
1734 SIDTABS dvbapi_sidtabs;
1735 int8_t dvbapi_reopenonzap;
1736 int8_t dvbapi_decodeforever; // do not stop after 3 tries
1737 int32_t dvbapi_delayer; // delayer ms, minimum time to write cw
1738#endif
1739
1740#ifdef CS_ANTICASC
1741 int8_t ac_enabled;
1742 int32_t ac_users; // num of users for account (0 - default)
1743 int32_t ac_stime; // time to collect AC statistics (3 min - default)
1744 int32_t ac_samples; // qty of samples
1745 int8_t ac_penalty; // 0 - write to log
1746 int32_t ac_fakedelay; // 100-1000 ms
1747 int32_t ac_denysamples;
1748 char *ac_logfile;
1749 struct s_cpmap *cpmap;
1750#endif
1751
1752#ifdef LEDSUPPORT
1753 int8_t enableled; // 0=disabled led, 1=enable led for routers, 2=enable qboxhd led
1754#endif
1755
1756#ifdef LCDSUPPORT
1757 int8_t enablelcd;
1758 char *lcd_output_path;
1759 int32_t lcd_hide_idle;
1760 int32_t lcd_write_intervall;
1761#endif
1762
1763#ifdef MODULE_PANDORA
1764 int8_t pand_skip_send_dw;
1765 struct s_ip *pand_allowed;
1766 char *pand_usr;
1767 char *pand_pass;
1768 int8_t pand_ecm;
1769 int32_t pand_port;
1770 IN_ADDR_T pand_srvip;
1771#endif
1772
1773 uint32_t max_cache_time; //seconds
1774 uint32_t max_cache_count; //count ecms
1775
1776 int8_t block_same_ip; //0=allow all, 1=block client requests to reader with same ip (default=1)
1777 int8_t block_same_name; //0=allow all, 1=block client requests to reader with same name (default=1)
1778
1779#ifdef CS_CACHEEX
1780 IN_ADDR_T csp_srvip;
1781 int32_t csp_port;
1782 CECSPVALUETAB cacheex_wait_timetab;
1783 CECSP csp; //CSP Settings
1784 uint8_t cacheex_enable_stats; //enable stats
1785 struct s_cacheex_matcher *cacheex_matcher;
1786#endif
1787
1788#ifdef CW_CYCLE_CHECK
1789 int8_t cwcycle_check_enable; // on or off
1790 CAIDTAB cwcycle_check_caidtab; // Caid for CW Cycle Check
1791 int32_t keepcycletime; // how long stay the learned Cycletime in Memory
1792 int32_t maxcyclelist; // max size of cwcyclelist
1793 int8_t onbadcycle; // what to do on bad cwcycle
1794 int8_t cwcycle_dropold; // what to do on old ecmd5/cw
1795#endif
1796
1797 //Global whitelist:
1798 struct s_global_whitelist *global_whitelist;
1799 int8_t global_whitelist_use_l;
1800 int8_t global_whitelist_use_m;
1801
1802 char *ecmfmt;
1803 char *pidfile;
1804
1805 int32_t max_pending;
1806};
1807
1808struct s_clientinit
1809{
1810 void *(*handler)(struct s_client*);
1811 struct s_client * client;
1812};
1813
1814struct s_clientmsg {
1815 uint8_t msg[1024];
1816 int32_t len;
1817 int32_t cmd;
1818};
1819
1820typedef struct reader_stat_t
1821{
1822 int32_t rc;
1823 uint16_t caid;
1824 uint32_t prid;
1825 uint16_t srvid;
1826 uint32_t chid;
1827 int16_t ecmlen;
1828
1829 time_t last_received;
1830
1831 int32_t ecm_count;
1832 int32_t time_avg;
1833 int32_t time_stat[LB_MAX_STAT_TIME];
1834 int32_t time_idx;
1835
1836 int32_t fail_factor;
1837} READER_STAT;
1838
1839typedef struct cs_stat_query {
1840 uint16_t caid;
1841 uint32_t prid;
1842 uint16_t srvid;
1843 uint32_t chid;
1844 int16_t ecmlen;
1845} STAT_QUERY;
1846
1847
1848typedef struct emm_packet_t
1849{
1850 uchar emm[258];
1851 int16_t emmlen;
1852 uchar caid[2];
1853 uchar provid[4];
1854 uchar hexserial[8]; //contains hexserial or SA of EMM
1855 uchar type;
1856 struct s_client *client;
1857} EMM_PACKET;
1858
1859
1860/* ===========================
1861 * global variables
1862 * =========================== */
1863extern pthread_key_t getclient;
1864extern struct s_client *first_client;
1865extern CS_MUTEX_LOCK config_lock;
1866extern CS_MUTEX_LOCK clientlist_lock;
1867extern CS_MUTEX_LOCK readerlist_lock;
1868extern struct s_reader *first_active_reader; //points to list of _active_ readers (enable = 1, deleted = 0)
1869extern LLIST *configured_readers;
1870
1871// These are used pretty much everywhere
1872extern struct s_config cfg;
1873extern uint16_t cs_dblevel;
1874
1875#include "oscam-log.h"
1876#include "oscam-log-reader.h"
1877
1878// Add here *only* funcs that are implemented in oscam.c and are called in other places
1879void cs_exit(int32_t sig);
1880void cs_exit_oscam(void);
1881void cs_restart_oscam(void);
1882int32_t cs_get_restartmode(void);
1883
1884void set_thread_name(const char *thread_name);
1885void start_thread(void *startroutine, char *nameroutine);
1886void kill_thread(struct s_client *cl);
1887
1888struct s_module *get_module(struct s_client *cl);
1889void module_reader_set(struct s_reader *rdr);
1890
1891// Until we find a better place for these (they are implemented in oscam-simples.h)
1892char *get_servicename(struct s_client *cl, uint16_t srvid, uint16_t caid, char *buf);
1893char *get_tiername(uint16_t tierid, uint16_t caid, char *buf);
1894char *get_provider(uint16_t caid, uint32_t provid, char *buf, uint32_t buflen);
1895void add_provider(uint16_t caid, uint32_t provid, const char *name, const char *sat, const char *lang);
1896
1897#endif
Note: See TracBrowser for help on using the repository browser.