Abstract libdvbcsa calls and move all CSA code in csa.c

Makefile

 
 DEFS = -DBUILD_ID=\"$(BUILD_ID)\" \
  -DVERSION=\"$(VERSION)\" -DGIT_VER=\"$(GIT_VER)\"
+DEFS += -DUSE_LIBDVBCSA=1
 
 PREFIX ?= /usr/local
 

camd.c

 #include <netinet/tcp.h>
 #include <arpa/inet.h>
 
-#include <dvbcsa/dvbcsa.h>
-
 #include "libfuncs/libfuncs.h"
 
 #include "data.h"
+#include "csa.h"
 #include "util.h"
 #include "camd.h"
 #include "notify.h"
 	return fd;
 }
 
-void camd_set_cw(struct ts *ts, unsigned char *new_cw, int check_validity) {
+void camd_set_cw(struct ts *ts, uint8_t *new_cw, int check_validity) {
 	struct camd *c = &ts->camd;
 
 	c->ecm_recv_errors = 0;
 	c->key->ts = c->key->ts_keyset.tv_sec;
 	ts->cw_last_warn = c->key->ts;
 
-	if (!check_validity || memcmp(c->key->cw, invalid_cw, 8) != 0) {
-		dvbcsa_key_set   (new_cw, c->key->s_csakey[0]);
-		dvbcsa_bs_key_set(new_cw, c->key->bs_csakey[0]);
-	}
+	if (!check_validity || memcmp(c->key->cw, invalid_cw, 8) != 0)
+		csa_set_even_cw(c->key->csakey, new_cw);
 
-	if (!check_validity || memcmp(c->key->cw + 8, invalid_cw, 8) != 0) {
-		dvbcsa_key_set(new_cw + 8, c->key->s_csakey[1]);
-		dvbcsa_bs_key_set(new_cw + 8, c->key->bs_csakey[1]);
-	}
+	if (!check_validity || memcmp(c->key->cw + 8, invalid_cw, 8) != 0)
+		csa_set_odd_cw(c->key->csakey, new_cw + 8);
 }
 
 static int camd_recv_cw(struct ts *ts) {

camd.h

 struct camd_msg *		camd_msg_alloc		(enum msg_type msg_type, uint16_t ca_id, uint16_t service_id, uint8_t *data, uint8_t data_len);
 void					camd_msg_free   	(struct camd_msg **pmsg);
 
-void					camd_set_cw			(struct ts *ts, unsigned char *new_cw, int check_validity);
+void					camd_set_cw			(struct ts *ts, uint8_t *new_cw, int check_validity);
 
 void					camd_start			(struct ts *ts);
 void					camd_stop			(struct ts *ts);

csa.c

 #include <inttypes.h>
 #include <sys/time.h>
 
-#include <dvbcsa/dvbcsa.h>
-
 #include "libfuncs/libfuncs.h"
 
+#include "csa.h"
+
+csakey_t *csa_key_alloc(void) {
+	struct csakey *key = calloc(1, sizeof(struct csakey));
+	key->s_csakey[0] = dvbcsa_key_alloc();
+	key->s_csakey[1] = dvbcsa_key_alloc();
+	key->bs_csakey[0] = dvbcsa_bs_key_alloc();
+	key->bs_csakey[1] = dvbcsa_bs_key_alloc();
+	return (csakey_t *)key;
+}
+
+void csa_key_free(csakey_t **pcsakey) {
+	struct csakey *key = *((struct csakey **)pcsakey);
+	if (key) {
+		dvbcsa_key_free(key->s_csakey[0]);
+		dvbcsa_key_free(key->s_csakey[1]);
+		dvbcsa_bs_key_free(key->bs_csakey[0]);
+		dvbcsa_bs_key_free(key->bs_csakey[1]);
+		FREE(*pcsakey);
+	}
+}
+
+inline unsigned int csa_get_batch_size(void) {
+	if (use_dvbcsa) {
+		return dvbcsa_bs_batch_size(); // 32?
+	}
+	return 0;
+}
+
+inline void csa_set_even_cw(csakey_t *csakey, uint8_t *even_cw) {
+	struct csakey *key = (struct csakey *)csakey;
+	dvbcsa_key_set(even_cw, key->s_csakey[0]);
+	dvbcsa_bs_key_set(even_cw, key->bs_csakey[0]);
+}
+
+inline void csa_set_odd_cw(csakey_t *csakey, uint8_t *odd_cw) {
+	struct csakey *key = (struct csakey *)csakey;
+	dvbcsa_key_set(odd_cw, key->s_csakey[1]);
+	dvbcsa_bs_key_set(odd_cw, key->bs_csakey[1]);
+}
+
+inline void csa_decrypt_single_packet(csakey_t *csakey, uint8_t *payload_start, unsigned int payload_len, unsigned int key_idx) {
+	struct csakey *key = (struct csakey *)csakey;
+	dvbcsa_decrypt(key->s_csakey[key_idx], payload_start, payload_len);
+}
+
+inline void csa_decrypt_multiple_even(csakey_t *csakey, struct csa_batch *batch) {
+	struct csakey *key = (struct csakey *)csakey;
+	dvbcsa_bs_decrypt(key->bs_csakey[0], (struct dvbcsa_bs_batch_s *)batch, 184);
+}
+
+inline void csa_decrypt_multiple_odd(csakey_t *csakey, struct csa_batch *batch) {
+	struct csakey *key = (struct csakey *)csakey;
+	dvbcsa_bs_decrypt(key->bs_csakey[1], (struct dvbcsa_bs_batch_s *)batch, 184);
+}
+
 /* The following routine is taken from benchbitslice in libdvbcsa */
 void csa_benchmark(void) {
 	struct timeval t0, t1;

csa.h

 #ifndef CSA_H
 #define CSA_H
 
+// The following *MUST* be the same as struct dvbcsa_bs_batch_s from libdvbcsa
+struct csa_batch {
+	uint8_t			*data;	// Pointer to payload
+	unsigned int	len;	// Payload bytes lenght
+};
+
+#if USE_LIBDVBCSA
+#include <dvbcsa/dvbcsa.h>
+#define use_dvbcsa 1
+#else
+#define use_dvbcsa 0
+#define dvbcsa_key_t void
+#define dvbcsa_bs_key_t void
+#define dvbcsa_bs_batch_s csa_batch
+static inline dvbcsa_key_t *	dvbcsa_key_alloc(void) { return NULL; }
+static inline void				dvbcsa_key_free(dvbcsa_key_t *key) { (void)key; }
+static inline void				dvbcsa_key_set(const uint8_t *cw, dvbcsa_key_t *key) { (void)cw; (void)key; }
+static inline void				dvbcsa_decrypt(const uint8_t *key, uint8_t *data, unsigned int len) { (void)key; (void)data; (void)len; }
+static inline unsigned int		dvbcsa_bs_batch_size(void) { return 0; }
+static inline dvbcsa_bs_key_t *	dvbcsa_bs_key_alloc(void) { return NULL; }
+static inline void				dvbcsa_bs_key_free(dvbcsa_bs_key_t *key) { (void)key; }
+static inline void				dvbcsa_bs_key_set(uint8_t *cw, dvbcsa_bs_key_t *key) { (void)cw; (void)key; }
+static inline void				dvbcsa_bs_decrypt(const dvbcsa_bs_key_t *key, const struct dvbcsa_bs_batch_s *pcks, unsigned int maxlen) { (void)key; (void)pcks; (void)maxlen; }
+#endif
+
+#include "data.h"
+
+struct csakey {
+	dvbcsa_key_t		*s_csakey[2];
+	dvbcsa_bs_key_t		*bs_csakey[2];
+};
+
+csakey_t *		csa_key_alloc		(void);
+void			csa_key_free		(csakey_t **pcsakey);
+
+unsigned int	csa_get_batch_size	(void);
+
+void			csa_set_even_cw		(csakey_t *csakey, uint8_t *even_cw);
+void			csa_set_odd_cw		(csakey_t *csakey, uint8_t *odd_cw);
+
+// key_idx 0 == even key
+// key_idx 1 == odd key
+void			csa_decrypt_single_packet	(csakey_t *csakey, uint8_t *payload, unsigned int payload_len, unsigned int key_idx);
+void			csa_decrypt_multiple_even	(csakey_t *csakey, struct csa_batch *batch);
+void			csa_decrypt_multiple_odd	(csakey_t *csakey, struct csa_batch *batch);
+
 void csa_benchmark(void);
 
 #endif

data.c

 #include <string.h>
 
 #include "data.h"
+#include "csa.h"
 #include "camd.h"
 
 void data_init(struct ts *ts) {
 
 	// Key
 	memset(&ts->key, 0, sizeof(ts->key));
-	ts->key.s_csakey[0] = dvbcsa_key_alloc();
-	ts->key.s_csakey[1] = dvbcsa_key_alloc();
-
-	ts->key.bs_csakey[0] = dvbcsa_bs_key_alloc();
-	ts->key.bs_csakey[1] = dvbcsa_bs_key_alloc();
-
+	ts->key.csakey = csa_key_alloc();
 	gettimeofday(&ts->key.ts_keyset, NULL);
 
 	// CAMD
 	ts->output.ttl  = 1;
 	ts->output.tos  = -1;
 
-	ts->decode_buf  = cbuf_init((7 * dvbcsa_bs_batch_size() * 188) * 16, "decode"); // ~658Kb
-	ts->write_buf   = cbuf_init((7 * dvbcsa_bs_batch_size() * 188) *  8, "write");  // ~324Kb
+	ts->decode_buf  = cbuf_init((7 * csa_get_batch_size() * 188) * 16, "decode"); // ~658Kb
+	ts->write_buf   = cbuf_init((7 * csa_get_batch_size() * 188) *  8, "write");  // ~324Kb
 
 	ts->input_buffer= list_new("input");
 
 	ts_privsec_free(&ts->last_ecm);
 	ts_privsec_free(&ts->tmp_ecm);
 
-	dvbcsa_key_free(ts->key.s_csakey[0]);
-	dvbcsa_key_free(ts->key.s_csakey[1]);
-
-	dvbcsa_bs_key_free(ts->key.bs_csakey[0]);
-	dvbcsa_bs_key_free(ts->key.bs_csakey[1]);
+	csa_key_free(&ts->key.csakey);
 
 	cbuf_free(&ts->decode_buf);
 	cbuf_free(&ts->write_buf);

data.h

 #include <openssl/des.h>
 #include <openssl/md5.h>
 
-#include <dvbcsa/dvbcsa.h>
-
 #include "libfuncs/libfuncs.h"
 #include "libtsfuncs/tsfuncs.h"
 
 
 #define CODEWORD_LENGTH 16
 
+typedef void csakey_t;
+
 struct key {
 	uint8_t				cw[CODEWORD_LENGTH];
+	csakey_t			*csakey;
 	int					is_valid_cw;
-	struct dvbcsa_key_s	*s_csakey[2];
-	struct dvbcsa_bs_key_s	*bs_csakey[2];
 	time_t					ts;				// At what time the key is set
 	struct timeval			ts_keyset;		// At what time the key is set
 };

process.c

 #include <sys/uio.h>
 
 #include "data.h"
+#include "csa.h"
 #include "tables.h"
 #include "util.h"
 
 			// scramble_idx 3 == odd key
 			ts_packet_set_not_scrambled(ts_packet);
 			uint8_t payload_ofs = ts_packet_get_payload_offset(ts_packet);
-			dvbcsa_decrypt(ts->key.s_csakey[scramble_idx - 2], ts_packet + payload_ofs, 188 - payload_ofs);
+			csa_decrypt_single_packet(ts->key.csakey, ts_packet + payload_ofs, 188 - payload_ofs, scramble_idx - 2);
 		} else {
 			// Can't decrypt the packet just make it NULL packet
 			if (ts->pid_filter)
 
 static void decode_buffer(struct ts *ts, uint8_t *data, int data_len) {
 	int i;
-	int batch_sz = dvbcsa_bs_batch_size(); // 32?
+	int batch_sz = csa_get_batch_size(); // 32?
 	int even_packets = 0;
 	int odd_packets  = 0;
-	struct dvbcsa_bs_batch_s even_pcks[batch_sz + 1];
-	struct dvbcsa_bs_batch_s odd_pcks [batch_sz + 1];
+	struct csa_batch even_pcks[batch_sz + 1];
+	struct csa_batch odd_pcks [batch_sz + 1];
 
 	int scramble_idx_old = 0;
 
 				int scramble_idx = ts_packet_get_scrambled(ts_packet);
 				if (!scramble_idx_old)
 					scramble_idx_old = scramble_idx;
-				uint8_t payload_ofs = ts_packet_get_payload_offset(ts_packet);
-				if (scramble_idx == 2) { // scramble_idx 2 == even key
-					even_pcks[even_packets].data = ts_packet + payload_ofs;
-					even_pcks[even_packets].len  = 188 - payload_ofs;
-					even_packets++;
+				if (use_dvbcsa) {
+					uint8_t payload_ofs = ts_packet_get_payload_offset(ts_packet);
+					if (scramble_idx == 2) { // scramble_idx 2 == even key
+						even_pcks[even_packets].data = ts_packet + payload_ofs;
+						even_pcks[even_packets].len  = 188 - payload_ofs;
+						even_packets++;
+					}
+					if (scramble_idx == 3) { // scramble_idx 3 == odd key
+						odd_pcks[odd_packets].data = ts_packet + payload_ofs;
+						odd_pcks[odd_packets].len  = 188 - payload_ofs;
+						odd_packets++;
+					}
+					ts_packet_set_not_scrambled(ts_packet);
 				}
-				if (scramble_idx == 3) { // scramble_idx 3 == odd key
-					odd_pcks[odd_packets].data = ts_packet + payload_ofs;
-					odd_pcks[odd_packets].len  = 188 - payload_ofs;
-					odd_packets++;
-				}
-				ts_packet_set_not_scrambled(ts_packet);
 				if (scramble_idx_old != scramble_idx && !ts->camd.constant_codeword) {
 					struct timeval tv;
 					gettimeofday(&tv, NULL);
 
 	// Decode packets
 	if (even_packets) {
-		even_pcks[even_packets].data = NULL; // Last one...
-		dvbcsa_bs_decrypt(ts->key.bs_csakey[0], even_pcks, 184);
+		if (use_dvbcsa) {
+			even_pcks[even_packets].data = NULL; // Last one...
+			csa_decrypt_multiple_even(ts->key.csakey, even_pcks);
+		}
 	}
 	if (odd_packets) {
-		odd_pcks[odd_packets].data = NULL; // Last one...
-		dvbcsa_bs_decrypt(ts->key.bs_csakey[1], odd_pcks, 184);
+		if (use_dvbcsa) {
+			odd_pcks[odd_packets].data = NULL; // Last one...
+			csa_decrypt_multiple_odd(ts->key.csakey, odd_pcks);
+		}
 	}
 
 	// Fill write buffer
 	struct ts *ts = _ts;
 	uint8_t *data;
 	int data_size;
-	int req_size = 188 * dvbcsa_bs_batch_size();
+	int req_size = 188 * csa_get_batch_size();
 
 	set_thread_name("tsdec-decode");