Add IPv6 support for input and output.

ChangeLog

  * Allow tsdecrypt to read ECM/EMM packet from text file. The added
    parameters are -n, -ecm-file <file> and -m --emm-file <file>.
  * Add support for CAMD server listening on IPv6.
- * Add support for forcing only IPv4 (-4, --ipv4) or IPv6 (-6, --ipv6)
-   server connections.
+ * Add support for input and output over IPv6.
+ * Add support for forcing only IPv4 (-4, --ipv4) or only IPv6 (-6, --ipv6).
  * Add support for multiple CAMD addresses returned when resolving CAMD
    server hostname. tsdecrypt would try each of the addresses and use
    the one that works.
+ * Change the way filenames are set in input/output options.
+   Now file:// prefix is must be added before the filename otherwise
+   the parameter is treated as network address.
  * Add --emm-filter (-a) option. This option implements EMM filtering.
 
 2012-04-19 : Version 8.1

README

 
 Input options:
  -I --input <source>        | Where to read from. File or multicast address.
-                            .    -I 224.0.0.1:5000 (multicast receive)
-                            .    -I file.ts        (read from file)
-                            .    -I -              (read from stdin) (default)
+                            .    -I 224.0.0.1:5000    (v4 multicast)
+                            .    -I [ff01::1111]:5000 (v6 multicast)
+                            .    -I file://in.ts      (read from file)
+                            . By default the input is stdin.
  -R --input-rtp             | Enable RTP input
  -z --input-ignore-disc     | Do not report discontinuty errors in input.
  -M --input-service <srvid> | Choose service id when input is MPTS.
 
 Output options:
  -O --output <dest>         | Where to send output. File or multicast address.
-                            .    -O 239.0.0.1:5000 (multicast send)
-                            .    -O file.ts        (write to file)
-                            .    -O -              (write to stdout) (default)
- -o --output-intf <addr>    | Set multicast output interface. Default: 0.0.0.0
+                            .    -O 239.0.0.1:5000    (v4 multicast)
+                            .    -O [ff01::2222]:5000 (v6 multicast)
+                            .    -O file://out.ts     (write to file)
+                            . By default the output is stdout.
+ -o --output-intf <value>   | Set multicast output interface.
+                             . Default for IPv4: 0.0.0.0 (intf addr)
+                             . Default for IPv6: -1      (intf number)
  -t --output-ttl <ttl>      | Set multicast ttl. Default: 1
  -r --output-rtp            | Enable RTP output.
  -k --output-rtp-ssrc <id>  | Set RTP SSRC. Default: 0
 
    # Decrypt file encypted with constant code word
    tsdecrypt --const-cw 0x00000000000000001111111111111111 \
-       --input encrypted-file.ts --output decrypted-file.ts
+       --input encrypted-file.ts --output file://decrypted-file.ts
 
    # Send ECM from file
    tsdecrypt --ecm-file ecm.txt --caid 0x5581 --input-service 12345 \

TODO

 - Sort nanos of viaccess and cryptoworks emms.
-- Add ipv6 support (multicast send/recv).

data.c

 	ts->output.type = FILE_IO;
 	ts->output.ttl  = 1;
 	ts->output.tos  = -1;
+	ts->output.v6_if_index = -1;
 
 	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
 	cbuf_free(&ts->decode_buf);
 	cbuf_free(&ts->write_buf);
 
-	FREE(ts->input.fname);
-	FREE(ts->output.fname);
-
 	list_free(&ts->input_buffer, free, NULL);
 
 	// glibc's crypt function allocates static buffer on first crypt() call.

data.h

 	int					fd;
 	enum io_type		type;
 	char				*fname;
-	struct in_addr		addr;
-	unsigned int		port;
+	char				*hostname;
+	char				*service;
 	// Used only for output
 	int					ttl;
 	int					tos;
 	struct in_addr		intf;
+	int					v6_if_index;
 };
 
 struct packet_buf {

tsdecrypt.1

 .PP
 .TP
 \fB\-I\fR, \fB\-\-input\fR <source>
-Where to read from. tsdecrypt supports input from files (\-I file.ts or \-I \-)
-or multicast (\-I 224.0.0.1:5000). By default tsdecrypt reads from \fBstdin\fR.
+Where to read from. tsdecrypt supports input from file (\-I file://file.ts),
+IPv4 multicast/unicast addresses (\-I 224.0.0.1:5000) or IPv6 multicast/unicast
+addresses (\-I [ff01::1111]:5000). By default tsdecrypt reads from \fBstdin\fR.
 .TP
 \fB\-R\fR, \fB\-\-input\-rtp\fR
 When reading from multicast assume the input is RTP stream. NOTE: No RTP
 .PP
 .TP
 \fB\-O\fR, \fB\-\-output\fR <dest>
-Output decrypted stream to <dest>. Destination can be multicast address
-(\-O 239.0.0.1:5000) or a file (\-O file.ts). The default output is \fBstdout\fR.
+Output decrypted stream to <dest>. The destination can be IPv4 multicast
+address (\-O 239.0.0.1:5000), IPv6 mulicast address (\-O [ff01::2222]:5000),
+hostname that resolves to IPv4/IPv6 address (\-O example.com:5000) or file.
+When the output is file, the file name should be prefixed with file://
+(\-O file://out.ts)if it doesn't contain / symbol. The default output
+is \fBstdout\fR.
 .TP
-\fB\-o\fR, \fB\-\-output\-intf\fR <addr>
-Set multicast output interface.
+\fB\-o\fR, \fB\-\-output\-intf\fR <value>
+Set multicast output interface. The value can be IPv4 address of the output
+interface  (default: 0.0.0.0 /any/) or in the case of IPv6 the interface
+number (default: -1 /any/).
 .TP
 \fB\-t\fR, \fB\-\-output\-ttl\fR
 Set multicast ttl. The default value is \fB1\fR.
 
    # Decrypt file encypted with constant code word
    tsdecrypt --const-cw 0x00000000000000001111111111111111 \\
-       --input encrypted-file.ts --output decrypted-file.ts
+       --input encrypted-file.ts --output file://decrypted-file.ts
 
    # Send ECM from file
    tsdecrypt --ecm-file ecm.txt --caid 0x5581 --input-service 12345 \\

tsdecrypt.c

 	printf("\n");
 	printf("Input options:\n");
 	printf(" -I --input <source>        | Where to read from. File or multicast address.\n");
-	printf("                            .    -I 224.0.0.1:5000 (multicast receive)\n");
-	printf("                            .    -I file.ts        (read from file)\n");
-	printf("                            .    -I -              (read from stdin) (default)\n");
+	printf("                            .    -I 224.0.0.1:5000    (v4 multicast)\n");
+	printf("                            .    -I [ff01::1111]:5000 (v6 multicast)\n");
+	printf("                            .    -I file://in.ts      (read from file)\n");
+	printf("                            . By default the input is stdin.\n");
 	printf(" -R --input-rtp             | Enable RTP input\n");
 	printf(" -z --input-ignore-disc     | Do not report discontinuty errors in input.\n");
 	printf(" -M --input-service <srvid> | Choose service id when input is MPTS.\n");
 	printf("\n");
 	printf("Output options:\n");
 	printf(" -O --output <dest>         | Where to send output. File or multicast address.\n");
-	printf("                            .    -O 239.0.0.1:5000 (multicast send)\n");
-	printf("                            .    -O file.ts        (write to file)\n");
-	printf("                            .    -O -              (write to stdout) (default)\n");
-	printf(" -o --output-intf <addr>    | Set multicast output interface. Default: %s\n", inet_ntoa(ts->output.intf));
+	printf("                            .    -O 239.0.0.1:5000    (v4 multicast)\n");
+	printf("                            .    -O [ff01::2222]:5000 (v6 multicast)\n");
+	printf("                            .    -O file://out.ts     (write to file)\n");
+	printf("                            . By default the output is stdout.\n");
+	printf(" -o --output-intf <value>   | Set multicast output interface.\n");
+	printf("                            . Default for IPv4: 0.0.0.0 (intf addr)\n");
+	printf("                            . Default for IPv6: -1      (intf number)\n");
 	printf(" -t --output-ttl <ttl>      | Set multicast ttl. Default: %d\n", ts->output.ttl);
 	printf(" -r --output-rtp            | Enable RTP output.\n");
 	printf(" -k --output-rtp-ssrc <id>  | Set RTP SSRC. Default: %u\n", ts->rtp_ssrc);
 }
 
 static int parse_io_param(struct io *io, char *opt, int open_flags, mode_t open_mode) {
+	int port_set = 0, host_set;
 	io->type = WTF_IO;
-	char *p = strrchr(opt, ':');
-	if (!p) {
+	if (strstr(opt, "file://") == opt) {
+		io->fname = opt + 7; // strlen("file://")
+		io->type = FILE_IO;
+	} else if (strchr(opt, '/')) {
+		io->fname = opt;
 		io->type = FILE_IO;
-		if (strcmp(opt, "-") != 0) {
-			io->fd = open(opt, open_flags, open_mode);
-			if (io->fd < 0) {
-				fprintf(stderr, "ERROR: Can not open file (%s): %s\n", opt, strerror(errno));
-				exit(EXIT_FAILURE);
-			}
-		}
-		io->fname = strdup(opt);
-		return 0;
 	}
-	*p = 0x00;
-	io->type = NET_IO;
-	io->port = atoi(p + 1);
-	if (inet_aton(opt, &io->addr) == 0)
+	if (io->type == FILE_IO) {
+		io->fd = open(io->fname, open_flags, open_mode);
+		if (io->fd < 0) {
+			fprintf(stderr, "ERROR: Can not open file (%s): %s\n", io->fname, strerror(errno));
+			exit(EXIT_FAILURE);
+		}
 		return 1;
-	return 0;
+	}
+	io->type = NET_IO;
+	host_set = parse_host_and_port(opt, &io->hostname, &io->service, &port_set);
+	return !(!port_set || !host_set);
 }
 
 extern char *optarg;
 extern int optind, opterr, optopt;
 
 static void parse_options(struct ts *ts, int argc, char **argv) {
-	int j, i, ca_err = 0, server_err = 1, input_addr_err = 0, output_addr_err = 0, output_intf_err = 0, ident_err = 0, port_set = 0;
+	int j, i, ca_err = 0, server_err = 1, input_addr_err = 0, output_addr_err = 0, ident_err = 0, port_set = 0;
 	opterr = 0; // Prevent printing of error messages for unknown options in getopt()
 	while ((j = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) {
 		if (j == '?') {
 				break;
 
 			case 'I': // --input
-				input_addr_err = parse_io_param(&ts->input, optarg, O_RDONLY, 0);
+				input_addr_err = !parse_io_param(&ts->input, optarg, O_RDONLY, 0);
 				break;
 			case 'R': // --input-rtp
 				ts->rtp_input = !ts->rtp_input;
 				break;
 
 			case 'O': // --output
-				output_addr_err = parse_io_param(&ts->output, optarg,
+				output_addr_err = !parse_io_param(&ts->output, optarg,
 					O_CREAT | O_WRONLY | O_TRUNC,
 					S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 				break;
 			case 'o': // --output-intf
-				if (inet_aton(optarg, &ts->output.intf) == 0)
-					output_intf_err = 1;
+				if (strchr(optarg, '.'))
+					inet_aton(optarg, &ts->output.intf);
+				else
+					ts->output.v6_if_index = atoi(optarg);
 				break;
 			case 't': // --output-ttl
 				ts->output.ttl = atoi(optarg);
 		if (server_err)
 			fprintf(stderr, "ERROR: CAMD server address is not set or it is invalid.\n");
 		if (input_addr_err)
-			fprintf(stderr, "ERROR: Input IP address is invalid.\n");
+			fprintf(stderr, "ERROR: Input address is invalid.\n");
 		if (output_addr_err)
-			fprintf(stderr, "ERROR: Output IP address is invalid.\n");
-		if (output_intf_err)
-			fprintf(stderr, "ERROR: Output interface address is invalid.\n");
+			fprintf(stderr, "ERROR: Output address is invalid.\n");
 		exit(EXIT_FAILURE);
 	}
 	if (decode_hex_string(ts->camd.newcamd.hex_des_key, ts->camd.newcamd.bin_des_key, DESKEY_LENGTH) < 0) {
 	}
 
 	if (ts->input.type == NET_IO) {
-		ts_LOGf("Input addr : %s://%s:%u/\n",
+		ts_LOGf("Input addr : %s://%s:%s/\n",
 			ts->rtp_input ? "rtp" : "udp",
-			inet_ntoa(ts->input.addr), ts->input.port);
+			ts->input.hostname, ts->input.service);
 		if (ts->input_buffer_time) {
 			ts_LOGf("Input buff : %u ms\n", ts->input_buffer_time);
 		}
 	if (!ts->emm_only)
 	{
 		if (ts->output.type == NET_IO) {
-			ts_LOGf("Output addr: %s://%s:%u/\n",
+			ts_LOGf("Output addr: %s://%s:%s/\n",
 				ts->rtp_output ? "rtp" : "udp",
-				inet_ntoa(ts->output.addr), ts->output.port);
-			ts_LOGf("Output intf: %s\n", inet_ntoa(ts->output.intf));
+				ts->output.hostname, ts->output.service);
+			ts_LOGf("Output intf: %s (IPv6 intf index:%d)\n",
+				inet_ntoa(ts->output.intf), ts->output.v6_if_index);
 			ts_LOGf("Output ttl : %d\n", ts->output.ttl);
 			if (ts->output.tos > -1)
 				ts_LOGf("Output TOS : %u (0x%02x)\n", ts->output.tos, ts->output.tos);
 				ts_LOGf("--- | Input read timeout.\n");
 				if (!ntimeouts) {
 					timeout_start = time(NULL);
-					notify(&ts, "INPUT_TIMEOUT", "Read timeout on input %s://%s:%u/",
+					notify(&ts, "INPUT_TIMEOUT", "Read timeout on input %s://%s:%s/",
 							ts.rtp_input ? "rtp" : "udp",
-							inet_ntoa(ts.input.addr), ts.input.port);
+							ts.input.hostname, ts.input.service);
 				}
 				ntimeouts++;
 			} else {
 				if (ntimeouts && readen > 0) {
-					notify(&ts, "INPUT_OK", "Data is available on input %s://%s:%u/ after %ld seconds timeout.",
+					notify(&ts, "INPUT_OK", "Data is available on input %s://%s:%s/ after %ld seconds timeout.",
 							ts.rtp_input ? "rtp" : "udp",
-							inet_ntoa(ts.input.addr), ts.input.port,
+							ts.input.hostname, ts.input.service,
 							(time(NULL) - timeout_start) + 2); // Timeout is detected when ~2 seconds there is no incoming data
 					ntimeouts = 0;
 				}

udp.c

 #include <arpa/inet.h>
 #include <errno.h>
 
+#include "util.h"
 #include "udp.h"
 
+#ifndef IPV6_ADD_MEMBERSHIP
+#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP
+#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
+#endif
+
+static int is_multicast(struct sockaddr_storage *addr) {
+	int ret = 0;
+	switch (addr->ss_family) {
+	case AF_INET: {
+		struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
+		ret = IN_MULTICAST(ntohl(addr4->sin_addr.s_addr));
+		break;
+	}
+	case AF_INET6: {
+		struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
+		ret = IN6_IS_ADDR_MULTICAST(&addr6->sin6_addr);
+		break;
+	} }
+	return ret;
+}
+
+extern int ai_family;
+
+static int bind_addr(const char *hostname, const char *service, int socktype, struct sockaddr_storage *addr, int *addrlen, int *sock) {
+	struct addrinfo hints, *res, *ressave;
+	int n, ret = -1;
+
+	memset(&hints, 0, sizeof(struct addrinfo));
+	hints.ai_family = ai_family;
+	hints.ai_socktype = socktype;
+
+	n = getaddrinfo(hostname, service, &hints, &res);
+	if (n < 0) {
+		ts_LOGf("ERROR: getaddrinfo(%s): %s\n", hostname, gai_strerror(n));
+		return ret;
+	}
+
+	ressave = res;
+	while (res) {
+		*sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
+		if (*sock > -1) {
+			if (bind(*sock, res->ai_addr, res->ai_addrlen) == 0) {
+				memcpy(addr, res->ai_addr, sizeof(*addr));
+				*addrlen = res->ai_addrlen;
+				ret = 0;
+				goto OUT;
+			} else {
+				char str_addr[INET6_ADDRSTRLEN];
+				my_inet_ntop(res->ai_family, res->ai_addr, str_addr, sizeof(str_addr));
+				ts_LOGf("ERROR: bind: %s:%s (%s): %s\n",
+					hostname, service, str_addr, strerror(errno));
+			}
+			close(*sock);
+			*sock = -1;
+		}
+		res = res->ai_next;
+	}
+OUT:
+	freeaddrinfo(ressave);
+
+	if (*sock > -1) {
+		int on = 1;
+		setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+		set_sock_nonblock(*sock);
+	}
+
+	return ret;
+}
+
+static int join_multicast_group(int sock, int ttl, struct sockaddr_storage *addr) {
+	switch (addr->ss_family) {
+	case AF_INET: {
+		struct ip_mreq mreq;
+		mreq.imr_multiaddr.s_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
+		mreq.imr_interface.s_addr = INADDR_ANY;
+
+		if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const void *)&mreq, sizeof(mreq)) < 0) {
+			ts_LOGf("ERROR: setsockopt(IP_ADD_MEMBERSHIP): %s\n", strerror(errno));
+			return -1;
+		}
+		if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
+			ts_LOGf("ERROR: setsockopt(IP_MULTICAST_TTL %d): %s\n", ttl, strerror(errno));
+		}
+		break;
+	}
+
+	case AF_INET6: {
+		struct ipv6_mreq mreq6;
+		memcpy(&mreq6.ipv6mr_multiaddr, &(((struct sockaddr_in6 *)addr)->sin6_addr), sizeof(struct in6_addr));
+		mreq6.ipv6mr_interface = 0; // interface index, will be set later
+
+		if (setsockopt(sock, IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mreq6, sizeof(mreq6)) < 0) {
+			ts_LOGf("ERROR: setsockopt(IPV6_ADD_MEMBERSHIP): %s\n", strerror(errno));
+			return -1;
+		}
+		if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &ttl, sizeof(ttl)) < 0) {
+			ts_LOGf("ERROR: setsockopt(IPV6_MULTICAST_HOPS %d): %s\n", ttl, strerror(errno));
+		}
+		break;
+	}
+	}
+
+	return 0;
+}
+
 int udp_connect_input(struct io *io) {
-	int sock = socket(AF_INET, SOCK_DGRAM, 0);
-	if (sock < 0) {
-		ts_LOGf("socket(SOCK_DGRAM): %s\n", strerror(errno));
+	struct sockaddr_storage addr;
+	int addrlen = sizeof(addr);
+	int sock = -1;
+
+	memset(&addr, 0, sizeof(addr));
+
+	ts_LOGf("Connecting input to %s port %s\n", io->hostname, io->service);
+	if (bind_addr(io->hostname, io->service, SOCK_DGRAM, &addr, &addrlen, &sock) < 0)
 		return -1;
-	}
-
-	ts_LOGf("Connecting input to udp://%s:%d/\n", inet_ntoa(io->addr), io->port);
-	int on = 1;
-	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
 
 	/* Set receive buffer size to ~2.0MB */
 	int bufsize = (2000000 / 1316) * 1316;
 	setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (void *)&bufsize, sizeof(bufsize));
 
-	// subscribe to multicast group
-	if (IN_MULTICAST(ntohl(io->addr.s_addr))) {
-		struct ip_mreq mreq;
-		memcpy(&mreq.imr_multiaddr, &io->addr, sizeof(struct in_addr));
-		mreq.imr_interface.s_addr = htonl(INADDR_ANY);
-		if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
-			ts_LOGf("setsockopt(IP_ADD_MEMBERSHIP %s): %s\n", inet_ntoa(io->addr), strerror(errno));
+	if (is_multicast(&addr)) {
+		if (join_multicast_group(sock, io->ttl, &addr) < 0) {
+			close(sock);
 			return -1;
 		}
 	}
-	// bind to the socket so data can be read
-	struct sockaddr_in receiving_from;
-	memset(&receiving_from, 0, sizeof(receiving_from));
-	receiving_from.sin_family = AF_INET;
-	receiving_from.sin_addr   = io->addr;
-	receiving_from.sin_port   = htons(io->port);
-	if (bind(sock, (struct sockaddr *) &receiving_from, sizeof(receiving_from)) < 0) {
-		ts_LOGf("bind(): %s\n", strerror(errno));
-		return -1;
-	}
 
 	io->fd = sock;
 	ts_LOGf("Input connected to fd:%d\n", io->fd);
 }
 
 int udp_connect_output(struct io *io) {
-	int sock = socket(AF_INET, SOCK_DGRAM, 0);
-	if (sock < 0) {
-		ts_LOGf("socket(SOCK_DGRAM): %s\n", strerror(errno));
+	struct sockaddr_storage addr;
+	int addrlen = sizeof(addr);
+	int sock = -1;
+
+	memset(&addr, 0, sizeof(addr));
+
+	ts_LOGf("Connecting output to %s port %s ttl: %d\n",
+		io->hostname, io->service, io->ttl);
+	if (bind_addr(io->hostname, io->service, SOCK_DGRAM, &addr, &addrlen, &sock) < 0)
 		return -1;
-	}
 
-	ts_LOGf("Connecting output to udp://%s:%d ttl:%d\n",
-		inet_ntoa(io->addr), io->port, io->ttl);
-
-	int on = 1;
-	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
-	set_sock_nonblock(sock);
-
-	/* Set receive buffer size to ~2.0MB */
+	/* Set send buffer size to ~2.0MB */
 	int bufsize = (2000000 / 1316) * 1316;
 	setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (void *)&bufsize, sizeof(bufsize));
 
-	// subscribe to multicast group
-	if (IN_MULTICAST(ntohl(io->addr.s_addr))) {
-		int ttl = io->ttl;
-		if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0) {
-			ts_LOGf("setsockopt(IP_MUTICAST_TTL): %s\n", strerror(errno));
-			close(sock);
-			return -1;
-		}
-		if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF, &io->intf, sizeof(io->intf)) < 0) {
-			ts_LOGf("setsockopt(IP_MUTICAST_IF %s): %s\n", inet_ntoa(io->intf), strerror(errno));
+	if (is_multicast(&addr)) {
+		if (join_multicast_group(sock, io->ttl, &addr) < 0) {
 			close(sock);
 			return -1;
+		} else {
+			if (addr.ss_family == AF_INET) {
+				if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF, &io->intf, sizeof(io->intf)) < 0) {
+					ts_LOGf("ERROR: setsockopt(IP_MUTICAST_IF %s): %s\n", inet_ntoa(io->intf), strerror(errno));
+					close(sock);
+					return -1;
+				}
+			}
+			if (addr.ss_family == AF_INET6 && io->v6_if_index > -1) {
+				if (setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_IF, (void *)&io->v6_if_index, sizeof(io->v6_if_index)) < 0) {
+					ts_LOGf("ERROR: setsockopt(IPV6_MUTICAST_IF %d): %s\n", io->v6_if_index, strerror(errno));
+					close(sock);
+					return -1;
+				}
+			}
 		}
 	}
 
-	if (io->tos > -1) {
+	if (addr.ss_family == AF_INET && io->tos > -1) {
 		if (setsockopt(sock, IPPROTO_IP, IP_TOS, &io->tos, sizeof(io->tos)) < 0) {
-			ts_LOGf("setsockopt(IP_TOS 0x%02x): %s\n", io->tos, strerror(errno));
+			ts_LOGf("ERROR: setsockopt(IP_TOS 0x%02x): %s\n", io->tos, strerror(errno));
 		}
 	}
 
-	struct sockaddr_in sockaddr;
-	memset(&sockaddr, 0, sizeof(sockaddr));
-	sockaddr.sin_family			= AF_INET;
-	sockaddr.sin_addr.s_addr	= io->addr.s_addr;
-	sockaddr.sin_port			= htons(io->port);
-	if (connect(sock, (struct sockaddr *)&sockaddr, sizeof(sockaddr))) {
-		ts_LOGf("udp_connect() error: %s\n", strerror(errno));
+	if (connect(sock, (struct sockaddr *)&addr, addrlen) < 0) {
+		ts_LOGf("ERROR: udp_connect(): %s\n", strerror(errno));
 		close(sock);
 		return -1;
 	}