New release 1.7.0

1 files changed, 1096 insertions, 0 deletions

diff --git a/ccast/ccmdns.c b/ccast/ccmdns.c
new file mode 100644
index 0000000..8dd889e
--- /dev/null
+++ b/ccast/ccmdns.c
@@ -0,0 +1,1096 @@
+
+/* 
+ * Argyll Color Correction System
+ * ChromCast support
+ *
+ * Author: Graeme W. Gill
+ * Date:   28/8/2014
+ *
+ * Copyright 2014 Graeme W. Gill
+ * All rights reserved.
+ *
+ * This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :-
+ * see the License2.txt file for licencing details.
+ *
+ */
+
+/*
+ * This class provides simple access to the Google ChromeCast
+ * for the purposes of generating Video Test patches.
+ */
+
+/*
+	TTBD:	Ideally we should use the system mDNS resource if it is available,
+	and fall back to our mDNS code if not.
+
+	ie. Linux may have nothing, be using avahi-daemon,
+	            possibly Zeroconf (== Bonjour ?)
+	  Avahi has Bonjour compatibility library ??
+
+	ie. OS X is using mDNSRespo (Bonjour ?)
+
+	MSWin may have Bonjour installed on it ?
+	 Has dns-sd command - what's that using (SSDP/UPnP ?)
+
+	  From <http://stackoverflow.com/questions/8659638/how-does-windows-know-how-to-resolve-mdns-queries>
+
+		Bonjour for Windows allows any software using the standard name resolution APIs
+		to resolve mDNS names; it does so by registering a DLL (mdnsnsp.dll) as a
+		namespace provider using WSCInstallNameSpace.
+
+		The corresponding code is included in the mDNSResponder source (in particular,
+		look at the mdnsNSP and NSPTool components).
+
+	To test on Linux:
+
+	  To check what's listening: sudo netstat -anp | grep 5353
+
+	  /etc/init.d/avahi-daemon stop
+	  /etc/init.d/avahi-daemon start
+
+	To test on OS X:
+
+	  To check what's listening: sudo netstat -an | grep 5353
+
+	  launchctl unload -w /System/Library/LaunchDaemons/com.apple.mDNSResponder.plist
+	  launchctl load -w /System/Library/LaunchDaemons/com.apple.mDNSResponder.plist
+ */
+
+
+#include <time.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <math.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <limits.h>
+#include "copyright.h"
+#include "aconfig.h"
+#include <sys/types.h>
+#ifndef SALONEINSTLIB
+#include "numlib.h"
+#else
+#include "numsup.h"
+#endif
+#include "ccmdns.h"
+
+#undef DEBUG
+
+#if defined(NT) // Windows specific
+# if _WIN32_WINNT < 0x0400
+#  undef _WIN32_WINNT
+#  define _WIN32_WINNT 0x0400 // To make it link in VS2005
+# endif
+# define WIN32_LEAN_AND_MEAN
+# include <winsock2.h>
+# include <windows.h>
+# include <ws2tcpip.h>
+
+# include <process.h>
+# include <direct.h>
+# include <io.h>
+
+# define ERRNO GetLastError()
+# define UDP_SOCKET_TIMEOUT WSAETIMEDOUT
+
+#else /* !NT = Unix, OS X */
+
+# include <errno.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <sys/socket.h>
+# include <sys/select.h>
+# include <netinet/in.h>
+# include <arpa/inet.h>
+# include <sys/time.h>
+# include <stdint.h>
+# include <inttypes.h>
+# include <netdb.h>
+
+# include <pwd.h>
+# include <unistd.h>
+# include <dirent.h>
+
+typedef int SOCKET;
+# define ERRNO errno
+
+# define INVALID_SOCKET -1
+# define SOCKET_ERROR -1
+# define UDP_SOCKET_TIMEOUT EAGAIN
+
+#define closesocket(xxx) close(xxx);
+
+#endif
+
+#ifdef DEBUG
+# define dbgo stdout
+# define DBG(xxx) fprintf xxx ;
+void cc_dump_bytes(FILE *fp, char *pfx, unsigned char *buf, int len);
+#else
+# define DBG(xxx) ;
+#endif  /* DEBUG */
+
+/* ================================================================ */
+
+/* mDNS details */
+#define DESTINATION_MCAST "224.0.0.251"
+#define DESTINATION_MCASTV6 "FF02::FB"
+#define SOURCE_PORT 5353 
+#define DESTINATION_PORT 5353 
+
+#define BUFSIZE 1024
+
+/* Various DNS defines */
+#define DNS_CLASS_IN 0x0001
+
+// Used by ChromeCast
+#define DNS_TYPE_PTR  12	/* Domain name pointer				*/
+#define DNS_TYPE_TXT  16	/* Text String						*/
+#define DNS_TYPE_SRV  33	/* Server selection (SRV) record	*/
+#define DNS_TYPE_A	   1	/* Host address (A) record			*/
+#define DNS_TYPE_AAAA 28	/* IPv6 address ???					*/
+#define DNS_TYPE_NSEC 47	/* DNS Next Secure Name				*/
+
+
+#ifdef NEVER
+/* Print out a V6 address in zero compresed form */
+/* (It would be nice to add zero compression) */
+static char *print_IPV6_Address(ORD8 *buf) {
+	static char sbuf[40], *p = sbuf;
+	int i;
+	for (i = 0; i < 8; i++) {
+		p += sprintf(p, "%x", buf[i * 2 + 1] * 256 + buf[i * 2 + 0]);
+		if (i < 7)
+		*p++ = ':';
+	}
+	*p++ = '\000';
+	return sbuf;
+}
+#endif
+
+/* Write a DNS string to a buffer. */
+/* return the offset of the next byte after the string */
+static int write_string(ORD8 *buf, int off, char *s) {
+	int len = strlen(s);
+	if (len >= 0xc0)
+		len = 0xc0;	// Hmm.
+	buf[off] = len;
+	off++;
+	memcpy(buf + off, s, len);
+	off += len;
+	return off;
+}
+
+/* Return NZ on error */
+static int init_mDNS() {
+
+#ifdef NT
+	WSADATA data;
+	if (WSAStartup(MAKEWORD(2,2), &data)) {
+		DBG((dbgo,"WSAStartup failed\n"))
+		return 1;
+	}
+#endif
+
+	return 0;
+}
+
+/* Setup the send socket */
+/* Return nz on error */
+static int init_send_mDNS(SOCKET *psock) {
+	int nRet, nOptVal; 
+	int off;
+	SOCKET sock; 
+	struct sockaddr_in stSourceAddr; 
+
+	DBG((dbgo,"init_send_mDNS() called\n")) 
+
+	/* get a datagram (UDP) socket */ 
+	sock = socket(PF_INET, SOCK_DGRAM, 0); 
+	if (sock == INVALID_SOCKET) { 
+		DBG((dbgo,"opening UDP socked failed with %d\n",ERRNO)) 
+		return 1;
+	} 
+
+	/*----------------------- to send --------------------------- */
+
+	/* Theoretically, you do not need any special preparation to 
+	 * send to a multicast address. However, you may want a few
+	 * things to overcome the limits of the default behavior 
+	 */
+
+	// If we're doing a one-shot, we shouldn't transmit from port 5353, */
+	// but ChromCast won't see the packet if we don't. */
+
+	/* We cant send from port 5353 if someone else is using it, */
+	/* so set the SO_REUSEADDR option (which is enough for MSWin), */
+	/* and SO_REUSEPORT for OS X and Linux */
+	{
+		int on = 1;
+		if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on))) {
+			DBG((dbgo,"setsockopt(SO_REUSEADDR)  failed with %d\n",ERRNO))
+			closesocket(sock);
+			return 1;
+		}
+
+		/* Need this to be able to open port on Unix like systems */
+#ifndef NT
+# ifndef SO_REUSEPORT
+#  ifdef __APPLE__
+#   define SO_REUSEPORT 0x0200 
+#  else	/* Linux */
+#   define SO_REUSEPORT 15 
+#  endif
+# endif
+		if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (const char *)&on, sizeof(on))) {
+			DBG((dbgo,"setsockopt(SO_REUSEPORT)  failed with %d\n",ERRNO))
+		}
+#endif
+	}
+
+	/* init source address structure */ 
+	stSourceAddr.sin_family = PF_INET; 
+	stSourceAddr.sin_port = htons(SOURCE_PORT); 
+	stSourceAddr.sin_addr.s_addr = INADDR_ANY; 
+
+	/* 
+	 * Calling bind() is not required, but some implementations need it 
+	 * before you can reference any multicast socket options
+	 * and in this case we must be on port 5353 for ChromeCast to see the packet
+	 */ 
+	nRet = bind(sock, (struct sockaddr *)&stSourceAddr, 
+				 sizeof(struct sockaddr)); 
+	if (nRet == SOCKET_ERROR) { 
+		DBG((dbgo,"bind failed with %d\n",ERRNO))
+		closesocket(sock);
+		return 1;
+	} 
+
+	/* disable loopback of multicast datagrams we send, since the 
+	 * default--according to Steve Deering--is to loopback all
+	 * datagrams sent on any interface which is a member of the
+	 * destination group address of that datagram.
+	 */ 
+	nOptVal = 0; 
+	nRet = setsockopt (sock, IPPROTO_IP, IP_MULTICAST_LOOP, 
+				(char *)&nOptVal, sizeof(int)); 
+	if (nRet == SOCKET_ERROR) { 
+		/* rather than notifying the user, we make note that this option 
+		 * failed. Some WinSocks don't support this option, and default
+		 * with loopback disabled), so this failure is of no consequence.
+		 * However, if we *do* get loop-backed data, we'll know why
+		 */ 
+		DBG((dbgo,"[disabling loopback failed with %d]\n",ERRNO)) 
+	} 
+
+#ifdef NEVER		// We only want this to be local
+	/* increase the IP TTL from the default of one to 64, so our
+	 * multicast datagrams can get off of the local network 
+	 */
+	nOptVal = 64; 
+	nRet = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL,
+				 (char *)&nOptVal, sizeof(int)); 
+	if (nRet == SOCKET_ERROR) { 
+		DBG((dbgo,"increasing TTL failed with %d\n",ERRNO))
+		closesocket(sock);
+		return 1;
+	} 
+#endif
+
+	if (psock != NULL)
+		*psock = sock;
+
+	DBG((dbgo,"init sending mDNS succeed\n",ERRNO))
+
+	return 0;
+}
+
+/* Send an mDNS quesry */
+/* on some platforms if we try to transmit & recieve at the same time */
+/* Return nz on error */
+static int send_mDNS(SOCKET sock) {
+	int nRet; 
+	int off;
+	ORD8 achOutBuf[BUFSIZE]; 
+	struct sockaddr_in stDestAddr; 
+
+	DBG((dbgo,"send_mDNS() called\n")) 
+
+	/* Initialize the Destination Address structure and send */ 
+	stDestAddr.sin_family = PF_INET; 
+	stDestAddr.sin_addr.s_addr = inet_addr(DESTINATION_MCAST);
+	stDestAddr.sin_port = htons(DESTINATION_PORT); 
+
+	/* Setup the FQDN data packet to send */
+	write_ORD16_be(0, achOutBuf + 0);	/* ID */
+	write_ORD16_be(0, achOutBuf + 2);	/* Flags */
+	write_ORD16_be(1, achOutBuf + 4);	/* QDCOUNT - one question */
+	write_ORD16_be(0, achOutBuf + 6);	/* ANCOUNT */
+	write_ORD16_be(0, achOutBuf + 8);	/* NSCOUNT */
+	write_ORD16_be(0, achOutBuf + 10);	/* ARCOUNT */
+	off = 12;
+	off = write_string(achOutBuf, off, "_googlecast");
+	off = write_string(achOutBuf, off, "_tcp");
+	off = write_string(achOutBuf, off, "local");
+	write_ORD8(0, achOutBuf + off);			/* null string */
+	off += 1;
+	write_ORD16_be(0x000c, achOutBuf + off);	/* QCOUNT */
+	off += 2;
+	/* Set top bit to get a unicast response (not for ChromeCast though) */
+	write_ORD16_be(0x0001, achOutBuf + off);	/* QCLASS */
+	off += 2;
+
+	nRet = sendto(sock, (char *)achOutBuf, off,
+					0, 
+					(struct sockaddr *) &stDestAddr, 
+					sizeof(struct sockaddr)); 
+	if (nRet == SOCKET_ERROR) { 
+		DBG((dbgo,"sending mDNS query failed with %d\n",ERRNO))
+		return 1;
+	} 
+
+	DBG((dbgo,"sending mDNS query succeed\n",ERRNO))
+
+	return 0;
+}
+
+static int parse_dns(char **name, char **ip, ORD8 *buf, int size);
+
+/* Free up what get_ccids returned */
+void free_ccids(ccast_id **ids) {
+	if (ids != NULL) {
+		int i;
+
+		for (i = 0; ids[i] != NULL; i++) {
+			free(ids[i]->name);
+			free(ids[i]->ip);
+			free(ids[i]);
+		}
+		free(ids);
+	}
+}
+
+/* Spend the given time waiting for replies. */
+/* (Note than on MSWin this will be a minimum of 500msec) */
+/* Add any ChromeCast replies to the list. */
+/* return nz on error */
+static int init_receive_mDNS(SOCKET *psock) {
+	int nRet; 
+	int off, size;
+	struct sockaddr_in stSourceAddr; 
+	struct ip_mreq stIpMreq; 
+	SOCKET sock;
+
+	DBG((dbgo,"init_receive_mDNS() called\n"))
+
+	/* get a datagram (UDP) socket */ 
+	sock = socket(PF_INET, SOCK_DGRAM, 0); 
+	if (sock == INVALID_SOCKET) { 
+		DBG((dbgo,"opening UDP socked failed with %d\n",ERRNO)) 
+		return 1;
+	} 
+
+	/* We can't receive from port 5353 if someone else is using it, */
+	/* so set the SO_REUSEADDR option (which is enough for MSWin), */
+	/* and SO_REUSEPORT for OS X and Linux */
+	{
+		int on = 1, off = 0;
+		if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *) &on, sizeof(on))) {
+			DBG((dbgo,"setsockopt(SO_REUSEADDR)  failed with %d\n",ERRNO))
+			closesocket(sock);
+			return 1;
+		}
+
+		/* Need this to be able to open port on Unix like systems */
+#ifndef NT
+# ifndef SO_REUSEPORT
+#  ifdef __APPLE__
+#   define SO_REUSEPORT 0x0200 
+#  else	/* Linux */
+#   define SO_REUSEPORT 15 
+#  endif
+# endif
+		if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (const char *)&on, sizeof(on))) {
+			DBG((dbgo,"setsockopt(SO_REUSEPORT)  failed with %d\n",ERRNO))
+		}
+#endif
+	}
+
+	/* init source address structure */ 
+	stSourceAddr.sin_family = PF_INET; 
+	stSourceAddr.sin_port = htons(SOURCE_PORT); 
+	stSourceAddr.sin_addr.s_addr = INADDR_ANY; 
+
+	/* 
+	 * Calling bind() is not required, but some implementations need it 
+	 * before you can reference any multicast socket options
+	 * and in this case we must be on port 5353.
+	 */ 
+	nRet = bind(sock, (struct sockaddr *)&stSourceAddr, 
+				sizeof(struct sockaddr)); 
+	if (nRet == SOCKET_ERROR) { 
+		DBG((dbgo,"bind failed with %d\n",ERRNO))
+		closesocket(sock);
+		return 1;
+	} 
+
+	/* join the multicast group we want to receive datagrams from */ 
+	stIpMreq.imr_multiaddr.s_addr = inet_addr(DESTINATION_MCAST); /* group addr */ 
+	stIpMreq.imr_interface.s_addr = INADDR_ANY; /* use default */ 
+	nRet = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+					(char *)&stIpMreq, sizeof (struct ip_mreq));
+
+	if (nRet == SOCKET_ERROR) { 
+		DBG((dbgo,"registering for read events failed with %d\n",ERRNO))
+		closesocket(sock);
+		return 1;
+	} 
+
+	/* Make this timeout after 100 msec second */
+#ifdef NT
+	{
+		DWORD tv;
+		tv = 100;
+		if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv)) < 0) {
+			DBG((dbgo,"setsockopt timout failed with %d\n",ERRNO))
+			closesocket(sock);
+			return 1;
+		}
+	}
+#else
+	{
+		struct timeval tv;
+		tv.tv_sec = 0;
+		tv.tv_usec = 100 * 1000;
+		if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof(tv)) < 0) {
+			DBG((dbgo,"setsockopt timout failed with %d\n",ERRNO))
+			closesocket(sock);
+			return 1;
+		}
+	}
+#endif
+
+	if (psock != NULL)
+		*psock = sock;
+
+	return 0;
+}
+
+/* Spend the given time waiting for replies. */
+/* (Note than on MSWin this will be a minimum of 500msec) */
+/* Add any ChromeCast replies to the list. */
+/* return nz on error & free *ids */
+static int receive_mDNS(SOCKET sock, ccast_id ***ids, int emsec) {
+	int nids = 0;
+	unsigned int smsec;
+	unsigned int nSize;
+	int off, size;
+	ORD8 achInBuf[BUFSIZE]; 
+	struct sockaddr_in stSourceAddr; 
+
+	/* Count the number of current id's */
+	if (*ids != NULL) {
+		for (nids = 0; (*ids)[nids] != NULL; nids++)
+			;
+	}
+
+	DBG((dbgo,"receive_mDNS() called with %d ids\n",nids))
+
+	for (smsec = msec_time(), emsec += smsec;msec_time() <= emsec;) {
+		int i;
+		char *name, *ip;
+		struct sockaddr stSockAddr; 
+
+		/* Recv the available data */ 
+		nSize = sizeof(struct sockaddr); 
+		size = recvfrom(sock, (char *)achInBuf, 
+						BUFSIZE, 0, (struct sockaddr *) &stSockAddr, &nSize); 
+		if (size == SOCKET_ERROR) { 
+			if (ERRNO == UDP_SOCKET_TIMEOUT)
+				continue;			/* Timeout */
+			DBG((dbgo,"recvfrom failed with %d\n",ERRNO))
+			free_ccids(*ids);
+			*ids = NULL;
+			return 1;
+		}
+		DBG((dbgo,"Got mDNS message length %d bytes\n",size))
+#ifdef DEBUG
+		cc_dump_bytes(dbgo, "    ", achInBuf, size);
+#endif
+
+		if (parse_dns(&name, &ip, achInBuf, size) != 0) {
+			DBG((dbgo,"Failed to parse the reply\n"))
+		} else {
+			DBG((dbgo,"Parsed reply OK\n"))
+
+//if (*pnids > 0) {
+//	name = strdup("Argyll1234");
+//	ip = strdup("10.0.0.129");
+//}
+			/* If we found an entry */
+			if (name != NULL && ip != NULL) {
+				DBG((dbgo,"Got a name '%s' & IP '%s'\n",name,ip))
+				/* Check if it is a duplcate */
+				for (i = 0; i < nids; i++) {
+					if (strcmp((*ids)[i]->name, name) == 0
+					 && strcmp((*ids)[i]->ip, ip) == 0)
+						break;	/* yes */
+				} 
+				if (i < nids) {
+					DBG((dbgo,"Duplicate\n"))
+					free(name);
+					free(ip);
+				} else {
+					ccast_id **tids;
+					if ((tids = realloc(*ids, (nids + 2) * sizeof(ccast_id *))) == NULL
+					 || (*ids = tids, (*ids)[nids] = malloc(sizeof(ccast_id)), (*ids)[nids]) == NULL) {
+						DBG((dbgo,"realloc/malloc fail\n"))
+						free(name);
+						free(ip);
+						free_ccids(*ids);
+						*ids = NULL;
+						return 1;
+					} else {
+						DBG((dbgo,"Adding entry\n"))
+						(*ids)[nids]->name = name;
+						(*ids)[nids]->ip = ip;
+						(*ids)[++nids] = NULL;		/* End marker */
+					}
+				}
+			}
+		}
+	}
+
+	DBG((dbgo,"receive_mDNS() returning %d in list\n",nids))
+
+	return 0;
+}
+
+/* ==================================================================== */
+
+/* Get a list of Chromecasts. Return NULL on error */
+/* Last pointer in array is NULL */
+/* Takes 0.5 second to return */
+ccast_id **get_ccids() {
+	ccast_id **ids = NULL;
+	int i, j;
+	unsigned int smsec;
+	SOCKET ssock, rsock;
+
+	if (init_mDNS()) {
+		DBG((dbgo,"init_mDNS() failed\n"))
+		return NULL;
+	}
+
+	if (init_send_mDNS(&ssock)) {
+		DBG((dbgo,"init_send_mDNS() failed\n"))
+		return NULL;
+	}
+
+	if (init_receive_mDNS(&rsock)) {
+		DBG((dbgo,"init_receive_mDNS() failed\n"))
+		closesocket(ssock);
+		return NULL;
+	}
+
+	smsec = msec_time();
+
+	DBG((dbgo,"Sending mDNS query:\n"))
+	if (send_mDNS(ssock)) {
+		DBG((dbgo,"send_mDNS() #1 failed\n"))
+		closesocket(ssock);
+		closesocket(rsock);
+		return NULL;
+	}
+
+	if (receive_mDNS(rsock, &ids, 100)) {
+		DBG((dbgo,"receive_mDNS() #1 failed\n"))
+		closesocket(ssock);
+		closesocket(rsock);
+		return NULL;
+	}
+
+	if (ids == NULL && (msec_time() - smsec) < 200) {
+
+		DBG((dbgo,"Sending another mDNS query:\n"))
+		if (send_mDNS(ssock)) {
+			DBG((dbgo,"send_mDNS() #2 failed\n"))
+			closesocket(ssock);
+			closesocket(rsock);
+			return NULL;
+		}
+
+		if (receive_mDNS(rsock, &ids, 500)) {
+			DBG((dbgo,"receive_mDNS() #2 failed\n"))
+			closesocket(ssock);
+			closesocket(rsock);
+			return NULL;
+		}
+	}
+
+	if (ids == NULL) {
+
+		DBG((dbgo,"Sending a final mDNS query:\n"))
+		if (send_mDNS(ssock)) {
+			DBG((dbgo,"send_mDNS() #3 failed\n"))
+			closesocket(ssock);
+			closesocket(rsock);
+			return NULL;
+		}
+
+		if (receive_mDNS(rsock, &ids, 500)) {
+			DBG((dbgo,"receive_mDNS() #3 failed\n"))
+			closesocket(ssock);
+			closesocket(rsock);
+			return NULL;
+		}
+	}
+
+	closesocket(ssock);
+	closesocket(rsock);
+
+	/* If no ChromCasts found, return an empty list */
+	if (ids == NULL) {
+		if ((ids = calloc(sizeof(ccast_id *), 1)) == NULL) {
+			DBG((dbgo,"calloc fail\n"))
+			return NULL;
+		}
+	}
+	/* Sort the results so that it is stable */
+	for (i = 0; ids[i] != NULL && ids[i+1] != NULL; i++) {
+		for (j = i+1; ids[j] != NULL; j++) {
+			if (strcmp(ids[i]->name, ids[j]->name) > 0) {
+				ccast_id *tmp;
+				tmp = ids[i];
+				ids[i] = ids[j];
+				ids[j] = tmp;
+			}
+		}
+	}
+
+	return ids;
+}
+
+void ccast_id_copy(ccast_id *dst, ccast_id *src) {
+	dst->name = strdup(src->name);
+	dst->ip = strdup(src->ip);
+}
+
+ccast_id *ccast_id_clone(ccast_id *src) {
+	ccast_id *dst;
+
+	if ((dst = calloc(sizeof(ccast_id), 1)) == NULL)
+		return dst;
+
+	if (src->name != NULL && (dst->name = strdup(src->name)) == NULL) {
+		free(dst);
+		return NULL;
+	}
+	if (src->ip != NULL && (dst->ip = strdup(src->ip)) == NULL) {
+		free(dst->name);
+		free(dst);
+		return NULL;
+	}
+	return dst;
+}
+
+void ccast_id_del(ccast_id *id) {
+	free(id->name);
+	free(id->ip);
+	free(id);
+}
+
+/* ==================================================================== */
+
+/* Read a string with a trailing '.' added. */
+/* Return the next offset or -1 and *rv = NULL on error */
+static int read_string_imp(char **rv, int *slen, ORD8 *buf, int off, int size, int rec) {
+	int len;
+	int d1 = 0;
+
+//printf("~1 read_string_imp called for off 0x%x rec %d\n",off,rec);
+
+	if (rec > 10)		/* Too many recursions */
+		return -1;		/* Error */
+
+	if (off >= size)
+		return -1;		/* Error */
+
+	for (;;) {
+//printf("~1 top of loop at off 0x%x\n",off);
+		len = buf[off];
+		if (len == 0xc0) {		/* Is it an offset marker */
+			int poff;
+//printf("~1 got pointer\n");
+			if ((size - off) < 2)
+				return -1;
+
+			poff = read_ORD16_be(buf + off); off += 2;
+			poff -= 0xc000;
+
+			if (poff < 0 || poff >= size)
+				return -1;
+
+			read_string_imp(rv, slen, buf, poff, size, rec+1);
+//if (slen != NULL) printf("~1 after recurse, slen = %d, off = 0x%x\n",*slen,off);
+
+			break;				/* we're done */
+
+		} else {
+//printf("~1 got string length %d\n",len);
+			off++;
+			if ((off + len) >= size)
+				return -1;
+
+			if (len == 0)
+				break;				/* we're done */
+
+			if (rv != NULL) {
+				memcpy(*rv, buf + off, len);
+//(*rv)[len] = '\000'; printf("Copied string %p = '%s'\n",*rv,*rv);
+
+				*rv += len;
+			}
+			off += len;
+
+			if (slen != NULL) {
+				(*slen) += len;
+//printf("~1 slen now = %d\n",*slen);
+			}
+
+		}
+		d1 = 1;
+
+		if (slen != NULL)
+			(*slen)++;
+
+		if (rv != NULL) {
+			(*rv)[0] = '.';
+			(*rv)++;
+		}
+	}
+//if (slen != NULL) printf("~1 returning slen = %d\n",*slen);
+	return off;
+}
+
+/* Read a string */
+/* Return the next offset or -1 and *rv = NULL on error */
+static int read_string(char **rv, ORD8 *buf, int off, int size) {
+	int len = 0, toff = off;
+	char *trv;
+
+//printf("~1 read_string called for off 0x%x\n",off);
+
+	/* See how long it will be */
+	if ((toff = read_string_imp(NULL, &len, buf, off, size, 0)) < 0) {
+//printf("~1 read_string_imp length returned error\n");
+		return toff;
+	}
+//printf("~1 read_string_imp got length %d\n",len);
+
+	if (len == 0) {
+//printf("~1 Got zero length string\n");
+		len++;			/* Room for null string */
+	}
+	if ((*rv = trv = malloc(len)) == NULL) {
+		return -1;
+	}
+//printf("Malloced %p\n",*rv);
+	off = read_string_imp(&trv, NULL, buf, off, size, 0);
+	if (off >= 0) {
+		(*rv)[len-1] = '\000';
+//printf("~1 read string ok: %p = '%s'\n",*rv, *rv);
+	}
+//else printf("~1 reading string failed\n");
+	return off;
+}
+ 
+/* Parse an mDNS query */
+/* Return updated off value or -1 on error */
+int parse_query(ORD8 *buf, int off, int size) {
+	char *sv;
+	int qtype, qclass;
+
+	DBG((dbgo,"Parsing query at 0x%x:\n",off))
+	if ((off = read_string(&sv, buf, off, size)) < 0)
+		return -1;
+	DBG((dbgo," Got string '%s'\n",sv))
+	free(sv);
+
+	if ((size - off) < 2)
+		return -1;
+	qtype = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," QTYPE = 0x%04x\n",qtype))
+
+	if ((size - off) < 2)
+		return -1;
+	qclass = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," QCLASS = 0x%04x\n",qtype))
+
+	return off;
+}
+
+/* Parse an mDNS reply */
+/* Return updated off value or -1 on error */
+int parse_reply(char **pname, char **pip, ORD8 *buf, int off, int size) {
+	char *sv;
+	int rtype, rclass, rdlength;
+	unsigned int ttl;
+
+	DBG((dbgo,"Parsing reply at 0x%x:\n",off))
+	if ((off = read_string(&sv, buf, off, size)) < 0)
+		return -1;
+
+	DBG((dbgo," Got string '%s'\n",sv))
+
+	if ((size - off) < 2) {
+		free(sv);
+		return -1;
+	}
+	rtype = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," RTYPE = %d\n",rtype))
+
+	if ((size - off) < 2) {
+		free(sv);
+		return -1;
+	}
+	rclass = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," RCLASS = 0x%04x\n",rclass))
+	/* rclass top bit is cache flush bit */
+
+	if ((rclass & 0x7fff) != DNS_CLASS_IN) {
+		DBG((dbgo," response has RCLASS != 0x%04x\n",DNS_CLASS_IN))
+		free(sv);
+		return -1;
+	}
+
+	if ((size - off) < 4)
+		return -1;
+	ttl = read_ORD32_be(buf + off); off += 4;
+	DBG((dbgo," TTL = %u\n",ttl))
+
+	if ((size - off) < 2)
+		return -1;
+	rdlength = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," RDLENGTH = %d\n",rdlength))
+
+	if ((off + rdlength) > size) {
+		DBG((dbgo," response RDLENGTH is longer than remaining buffer (%d)\n",size - off))
+		free(sv);
+		return -1;
+	}
+	
+	/* Just decode the replies we need */
+	if (rtype == DNS_TYPE_TXT) {	/* Check it's a ChromeCast & get its name */
+		char *cp;
+		if ((cp = strchr(sv, '.')) == NULL) {
+			free(sv);
+			return -1;
+		}
+		*cp = '\000';
+		if (strcmp(cp+1, "_googlecast._tcp.local") != 0) {
+			DBG((dbgo,"Not a chromecast (got '%s')\n",cp+1))
+			free(sv);
+			return -1;
+		}
+
+		DBG((dbgo," Chromacast '%s'\n", sv))
+		if ((*pname = strdup(sv)) == NULL) {
+			DBG((dbgo,"strdup failed\n"))
+			free(sv);
+			return -1;
+		}
+	} else if (rtype == DNS_TYPE_A) {
+		/* Should we check name matches ? */
+		if ((*pip = malloc(3 * 4 + 3 + 1)) == NULL) {
+			DBG((dbgo,"malloc failed\n"))
+			free(*pname);
+			free(sv);
+		}
+		sprintf(*pip, "%d.%d.%d.%d", buf[off], buf[off+1], buf[off+2], buf[off+3]);
+		DBG((dbgo," V4 address = %s\n",*pip))
+	
+	} else if (rtype == DNS_TYPE_AAAA) {		/* The IPV6 address */
+		/* Should we check name matches ? */
+		if ((*pip = malloc(8 * 4 + 7 + 1)) == NULL) {
+			DBG((dbgo,"malloc failed\n"))
+			free(*pname);
+			free(sv);
+		}
+		sprintf(*pip, "%x:%x:%x:%x:%x:%x:%x:%x",
+		buf[off+0] * 245 + buf[off+1],
+		buf[off+2] * 245 + buf[off+3],
+		buf[off+4] * 245 + buf[off+5],
+		buf[off+6] * 245 + buf[off+7],
+		buf[off+8] * 245 + buf[off+9],
+		buf[off+10] * 245 + buf[off+11],
+		buf[off+12] * 245 + buf[off+13],
+		buf[off+14] * 245 + buf[off+15]);
+		DBG((dbgo," V6 address = %s\n",*pip))
+
+	} else {
+		DBG((dbgo," Skipping reply at 0x%x\n",off))
+	}
+	off += rdlength;
+	free(sv);
+
+	return off;
+}
+
+/* Parse an mDNS reply into a ChromCast name & IP address */
+/* Allocate and return name and IP on finding ChromeCast reply, NULL otherwise */
+/* Return nz on failure */
+static int parse_dns(char **pname, char **pip, ORD8 *buf, int size) {
+	int i, off = 0;
+	int id, flags, qdcount, ancount, nscount, arcount;
+
+	DBG((dbgo,"Parsing mDNS reply:\n"))
+
+	*pname = NULL;
+	*pip = NULL;
+
+	// Parse reply header
+	if ((size - off) < 2) return 1;
+	id = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," ID = %d\n",id))
+
+	if ((size - off) < 2) return 1;
+	flags = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," FLAGS = 0x%04x\n",flags))
+
+	if ((size - off) < 2) return 1;
+	qdcount = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," QDCOUNT = %d\n",qdcount))
+
+	if ((size - off) < 2) return 1;
+	ancount = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," ANCOUNT = %d\n",ancount))
+
+	if ((size - off) < 2) return 1;
+	nscount = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," NSCOUNT = %d\n",nscount))
+
+	if ((size - off) < 2) return 1;
+	arcount = read_ORD16_be(buf + off); off += 2;
+	DBG((dbgo," ARCOUNT = %d\n",arcount))
+
+//printf("~1 after strings, off = 0x%x\n",off);
+
+	// Parse all the queries (QDCOUNT)
+	for (i = 0; i < qdcount; i++) {
+		if ((off = parse_query(buf, off, size)) < 0) {
+			DBG((dbgo," ### Parsing query failed ###\n"))
+			return 1;
+		}
+	}
+
+	// Parse all the answers (ANCOUNT)
+	for (i = 0; i < ancount; i++) {
+		if ((off = parse_reply(pname, pip, buf, off, size)) < 0) {
+			DBG((dbgo," ### Parsing answer failed ###\n"))
+			return 1;
+		}
+	}
+
+	// Parse all the NS records (NSCOUNT)
+	for (i = 0; i < nscount; i++) {
+		if ((off = parse_reply(pname, pip, buf, off, size)) < 0) {
+			DBG((dbgo," ### Parsing NS record failed ###\n"))
+			return 1;
+		}
+	}
+
+	// Parse all the addition RR answers (ARCOUNT)
+	for (i = 0; i < arcount; i++) {
+		if ((off = parse_reply(pname, pip, buf, off, size)) < 0) {
+			DBG((dbgo," ### Parsing additional records failed ###\n"))
+			return 1;
+		}
+	}
+	return 0;
+}
+
+/*
+	Analysis of ChromeCast reply
+
+    0000: 00 00  84 00  00 00  00 01  00 00  00 05  0b 5f 67 6f  ............._go
+
+	ID 		0x0000		// ID 0
+	Flags	0x8400		// Standard query response, No error
+	QDCOUNT 0x0000		// No queries
+	ANCOUNT 0x0001		// 1 Answer
+	NSCOUNT 0x0000
+	ARCOUNT 0x0005		// 5 Additional records
+
+	// Answer
+                                              0b 5f 67 6f  _go
+    0010: 6f 67 6c 65 63 61 73 74                          oglecast
+
+    0010:                         04 5f 74 63 70           _tcp
+
+    0010: 05 6c 6f  lo
+    0020: 63 61 6c 00                                       cal.
+
+	"_googlecast" "_tcp" "cal" ""		//TLD
+
+    0020: 00 0c  00 01  00 00 11 94  00 11  0e 43  ...........C
+
+	RTYPE    0x000c
+	RCLASS   0x0001
+	TTL      0x00001194 
+	RDLENGTH 0x0011
+
+	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    0000: 00 00 84 00 00 00 00 01 00 00 00 05 0b 5f 67 6f  ............._go
+    0010: 6f 67 6c 65 63 61 73 74 04 5f 74 63 70 05 6c 6f  oglecast._tcp.lo
+    0020: 63 61 6c 00 00 0c 00 01 00 00 11 94 00 11 0e 43  cal............C
+    0030: 68 72 6f 6d 65 63 61 73 74 36 38 39 32 c0 0c c0  hromecast6892...
+    0040: 2e 00 10 80 01 00 00 11 94 00 67 23 69 64 3d 63  ..........g#id=c
+    0050: 31 37 61 65 38 38 32 65 37 65 31 38 37 35 64 30  17ae882e7e1875d0
+    0060: 31 33 65 64 32 31 32 63 31 36 62 62 64 34 30 05  13ed212c16bbd40.
+    0070: 76 65 3d 30 32 0d 6d 64 3d 43 68 72 6f 6d 65 63  ve=02.md=Chromec
+    0080: 61 73 74 12 69 63 3d 2f 73 65 74 75 70 2f 69 63  ast.ic=/setup/ic
+    0090: 6f 6e 2e 70 6e 67 11 66 6e 3d 43 68 72 6f 6d 65  on.png.fn=Chrome
+    00a0: 63 61 73 74 36 38 39 32 04 63 61 3d 35 04 73 74  cast6892.ca=5.st
+    00b0: 3d 30 c0 2e 00 21 80 01 00 00 00 78 00 17 00 00  =0...!.....x....
+    00c0: 00 00 1f 49 0e 43 68 72 6f 6d 65 63 61 73 74 36  ...I.Chromecast6
+    00d0: 38 39 32 c0 1d c0 c4 00 01 80 01 00 00 00 78 00  892...........x.
+    00e0: 04 0a 00 00 80 c0 2e 00 2f 80 01 00 00 11 94 00  ......../.......
+    00f0: 09 c0 2e 00 05 00 00 80 00 40 c0 c4 00 2f 80 01  .........@.../..
+    0100: 00 00 00 78 00 05 c0 c4 00 01 40                 ...x......@
+
+
+*/
+
+/* ================================================================== */
+/* Debug */
+
+// Print bytes as hex to stdout
+void cc_dump_bytes(FILE *fp, char *pfx, unsigned char *buf, int len) {
+	int i, j, ii;
+	char oline[200] = { '\000' }, *bp = oline;
+	for (i = j = 0; i < len; i++) {
+		if ((i % 16) == 0)
+			bp += sprintf(bp,"%s%04x:",pfx,i);
+		bp += sprintf(bp," %02x",buf[i]);
+		if ((i+1) >= len || ((i+1) % 16) == 0) {
+			for (ii = i; ((ii+1) % 16) != 0; ii++)
+				bp += sprintf(bp,"   ");
+			bp += sprintf(bp,"  ");
+			for (; j <= i; j++) {
+				if (!(buf[j] & 0x80) && isprint(buf[j]))
+					bp += sprintf(bp,"%c",buf[j]);
+				else
+					bp += sprintf(bp,".");
+			}
+			bp += sprintf(bp,"\n");
+			fprintf(fp, "%s", oline);
+			bp = oline;
+		}
+	}
+}
+