Add all data to struct ts

camd.h

@@ -1,26 +1,8 @@
 #ifndef CAMD_H
 #define CAMD_H
 
-#include <openssl/aes.h>
-#include <openssl/md5.h>
-
 #include "data.h"
 
-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);
 

data.c

@@ -1,12 +1,12 @@
 #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));
+void data_init(struct ts *ts) {
+	memset(ts, 0, sizeof(struct ts));
+	// Stream
 	ts->pat	     = ts_pat_alloc();
 	ts->curpat   = ts_pat_alloc();
 
@@ -24,64 +24,39 @@ struct ts *ts_alloc() {
 
 	pidmap_clear(&ts->pidmap);
 
-	return ts;
-}
+	// Key
+	memset(&ts->key, 0, sizeof(ts->key));
+	ts->key.csakey[0] = dvbcsa_key_alloc();
+	ts->key.csakey[1] = dvbcsa_key_alloc();
 
-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);
-	}
-}
+	// CAMD
+	memset(&ts->camd35, 0, sizeof(ts->camd35));
+	ts->camd35.server_fd    = -1;
+	ts->camd35.server_port  = 2233;
+	ts->camd35.key          = &ts->key;
+	strcpy(ts->camd35.user, "user");
+	strcpy(ts->camd35.pass, "pass");
 
-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);
+	// Config
+	ts->debug_level = 0;
+	ts->req_CA_sys  = CA_CONNAX;
+	ts->emm_send    = 1;
+	ts->pid_filter  = 0;
+	ts->output_ttl  = 1;
 }
 
-extern int debug_level;
-extern unsigned long ts_pack;
-extern int ts_pack_shown;
-extern struct key key;
-
-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, key.cw    , 8, 0);
-		ts_hex_dump_buf(cw2_dump, 8 * 6, key.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 data_free(struct ts *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);
 
-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);
+	dvbcsa_key_free(ts->key.csakey[0]);
+	dvbcsa_key_free(ts->key.csakey[1]);
 }

data.h

@@ -1,11 +1,36 @@
 #ifndef DATA_H
 #define DATA_H
 
+#include <openssl/aes.h>
+#include <openssl/md5.h>
+
 #include <dvbcsa/dvbcsa.h>
 
 #include "libts/tsfuncs.h"
 
+struct key {
+	uint8_t				cw[16];
+	int					is_valid_cw;
+	struct dvbcsa_key_s	*csakey[2];
+};
+
+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;
+};
+
 struct ts {
+	// Stream handling
 	struct ts_pat		*pat, *curpat;
 	struct ts_cat		*cat, *curcat;
 	struct ts_pmt		*pmt, *curpmt;
@@ -17,20 +42,26 @@ struct ts {
 	uint16_t			ecm_caid, ecm_pid;
 	uint16_t			ecm_counter;
 	pidmap_t			pidmap;
-};
 
-struct key {
-	uint8_t				cw[16];
-	int					is_valid_cw;
-	struct dvbcsa_key_s	*csakey[2];
-};
+	// CAMD handling
+	struct key			key;
+	struct camd35		camd35;
+
+	// Config
+	enum CA_system		req_CA_sys;
 
-struct ts *ts_alloc();
-void ts_free(struct ts **pts);
+	int					emm_send;
+	int					pid_filter;
 
-void LOG_func(const char *msg);
+	struct in_addr		output_addr;
+	unsigned int		output_port;
+	int					output_ttl;
+	struct in_addr		output_intf;
+
+	int					debug_level;
+};
 
-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);
+void data_init(struct ts *ts);
+void data_free(struct ts *ts);
 
 #endif

tables.c

@@ -5,15 +5,11 @@
 #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;
+extern void show_ts_pack(struct ts *ts, uint16_t pid, char *wtf, char *extra, uint8_t *ts_packet);
 
 #define handle_table_changes(TABLE) \
 	do { \
-		show_ts_pack(pid, #TABLE, NULL, ts_packet); \
+		show_ts_pack(ts, pid, #TABLE, NULL, ts_packet); \
 		ts->cur##TABLE = ts_##TABLE##_push_packet(ts->cur##TABLE, ts_packet); \
 		if (!ts->cur##TABLE->initialized) \
 			return;  \
@@ -24,7 +20,7 @@ extern int emm_send;
 		ts_##TABLE##_free(&ts->TABLE); \
 		ts->TABLE = ts_##TABLE##_copy(ts->cur##TABLE); \
 		ts_##TABLE##_clear(ts->cur##TABLE); \
-		if (debug_level >= 1) \
+		if (ts->debug_level >= 1) \
 			ts_##TABLE##_dump(ts->TABLE); \
 	} while(0)
 
@@ -52,7 +48,7 @@ void process_cat(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 
 	handle_table_changes(cat);
 
-	ts_get_emm_info(ts->cat, req_CA_sys, &ts->emm_caid, &ts->emm_pid);
+	ts_get_emm_info(ts->cat, ts->req_CA_sys, &ts->emm_caid, &ts->emm_pid);
 }
 
 void process_pmt(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
@@ -73,7 +69,7 @@ void process_pmt(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 	}
 
 	if (!ts->ecm_caid) {
-		ts_get_ecm_info(ts->pmt, req_CA_sys, &ts->ecm_caid, &ts->ecm_pid);
+		ts_get_ecm_info(ts->pmt, ts->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);
@@ -90,9 +86,9 @@ void process_emm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 	if (!ts->emm_pid || ts->emm_pid != pid)
 		return;
 
-	show_ts_pack(pid, "emm", NULL, ts_packet);
+	show_ts_pack(ts, pid, "emm", NULL, ts_packet);
 
-	if (!emm_send)
+	if (!ts->emm_send)
 		return;
 
 	ts->emm = ts_privsec_push_packet(ts->emm, ts_packet);
@@ -101,7 +97,7 @@ void process_emm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 
 	struct ts_header *th = &ts->emm->ts_header;
 	struct ts_section_header *sec = ts->emm->section_header;
-	if (debug_level >= 2) {
+	if (ts->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,
@@ -110,7 +106,7 @@ void process_emm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 			sec->section_data_len,
 			dump);
 	}
-	camd35_send_emm(&camd35, ts->emm_caid, sec->section_data, sec->section_data_len);
+	camd35_send_emm(&ts->camd35, ts->emm_caid, sec->section_data, sec->section_data_len);
 	ts_privsec_copy(ts->emm, ts->last_emm);
 	ts_privsec_clear(ts->emm);
 }
@@ -136,8 +132,8 @@ void process_ecm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 			sec->section_data_len,
 			ts->ecm_counter,
 			dump);
-		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) {
+		camd35_send_ecm(&ts->camd35, ts->service_id, ts->ecm_caid, ts->ecm_counter++, sec->section_data, sec->section_data_len);
+	} else if (ts->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,
@@ -148,5 +144,5 @@ void process_ecm(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
 	ts_privsec_copy(ts->ecm, ts->last_ecm);
 	ts_privsec_clear(ts->ecm);
 
-	show_ts_pack(pid, !duplicate ? "ecm" : "ec+", NULL, ts_packet);
+	show_ts_pack(ts, pid, !duplicate ? "ecm" : "ec+", NULL, ts_packet);
 }

tsdecrypt.c

@@ -13,47 +13,40 @@
 #include "camd.h"
 #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;
-
-int emm_send = 1;
-int pid_filter = 0;
-
-struct in_addr output_addr;
-unsigned int output_port;
-int output_ttl = 1;
-struct in_addr output_intf;
-
-void show_help() {
-	printf("TSDECRYPT v1.0\n");
+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);
+}
+
+void show_help(struct ts *ts) {
+	printf("ts v1.0\n");
 	printf("Copyright (c) 2011 Unix Solutions Ltd.\n");
 	printf("\n");
-	printf("	Usage: tsdecrypt [opts] < mpeg_ts\n");
+	printf("	Usage: ts [opts] < mpeg_ts\n");
 	printf("\n");
 	printf("  Options:\n");
-	printf("    -c ca_system   | default: %s valid: IRDETO, CONNAX, CRYPTOWORKS\n", ts_get_CA_sys_txt(req_CA_sys));
+	printf("    -c ca_system   | default: %s valid: IRDETO, CONNAX, CRYPTOWORKS\n", ts_get_CA_sys_txt(ts->req_CA_sys));
 	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", ts->camd35.user);
+	printf("    -P server_pass | default: %s\n", ts->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");
-	printf("    -i output_intf | default: %s\n", inet_ntoa(output_intf));
-	printf("    -t output_ttl  | default: %d\n", output_ttl);
+	printf("    -i output_intf | default: %s\n", inet_ntoa(ts->output_intf));
+	printf("    -t output_ttl  | default: %d\n", ts->output_ttl);
 	printf("\n");
 	printf("  Filtering options:\n");
-	printf("    -e             | EMM send (default: %s).\n", emm_send ? "enabled" : "disabled");
+	printf("    -e             | EMM send (default: %s).\n", ts->emm_send ? "enabled" : "disabled");
 	printf("                   | - Send EMMs to CAMD server for processing.\n");
 	printf("\n");
-	printf("    -p             | Output PID filter (default: %s).\n", pid_filter ? "enabled" : "disabled");
+	printf("    -p             | Output PID filter (default: %s).\n", ts->pid_filter ? "enabled" : "disabled");
 	printf("                   | - When PID filter is enabled only PAT/PMT/SDT/data\n");
 	printf("                   | - packets are left in the output.\n");
 	printf("\n");
@@ -66,18 +59,18 @@ void show_help() {
 	printf("\n");
 }
 
-void parse_options(int argc, char **argv) {
+void parse_options(struct ts *ts, int argc, char **argv) {
 	int j, ca_err = 0, server_err = 1, output_addr_err = 0, output_intf_err = 0;
 	while ((j = getopt(argc, argv, "cFs:o:i:t:U:P:epD:h")) != -1) {
 		char *p = NULL;
 		switch (j) {
 			case 'c':
 				if (strcasecmp("IRDETO", optarg) == 0)
-					req_CA_sys = CA_IRDETO;
+					ts->req_CA_sys = CA_IRDETO;
 				else if (strcasecmp("CONNAX", optarg) == 0)
-					req_CA_sys = CA_CONNAX;
+					ts->req_CA_sys = CA_CONNAX;
 				else if (strcasecmp("CRYPTOWORKS", optarg) == 0)
-					req_CA_sys = CA_CRYPTOWORKS;
+					ts->req_CA_sys = CA_CRYPTOWORKS;
 				else
 					ca_err = 1;
 				break;
@@ -86,9 +79,9 @@ void parse_options(int argc, char **argv) {
 				p = strrchr(optarg, ':');
 				if (p) {
 					*p = 0x00;
-					camd35.server_port = atoi(p + 1);
+					ts->camd35.server_port = atoi(p + 1);
 				}
-				if (inet_aton(optarg, &camd35.server_addr) == 0)
+				if (inet_aton(optarg, &ts->camd35.server_addr) == 0)
 					server_err = 1;
 				else
 					server_err = 0;
@@ -98,46 +91,46 @@ void parse_options(int argc, char **argv) {
 				p = strrchr(optarg, ':');
 				if (p) {
 					*p = 0x00;
-					output_port = atoi(p + 1);
+					ts->output_port = atoi(p + 1);
 				}
-				if (inet_aton(optarg, &output_addr) == 0)
+				if (inet_aton(optarg, &ts->output_addr) == 0)
 					output_addr_err = 1;
 				break;
 			case 'i':
-				if (inet_aton(optarg, &output_intf) == 0)
+				if (inet_aton(optarg, &ts->output_intf) == 0)
 					output_intf_err = 1;
 				break;
 			case 't':
-				output_ttl = atoi(optarg);
+				ts->output_ttl = atoi(optarg);
 				break;
 
 			case 'U':
-				strncpy(camd35.user, optarg, sizeof(camd35.user) - 1);
-				camd35.user[sizeof(camd35.user) - 1] = 0;
+				strncpy(ts->camd35.user, optarg, sizeof(ts->camd35.user) - 1);
+				ts->camd35.user[sizeof(ts->camd35.user) - 1] = 0;
 				break;
 			case 'P':
-				strncpy(camd35.pass, optarg, sizeof(camd35.pass) - 1);
-				camd35.pass[sizeof(camd35.pass) - 1] = 0;
+				strncpy(ts->camd35.pass, optarg, sizeof(ts->camd35.pass) - 1);
+				ts->camd35.pass[sizeof(ts->camd35.pass) - 1] = 0;
 				break;
 
 			case 'e':
-				emm_send = !emm_send;
+				ts->emm_send = !ts->emm_send;
 				break;
 			case 'p':
-				pid_filter = !pid_filter;
+				ts->pid_filter = !ts->pid_filter;
 				break;
 
 			case 'D':
-				debug_level = atoi(optarg);
+				ts->debug_level = atoi(optarg);
 				break;
 
 			case 'h':
-				show_help();
+				show_help(ts);
 				exit(0);
 		}
 	}
 	if (ca_err || server_err) {
-		show_help();
+		show_help(ts);
 		if (ca_err)
 			fprintf(stderr, "ERROR: Requested CA system is unsupported.\n");
 		if (server_err)
@@ -148,17 +141,48 @@ void parse_options(int argc, char **argv) {
 			fprintf(stderr, "ERROR: Output interface address is invalid.\n");
 		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);
-	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));
-		ts_LOGf("Output ttl : %d\n", output_ttl);
+	ts_LOGf("CA System  : %s\n", ts_get_CA_sys_txt(ts->req_CA_sys));
+	ts_LOGf("Server addr: %s:%u\n", inet_ntoa(ts->camd35.server_addr), ts->camd35.server_port);
+	ts_LOGf("Server user: %s\n", ts->camd35.user);
+	ts_LOGf("Server pass: %s\n", ts->camd35.pass);
+	if (ts->output_port) {
+		ts_LOGf("Output addr: %s:%u\n", inet_ntoa(ts->output_addr), ts->output_port);
+		ts_LOGf("Output intf: %s\n", inet_ntoa(ts->output_intf));
+		ts_LOGf("Output ttl : %d\n", ts->output_ttl);
 	}
-	ts_LOGf("EMM send   : %s\n", emm_send   ? "enabled" : "disabled");
-	ts_LOGf("PID filter : %s\n", pid_filter ? "enabled" : "disabled");
+	ts_LOGf("EMM send   : %s\n", ts->emm_send   ? "enabled" : "disabled");
+	ts_LOGf("PID filter : %s\n", ts->pid_filter ? "enabled" : "disabled");
+}
+
+
+static unsigned long ts_pack;
+static int ts_pack_shown;
+
+void show_ts_pack(struct ts *ts, uint16_t pid, char *wtf, char *extra, uint8_t *ts_packet) {
+	char cw1_dump[8 * 6];
+	char cw2_dump[8 * 6];
+	if (ts->debug_level >= 4) {
+		if (ts_pack_shown)
+			return;
+		int stype = ts_packet_get_scrambled(ts_packet);
+		ts_hex_dump_buf(cw1_dump, 8 * 6, ts->key.cw    , 8, 0);
+		ts_hex_dump_buf(cw2_dump, 8 * 6, ts->key.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(struct ts *ts, uint16_t pid, uint8_t *ts_packet) {
+	if (pid == 0x010)		show_ts_pack(ts, pid, "nit", NULL, ts_packet);
+	else if (pid == 0x11)	show_ts_pack(ts, pid, "sdt", NULL, ts_packet);
+	else if (pid == 0x12)	show_ts_pack(ts, pid, "epg", NULL, ts_packet);
+	else					show_ts_pack(ts, pid, "---", NULL, ts_packet);
 }
 
 void ts_process_packets(struct ts *ts, uint8_t *data, ssize_t data_len) {
@@ -176,18 +200,18 @@ void ts_process_packets(struct ts *ts, uint8_t *data, ssize_t data_len) {
 		process_ecm(ts, pid, ts_packet);
 
 		if (!ts_pack_shown)
-			dump_ts_pack(pid, ts_packet);
+			dump_ts_pack(ts, pid, ts_packet);
 
 		int scramble_idx = ts_packet_get_scrambled(ts_packet);
 		if (scramble_idx > 1) {
-			if (key.is_valid_cw) {
+			if (ts->key.is_valid_cw) {
 				// scramble_idx 2 == even key
 				// scramble_idx 3 == odd key
 				ts_packet_set_not_scrambled(ts_packet);
-				dvbcsa_decrypt(key.csakey[scramble_idx - 2], ts_packet + 4, 184);
+				dvbcsa_decrypt(ts->key.csakey[scramble_idx - 2], ts_packet + 4, 184);
 			} else {
 				// Can't decrypt the packet just make it NULL packet
-				if (pid_filter)
+				if (ts->pid_filter)
 					ts_packet_set_pid(ts_packet, 0x1fff);
 			}
 		}
@@ -201,7 +225,7 @@ void ts_write_packets(struct ts *ts, uint8_t *data, ssize_t data_len) {
 	for (i=0; i<data_len; i += 188) {
 		uint8_t *ts_packet = data + i;
 		uint16_t pid = ts_packet_get_pid(ts_packet);
-		if (pid_filter) {
+		if (ts->pid_filter) {
 			if (pidmap_get(&ts->pidmap, pid)) // PAT or allowed PIDs
 				write(1, ts_packet, 188);
 		} else {
@@ -215,37 +239,25 @@ void ts_write_packets(struct ts *ts, uint8_t *data, ssize_t data_len) {
 int main(int argc, char **argv) {
 	ssize_t readen;
 	uint8_t ts_packet[FRAME_SIZE];
-
-	memset(&key, 0, sizeof(key));
-	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;
+	struct ts ts;
 
 	ts_set_log_func(LOG_func);
 
-	parse_options(argc, argv);
+	data_init(&ts);
 
-	camd35_connect(&camd35);
+	parse_options(&ts, argc, argv);
 
-	struct ts *ts = ts_alloc();
+	camd35_connect(&ts.camd35);
 	do {
 		readen = read(0, ts_packet, FRAME_SIZE);
 		if (readen > 0) {
-			ts_process_packets(ts, ts_packet, readen);
-			ts_write_packets(ts, ts_packet, readen);
+			ts_process_packets(&ts, ts_packet, readen);
+			ts_write_packets(&ts, ts_packet, readen);
 		}
 	} while (readen > 0);
-	ts_free(&ts);
+	camd35_disconnect(&ts.camd35);
 
-	dvbcsa_key_free(key.csakey[0]);
-	dvbcsa_key_free(key.csakey[1]);
+	data_free(&ts);
 
-	camd35_disconnect(&camd35);
 	exit(0);
 }