Split tsdecrypt to data.{c,h}, camd.{c,h} and tables.{c,h}

Makefile

@@ -10,7 +10,7 @@ FUNCS_LIB = $(FUNCS_DIR)/libfuncs.a
 TS_DIR = libts
 TS_LIB = $(TS_DIR)/libts.a
 
-tsdecrypt_OBJS = util.o tsdecrypt.o $(FUNCS_LIB) $(TS_LIB)
+tsdecrypt_OBJS = data.o util.o camd.o tables.o tsdecrypt.o $(FUNCS_LIB) $(TS_LIB)
 tsdecrypt_LIBS = -lcrypto -ldvbcsa -lpthread
 
 CLEAN_OBJS = tsdecrypt $(tsdecrypt_OBJS) *~

camd.c

@@ -0,0 +1,206 @@
+#include <string.h>
+#include <sys/errno.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <openssl/aes.h>
+#include <openssl/md5.h>
+
+#include <dvbcsa/dvbcsa.h>
+
+#include "libfuncs/libfuncs.h"
+#include "libts/tsfuncs.h"
+
+#include "util.h"
+#include "camd.h"
+
+
+extern uint8_t cur_cw[16];
+extern int is_valid_cw;
+extern struct dvbcsa_key_s *csakey[2];
+
+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);
+
+	int fd = socket(PF_INET, SOCK_STREAM, 0);
+	if (fd < 0)	{
+		ts_LOGf("Could not create socket | %s\n", strerror(errno));
+		return -1;
+	}
+
+	struct sockaddr_in sock;
+	sock.sin_family = AF_INET;
+	sock.sin_port = htons(port);
+	sock.sin_addr = ip;
+	if (do_connect(fd, (struct sockaddr *)&sock, sizeof(sock), 1000) < 0) {
+		ts_LOGf("Could not connect to %s:%d | %s\n", inet_ntoa(ip), port, strerror(errno));
+		return -1;
+	}
+
+	ts_LOGf("Connected with fd:%d\n", fd);
+	return fd;
+}
+
+// 4 auth header, 20 header size, 256 max data size, 16 potential padding
+#define HDR_LEN     (20)
+#define BUF_SIZE	(4 + HDR_LEN + 256 + 16)
+
+static void camd35_init_auth(char *user, char *pass) {
+	unsigned char dump[16];
+	camd35_auth = crc32(0L, MD5((unsigned char *)user, strlen(user), dump), 16);
+
+	MD5((unsigned char *)pass, strlen(pass), dump);
+
+	AES_set_encrypt_key(dump, 128, &camd35_aes_encrypt_key);
+	AES_set_decrypt_key(dump, 128, &camd35_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;
+}
+
+void camd35_disconnect() {
+	shutdown_fd(&camd35_server_fd);
+}
+
+static int camd35_recv(uint8_t *data, int *data_len) {
+	int i;
+
+	// Read AUTH token
+	ssize_t r = fdread(camd35_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);
+
+	*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);
+		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)
+
+static uint8_t *camd35_recv_cw() {
+	uint8_t data[BUF_SIZE];
+	int data_len = 0;
+
+NEXT:
+	if (camd35_recv(data, &data_len) < 0)
+		ERR("No data!");
+
+	if (data[0] < 0x01) {
+		ts_LOGf("Not valid CW response, skipping it. data[0] = 0x%02x\n", data[0]);
+		goto NEXT;
+	}
+
+	if (data_len < 48)
+		ERR("len mismatch != 48");
+
+	if (data[1] < 0x10)
+		ERR("CW len mismatch != 0x10");
+
+	uint16_t ca_id = (data[10] << 8) | data[11];
+	uint16_t idx   = (data[16] << 8) | data[17];
+	uint8_t *cw = data + 20;
+	memcpy(cur_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);
+
+	is_valid_cw = valid_cw(cur_cw);
+	dvbcsa_key_set(cur_cw    , csakey[0]);
+	dvbcsa_key_set(cur_cw + 8, csakey[1]);
+
+	return NULL;
+}
+
+#undef ERR
+
+
+static int camd35_send(uint8_t *data, uint8_t data_len) {
+	unsigned int i;
+	uint8_t buf[BUF_SIZE];
+	uint8_t *bdata = buf + 4;
+
+	camd35_connect();
+
+	if (!camd35_auth)
+		camd35_init_auth(camd35_user, camd35_pass);
+
+	init_4b(camd35_auth, 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);
+
+	return fdwrite(camd35_server_fd, (char *)buf, data_len + 4);
+}
+
+static void camd35_buf_init(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
+	init_4b(crc32(0L, data, data_len), buf + 4); // Data CRC is at buf[4]
+	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) {
+	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);
+
+	buf[0] = 0x00; // CMD ECM request
+	init_2b(service_id , buf + 8);
+	init_2b(ca_id      , buf + 10);
+	init_4b(provider_id, buf + 12);
+	init_2b(idx        , buf + 16);
+	buf[18] = 0xff;
+	buf[19] = 0xff;
+
+	camd35_send(buf, to_send);
+	camd35_recv_cw();
+	return 0;
+}
+
+int camd35_send_emm(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);
+
+	buf[0] = 0x06; // CMD incomming EMM
+	init_2b(ca_id  , buf + 10);
+	init_4b(prov_id, buf + 12);
+
+	return camd35_send(buf, to_send);
+}

camd.h

@@ -0,0 +1,12 @@
+#ifndef CAMD_H
+#define CAMD_H
+
+#include <inttypes.h>
+
+int camd35_connect();
+void camd35_disconnect();
+
+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);
+
+#endif

data.c

@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string.h>
+
+#include "data.h"
+
+struct ts *ts_alloc() {
+	struct ts *ts = calloc(1, sizeof(struct ts));
+	ts->pat	     = ts_pat_alloc();
+	ts->curpat   = ts_pat_alloc();
+
+	ts->cat      = ts_cat_alloc();
+	ts->curcat   = ts_cat_alloc();
+
+	ts->pmt      = ts_pmt_alloc();
+	ts->curpmt   = ts_pmt_alloc();
+
+	ts->emm      = ts_privsec_alloc();
+	ts->last_emm = ts_privsec_alloc();
+
+	ts->ecm      = ts_privsec_alloc();
+	ts->last_ecm = ts_privsec_alloc();
+
+	pidmap_clear(&ts->pidmap);
+
+	return ts;
+}
+
+void ts_free(struct ts **pts) {
+	struct ts *ts = *pts;
+	if (ts) {
+		ts_pat_free(&ts->pat);
+		ts_pat_free(&ts->curpat);
+		ts_cat_free(&ts->cat);
+		ts_cat_free(&ts->curcat);
+		ts_pmt_free(&ts->pmt);
+		ts_pmt_free(&ts->curpmt);
+		ts_privsec_free(&ts->emm);
+		ts_privsec_free(&ts->last_emm);
+		ts_privsec_free(&ts->ecm);
+		ts_privsec_free(&ts->last_ecm);
+		FREE(*pts);
+	}
+}
+
+void LOG_func(const char *msg) {
+	char date[64];
+	struct tm tm;
+	time_t now;
+	now = time(NULL);
+	localtime_r(&now, &tm);
+	strftime(date, sizeof(date), "%F %H:%M:%S", localtime(&now));
+	fprintf(stderr, "%s | %s", date, msg);
+}
+
+extern int debug_level;
+extern unsigned long ts_pack;
+extern int ts_pack_shown;
+extern uint8_t cur_cw[16];
+
+void show_ts_pack(uint16_t pid, char *wtf, char *extra, uint8_t *ts_packet) {
+	char cw1_dump[8 * 6];
+	char cw2_dump[8 * 6];
+	if (debug_level >= 4) {
+		if (ts_pack_shown)
+			return;
+		int stype = ts_packet_get_scrambled(ts_packet);
+		ts_hex_dump_buf(cw1_dump, 8 * 6, cur_cw    , 8, 0);
+		ts_hex_dump_buf(cw2_dump, 8 * 6, cur_cw + 8, 8, 0);
+		fprintf(stderr, "@ %s %s %03x %5ld %7ld | %s   %s | %s\n",
+			stype == 0 ? "------" :
+			stype == 2 ? "even 0" :
+			stype == 3 ? "odd  1" : "??????",
+			wtf,
+			pid,
+			ts_pack, ts_pack * 188,
+			cw1_dump, cw2_dump, extra ? extra : wtf);
+	}
+}
+
+void dump_ts_pack(uint16_t pid, uint8_t *ts_packet) {
+	if (pid == 0x010)		show_ts_pack(pid, "nit", NULL, ts_packet);
+	else if (pid == 0x11)	show_ts_pack(pid, "sdt", NULL, ts_packet);
+	else if (pid == 0x12)	show_ts_pack(pid, "epg", NULL, ts_packet);
+	else					show_ts_pack(pid, "---", NULL, ts_packet);
+}

data.h

@@ -0,0 +1,28 @@
+#ifndef DATA_H
+#define DATA_H
+
+#include "libts/tsfuncs.h"
+
+struct ts {
+	struct ts_pat		*pat, *curpat;
+	struct ts_cat		*cat, *curcat;
+	struct ts_pmt		*pmt, *curpmt;
+	struct ts_privsec	*emm, *last_emm;
+	struct ts_privsec	*ecm, *last_ecm;
+	uint16_t			pmt_pid;
+	uint16_t			service_id;
+	uint16_t			emm_caid, emm_pid;
+	uint16_t			ecm_caid, ecm_pid;
+	uint16_t			ecm_counter;
+	pidmap_t			pidmap;
+};
+
+struct ts *ts_alloc();
+void ts_free(struct ts **pts);
+
+void LOG_func(const char *msg);
+
+void show_ts_pack(uint16_t pid, char *wtf, char *extra, uint8_t *ts_packet);
+void dump_ts_pack(uint16_t pid, uint8_t *ts_packet);
+
+#endif

tables.c

@@ -0,0 +1,150 @@
+#include "data.h"
+#include "tables.h"
+#include "camd.h"
+
+#include "libts/tsfuncs.h"
+#include "libfuncs/libfuncs.h"
+
+extern enum CA_system req_CA_sys;
+extern int debug_level;
+extern int emm_send;
+
+#define handle_table_changes(TABLE) \
+	do { \
+		show_ts_pack(pid, #TABLE, NULL, ts_packet); \
+		ts->cur##TABLE = ts_##TABLE##_push_packet(ts->cur##TABLE, ts_packet); \
+		if (!ts->cur##TABLE->initialized) \
+			return;  \
+		if (ts_##TABLE##_is_same(ts->TABLE, ts->cur##TABLE)) { \
+			ts_##TABLE##_clear(ts->cur##TABLE); \
+			return; \
+		} \
+		ts_##TABLE##_free(&ts->TABLE); \
+		ts->TABLE = ts_##TABLE##_copy(ts->cur##TABLE); \
+		ts_##TABLE##_clear(ts->cur##TABLE); \
+		if (debug_level >= 1) \
+			ts_##TABLE##_dump(ts->TABLE); \
+	} while(0)
+
+void process_pat(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
+	int i;
+	if (pid != 0x00)
+		return;
+
+	handle_table_changes(pat);
+
+	for (i=0;i<ts->pat->programs_num;i++) {
+		struct ts_pat_program *prg = ts->pat->programs[i];
+		if (prg->pid) {
+			if (prg->program != 0) {
+				ts->pmt_pid    = prg->pid;
+				ts->service_id = prg->program;
+			}
+		}
+	}
+}
+
+void process_cat(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
+	if (pid != 0x01)
+		return;
+
+	handle_table_changes(cat);
+
+	ts_get_emm_info(ts->cat, req_CA_sys, &ts->emm_caid, &ts->emm_pid);
+}
+
+void process_pmt(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
+	int i;
+	if (!pid || pid != ts->pmt_pid)
+		return;
+
+	handle_table_changes(pmt);
+
+	pidmap_clear(&ts->pidmap);
+	pidmap_set(&ts->pidmap, 0x0000); // PAT
+	pidmap_set(&ts->pidmap, 0x0011); // SDT
+	pidmap_set(&ts->pidmap, ts->pmt->ts_header.pid); // PMT PID
+	pidmap_set(&ts->pidmap, ts->pmt->PCR_pid); // PCR
+	for (i=0;i<ts->pmt->streams_num;i++) {
+		struct ts_pmt_stream *stream = ts->pmt->streams[i];
+		pidmap_set(&ts->pidmap, stream->pid); // Data
+	}
+
+	if (!ts->ecm_caid) {
+		ts_get_ecm_info(ts->pmt, req_CA_sys, &ts->ecm_caid, &ts->ecm_pid);
+		char *CA_sys = ts_get_CA_sys_txt(ts_get_CA_sys(ts->ecm_caid));
+		ts_LOGf("%s Service : 0x%04x\n", CA_sys, ts->service_id);
+		ts_LOGf("%s CA_id   : 0x%04x\n", CA_sys, ts->emm_caid);
+		ts_LOGf("%s EMM pid : 0x%04x\n", CA_sys, ts->emm_pid);
+		ts_LOGf("%s ECM pid : 0x%04x\n", CA_sys, ts->ecm_pid);
+	}
+}
+
+#define dump_sz      (16)
+#define dump_buf_sz  (dump_sz * 6)
+
+void process_emm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
+	char dump[dump_buf_sz];
+	if (!ts->emm_pid || ts->emm_pid != pid)
+		return;
+
+	show_ts_pack(pid, "emm", NULL, ts_packet);
+
+	if (!emm_send)
+		return;
+
+	ts->emm = ts_privsec_push_packet(ts->emm, ts_packet);
+	if (!ts->emm->initialized)
+		return;
+
+	struct ts_header *th = &ts->emm->ts_header;
+	struct ts_section_header *sec = ts->emm->section_header;
+	if (debug_level >= 2) {
+		ts_hex_dump_buf(dump, dump_buf_sz, sec->section_data, min(dump_sz, sec->section_data_len), 0);
+		ts_LOGf("EMM | CAID: 0x%04x PID 0x%04x Table: 0x%02x Length: %3d ----------- Data: %s..\n",
+			ts->emm_caid,
+			th->pid,
+			sec->table_id,
+			sec->section_data_len,
+			dump);
+	}
+	camd35_send_emm(ts->emm_caid, sec->section_data, sec->section_data_len);
+	ts_privsec_copy(ts->emm, ts->last_emm);
+	ts_privsec_clear(ts->emm);
+}
+
+void process_ecm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
+	char dump[dump_buf_sz];
+	if (!ts->ecm_pid || ts->ecm_pid != pid)
+		return;
+
+	ts->ecm = ts_privsec_push_packet(ts->ecm, ts_packet);
+	if (!ts->ecm->initialized)
+		return;
+
+	struct ts_header *th = &ts->ecm->ts_header;
+	struct ts_section_header *sec = ts->ecm->section_header;
+	int duplicate = ts_privsec_is_same(ts->ecm, ts->last_ecm);
+	if (!duplicate) {
+		ts_hex_dump_buf(dump, dump_buf_sz, sec->section_data, min(dump_sz, sec->section_data_len), 0);
+		ts_LOGf("ECM | CAID: 0x%04x PID 0x%04x Table: 0x%02x Length: %3d IDX: 0x%04x Data: %s..\n",
+			ts->ecm_caid,
+			th->pid,
+			sec->table_id,
+			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);
+	} 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,
+			th->pid,
+			sec->table_id,
+			sec->section_data_len,
+			ts->ecm_counter - 1);
+	}
+	ts_privsec_copy(ts->ecm, ts->last_ecm);
+	ts_privsec_clear(ts->ecm);
+
+	show_ts_pack(pid, !duplicate ? "ecm" : "ec+", NULL, ts_packet);
+}

tables.h

@@ -0,0 +1,12 @@
+#ifndef TABLE_H
+#define TABLES_H
+
+#include "data.h"
+
+void process_pat(struct ts *ts, uint16_t pid, uint8_t *ts_packet);
+void process_cat(struct ts *ts, uint16_t pid, uint8_t *ts_packet);
+void process_pmt(struct ts *ts, uint16_t pid, uint8_t *ts_packet);
+void process_emm(struct ts *ts, uint16_t pid, uint8_t *ts_packet);
+void process_ecm(struct ts *ts, uint16_t pid, uint8_t *ts_packet);
+
+#endif

tsdecrypt.c

@@ -1,143 +1,32 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <netdb.h>
-#include <sched.h>
 #include <string.h>
-#include <time.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/errno.h>
-
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#include <openssl/aes.h>
-#include <openssl/md5.h>
 
 #include <dvbcsa/dvbcsa.h>
 
 #include "libfuncs/libfuncs.h"
 #include "libts/tsfuncs.h"
 
+#include "data.h"
 #include "util.h"
+#include "camd.h"
+#include "tables.h"
 
 uint8_t cur_cw[16];
 int is_valid_cw = 0;
-uint8_t invalid_cw[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 struct dvbcsa_key_s *csakey[2];
 
-static inline int valid_cw(uint8_t *cw) {
-	return memcmp(cw, invalid_cw, 16) != 0;
-}
-
-
-struct ts {
-	struct ts_pat		*pat, *curpat;
-	struct ts_cat		*cat, *curcat;
-	struct ts_pmt		*pmt, *curpmt;
-	struct ts_privsec	*emm, *last_emm;
-	struct ts_privsec	*ecm, *last_ecm;
-	uint16_t			pmt_pid;
-	uint16_t			service_id;
-	uint16_t			emm_caid, emm_pid;
-	uint16_t			ecm_caid, ecm_pid;
-	uint16_t			ecm_counter;
-	pidmap_t			pidmap;
-};
-
-struct ts *ts_alloc() {
-	struct ts *ts = calloc(1, sizeof(struct ts));
-	ts->pat	     = ts_pat_alloc();
-	ts->curpat   = ts_pat_alloc();
-
-	ts->cat      = ts_cat_alloc();
-	ts->curcat   = ts_cat_alloc();
-
-	ts->pmt      = ts_pmt_alloc();
-	ts->curpmt   = ts_pmt_alloc();
-
-	ts->emm      = ts_privsec_alloc();
-	ts->last_emm = ts_privsec_alloc();
-
-	ts->ecm      = ts_privsec_alloc();
-	ts->last_ecm = ts_privsec_alloc();
-
-	pidmap_clear(&ts->pidmap);
-
-	return ts;
-}
-
-void ts_free(struct ts **pts) {
-	struct ts *ts = *pts;
-	if (ts) {
-		ts_pat_free(&ts->pat);
-		ts_pat_free(&ts->curpat);
-		ts_cat_free(&ts->cat);
-		ts_cat_free(&ts->curcat);
-		ts_pmt_free(&ts->pmt);
-		ts_pmt_free(&ts->curpmt);
-		ts_privsec_free(&ts->emm);
-		ts_privsec_free(&ts->last_emm);
-		ts_privsec_free(&ts->ecm);
-		ts_privsec_free(&ts->last_ecm);
-		FREE(*pts);
-	}
-}
-
-void LOG_func(const char *msg) {
-	char date[64];
-	struct tm tm;
-	time_t now;
-	now = time(NULL);
-	localtime_r(&now, &tm);
-	strftime(date, sizeof(date), "%F %H:%M:%S", localtime(&now));
-	fprintf(stderr, "%s | %s", date, msg);
-}
-
+int debug_level = 0;
 unsigned long ts_pack = 0;
 int ts_pack_shown = 0;
-int debug_level = 0;
-
-static void show_ts_pack(uint16_t pid, char *wtf, char *extra, uint8_t *ts_packet) {
-	char cw1_dump[8 * 6];
-	char cw2_dump[8 * 6];
-	if (debug_level >= 4) {
-		if (ts_pack_shown)
-			return;
-		int stype = ts_packet_get_scrambled(ts_packet);
-		ts_hex_dump_buf(cw1_dump, 8 * 6, cur_cw    , 8, 0);
-		ts_hex_dump_buf(cw2_dump, 8 * 6, cur_cw + 8, 8, 0);
-		fprintf(stderr, "@ %s %s %03x %5ld %7ld | %s   %s | %s\n",
-			stype == 0 ? "------" :
-			stype == 2 ? "even 0" :
-			stype == 3 ? "odd  1" : "??????",
-			wtf,
-			pid,
-			ts_pack, ts_pack * 188,
-			cw1_dump, cw2_dump, extra ? extra : wtf);
-	}
-}
-
-static void dump_ts_pack(uint16_t pid, uint8_t *ts_packet) {
-	if (pid == 0x010)		show_ts_pack(pid, "nit", NULL, ts_packet);
-	else if (pid == 0x11)	show_ts_pack(pid, "sdt", NULL, ts_packet);
-	else if (pid == 0x12)	show_ts_pack(pid, "epg", NULL, ts_packet);
-	else					show_ts_pack(pid, "---", NULL, ts_packet);
-}
 
 enum CA_system req_CA_sys = CA_CONNAX;
-int server_fd = -1;
 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;
-AES_KEY camd35_aes_encrypt_key;
-AES_KEY camd35_aes_decrypt_key;
 
 int emm_send = 1;
 int pid_filter = 0;
@@ -276,309 +165,6 @@ void parse_options(int argc, char **argv) {
 	ts_LOGf("PID filter : %s\n", pid_filter ? "enabled" : "disabled");
 }
 
-static int connect_to(struct in_addr ip, int port) {
-	ts_LOGf("Connecting to %s:%d\n", inet_ntoa(ip), port);
-
-	int fd = socket(PF_INET, SOCK_STREAM, 0);
-	if (fd < 0)	{
-		ts_LOGf("Could not create socket | %s\n", strerror(errno));
-		return -1;
-	}
-
-	struct sockaddr_in sock;
-	sock.sin_family = AF_INET;
-	sock.sin_port = htons(port);
-	sock.sin_addr = ip;
-	if (do_connect(fd, (struct sockaddr *)&sock, sizeof(sock), 1000) < 0) {
-		ts_LOGf("Could not connect to %s:%d | %s\n", inet_ntoa(ip), port, strerror(errno));
-		return -1;
-	}
-
-	ts_LOGf("Connected with fd:%d\n", fd);
-	return fd;
-}
-
-// 4 auth header, 20 header size, 256 max data size, 16 potential padding
-#define HDR_LEN     (20)
-#define BUF_SIZE	(4 + HDR_LEN + 256 + 16)
-
-static void camd35_init_auth(char *user, char *pass) {
-	unsigned char dump[16];
-	camd35_auth = crc32(0L, MD5((unsigned char *)user, strlen(user), dump), 16);
-
-	MD5((unsigned char *)pass, strlen(pass), dump);
-
-	AES_set_encrypt_key(dump, 128, &camd35_aes_encrypt_key);
-	AES_set_decrypt_key(dump, 128, &camd35_aes_decrypt_key);
-}
-
-static void camd35_connect() {
-	if (server_fd < 0)
-		server_fd = connect_to(camd35_server_addr, camd35_server_port);
-}
-
-static int camd35_recv(uint8_t *data, int *data_len) {
-	int i;
-
-	// Read AUTH token
-	ssize_t r = fdread(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);
-
-	*data_len = 256;
-	for (i = 0; i < *data_len; i += 16) { // Read and decrypt payload
-		fdread(server_fd, (char *)data + i, 16);
-		AES_decrypt(data + i, data + i, &camd35_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)
-
-static uint8_t *camd35_recv_cw() {
-	uint8_t data[BUF_SIZE];
-	int data_len = 0;
-
-NEXT:
-	if (camd35_recv(data, &data_len) < 0)
-		ERR("No data!");
-
-	if (data[0] < 0x01) {
-		ts_LOGf("Not valid CW response, skipping it. data[0] = 0x%02x\n", data[0]);
-		goto NEXT;
-	}
-
-	if (data_len < 48)
-		ERR("len mismatch != 48");
-
-	if (data[1] < 0x10)
-		ERR("CW len mismatch != 0x10");
-
-	uint16_t ca_id = (data[10] << 8) | data[11];
-	uint16_t idx   = (data[16] << 8) | data[17];
-	uint8_t *cw = data + 20;
-	memcpy(cur_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);
-
-	is_valid_cw = valid_cw(cur_cw);
-	dvbcsa_key_set(cur_cw    , csakey[0]);
-	dvbcsa_key_set(cur_cw + 8, csakey[1]);
-
-	return NULL;
-}
-
-#undef ERR
-
-
-static int camd35_send(uint8_t *data, uint8_t data_len) {
-	unsigned int i;
-	uint8_t buf[BUF_SIZE];
-	uint8_t *bdata = buf + 4;
-
-	camd35_connect();
-
-	if (!camd35_auth)
-		camd35_init_auth(camd35_user, camd35_pass);
-
-	init_4b(camd35_auth, 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);
-
-	return fdwrite(server_fd, (char *)buf, data_len + 4);
-}
-
-static void camd35_buf_init(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
-	init_4b(crc32(0L, data, data_len), buf + 4); // Data CRC is at buf[4]
-	memcpy(buf + HDR_LEN, data, data_len); // Copy data to buf
-}
-
-static int camd35_send_ecm(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);
-
-	buf[0] = 0x00; // CMD ECM request
-	init_2b(service_id , buf + 8);
-	init_2b(ca_id      , buf + 10);
-	init_4b(provider_id, buf + 12);
-	init_2b(idx        , buf + 16);
-	buf[18] = 0xff;
-	buf[19] = 0xff;
-
-	camd35_send(buf, to_send);
-	camd35_recv_cw();
-	return 0;
-}
-
-static int camd35_send_emm(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);
-
-	buf[0] = 0x06; // CMD incomming EMM
-	init_2b(ca_id  , buf + 10);
-	init_4b(prov_id, buf + 12);
-
-	return camd35_send(buf, to_send);
-}
-
-#define handle_table_changes(TABLE) \
-	do { \
-		show_ts_pack(pid, #TABLE, NULL, ts_packet); \
-		ts->cur##TABLE = ts_##TABLE##_push_packet(ts->cur##TABLE, ts_packet); \
-		if (!ts->cur##TABLE->initialized) \
-			return;  \
-		if (ts_##TABLE##_is_same(ts->TABLE, ts->cur##TABLE)) { \
-			ts_##TABLE##_clear(ts->cur##TABLE); \
-			return; \
-		} \
-		ts_##TABLE##_free(&ts->TABLE); \
-		ts->TABLE = ts_##TABLE##_copy(ts->cur##TABLE); \
-		ts_##TABLE##_clear(ts->cur##TABLE); \
-		if (debug_level >= 1) \
-			ts_##TABLE##_dump(ts->TABLE); \
-	} while(0)
-
-void process_pat(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
-	int i;
-	if (pid != 0x00)
-		return;
-
-	handle_table_changes(pat);
-
-	for (i=0;i<ts->pat->programs_num;i++) {
-		struct ts_pat_program *prg = ts->pat->programs[i];
-		if (prg->pid) {
-			if (prg->program != 0) {
-				ts->pmt_pid    = prg->pid;
-				ts->service_id = prg->program;
-			}
-		}
-	}
-}
-
-void process_cat(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
-	if (pid != 0x01)
-		return;
-
-	handle_table_changes(cat);
-
-	ts_get_emm_info(ts->cat, req_CA_sys, &ts->emm_caid, &ts->emm_pid);
-}
-
-void process_pmt(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
-	int i;
-	if (!pid || pid != ts->pmt_pid)
-		return;
-
-	handle_table_changes(pmt);
-
-	pidmap_clear(&ts->pidmap);
-	pidmap_set(&ts->pidmap, 0x0000); // PAT
-	pidmap_set(&ts->pidmap, 0x0011); // SDT
-	pidmap_set(&ts->pidmap, ts->pmt->ts_header.pid); // PMT PID
-	pidmap_set(&ts->pidmap, ts->pmt->PCR_pid); // PCR
-	for (i=0;i<ts->pmt->streams_num;i++) {
-		struct ts_pmt_stream *stream = ts->pmt->streams[i];
-		pidmap_set(&ts->pidmap, stream->pid); // Data
-	}
-
-	if (!ts->ecm_caid) {
-		ts_get_ecm_info(ts->pmt, req_CA_sys, &ts->ecm_caid, &ts->ecm_pid);
-		char *CA_sys = ts_get_CA_sys_txt(ts_get_CA_sys(ts->ecm_caid));
-		ts_LOGf("%s Service : 0x%04x\n", CA_sys, ts->service_id);
-		ts_LOGf("%s CA_id   : 0x%04x\n", CA_sys, ts->emm_caid);
-		ts_LOGf("%s EMM pid : 0x%04x\n", CA_sys, ts->emm_pid);
-		ts_LOGf("%s ECM pid : 0x%04x\n", CA_sys, ts->ecm_pid);
-	}
-}
-
-#define dump_sz      (16)
-#define dump_buf_sz  (dump_sz * 6)
-
-void process_emm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
-	char dump[dump_buf_sz];
-	if (!ts->emm_pid || ts->emm_pid != pid)
-		return;
-
-	show_ts_pack(pid, "emm", NULL, ts_packet);
-
-	if (!emm_send)
-		return;
-
-	ts->emm = ts_privsec_push_packet(ts->emm, ts_packet);
-	if (!ts->emm->initialized)
-		return;
-
-	struct ts_header *th = &ts->emm->ts_header;
-	struct ts_section_header *sec = ts->emm->section_header;
-	if (debug_level >= 2) {
-		ts_hex_dump_buf(dump, dump_buf_sz, sec->section_data, min(dump_sz, sec->section_data_len), 0);
-		ts_LOGf("EMM | CAID: 0x%04x PID 0x%04x Table: 0x%02x Length: %3d ----------- Data: %s..\n",
-			ts->emm_caid,
-			th->pid,
-			sec->table_id,
-			sec->section_data_len,
-			dump);
-	}
-	camd35_send_emm(ts->emm_caid, sec->section_data, sec->section_data_len);
-	ts_privsec_copy(ts->emm, ts->last_emm);
-	ts_privsec_clear(ts->emm);
-}
-
-void process_ecm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
-	char dump[dump_buf_sz];
-	if (!ts->ecm_pid || ts->ecm_pid != pid)
-		return;
-
-	ts->ecm = ts_privsec_push_packet(ts->ecm, ts_packet);
-	if (!ts->ecm->initialized)
-		return;
-
-	struct ts_header *th = &ts->ecm->ts_header;
-	struct ts_section_header *sec = ts->ecm->section_header;
-	int duplicate = ts_privsec_is_same(ts->ecm, ts->last_ecm);
-	if (!duplicate) {
-		ts_hex_dump_buf(dump, dump_buf_sz, sec->section_data, min(dump_sz, sec->section_data_len), 0);
-		ts_LOGf("ECM | CAID: 0x%04x PID 0x%04x Table: 0x%02x Length: %3d IDX: 0x%04x Data: %s..\n",
-			ts->ecm_caid,
-			th->pid,
-			sec->table_id,
-			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);
-	} 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,
-			th->pid,
-			sec->table_id,
-			sec->section_data_len,
-			ts->ecm_counter - 1);
-	}
-	ts_privsec_copy(ts->ecm, ts->last_ecm);
-	ts_privsec_clear(ts->ecm);
-
-	show_ts_pack(pid, !duplicate ? "ecm" : "ec+", NULL, ts_packet);
-}
-
 void ts_process_packets(struct ts *ts, uint8_t *data, ssize_t data_len) {
 	ssize_t i;
 	for (i=0; i<data_len; i += 188) {
@@ -657,6 +243,6 @@ int main(int argc, char **argv) {
 	dvbcsa_key_free(csakey[0]);
 	dvbcsa_key_free(csakey[1]);
 
-	shutdown_fd(&server_fd);
+	camd35_disconnect();
 	exit(0);
 }