Add struct camd35

camd.c

@@ -17,24 +17,6 @@
 #include "util.h"
 #include "camd.h"
 
-extern struct key key;
-
-static int camd35_server_fd;
-extern struct in_addr camd35_server_addr;
-extern unsigned int camd35_server_port;
-extern char *camd35_user;
-extern char *camd35_pass;
-
-static uint32_t camd35_auth = 0;
-static AES_KEY camd35_aes_encrypt_key;
-static AES_KEY camd35_aes_decrypt_key;
-
-static uint8_t invalid_cw[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
-
-static inline int valid_cw(uint8_t *cw) {
-	return memcmp(cw, invalid_cw, 16) != 0;
-}
-
 static int connect_to(struct in_addr ip, int port) {
 	ts_LOGf("Connecting to %s:%d\n", inet_ntoa(ip), port);
 
@@ -61,55 +43,61 @@ static int connect_to(struct in_addr ip, int port) {
 #define HDR_LEN     (20)
 #define BUF_SIZE	(4 + HDR_LEN + 256 + 16)
 
-static void camd35_init_auth(char *user, char *pass) {
+static void camd35_init_auth(struct camd35 *c) {
 	unsigned char dump[16];
-	camd35_auth = crc32(0L, MD5((unsigned char *)user, strlen(user), dump), 16);
 
-	MD5((unsigned char *)pass, strlen(pass), dump);
+	if (c->auth_token)
+		return;
 
-	AES_set_encrypt_key(dump, 128, &camd35_aes_encrypt_key);
-	AES_set_decrypt_key(dump, 128, &camd35_aes_decrypt_key);
+	c->auth_token = crc32(0L, MD5((unsigned char *)c->user, strlen(c->user), dump), 16);
+
+	MD5((unsigned char *)c->pass, strlen(c->pass), dump);
+
+	AES_set_encrypt_key(dump, 128, &c->aes_encrypt_key);
+	AES_set_decrypt_key(dump, 128, &c->aes_decrypt_key);
 }
 
-int camd35_connect() {
-	if (camd35_server_fd < 0)
-		camd35_server_fd = connect_to(camd35_server_addr, camd35_server_port);
-	return camd35_server_fd;
+int camd35_connect(struct camd35 *c) {
+	if (c->server_fd < 0)
+		c->server_fd = connect_to(c->server_addr, c->server_port);
+	return c->server_fd;
 }
 
-void camd35_disconnect() {
-	shutdown_fd(&camd35_server_fd);
+void camd35_disconnect(struct camd35 *c) {
+	shutdown_fd(&c->server_fd);
 }
 
-static int camd35_recv(uint8_t *data, int *data_len) {
+static int camd35_recv(struct camd35 *c, uint8_t *data, int *data_len) {
 	int i;
 
 	// Read AUTH token
-	ssize_t r = fdread(camd35_server_fd, (char *)data, 4);
+	ssize_t r = fdread(c->server_fd, (char *)data, 4);
 	if (r < 4)
 		return -1;
 	uint32_t auth_token = (((data[0] << 24) | (data[1] << 16) | (data[2]<<8) | data[3]) & 0xffffffffL);
-	if (auth_token != camd35_auth)
-		ts_LOGf("WARN: recv auth 0x%08x != camd35_auth 0x%08x\n", auth_token, camd35_auth);
+	if (auth_token != c->auth_token)
+		ts_LOGf("WARN: recv auth 0x%08x != camd35_auth 0x%08x\n", auth_token, c->auth_token);
 
 	*data_len = 256;
 	for (i = 0; i < *data_len; i += 16) { // Read and decrypt payload
-		fdread(camd35_server_fd, (char *)data + i, 16);
-		AES_decrypt(data + i, data + i, &camd35_aes_decrypt_key);
+		fdread(c->server_fd, (char *)data + i, 16);
+		AES_decrypt(data + i, data + i, &c->aes_decrypt_key);
 		if (i == 0)
 			*data_len = boundary(4, data[1] + 20); // Initialize real data length
 	}
 	return *data_len;
 }
 
-#define ERR(x) do { ts_LOGf("%s", x); return NULL; } while (0)
+#define ERR(x) do { ts_LOGf("%s\n", x); return NULL; } while (0)
 
-static uint8_t *camd35_recv_cw() {
+
+static uint8_t *camd35_recv_cw(struct camd35 *c) {
+	static uint8_t invalid_cw[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 	uint8_t data[BUF_SIZE];
 	int data_len = 0;
 
 NEXT:
-	if (camd35_recv(data, &data_len) < 0)
+	if (camd35_recv(c, data, &data_len) < 0)
 		ERR("No data!");
 
 	if (data[0] < 0x01) {
@@ -126,15 +114,15 @@ NEXT:
 	uint16_t ca_id = (data[10] << 8) | data[11];
 	uint16_t idx   = (data[16] << 8) | data[17];
 	uint8_t *cw = data + 20;
-	memcpy(key.cw, cw, 16);
+	memcpy(c->key->cw, cw, 16);
 
 	char cw_dump[16 * 6];
 	ts_hex_dump_buf(cw_dump, 16 * 6, cw, 16, 0);
 	ts_LOGf("CW  | CAID: 0x%04x ---------------------------------- IDX: 0x%04x Data: %s\n", ca_id, idx, cw_dump);
 
-	key.is_valid_cw = valid_cw(key.cw);
-	dvbcsa_key_set(key.cw    , key.csakey[0]);
-	dvbcsa_key_set(key.cw + 8, key.csakey[1]);
+	c->key->is_valid_cw = memcmp(c->key->cw, invalid_cw, 16) != 0;
+	dvbcsa_key_set(c->key->cw    , c->key->csakey[0]);
+	dvbcsa_key_set(c->key->cw + 8, c->key->csakey[1]);
 
 	return NULL;
 }
@@ -142,26 +130,24 @@ NEXT:
 #undef ERR
 
 
-static int camd35_send(uint8_t *data, uint8_t data_len) {
+static int camd35_send(struct camd35 *c, uint8_t *data, uint8_t data_len) {
 	unsigned int i;
 	uint8_t buf[BUF_SIZE];
 	uint8_t *bdata = buf + 4;
 
-	camd35_connect();
+	camd35_connect(c);
+	camd35_init_auth(c);
 
-	if (!camd35_auth)
-		camd35_init_auth(camd35_user, camd35_pass);
-
-	init_4b(camd35_auth, buf); // Put authentication token
+	init_4b(c->auth_token, buf); // Put authentication token
 	memcpy(bdata, data, data_len); // Put data
 
 	for (i = 0; i < data_len; i += 16) // Encrypt payload
-		AES_encrypt(data + i, bdata + i, &camd35_aes_encrypt_key);
+		AES_encrypt(data + i, bdata + i, &c->aes_encrypt_key);
 
-	return fdwrite(camd35_server_fd, (char *)buf, data_len + 4);
+	return fdwrite(c->server_fd, (char *)buf, data_len + 4);
 }
 
-static void camd35_buf_init(uint8_t *buf, uint8_t *data, uint8_t data_len) {
+static void camd35_buf_init(struct camd35 *c, uint8_t *buf, uint8_t *data, uint8_t data_len) {
 	memset(buf, 0, HDR_LEN); // Reset header
 	memset(buf + HDR_LEN, 0xff, BUF_SIZE - HDR_LEN); // Reset data
 	buf[1] = data_len; // Data length
@@ -169,12 +155,12 @@ static void camd35_buf_init(uint8_t *buf, uint8_t *data, uint8_t data_len) {
 	memcpy(buf + HDR_LEN, data, data_len); // Copy data to buf
 }
 
-int camd35_send_ecm(uint16_t service_id, uint16_t ca_id, uint16_t idx, uint8_t *data, uint8_t data_len) {
+int camd35_send_ecm(struct camd35 *c, uint16_t service_id, uint16_t ca_id, uint16_t idx, uint8_t *data, uint8_t data_len) {
 	uint8_t buf[BUF_SIZE];
 	uint32_t provider_id = 0;
 	int to_send = boundary(4, HDR_LEN + data_len);
 
-	camd35_buf_init(buf, data, data_len);
+	camd35_buf_init(c, buf, data, data_len);
 
 	buf[0] = 0x00; // CMD ECM request
 	init_2b(service_id , buf + 8);
@@ -184,21 +170,21 @@ int camd35_send_ecm(uint16_t service_id, uint16_t ca_id, uint16_t idx, uint8_t *
 	buf[18] = 0xff;
 	buf[19] = 0xff;
 
-	camd35_send(buf, to_send);
-	camd35_recv_cw();
+	camd35_send(c, buf, to_send);
+	camd35_recv_cw(c);
 	return 0;
 }
 
-int camd35_send_emm(uint16_t ca_id, uint8_t *data, uint8_t data_len) {
+int camd35_send_emm(struct camd35 *c, uint16_t ca_id, uint8_t *data, uint8_t data_len) {
 	uint8_t buf[BUF_SIZE];
 	uint32_t prov_id = 0;
 	int to_send = boundary(4, data_len + HDR_LEN);
 
-	camd35_buf_init(buf, data, data_len);
+	camd35_buf_init(c, buf, data, data_len);
 
 	buf[0] = 0x06; // CMD incomming EMM
 	init_2b(ca_id  , buf + 10);
 	init_4b(prov_id, buf + 12);
 
-	return camd35_send(buf, to_send);
+	return camd35_send(c, buf, to_send);
 }

camd.h

@@ -1,12 +1,30 @@
 #ifndef CAMD_H
 #define CAMD_H
 
-#include <inttypes.h>
+#include <openssl/aes.h>
+#include <openssl/md5.h>
 
-int camd35_connect();
-void camd35_disconnect();
+#include "data.h"
 
-int camd35_send_ecm(uint16_t service_id, uint16_t ca_id, uint16_t idx, uint8_t *data, uint8_t data_len);
-int camd35_send_emm(uint16_t ca_id, uint8_t *data, uint8_t data_len);
+struct camd35 {
+	int				server_fd;
+	struct in_addr	server_addr;
+	unsigned int	server_port;
+	char			user[64];
+	char			pass[64];
+
+	AES_KEY			aes_encrypt_key;
+	AES_KEY			aes_decrypt_key;
+
+	uint32_t		auth_token;
+
+	struct key		*key;
+};
+
+int camd35_connect		(struct camd35 *c);
+void camd35_disconnect	(struct camd35 *c);
+
+int camd35_send_ecm		(struct camd35 *c, uint16_t service_id, uint16_t ca_id, uint16_t idx, uint8_t *data, uint8_t data_len);
+int camd35_send_emm		(struct camd35 *c, uint16_t ca_id, uint8_t *data, uint8_t data_len);
 
 #endif

tables.c

@@ -5,6 +5,8 @@
 #include "libts/tsfuncs.h"
 #include "libfuncs/libfuncs.h"
 
+extern struct camd35 camd35;
+
 extern enum CA_system req_CA_sys;
 extern int debug_level;
 extern int emm_send;
@@ -108,7 +110,7 @@ void process_emm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 			sec->section_data_len,
 			dump);
 	}
-	camd35_send_emm(ts->emm_caid, sec->section_data, sec->section_data_len);
+	camd35_send_emm(&camd35, ts->emm_caid, sec->section_data, sec->section_data_len);
 	ts_privsec_copy(ts->emm, ts->last_emm);
 	ts_privsec_clear(ts->emm);
 }
@@ -134,7 +136,7 @@ void process_ecm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 			sec->section_data_len,
 			ts->ecm_counter,
 			dump);
-		camd35_send_ecm(ts->service_id, ts->ecm_caid, ts->ecm_counter++, sec->section_data, sec->section_data_len);
+		camd35_send_ecm(&camd35, ts->service_id, ts->ecm_caid, ts->ecm_counter++, sec->section_data, sec->section_data_len);
 	} else if (debug_level >= 3) {
 		ts_LOGf("ECM | CAID: 0x%04x PID 0x%04x Table: 0x%02x Length: %3d IDX: 0x%04x Data: -dup-\n",
 			ts->ecm_caid,

tsdecrypt.c

@@ -14,17 +14,13 @@
 #include "tables.h"
 
 struct key key;
+struct camd35 camd35;
 
 int debug_level = 0;
 unsigned long ts_pack = 0;
 int ts_pack_shown = 0;
 
 enum CA_system req_CA_sys = CA_CONNAX;
-struct in_addr camd35_server_addr;
-unsigned int camd35_server_port = 2233;
-char *camd35_user = "user";
-char *camd35_pass = "pass";
-uint32_t camd35_auth = 0;
 
 int emm_send = 1;
 int pid_filter = 0;
@@ -45,8 +41,8 @@ void show_help() {
 	printf("\n");
 	printf("  CAMD35 server options:\n");
 	printf("    -s server_addr | default: disabled (format 1.2.3.4:2233)\n");
-	printf("    -U server_user | default: %s\n", camd35_user);
-	printf("    -P server_pass | default: %s\n", camd35_pass);
+	printf("    -U server_user | default: %s\n", camd35.user);
+	printf("    -P server_pass | default: %s\n", camd35.pass);
 	printf("\n");
 	printf("  Output options (if output is disabled stdout is used for output):\n");
 	printf("    -o output_addr | default: disabled (format: 239.78.78.78:5000)\n");
@@ -90,9 +86,9 @@ void parse_options(int argc, char **argv) {
 				p = strrchr(optarg, ':');
 				if (p) {
 					*p = 0x00;
-					camd35_server_port = atoi(p + 1);
+					camd35.server_port = atoi(p + 1);
 				}
-				if (inet_aton(optarg, &camd35_server_addr) == 0)
+				if (inet_aton(optarg, &camd35.server_addr) == 0)
 					server_err = 1;
 				else
 					server_err = 0;
@@ -116,10 +112,12 @@ void parse_options(int argc, char **argv) {
 				break;
 
 			case 'U':
-				camd35_user = optarg;
+				strncpy(camd35.user, optarg, sizeof(camd35.user) - 1);
+				camd35.user[sizeof(camd35.user) - 1] = 0;
 				break;
 			case 'P':
-				camd35_pass = optarg;
+				strncpy(camd35.pass, optarg, sizeof(camd35.pass) - 1);
+				camd35.pass[sizeof(camd35.pass) - 1] = 0;
 				break;
 
 			case 'e':
@@ -151,9 +149,9 @@ void parse_options(int argc, char **argv) {
 		exit(1);
 	}
 	ts_LOGf("CA System  : %s\n", ts_get_CA_sys_txt(req_CA_sys));
-	ts_LOGf("Server addr: %s:%u\n", inet_ntoa(camd35_server_addr), camd35_server_port);
-	ts_LOGf("Server user: %s\n", camd35_user);
-	ts_LOGf("Server pass: %s\n", camd35_pass);
+	ts_LOGf("Server addr: %s:%u\n", inet_ntoa(camd35.server_addr), camd35.server_port);
+	ts_LOGf("Server user: %s\n", camd35.user);
+	ts_LOGf("Server pass: %s\n", camd35.pass);
 	if (output_port) {
 		ts_LOGf("Output addr: %s:%u\n", inet_ntoa(output_addr), output_port);
 		ts_LOGf("Output intf: %s\n", inet_ntoa(output_intf));
@@ -222,11 +220,18 @@ int main(int argc, char **argv) {
 	key.csakey[0] = dvbcsa_key_alloc();
 	key.csakey[1] = dvbcsa_key_alloc();
 
+	memset(&camd35, 0, sizeof(camd35));
+	camd35.server_fd = -1;
+	camd35.server_port = 2233;
+	strcpy(camd35.user, "user");
+	strcpy(camd35.pass, "pass");
+	camd35.key = &key;
+
 	ts_set_log_func(LOG_func);
 
 	parse_options(argc, argv);
 
-	camd35_connect();
+	camd35_connect(&camd35);
 
 	struct ts *ts = ts_alloc();
 	do {
@@ -241,6 +246,6 @@ int main(int argc, char **argv) {
 	dvbcsa_key_free(key.csakey[0]);
 	dvbcsa_key_free(key.csakey[1]);
 
-	camd35_disconnect();
+	camd35_disconnect(&camd35);
 	exit(0);
 }