Ticket #7970: hdhr.patch

libs/libmythhdhomerun/hdhomerun.h

@@ -3 +3 @@
 /*
  * hdhomerun.h
  *
- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -35 +35 @@
 #include "hdhomerun_os.h"
 #include "hdhomerun_types.h"
 #include "hdhomerun_pkt.h"
+#include "hdhomerun_sock.h"
 #include "hdhomerun_debug.h"
 #include "hdhomerun_discover.h"
 #include "hdhomerun_control.h"

libs/libmythhdhomerun/hdhomerun_debug.c

@@ -1 +1 @@
 /*
  * hdhomerun_debug.c
  *
- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -44 +44 @@
 #define HDHOMERUN_DEBUG_HOST "debug.silicondust.com"
 #endif
 #if !defined(HDHOMERUN_DEBUG_PORT)
-#define HDHOMERUN_DEBUG_PORT "8002"
+#define HDHOMERUN_DEBUG_PORT 8002
 #endif
 
+#define HDHOMERUN_DEBUG_CONNECT_RETRY_TIME 30000
+#define HDHOMERUN_DEBUG_CONNECT_TIMEOUT 10000
+#define HDHOMERUN_DEBUG_SEND_TIMEOUT 10000
+
 struct hdhomerun_debug_message_t
 {
         struct hdhomerun_debug_message_t *next;
@@ -73 +77 @@
 
         char *file_name;
         FILE *file_fp;
-        int sock;
+        hdhomerun_sock_t sock;
 };
 
 static THREAD_FUNC_PREFIX hdhomerun_debug_thread_execute(void *arg);
@@ -85 +89 @@
                 return NULL;
         }
 
-        dbg->sock = -1;
+        dbg->sock = HDHOMERUN_SOCK_INVALID;
 
         pthread_mutex_init(&dbg->print_lock, NULL);
         pthread_mutex_init(&dbg->queue_lock, NULL);
@@ -117 +121 @@
         if (dbg->file_fp) {
                 fclose(dbg->file_fp);
         }
-        if (dbg->sock != -1) {
-                close(dbg->sock);
+        if (dbg->sock != HDHOMERUN_SOCK_INVALID) {
+                hdhomerun_sock_destroy(dbg->sock);
         }
 
         free(dbg);
@@ -132 +136 @@
                 dbg->file_fp = NULL;
         }
 
-        if (dbg->sock != -1) {
-                close(dbg->sock);
-                dbg->sock = -1;
+        if (dbg->sock != HDHOMERUN_SOCK_INVALID) {
+                hdhomerun_sock_destroy(dbg->sock);
+                dbg->sock = HDHOMERUN_SOCK_INVALID;
         }
 }
 
@@ -251 +255 @@
                         return;
                 }
 
-                msleep(10);
+                msleep_approx(10);
         }
 }
 
@@ -372 +376 @@
 }
 
 /* Send lock held by caller */
-#if defined(__CYGWIN__)
 static bool_t hdhomerun_debug_output_message_sock(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
 {
-        return TRUE;
-}
-#else
-static bool_t hdhomerun_debug_output_message_sock(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
-{
-        if (dbg->sock == -1) {
+        if (dbg->sock == HDHOMERUN_SOCK_INVALID) {
                 uint64_t current_time = getcurrenttime();
                 if (current_time < dbg->connect_delay) {
                         return FALSE;
                 }
-                dbg->connect_delay = current_time + 30*1000;
+                dbg->connect_delay = current_time + HDHOMERUN_DEBUG_CONNECT_RETRY_TIME;
 
-                dbg->sock = (int)socket(AF_INET, SOCK_STREAM, 0);
-                if (dbg->sock == -1) {
+                dbg->sock = hdhomerun_sock_create_tcp();
+                if (dbg->sock == HDHOMERUN_SOCK_INVALID) {
                         return FALSE;
                 }
 
-                struct addrinfo hints;
-                memset(&hints, 0, sizeof(hints));
-                hints.ai_family = AF_INET;
-                hints.ai_socktype = SOCK_STREAM;
-                hints.ai_protocol = IPPROTO_TCP;
-
-                struct addrinfo *sock_info;
-                if (getaddrinfo(HDHOMERUN_DEBUG_HOST, HDHOMERUN_DEBUG_PORT, &hints, &sock_info) != 0) {
+                uint32_t remote_addr = hdhomerun_sock_getaddrinfo_addr(dbg->sock, HDHOMERUN_DEBUG_HOST);
+                if (remote_addr == 0) {
                         hdhomerun_debug_close_internal(dbg);
                         return FALSE;
                 }
-                if (connect(dbg->sock, sock_info->ai_addr, (int)sock_info->ai_addrlen) != 0) {
-                        freeaddrinfo(sock_info);
+
+                if (!hdhomerun_sock_connect(dbg->sock, remote_addr, HDHOMERUN_DEBUG_PORT, HDHOMERUN_DEBUG_CONNECT_TIMEOUT)) {
                         hdhomerun_debug_close_internal(dbg);
                         return FALSE;
                 }
-                freeaddrinfo(sock_info);
         }
 
         size_t length = strlen(message->buffer);
-        if (send(dbg->sock, (char *)message->buffer, (int)length, 0) != length) {
+        if (!hdhomerun_sock_send(dbg->sock, message->buffer, length, HDHOMERUN_DEBUG_SEND_TIMEOUT)) {
                 hdhomerun_debug_close_internal(dbg);
                 return FALSE;
         }
 
         return TRUE;
 }
-#endif
 
 static bool_t hdhomerun_debug_output_message(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
 {
@@ -466 +456 @@
                 pthread_mutex_unlock(&dbg->queue_lock);
 
                 if (!message) {
-                        msleep(250);
+                        msleep_approx(250);
                         continue;
                 }
 
@@ -476 +466 @@
                 }
 
                 if (!hdhomerun_debug_output_message(dbg, message)) {
-                        msleep(250);
+                        msleep_approx(250);
                         continue;
                 }
 

libs/libmythhdhomerun/libmythhdhomerun.pro

@@ -10 +10 @@
 
 QMAKE_CLEAN += $(TARGET) $(TARGETA) $(TARGETD) $(TARGET0) $(TARGET1) $(TARGET2)
 
-HEADERS += hdhomerun.h  hdhomerun_os.h  hdhomerun_types.h
+HEADERS += hdhomerun.h  hdhomerun_os.h  hdhomerun_sock.h  hdhomerun_types.h
 
 HEADERS += hdhomerun_channels.h  hdhomerun_channelscan.h  hdhomerun_control.h
-HEADERS += hdhomerun_debug.h     hdhomerun_device.h       hdhomerun_dhcp.h
-HEADERS += hdhomerun_discover.h  hdhomerun_pkt.h          hdhomerun_video.h 
+HEADERS += hdhomerun_debug.h     hdhomerun_device.h
 HEADERS += hdhomerun_device_selector.h
+HEADERS += hdhomerun_discover.h  hdhomerun_os_posix.h
+HEADERS += hdhomerun_pkt.h       hdhomerun_video.h 
 
+SOURCES += hdhomerun_config.c
+
 SOURCES += hdhomerun_channels.c  hdhomerun_channelscan.c  hdhomerun_control.c
-SOURCES += hdhomerun_debug.c     hdhomerun_device.c       hdhomerun_dhcp.c
-SOURCES += hdhomerun_discover.c  hdhomerun_pkt.c          hdhomerun_video.c
+SOURCES += hdhomerun_debug.c     hdhomerun_device.c
 SOURCES += hdhomerun_device_selector.c
+SOURCES += hdhomerun_discover.c  hdhomerun_os_posix.c
+SOURCES += hdhomerun_pkt.c       hdhomerun_video.c
 
+
+unix:SOURCES += hdhomerun_sock_posix.c
+
 mingw {
     HEADERS += hdhomerun_os_windows.h
+    SOURCES += hdhomerun_os_windows.c
+    SOURCES += hdhomerun_sock_windows.c
     LIBS += -lws2_32 -liphlpapi -lpthread
 }
 

libs/libmythhdhomerun/hdhomerun_config.c

@@ -286 +286 @@
                 }
 
                 cmd_scan_printf(fp, "SCANNING: %lu (%s)\n",
-                        result.frequency, result.channel_str
+                        (unsigned long)result.frequency, result.channel_str
                 );
 
                 ret = hdhomerun_device_channelscan_detect(hd, &result);
@@ -364 +364 @@
                 size_t actual_size;
                 uint8_t *ptr = hdhomerun_device_stream_recv(hd, VIDEO_DATA_BUFFER_SIZE_1S, &actual_size);
                 if (!ptr) {
-                        msleep(64);
+                        msleep_approx(64);
                         continue;
                 }
 
@@ -381 +381 @@
                                 next_progress = loop_start_time + 1000;
                         }
 
+                        /* Windows - indicate activity to suppress auto sleep mode. */
+                        #if defined(__WINDOWS__)
+                        SetThreadExecutionState(ES_SYSTEM_REQUIRED);
+                        #endif
+
+                        /* Video stats. */
                         hdhomerun_device_get_video_stats(hd, &stats_cur);
 
                         if (stats_cur.overflow_error_count > stats_old.overflow_error_count) {
@@ -404 +410 @@
                         continue;
                 }
 
-                msleep(delay);
+                msleep_approx(delay);
         }
 
         if (fp) {
@@ -440 +446 @@
                 fclose(fp);
                 return -1;
         }
-        sleep(2);
+        msleep_minimum(2000);
 
         printf("upgrading firmware...\n");
-        sleep(8);
+        msleep_minimum(8000);
 
         printf("rebooting...\n");
         int count = 0;
@@ -460 +466 @@
                         return -1;
                 }
 
-                sleep(1);
+                msleep_minimum(1000);
         }
 
         printf("upgrade complete - now running firmware %s\n", version_str);

libs/libmythhdhomerun/hdhomerun_video.c

@@ -34 +34 @@
 
 struct hdhomerun_video_sock_t {
         pthread_mutex_t lock;
+        struct hdhomerun_debug_t *dbg;
+
+        int sock;
+        uint32_t multicast_ip;
+
+        volatile size_t head;
+        volatile size_t tail;
         uint8_t *buffer;
         size_t buffer_size;
-        volatile size_t head;
-        volatile size_t tail;
         size_t advance;
+
+        pthread_t thread;
         volatile bool_t terminate;
-        pthread_t thread;
-        int sock;
-        uint32_t rtp_sequence;
-        struct hdhomerun_debug_t *dbg;
+
         volatile uint32_t packet_count;
         volatile uint32_t transport_error_count;
         volatile uint32_t network_error_count;
         volatile uint32_t sequence_error_count;
         volatile uint32_t overflow_error_count;
+
+        volatile uint32_t rtp_sequence;
         volatile uint8_t sequence[0x2000];
 };
 
@@ -64 +70 @@
         }
 
         vs->dbg = dbg;
-        vs->sock = -1;
+        vs->sock = HDHOMERUN_SOCK_INVALID;
         pthread_mutex_init(&vs->lock, NULL);
 
         /* Reset sequence tracking. */
@@ -86 +92 @@
         }
         
         /* Create socket. */
-        vs->sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
-        if (vs->sock == -1) {
+        vs->sock = hdhomerun_sock_create_udp();
+        if (vs->sock == HDHOMERUN_SOCK_INVALID) {
                 hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to allocate socket\n");
                 goto error;
         }
@@ -96 +102 @@
         int rx_size = 1024 * 1024;
         setsockopt(vs->sock, SOL_SOCKET, SO_RCVBUF, (char *)&rx_size, sizeof(rx_size));
 
-        /* Set timeouts. */
-        setsocktimeout(vs->sock, SOL_SOCKET, SO_SNDTIMEO, 1000);
-        setsocktimeout(vs->sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
-
         /* Bind socket. */
-        struct sockaddr_in sock_addr;
-        memset(&sock_addr, 0, sizeof(sock_addr));
-        sock_addr.sin_family = AF_INET;
-        sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
-        sock_addr.sin_port = htons(listen_port);
-        if (bind(vs->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
+        if (!hdhomerun_sock_bind(vs->sock, INADDR_ANY, listen_port)) {
                 hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to bind socket (port %u)\n", listen_port);
                 goto error;
         }
@@ -121 +118 @@
         return vs;
 
 error:
-        if (vs->sock != -1) {
-                close(vs->sock);
+        if (vs->sock != HDHOMERUN_SOCK_INVALID) {
+                hdhomerun_sock_destroy(vs->sock);
         }
         if (vs->buffer) {
                 free(vs->buffer);
@@ -136 +133 @@
         vs->terminate = TRUE;
         pthread_join(vs->thread, NULL);
 
-        close(vs->sock);
+        hdhomerun_sock_destroy(vs->sock);
         free(vs->buffer);
 
         free(vs);
@@ -144 +141 @@
 
 uint16_t hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs)
 {
-        struct sockaddr_in sock_addr;
-        socklen_t sockaddr_size = sizeof(sock_addr);
-        if (getsockname(vs->sock, (struct sockaddr*)&sock_addr, &sockaddr_size) != 0) {
-                hdhomerun_debug_printf(vs->dbg, "hdhomerun_video_get_local_port: getsockname failed (%d)\n", sock_getlasterror);
+        uint16_t port = hdhomerun_sock_getsockname_port(vs->sock);
+        if (port == 0) {
+                hdhomerun_debug_printf(vs->dbg, "hdhomerun_video_get_local_port: getsockname failed (%d)\n", hdhomerun_sock_getlasterror());
                 return 0;
         }
 
-        return ntohs(sock_addr.sin_port);
+        return port;
 }
 
+int hdhomerun_video_join_multicast_group(struct hdhomerun_video_sock_t *vs, uint32_t multicast_ip, uint32_t local_ip)
+{
+        if (vs->multicast_ip != 0) {
+                hdhomerun_video_leave_multicast_group(vs);
+        }
+
+        struct ip_mreq imr;
+        memset(&imr, 0, sizeof(imr));
+        imr.imr_multiaddr.s_addr  = htonl(multicast_ip);
+        imr.imr_interface.s_addr  = htonl(local_ip);
+
+        if (setsockopt(vs->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) {
+                hdhomerun_debug_printf(vs->dbg, "hdhomerun_video_join_multicast_group: setsockopt failed (%d)\n", hdhomerun_sock_getlasterror());
+                return -1;
+        }
+
+        vs->multicast_ip = multicast_ip;
+        return 1;
+}
+
+int hdhomerun_video_leave_multicast_group(struct hdhomerun_video_sock_t *vs)
+{
+        if (vs->multicast_ip == 0) {
+                return 1;
+        }
+
+        struct ip_mreq imr;
+        memset(&imr, 0, sizeof(imr));
+        imr.imr_multiaddr.s_addr  = htonl(vs->multicast_ip);
+        imr.imr_interface.s_addr  = htonl(INADDR_ANY);
+
+        if (setsockopt(vs->sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) {
+                hdhomerun_debug_printf(vs->dbg, "hdhomerun_video_leave_multicast_group: setsockopt failed (%d)\n", hdhomerun_sock_getlasterror());
+        }
+
+        vs->multicast_ip = 0;
+        return 1;
+}
+
 static void hdhomerun_video_stats_ts_pkt(struct hdhomerun_video_sock_t *vs, uint8_t *ptr)
 {
         uint16_t packet_identifier = ((uint16_t)(ptr[1] & 0x1F) << 8) | (uint16_t)ptr[2];
@@ -168 +203 @@
                 return;
         }
 
-        uint8_t continuity_counter = ptr[3] & 0x0F;
+        uint8_t sequence = ptr[3] & 0x0F;
+
         uint8_t previous_sequence = vs->sequence[packet_identifier];
+        vs->sequence[packet_identifier] = sequence;
 
-        if (continuity_counter == ((previous_sequence + 1) & 0x0F)) {
-                vs->sequence[packet_identifier] = continuity_counter;
+        if (previous_sequence == 0xFF) {
                 return;
         }
-        if (previous_sequence == 0xFF) {
-                vs->sequence[packet_identifier] = continuity_counter;
+        if (sequence == ((previous_sequence + 1) & 0x0F)) {
                 return;
         }
-        if (continuity_counter == previous_sequence) {
+        if (sequence == previous_sequence) {
                 return;
         }
 
         vs->sequence_error_count++;
-        vs->sequence[packet_identifier] = continuity_counter;
 }
 
 static void hdhomerun_video_parse_rtp(struct hdhomerun_video_sock_t *vs, struct hdhomerun_pkt_t *pkt)
@@ -193 +227 @@
         uint32_t rtp_sequence = hdhomerun_pkt_read_u16(pkt);
         pkt->pos += 8;
 
-        if (rtp_sequence != ((vs->rtp_sequence + 1) & 0xFFFF)) {
-                if (vs->rtp_sequence != 0xFFFFFFFF) {
-                        vs->network_error_count++;
+        uint32_t previous_rtp_sequence = vs->rtp_sequence;
+        vs->rtp_sequence = rtp_sequence;
 
-                        /* restart pid sequence check */
-                        /* can't use memset bcs sequence is volatile */
-                        int i;
-                        for (i = 0; i < sizeof(vs->sequence) / sizeof(uint8_t) ; i++)
-                                vs->sequence[i] = 0xFF;
-                }
+        /* Initial case - first packet received. */
+        if (previous_rtp_sequence == 0xFFFFFFFF) {
+                return;
         }
 
-        vs->rtp_sequence = rtp_sequence;
+        /* Normal case - next sequence number. */
+        if (rtp_sequence == ((previous_rtp_sequence + 1) & 0xFFFF)) {
+                return;
+        }
+
+        /* Error case - sequence missed. */
+        vs->network_error_count++;
+
+        /* Restart pid sequence check after packet loss. */
+        int i;
+        for (i = 0; i < 0x2000; i++) {
+                vs->sequence[i] = 0xFF;
+        }
 }
 
 static THREAD_FUNC_PREFIX hdhomerun_video_thread_execute(void *arg)
@@ -218 +260 @@
                 hdhomerun_pkt_reset(pkt);
 
                 /* Receive. */
-                int length = recv(vs->sock, (char *)pkt->end, VIDEO_RTP_DATA_PACKET_SIZE, 0);
+                size_t length = VIDEO_RTP_DATA_PACKET_SIZE;
+                if (!hdhomerun_sock_recv(vs->sock, pkt->end, &length, 25)) {
+                        continue;
+                }
+
                 pkt->end += length;
 
                 if (length == VIDEO_RTP_DATA_PACKET_SIZE) {
@@ -227 +273 @@
                 }
 
                 if (length != VIDEO_DATA_PACKET_SIZE) {
-                        if (length > 0) {
-                                /* Data received but not valid - ignore. */
-                                continue;
-                        }
-                        if (sock_getlasterror_socktimeout) {
-                                /* Wait for more data. */
-                                continue;
-                        }
-                        vs->terminate = TRUE;
-                        return NULL;
+                        /* Data received but not valid - ignore. */
+                        continue;
                 }
 
                 pthread_mutex_lock(&vs->lock);
@@ -269 +307 @@
                         continue;
                 }
 
-                /* Atomic update. */
                 vs->head = head;
 
                 pthread_mutex_unlock(&vs->lock);
@@ -291 +328 @@
                         tail -= vs->buffer_size;
                 }
         
-                /* Atomic update. */
                 vs->tail = tail;
         }
 
@@ -334 +370 @@
         vs->tail = vs->head;
         vs->advance = 0;
 
-        /* can't use memset bcs sequence is volatile */
+        vs->rtp_sequence = 0xFFFFFFFF;
         int i;
-        for (i = 0; i < sizeof(vs->sequence) / sizeof(uint8_t) ; i++)
+        for (i = 0; i < 0x2000; i++) {
                 vs->sequence[i] = 0xFF;
+        }
 
-        vs->rtp_sequence = 0xFFFFFFFF;
-
         vs->packet_count = 0;
         vs->transport_error_count = 0;
         vs->network_error_count = 0;
@@ -355 +390 @@
         struct hdhomerun_video_stats_t stats;
         hdhomerun_video_get_stats(vs, &stats);
 
-        hdhomerun_debug_printf(vs->dbg, "video sock: pkt=%ld net=%ld te=%ld miss=%ld drop=%ld\n",
-                stats.packet_count, stats.network_error_count,
-                stats.transport_error_count, stats.sequence_error_count,
-                stats.overflow_error_count
+        hdhomerun_debug_printf(vs->dbg, "video sock: pkt=%lu net=%lu te=%lu miss=%lu drop=%lu\n",
+                (unsigned long)stats.packet_count, (unsigned long)stats.network_error_count,
+                (unsigned long)stats.transport_error_count, (unsigned long)stats.sequence_error_count,
+                (unsigned long)stats.overflow_error_count
         );
 }
 

libs/libmythhdhomerun/hdhomerun_os_posix.h

@@ -1 +1 @@
 /*
  * hdhomerun_os_posix.h
  *
- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -52 +52 @@
 typedef int bool_t;
 
 #define LIBTYPE
-#define sock_getlasterror errno
-#define sock_getlasterror_socktimeout (errno == EAGAIN)
 #define console_vprintf vprintf
 #define console_printf printf
 #define THREAD_FUNC_PREFIX void *
 
-static inline uint64_t getcurrenttime(void)
-{
-        struct timeval t;
-        gettimeofday(&t, NULL);
-        return ((uint64_t)t.tv_sec * 1000) + (t.tv_usec / 1000);
-}
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-static inline int msleep(unsigned int ms)
-{
-        uint64_t stop_time = getcurrenttime() + ms;
+extern LIBTYPE uint64_t getcurrenttime(void);
+extern LIBTYPE void msleep_approx(uint64_t ms);
+extern LIBTYPE void msleep_minimum(uint64_t ms);
 
-        while (1) {
-                uint64_t current_time = getcurrenttime();
-                if (current_time >= stop_time) {
-                        return 0;
-                }
-
-                uint64_t delay_s = (stop_time - current_time) / 1000;
-                if (delay_s > 0) {
-                        sleep((unsigned int)delay_s);
-                        continue;
-                }
-
-                uint64_t delay_us = (stop_time - current_time) * 1000;
-                usleep((unsigned int)delay_us);
-        }
+#ifdef __cplusplus
 }
-
-static inline int setsocktimeout(int s, int level, int optname, uint64_t timeout)
-{
-        struct timeval t;
-        t.tv_sec = timeout / 1000;
-        t.tv_usec = (timeout % 1000) * 1000;
-        return setsockopt(s, level, optname, (char *)&t, sizeof(t));
-}
+#endif

libs/libmythhdhomerun/hdhomerun_video.h

@@ -71 +71 @@
 extern LIBTYPE uint16_t hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs);
 
 /*
+ * Join/leave multicast group.
+ */
+extern LIBTYPE int hdhomerun_video_join_multicast_group(struct hdhomerun_video_sock_t *vs, uint32_t multicast_ip, uint32_t local_ip);
+extern LIBTYPE int hdhomerun_video_leave_multicast_group(struct hdhomerun_video_sock_t *vs);
+
+/*
  * Read data from buffer.
  *
  * size_t max_size: The maximum amount of data to be returned.

libs/libmythhdhomerun/hdhomerun_channelscan.c

@@ -1 +1 @@
 /*
  * hdhomerun_channelscan.c
  *
- * Copyright © 2007-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2007-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -99 +99 @@
                         return 1;
                 }
 
-                msleep(250);
+                msleep_approx(250);
         }
 }
 
@@ -303 +303 @@
                         break;
                 }
 
-                msleep(250);
+                msleep_approx(250);
         }
 
         /* Lock => skip overlapping channels. */

libs/libmythhdhomerun/hdhomerun_discover.c

@@ -1 +1 @@
 /*
  * hdhomerun_discover.c
  *
- * Copyright © 2006-2007 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -44 +44 @@
 #endif
 #endif
 
-#include <sys/param.h>  // Defines BSD on FreeBSD and Mac OS X
-#if defined(__linux__) || defined(__APPLE__) || defined(BSD)
-#  include <ifaddrs.h>
-#  define USE_IFADDRS 1
-#  include <sys/select.h>
-#endif
-
 #define HDHOMERUN_DISOCVER_MAX_SOCK_COUNT 16
 
 struct hdhomerun_discover_sock_t {
-        int sock;
+        hdhomerun_sock_t sock;
+        bool_t detected;
         uint32_t local_ip;
         uint32_t subnet_mask;
 };
@@ -66 +60 @@
         struct hdhomerun_pkt_t rx_pkt;
 };
 
-static bool_t hdhomerun_discover_sock_create(struct hdhomerun_discover_t *ds, uint32_t local_ip, uint32_t subnet_mask)
+static bool_t hdhomerun_discover_sock_add(struct hdhomerun_discover_t *ds, uint32_t local_ip, uint32_t subnet_mask)
 {
+        unsigned int i;
+        for (i = 1; i < ds->sock_count; i++) {
+                struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
+
+                if ((dss->local_ip == local_ip) && (dss->subnet_mask == subnet_mask)) {
+                        dss->detected = TRUE;
+                        return TRUE;
+                }
+        }
+
         if (ds->sock_count >= HDHOMERUN_DISOCVER_MAX_SOCK_COUNT) {
                 return FALSE;
         }
 
         /* Create socket. */
-        int sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
-        if (sock == -1) {
+        hdhomerun_sock_t sock = hdhomerun_sock_create_udp();
+        if (sock == HDHOMERUN_SOCK_INVALID) {
                 return FALSE;
         }
 
-        /* Set timeouts. */
-        setsocktimeout(sock, SOL_SOCKET, SO_SNDTIMEO, 1000);
-        setsocktimeout(sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
-
-        /* Allow broadcast. */
-        int sock_opt = 1;
-        setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&sock_opt, sizeof(sock_opt));
-
         /* Bind socket. */
-        struct sockaddr_in sock_addr;
-        memset(&sock_addr, 0, sizeof(sock_addr));
-        sock_addr.sin_family = AF_INET;
-        sock_addr.sin_addr.s_addr = htonl(local_ip);
-        sock_addr.sin_port = htons(0);
-        if (bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
-                close(sock);
+        if (!hdhomerun_sock_bind(sock, local_ip, 0)) {
+                hdhomerun_sock_destroy(sock);
                 return FALSE;
         }
 
         /* Write sock entry. */
         struct hdhomerun_discover_sock_t *dss = &ds->socks[ds->sock_count++];
         dss->sock = sock;
+        dss->detected = TRUE;
         dss->local_ip = local_ip;
         dss->subnet_mask = subnet_mask;
 
         return TRUE;
 }
 
+struct hdhomerun_discover_t *hdhomerun_discover_create(void)
+{
+        struct hdhomerun_discover_t *ds = (struct hdhomerun_discover_t *)calloc(1, sizeof(struct hdhomerun_discover_t));
+        if (!ds) {
+                return NULL;
+        }
+
+        /* Create a routable socket (always first entry). */
+        if (!hdhomerun_discover_sock_add(ds, 0, 0)) {
+                free(ds);
+                return NULL;
+        }
+
+        /* Success. */
+        return ds;
+}
+
+void hdhomerun_discover_destroy(struct hdhomerun_discover_t *ds)
+{
+        unsigned int i;
+        for (i = 0; i < ds->sock_count; i++) {
+                struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
+                hdhomerun_sock_destroy(dss->sock);
+        }
+
+        free(ds);
+}
+
 #if defined(USE_IPHLPAPI)
-static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds)
+static void hdhomerun_discover_sock_detect_internal(struct hdhomerun_discover_t *ds)
 {
         PIP_ADAPTER_INFO pAdapterInfo = (IP_ADAPTER_INFO *)malloc(sizeof(IP_ADAPTER_INFO));
         ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
@@ -138 +158 @@
                                 continue;
                         }
 
-                        hdhomerun_discover_sock_create(ds, local_ip, mask);
+                        hdhomerun_discover_sock_add(ds, local_ip, mask);
                         pIPAddr = pIPAddr->Next;
                 }
 
@@ -150 +170 @@
 
 #else
 
-static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds)
+static void hdhomerun_discover_sock_detect_internal(struct hdhomerun_discover_t *ds)
 {
-        int fd = socket(AF_INET, SOCK_DGRAM, 0);
-        if (fd == -1) {
-                return;
-        }
+        int sock = ds->socks[0].sock;
 
         struct ifconf ifc;
         uint8_t buf[8192];
@@ -164 +181 @@
 
         memset(buf, 0, sizeof(buf));
 
-        if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) {
-                close(fd);
+        if (ioctl(sock, SIOCGIFCONF, &ifc) != 0) {
                 return;
         }
 
@@ -176 +192 @@
                 struct ifreq *ifr = (struct ifreq *)ptr;
                 ptr += _SIZEOF_ADDR_IFREQ(*ifr);
 
-                if (ioctl(fd, SIOCGIFADDR, ifr) != 0) {
+                if (ioctl(sock, SIOCGIFADDR, ifr) != 0) {
                         continue;
                 }
                 struct sockaddr_in *addr_in = (struct sockaddr_in *)&(ifr->ifr_addr);
@@ -185 +201 @@
                         continue;
                 }
 
-                if (ioctl(fd, SIOCGIFNETMASK, ifr) != 0) {
+                if (ioctl(sock, SIOCGIFNETMASK, ifr) != 0) {
                         continue;
                 }
                 struct sockaddr_in *mask_in = (struct sockaddr_in *)&(ifr->ifr_addr);
                 uint32_t mask = ntohl(mask_in->sin_addr.s_addr);
 
-                hdhomerun_discover_sock_create(ds, local_ip, mask);
+                hdhomerun_discover_sock_add(ds, local_ip, mask);
         }
-
-        close(fd);
 }
 #endif
 
-static struct hdhomerun_discover_t *hdhomerun_discover_create(void)
+static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds)
 {
-        struct hdhomerun_discover_t *ds = (struct hdhomerun_discover_t *)calloc(1, sizeof(struct hdhomerun_discover_t));
-        if (!ds) {
-                return NULL;
+        unsigned int i;
+        for (i = 1; i < ds->sock_count; i++) {
+                struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
+                dss->detected = FALSE;
         }
 
-        /* Create a routable socket. */
-        if (!hdhomerun_discover_sock_create(ds, 0, 0)) {
-                free(ds);
-                return NULL;
-        }
+        hdhomerun_discover_sock_detect_internal(ds);
 
-        /* Detect & create local sockets. */
-        hdhomerun_discover_sock_detect(ds);
-
-        /* Success. */
-        return ds;
-}
-
-static void hdhomerun_discover_destroy(struct hdhomerun_discover_t *ds)
-{
-        unsigned int i;
-        for (i = 0; i < ds->sock_count; i++) {
-                struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
-                close(dss->sock);
+        struct hdhomerun_discover_sock_t *src = &ds->socks[1];
+        struct hdhomerun_discover_sock_t *dst = &ds->socks[1];
+        unsigned int count = 1;
+        for (i = 1; i < ds->sock_count; i++) {
+                if (!src->detected) {
+                        hdhomerun_sock_destroy(src->sock);
+                        src++;
+                        continue;
+                }
+                if (dst != src) {
+                        *dst = *src;
+                }
+                src++;
+                dst++;
+                count++;
         }
 
-        free(ds);
+        ds->sock_count = count;
 }
 
 static bool_t hdhomerun_discover_send_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, uint32_t target_ip, uint32_t device_type, uint32_t device_id)
@@ -242 +255 @@
         hdhomerun_pkt_write_u32(tx_pkt, device_id);
         hdhomerun_pkt_seal_frame(tx_pkt, HDHOMERUN_TYPE_DISCOVER_REQ);
 
-        struct sockaddr_in sock_addr;
-        memset(&sock_addr, 0, sizeof(sock_addr));
-        sock_addr.sin_family = AF_INET;
-        sock_addr.sin_addr.s_addr = htonl(target_ip);
-        sock_addr.sin_port = htons(HDHOMERUN_DISCOVER_UDP_PORT);
-
-        int length = (int)(tx_pkt->end - tx_pkt->start);
-        if (sendto(dss->sock, (char *)tx_pkt->start, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != length) {
-                return FALSE;
-        }
-
-        return TRUE;
+        return hdhomerun_sock_sendto(dss->sock, target_ip, HDHOMERUN_DISCOVER_UDP_PORT, tx_pkt->start, tx_pkt->end - tx_pkt->start, 0);
 }
 
 static bool_t hdhomerun_discover_send_wildcard_ip(struct hdhomerun_discover_t *ds, uint32_t device_type, uint32_t device_id)
@@ -313 +315 @@
 
 static bool_t hdhomerun_discover_send(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id)
 {
-        if (target_ip != 0) {
+        if (target_ip == 0) {
+                return hdhomerun_discover_send_wildcard_ip(ds, device_type, device_id);
+        } else {
                 return hdhomerun_discover_send_target_ip(ds, target_ip, device_type, device_id);
         }
-
-        return hdhomerun_discover_send_wildcard_ip(ds, device_type, device_id);
 }
 
-static int hdhomerun_discover_recv_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, struct hdhomerun_discover_device_t *result)
+static bool_t hdhomerun_discover_recv_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, struct hdhomerun_discover_device_t *result)
 {
         struct hdhomerun_pkt_t *rx_pkt = &ds->rx_pkt;
         hdhomerun_pkt_reset(rx_pkt);
 
-        struct sockaddr_in sock_addr;
-        memset(&sock_addr, 0, sizeof(sock_addr));
-        socklen_t sockaddr_size = sizeof(sock_addr);
-
-        int rx_length = recvfrom(dss->sock, (char *)rx_pkt->end, (int)(rx_pkt->limit - rx_pkt->end), 0, (struct sockaddr *)&sock_addr, &sockaddr_size);
-        if (rx_length <= 0) {
-                /* Don't return error - windows machine on VPN can sometimes cause a sock error here but otherwise works. */
-                return 0;
+        uint32_t remote_addr;
+        uint16_t remote_port;
+        size_t length = rx_pkt->limit - rx_pkt->end;
+        if (!hdhomerun_sock_recvfrom(dss->sock, &remote_addr, &remote_port, rx_pkt->end, &length, 0)) {
+                return FALSE;
         }
-        rx_pkt->end += rx_length;
 
+        rx_pkt->end += length;
+
         uint16_t type;
         if (hdhomerun_pkt_open_frame(rx_pkt, &type) <= 0) {
-                return 0;
+                return FALSE;
         }
         if (type != HDHOMERUN_TYPE_DISCOVER_RPY) {
-                return 0;
+                return FALSE;
         }
 
-        result->ip_addr = ntohl(sock_addr.sin_addr.s_addr);
+        result->ip_addr = remote_addr;
         result->device_type = 0;
         result->device_id = 0;
 
@@ -378 +378 @@
                 rx_pkt->pos = next;
         }
 
-        return 1;
+        return TRUE;
 }
 
-static int hdhomerun_discover_recv(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_device_t *result)
+static bool_t hdhomerun_discover_recv(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_device_t *result)
 {
-        struct timeval t;
-        t.tv_sec = 0;
-        t.tv_usec = 250000;
-
-        fd_set readfds;
-        FD_ZERO(&readfds);
-        int max_sock = -1;
-
         unsigned int i;
         for (i = 0; i < ds->sock_count; i++) {
                 struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
-                FD_SET(dss->sock, &readfds);
-                if (dss->sock > max_sock) {
-                        max_sock = dss->sock;
-                }
-        }
 
-        if (select(max_sock+1, &readfds, NULL, NULL, &t) < 0) {
-                return -1;
-        }
-
-        for (i = 0; i < ds->sock_count; i++) {
-                struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
-                if (!FD_ISSET(dss->sock, &readfds)) {
-                        continue;
+                if (hdhomerun_discover_recv_internal(ds, dss, result)) {
+                        return TRUE;
                 }
-
-                if (hdhomerun_discover_recv_internal(ds, dss, result) <= 0) {
-                        continue;
-                }
-
-                return 1;
         }
 
-        return 0;
+        return FALSE;
 }
 
-static struct hdhomerun_discover_device_t *hdhomerun_discover_find_in_list(struct hdhomerun_discover_device_t result_list[], int count, uint32_t ip_addr)
+static struct hdhomerun_discover_device_t *hdhomerun_discover_find_in_list(struct hdhomerun_discover_device_t result_list[], int count, struct hdhomerun_discover_device_t *lookup)
 {
         int index;
         for (index = 0; index < count; index++) {
-                struct hdhomerun_discover_device_t *result = &result_list[index];
-                if (result->ip_addr == ip_addr) {
-                        return result;
+                struct hdhomerun_discover_device_t *entry = &result_list[index];
+                if (memcmp(lookup, entry, sizeof(struct hdhomerun_discover_device_t)) == 0) {
+                        return entry;
                 }
         }
 
         return NULL;
 }
 
-static int hdhomerun_discover_find_devices_internal(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count)
+int hdhomerun_discover_find_devices(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count)
 {
+        hdhomerun_discover_sock_detect(ds);
+
         int count = 0;
         int attempt;
         for (attempt = 0; attempt < 2; attempt++) {
@@ -443 +420 @@
                 }
 
                 uint64_t timeout = getcurrenttime() + 200;
-                while (getcurrenttime() < timeout) {
+                while (1) {
                         struct hdhomerun_discover_device_t *result = &result_list[count];
 
-                        int ret = hdhomerun_discover_recv(ds, result);
-                        if (ret < 0) {
-                                return -1;
-                        }
-                        if (ret == 0) {
+                        if (!hdhomerun_discover_recv(ds, result)) {
+                                if (getcurrenttime() >= timeout) {
+                                        break;
+                                }
+                                msleep_approx(10);
                                 continue;
                         }
 
@@ -467 +444 @@
                         }
 
                         /* Ensure not already in list. */
-                        if (hdhomerun_discover_find_in_list(result_list, count, result->ip_addr)) {
+                        if (hdhomerun_discover_find_in_list(result_list, count, result)) {
                                 continue;
                         }
 
@@ -484 +461 @@
 
 int hdhomerun_discover_find_devices_custom(uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count)
 {
+        if (hdhomerun_discover_is_ip_multicast(target_ip)) {
+                return 0;
+        }
+
         struct hdhomerun_discover_t *ds = hdhomerun_discover_create();
         if (!ds) {
                 return -1;
         }
 
-        int ret = hdhomerun_discover_find_devices_internal(ds, target_ip, device_type, device_id, result_list, max_count);
+        int ret = hdhomerun_discover_find_devices(ds, target_ip, device_type, device_id, result_list, max_count);
 
         hdhomerun_discover_destroy(ds);
         return ret;
@@ -513 +494 @@
         return (checksum == 0);
 }
 
+bool_t hdhomerun_discover_is_ip_multicast(uint32_t ip_addr)
+{
+        return (ip_addr >= 0xE0000000) && (ip_addr < 0xF0000000);
+}

libs/libmythhdhomerun/hdhomerun_discover.h

@@ -44 +44 @@
  *
  * The device information is stored in caller-supplied array of hdhomerun_discover_device_t vars.
  * Multiple attempts are made to find devices.
- * Execution time is 1 second.
+ * Execution time is typically 400ms if max_count is not reached.
  *
  * Set target_ip to zero to auto-detect IP address.
+ * Set device_type to HDHOMERUN_DEVICE_TYPE_TUNER to detect HDHomeRun tuner devices.
+ * Set device_id to HDHOMERUN_DEVICE_ID_WILDCARD to detect all device ids.
  *
  * Returns the number of devices found.
  * Retruns -1 on error.
@@ -54 +56 @@
 extern LIBTYPE int hdhomerun_discover_find_devices_custom(uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count);
 
 /*
+ * Optional: persistent discover instance available for discover polling use.
+ */
+extern LIBTYPE struct hdhomerun_discover_t *hdhomerun_discover_create(void);
+extern LIBTYPE void hdhomerun_discover_destroy(struct hdhomerun_discover_t *ds);
+extern LIBTYPE int hdhomerun_discover_find_devices(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count);
+
+/*
  * Verify that the device ID given is valid.
  *
  * The device ID contains a self-check sequence that detects common user input errors including
@@ -64 +73 @@
  */
 extern LIBTYPE bool_t hdhomerun_discover_validate_device_id(uint32_t device_id);
 
+/*
+ * Detect if an IP address is multicast.
+ *
+ * Returns TRUE if multicast.
+ * Returns FALSE if zero, unicast, expermental, or broadcast.
+ */
+extern LIBTYPE bool_t hdhomerun_discover_is_ip_multicast(uint32_t ip_addr);
+
 #ifdef __cplusplus
 }
 #endif

libs/libmythhdhomerun/Makefile.bin

@@ -1 @@
-LIBSRCS += hdhomerun_pkt.c
-LIBSRCS += hdhomerun_debug.c
-LIBSRCS += hdhomerun_discover.c
+
 LIBSRCS += hdhomerun_channels.c
 LIBSRCS += hdhomerun_channelscan.c
 LIBSRCS += hdhomerun_control.c
-LIBSRCS += hdhomerun_video.c
+LIBSRCS += hdhomerun_debug.c
 LIBSRCS += hdhomerun_device.c
 LIBSRCS += hdhomerun_device_selector.c
+LIBSRCS += hdhomerun_discover.c
+LIBSRCS += hdhomerun_os_posix.c
+LIBSRCS += hdhomerun_pkt.c
+LIBSRCS += hdhomerun_sock_posix.c
+LIBSRCS += hdhomerun_video.c
 
 CC    := $(CROSS_COMPILE)gcc
 STRIP := $(CROSS_COMPILE)strip
@@ -20 +23 @@
   LIBEXT := .dll
   LDFLAGS += -liphlpapi
 else
+  OS := $(shell uname -s)
   LIBEXT := .so
-  ifneq ($(findstring solaris,$(shell echo $$OSTYPE)),)
+  ifeq ($(OS),Linux)
+    LDFLAGS += -lrt
+  endif
+  ifeq ($(OS),SunOS)
     LDFLAGS += -lns -lsocket
   endif
-  ifneq ($(findstring darwin,$(shell echo $$OSTYPE)),)
+  ifeq ($(OS),Darwin)
     CFLAGS += -arch i386 -arch ppc
     LIBEXT := .dylib
     SHARED := -dynamiclib -install_name libhdhomerun$(LIBEXT)

libs/libmythhdhomerun/hdhomerun_device_selector.c

@@ -1 +1 @@
 /*
  * hdhomerun_device_selector.c
  *
- * Copyright © 2009 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2009-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -68 +68 @@
         free(hds);
 }
 
+LIBTYPE int hdhomerun_device_selector_get_device_count(struct hdhomerun_device_selector_t *hds)
+{
+        return (int)hds->hd_count;
+}
+
 void hdhomerun_device_selector_add_device(struct hdhomerun_device_selector_t *hds, struct hdhomerun_device_t *hd)
 {
         size_t index;
@@ -129 +134 @@
         return NULL;
 }
 
-void hdhomerun_device_selector_load_from_file(struct hdhomerun_device_selector_t *hds, char *filename)
+int hdhomerun_device_selector_load_from_file(struct hdhomerun_device_selector_t *hds, char *filename)
 {
         FILE *fp = fopen(filename, "r");
         if (!fp) {
-                return;
+                return 0;
         }
 
         while(1) {
@@ -151 +156 @@
         }
 
         fclose(fp);
+        return (int)hds->hd_count;
 }
 
 #if defined(__WINDOWS__)
-void hdhomerun_device_selector_load_from_windows_registry(struct hdhomerun_device_selector_t *hds, wchar_t *wsource)
+int hdhomerun_device_selector_load_from_windows_registry(struct hdhomerun_device_selector_t *hds, wchar_t *wsource)
 {
         HKEY tuners_key;
         LONG ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Silicondust\\HDHomeRun\\Tuners", 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS, &tuners_key);
         if (ret != ERROR_SUCCESS) {
-                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_load_from_windows_registry: failed to open tuners registry key (%ld)\n", ret);
-                return;
+                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_load_from_windows_registry: failed to open tuners registry key (%ld)\n", (long)ret);
+                return 0;
         }
 
         DWORD index = 0;
@@ -177 +183 @@
                 HKEY device_key;
                 ret = RegOpenKeyEx(tuners_key, wdevice_name, 0, KEY_QUERY_VALUE, &device_key);
                 if (ret != ERROR_SUCCESS) {
-                        hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_load_from_windows_registry: failed to open registry key for %S (%ld)\n", wdevice_name, ret);
+                        hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_load_from_windows_registry: failed to open registry key for %S (%ld)\n", wdevice_name, (long)ret);
                         continue;
                 }
 
@@ -207 +213 @@
         }
 
         RegCloseKey(tuners_key);
+        return (int)hds->hd_count;
 }
 #endif
 
@@ -268 +275 @@
         /*
          * Test local port.
          */
-        int test_sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
-        if (test_sock == -1) {
+        hdhomerun_sock_t test_sock = hdhomerun_sock_create_udp();
+        if (test_sock == HDHOMERUN_SOCK_INVALID) {
                 hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, failed to create test sock\n", name);
                 return FALSE;
         }
 
-        struct sockaddr_in sock_addr;
-        memset(&sock_addr, 0, sizeof(sock_addr));
-        sock_addr.sin_family = AF_INET;
-        sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
-        sock_addr.sin_port = htons((uint16_t)target_port);
-        ret = bind(test_sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
-        close(test_sock);
+        bool_t inuse = (hdhomerun_sock_bind(test_sock, INADDR_ANY, (uint16_t)target_port) == FALSE);
+        hdhomerun_sock_destroy(test_sock);
 
-        if (ret != 0) {
+        if (inuse) {
                 hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by local machine\n", name);
                 return FALSE;
         }

libs/libmythhdhomerun/hdhomerun_device.c

@@ -37 +37 @@
         struct hdhomerun_video_sock_t *vs;
         struct hdhomerun_debug_t *dbg;
         struct hdhomerun_channelscan_t *scan;
+        uint32_t multicast_ip;
+        uint16_t multicast_port;
         uint32_t device_id;
         unsigned int tuner;
         uint32_t lockkey;
@@ -44 +46 @@
         char model[32];
 };
 
-static void hdhomerun_device_set_update(struct hdhomerun_device_t *hd)
+static int hdhomerun_device_set_device_normal(struct hdhomerun_device_t *hd, uint32_t device_id, uint32_t device_ip)
 {
-        /* Clear cached information. */
-        *hd->model = 0;
+        if (!hd->cs) {
+                hd->cs = hdhomerun_control_create(0, 0, hd->dbg);
+                if (!hd->cs) {
+                        hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_device: failed to create control object\n");
+                        return -1;
+                }
+        }
 
-        /* New name. */
-        sprintf(hd->name, "%08lX-%u", (unsigned long)hd->device_id, hd->tuner);
-}
-
-void hdhomerun_device_set_device(struct hdhomerun_device_t *hd, uint32_t device_id, uint32_t device_ip)
-{
         hdhomerun_control_set_device(hd->cs, device_id, device_ip);
 
         if ((device_id == 0) || (device_id == HDHOMERUN_DEVICE_ID_WILDCARD)) {
                 device_id = hdhomerun_control_get_device_id(hd->cs);
         }
 
+        hd->multicast_ip = 0;
+        hd->multicast_port = 0;
         hd->device_id = device_id;
-        hdhomerun_device_set_update(hd);
+        hd->tuner = 0;
+        hd->lockkey = 0;
+
+        sprintf(hd->name, "%08lX-%u", (unsigned long)hd->device_id, hd->tuner);
+        hd->model[0] = 0; /* clear cached model string */
+
+        return 1;
 }
 
-void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner)
+static int hdhomerun_device_set_device_multicast(struct hdhomerun_device_t *hd, uint32_t multicast_ip)
 {
+        if (hd->cs) {
+                hdhomerun_control_destroy(hd->cs);
+                hd->cs = NULL;
+        }
+
+        hd->multicast_ip = multicast_ip;
+        hd->multicast_port = 0;
+        hd->device_id = 0;
+        hd->tuner = 0;
+        hd->lockkey = 0;
+
+        unsigned long ip = multicast_ip;
+        sprintf(hd->name, "%lu.%lu.%lu.%lu", (ip >> 24) & 0xFF, (ip >> 16) & 0xFF, (ip >> 8) & 0xFF, (ip >> 0) & 0xFF);
+        sprintf(hd->model, "multicast");
+
+        return 1;
+}
+
+int hdhomerun_device_set_device(struct hdhomerun_device_t *hd, uint32_t device_id, uint32_t device_ip)
+{
+        if ((device_id == 0) && (device_ip == 0)) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_device: device not specified\n");
+                return -1;
+        }
+
+        if (hdhomerun_discover_is_ip_multicast(device_ip)) {
+                return hdhomerun_device_set_device_multicast(hd, device_ip);
+        }
+
+        return hdhomerun_device_set_device_normal(hd, device_id, device_ip);
+}
+
+int hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner)
+{
+        if (hd->multicast_ip != 0) {
+                if (tuner != 0) {
+                        hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner: tuner cannot be specified in multicast mode\n");
+                        return -1;
+                }
+
+                return 1;
+        }
+
         hd->tuner = tuner;
-        hdhomerun_device_set_update(hd);
+        sprintf(hd->name, "%08lX-%u", (unsigned long)hd->device_id, hd->tuner);
+
+        return 1;
 }
 
 struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner, struct hdhomerun_debug_t *dbg)
 {
         struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)calloc(1, sizeof(struct hdhomerun_device_t));
         if (!hd) {
-                hdhomerun_debug_printf(dbg, "hdhomerun_device_create: failed to allocate device object\n");
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_create: failed to allocate device object\n");
                 return NULL;
         }
 
         hd->dbg = dbg;
 
-        hd->cs = hdhomerun_control_create(0, 0, hd->dbg);
-        if (!hd->cs) {
-                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_create: failed to create control object\n");
+        if ((device_id == 0) && (device_ip == 0) && (tuner == 0)) {
+                return hd;
+        }
+
+        if (hdhomerun_device_set_device(hd, device_id, device_ip) <= 0) {
                 free(hd);
                 return NULL;
         }
+        if (hdhomerun_device_set_tuner(hd, tuner) <= 0) {
+                free(hd);
+                return NULL;
+        }
 
-        hdhomerun_device_set_device(hd, device_id, device_ip);
-        hdhomerun_device_set_tuner(hd, tuner);
-
         return hd;
 }
 
@@ -104 +161 @@
                 hdhomerun_video_destroy(hd->vs);
         }
 
-        hdhomerun_control_destroy(hd->cs);
+        if (hd->cs) {
+                hdhomerun_control_destroy(hd->cs);
+        }
 
         free(hd);
 }
@@ -156 +215 @@
 static struct hdhomerun_device_t *hdhomerun_device_create_from_str_ip(const char *device_str, struct hdhomerun_debug_t *dbg)
 {
         unsigned long a[4];
-        unsigned int tuner;
-
-        if (sscanf(device_str, "%lu.%lu.%lu.%lu-%u", &a[0], &a[1], &a[2], &a[3], &tuner) != 5) {
-                tuner = 0;
+        unsigned int port = 0;
+        if (sscanf(device_str, "%lu.%lu.%lu.%lu:%u", &a[0], &a[1], &a[2], &a[3], &port) != 5) {
                 if (sscanf(device_str, "%lu.%lu.%lu.%lu", &a[0], &a[1], &a[2], &a[3]) != 4) {
                         return NULL;
                 }
         }
 
         unsigned long device_ip = (a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0);
-        return hdhomerun_device_create(HDHOMERUN_DEVICE_ID_WILDCARD, (uint32_t)device_ip, tuner, dbg);
+        struct hdhomerun_device_t *hd = hdhomerun_device_create(HDHOMERUN_DEVICE_ID_WILDCARD, (uint32_t)device_ip, 0, dbg);
+        if (!hd) {
+                return NULL;
+        }
+
+        if (hd->multicast_ip != 0) {
+                hd->multicast_port = port;
+        }
+
+        return hd;
 }
 
 static struct hdhomerun_device_t *hdhomerun_device_create_from_str_dns(const char *device_str, struct hdhomerun_debug_t *dbg)
@@ -239 +305 @@
 
 uint32_t hdhomerun_device_get_device_id(struct hdhomerun_device_t *hd)
 {
-        return hdhomerun_control_get_device_id(hd->cs);
+        return hd->device_id;
 }
 
 uint32_t hdhomerun_device_get_device_ip(struct hdhomerun_device_t *hd)
 {
-        return hdhomerun_control_get_device_ip(hd->cs);
+        if (hd->multicast_ip != 0) {
+                return hd->multicast_ip;
+        }
+        if (hd->cs) {
+                return hdhomerun_control_get_device_ip(hd->cs);
+        }
+
+        return 0;
 }
 
 uint32_t hdhomerun_device_get_device_id_requested(struct hdhomerun_device_t *hd)
 {
-        return hdhomerun_control_get_device_id_requested(hd->cs);
+        if (hd->multicast_ip != 0) {
+                return 0;
+        }
+        if (hd->cs) {
+                return hdhomerun_control_get_device_id_requested(hd->cs);
+        }
+
+        return 0;
 }
 
 uint32_t hdhomerun_device_get_device_ip_requested(struct hdhomerun_device_t *hd)
 {
-        return hdhomerun_control_get_device_ip_requested(hd->cs);
+        if (hd->multicast_ip != 0) {
+                return hd->multicast_ip;
+        }
+        if (hd->cs) {
+                return hdhomerun_control_get_device_ip_requested(hd->cs);
+        }
+
+        return 0;
 }
 
 unsigned int hdhomerun_device_get_tuner(struct hdhomerun_device_t *hd)
@@ -273 +360 @@
                 return hd->vs;
         }
 
-        hd->vs = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S * 2, hd->dbg);
+        hd->vs = hdhomerun_video_create(hd->multicast_port, VIDEO_DATA_BUFFER_SIZE_1S * 2, hd->dbg);
         if (!hd->vs) {
                 hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_video_sock: failed to create video object\n");
                 return NULL;
@@ -284 +371 @@
 
 uint32_t hdhomerun_device_get_local_machine_addr(struct hdhomerun_device_t *hd)
 {
-        return hdhomerun_control_get_local_addr(hd->cs);
+        if (hd->cs) {
+                return hdhomerun_control_get_local_addr(hd->cs);
+        }
+
+        return 0;
 }
 
 static uint32_t hdhomerun_device_get_status_parse(const char *status_str, const char *tag)
@@ -368 +459 @@
 
 int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, char **pstatus_str, struct hdhomerun_tuner_status_t *status)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_status: device not set\n");
+                return -1;
+        }
+
         memset(status, 0, sizeof(struct hdhomerun_tuner_status_t));
 
         char name[32];
@@ -414 +510 @@
 
 int hdhomerun_device_get_tuner_streaminfo(struct hdhomerun_device_t *hd, char **pstreaminfo)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_streaminfo: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/streaminfo", hd->tuner);
         return hdhomerun_control_get(hd->cs, name, pstreaminfo, NULL);
@@ -421 +522 @@
 
 int hdhomerun_device_get_tuner_channel(struct hdhomerun_device_t *hd, char **pchannel)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_channel: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/channel", hd->tuner);
         return hdhomerun_control_get(hd->cs, name, pchannel, NULL);
@@ -428 +534 @@
 
 int hdhomerun_device_get_tuner_channelmap(struct hdhomerun_device_t *hd, char **pchannelmap)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_channelmap: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/channelmap", hd->tuner);
         return hdhomerun_control_get(hd->cs, name, pchannelmap, NULL);
@@ -435 +546 @@
 
 int hdhomerun_device_get_tuner_filter(struct hdhomerun_device_t *hd, char **pfilter)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_filter: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/filter", hd->tuner);
         return hdhomerun_control_get(hd->cs, name, pfilter, NULL);
@@ -442 +558 @@
 
 int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, char **pprogram)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_program: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/program", hd->tuner);
         return hdhomerun_control_get(hd->cs, name, pprogram, NULL);
@@ -449 +570 @@
 
 int hdhomerun_device_get_tuner_target(struct hdhomerun_device_t *hd, char **ptarget)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_target: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/target", hd->tuner);
         return hdhomerun_control_get(hd->cs, name, ptarget, NULL);
@@ -456 +582 @@
 
 int hdhomerun_device_get_tuner_plotsample(struct hdhomerun_device_t *hd, struct hdhomerun_plotsample_t **psamples, size_t *pcount)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_plotsample: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/plotsample", hd->tuner);
 
@@ -505 +636 @@
 
 int hdhomerun_device_get_tuner_lockkey_owner(struct hdhomerun_device_t *hd, char **powner)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_tuner_lockkey_owner: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/lockkey", hd->tuner);
         return hdhomerun_control_get(hd->cs, name, powner, NULL);
@@ -512 +648 @@
 
 int hdhomerun_device_get_ir_target(struct hdhomerun_device_t *hd, char **ptarget)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_ir_target: device not set\n");
+                return -1;
+        }
+
         return hdhomerun_control_get(hd->cs, "/ir/target", ptarget, NULL);
 }
 
 int hdhomerun_device_get_lineup_location(struct hdhomerun_device_t *hd, char **plocation)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_lineup_location: device not set\n");
+                return -1;
+        }
+
         return hdhomerun_control_get(hd->cs, "/lineup/location", plocation, NULL);
 }
 
 int hdhomerun_device_get_version(struct hdhomerun_device_t *hd, char **pversion_str, uint32_t *pversion_num)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_version: device not set\n");
+                return -1;
+        }
+
         char *version_str;
         int ret = hdhomerun_control_get(hd->cs, "/sys/version", &version_str, NULL);
         if (ret <= 0) {
@@ -546 +697 @@
 
 int hdhomerun_device_set_tuner_channel(struct hdhomerun_device_t *hd, const char *channel)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_channel: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/channel", hd->tuner);
         return hdhomerun_control_set_with_lockkey(hd->cs, name, channel, hd->lockkey, NULL, NULL);
@@ -553 +709 @@
 
 int hdhomerun_device_set_tuner_channelmap(struct hdhomerun_device_t *hd, const char *channelmap)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_channelmap: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/channelmap", hd->tuner);
         return hdhomerun_control_set_with_lockkey(hd->cs, name, channelmap, hd->lockkey, NULL, NULL);
@@ -560 +721 @@
 
 int hdhomerun_device_set_tuner_filter(struct hdhomerun_device_t *hd, const char *filter)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_filter: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/filter", hd->tuner);
         return hdhomerun_control_set_with_lockkey(hd->cs, name, filter, hd->lockkey, NULL, NULL);
@@ -635 +801 @@
 
 int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, const char *program)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_program: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/program", hd->tuner);
         return hdhomerun_control_set_with_lockkey(hd->cs, name, program, hd->lockkey, NULL, NULL);
@@ -642 +813 @@
 
 int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, const char *target)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_target: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/target", hd->tuner);
         return hdhomerun_control_set_with_lockkey(hd->cs, name, target, hd->lockkey, NULL, NULL);
 }
 
-int hdhomerun_device_set_tuner_target_to_local_protocol(struct hdhomerun_device_t *hd, const char *protocol)
+static int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd, const char *protocol)
 {
-        /* Create video socket. */
-        hdhomerun_device_get_video_sock(hd);
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_target_to_local: device not set\n");
+                return -1;
+        }
         if (!hd->vs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_target_to_local: video not initialized\n");
                 return -1;
         }
 
@@ -669 +848 @@
         return hdhomerun_device_set_tuner_target(hd, target);
 }
 
-int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd)
+int hdhomerun_device_set_ir_target(struct hdhomerun_device_t *hd, const char *target)
 {
-        return hdhomerun_device_set_tuner_target_to_local_protocol(hd, HDHOMERUN_TARGET_PROTOCOL_UDP); 
-}
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_ir_target: device not set\n");
+                return -1;
+        }
 
-int hdhomerun_device_set_ir_target(struct hdhomerun_device_t *hd, const char *target)
-{
         return hdhomerun_control_set(hd->cs, "/ir/target", target, NULL, NULL);
 }
 
 int hdhomerun_device_set_lineup_location(struct hdhomerun_device_t *hd, const char *location)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_lineup_location: device not set\n");
+                return -1;
+        }
+
         return hdhomerun_control_set(hd->cs, "/lineup/location", location, NULL, NULL);
 }
 
+int hdhomerun_device_set_sys_dvbc_modulation(struct hdhomerun_device_t *hd, const char *modulation_list)
+{
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_sys_dvbc_modulation: device not set\n");
+                return -1;
+        }
+
+        return hdhomerun_control_set(hd->cs, "/sys/dvbc_modulation", modulation_list, NULL, NULL);
+}
+
 int hdhomerun_device_get_var(struct hdhomerun_device_t *hd, const char *name, char **pvalue, char **perror)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_var: device not set\n");
+                return -1;
+        }
+
         return hdhomerun_control_get(hd->cs, name, pvalue, perror);
 }
 
 int hdhomerun_device_set_var(struct hdhomerun_device_t *hd, const char *name, const char *value, char **pvalue, char **perror)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_var: device not set\n");
+                return -1;
+        }
+
         return hdhomerun_control_set_with_lockkey(hd->cs, name, value, hd->lockkey, pvalue, perror);
 }
 
 int hdhomerun_device_tuner_lockkey_request(struct hdhomerun_device_t *hd, char **perror)
 {
+        if (hd->multicast_ip != 0) {
+                return 1;
+        }
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_tuner_lockkey_request: device not set\n");
+                return -1;
+        }
+
         uint32_t new_lockkey = (uint32_t)getcurrenttime();
 
         char name[32];
@@ -716 +928 @@
 
 int hdhomerun_device_tuner_lockkey_release(struct hdhomerun_device_t *hd)
 {
+        if (hd->multicast_ip != 0) {
+                return 1;
+        }
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_tuner_lockkey_release: device not set\n");
+                return -1;
+        }
+
         if (hd->lockkey == 0) {
                 return 1;
         }
@@ -730 +950 @@
 
 int hdhomerun_device_tuner_lockkey_force(struct hdhomerun_device_t *hd)
 {
+        if (hd->multicast_ip != 0) {
+                return 1;
+        }
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_tuner_lockkey_force: device not set\n");
+                return -1;
+        }
+
         char name[32];
         sprintf(name, "/tuner%u/lockkey", hd->tuner);
         int ret = hdhomerun_control_set(hd->cs, name, "force", NULL, NULL);
@@ -740 +968 @@
 
 void hdhomerun_device_tuner_lockkey_use_value(struct hdhomerun_device_t *hd, uint32_t lockkey)
 {
+        if (hd->multicast_ip != 0) {
+                return;
+        }
+
         hd->lockkey = lockkey;
 }
 
 int hdhomerun_device_wait_for_lock(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status)
 {
         /* Delay for SS reading to be valid (signal present). */
-        msleep(250);
+        msleep_minimum(250);
 
         /* Wait for up to 2.5 seconds for lock. */
         uint64_t timeout = getcurrenttime() + 2500;
@@ -768 +1000 @@
                         return 1;
                 }
 
-                msleep(250);
+                msleep_approx(250);
         }
 }
 
 int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd)
 {
+        hdhomerun_device_get_video_sock(hd);
+        if (!hd->vs) {
+                return -1;
+        }
+
         /* Set target. */
-        int ret = hdhomerun_device_stream_refresh_target(hd);
-        if (ret <= 0) {
-                return ret;
+        if (hd->multicast_ip != 0) {
+                int ret = hdhomerun_video_join_multicast_group(hd->vs, hd->multicast_ip, 0);
+                if (ret <= 0) {
+                        return ret;
+                }
+        } else {
+                int ret = hdhomerun_device_set_tuner_target_to_local(hd, HDHOMERUN_TARGET_PROTOCOL_RTP);
+                if (ret == 0) {
+                        ret = hdhomerun_device_set_tuner_target_to_local(hd, HDHOMERUN_TARGET_PROTOCOL_UDP);
+                }
+                if (ret <= 0) {
+                        return ret;
+                }
         }
 
         /* Flush video buffer. */
-        msleep(64);
+        msleep_minimum(64);
         hdhomerun_video_flush(hd->vs);
 
         /* Success. */
         return 1;
 }
 
-int hdhomerun_device_stream_refresh_target(struct hdhomerun_device_t *hd)
-{
-        int ret = hdhomerun_device_set_tuner_target_to_local_protocol(hd, HDHOMERUN_TARGET_PROTOCOL_RTP);
-        if (ret == 0) {
-                ret = hdhomerun_device_set_tuner_target_to_local_protocol(hd, HDHOMERUN_TARGET_PROTOCOL_UDP);
-        }
-        return ret;
-}
-
 uint8_t *hdhomerun_device_stream_recv(struct hdhomerun_device_t *hd, size_t max_size, size_t *pactual_size)
 {
         if (!hd->vs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_stream_recv: video not initialized\n");
                 return NULL;
         }
+
         return hdhomerun_video_recv(hd->vs, max_size, pactual_size);
 }
 
 void hdhomerun_device_stream_flush(struct hdhomerun_device_t *hd)
 {
+        if (!hd->vs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_stream_flush: video not initialized\n");
+                return;
+        }
+
         hdhomerun_video_flush(hd->vs);
 }
 
 void hdhomerun_device_stream_stop(struct hdhomerun_device_t *hd)
 {
-        hdhomerun_device_set_tuner_target(hd, "none");
+        if (!hd->vs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_stream_stop: video not initialized\n");
+                return;
+        }
+
+        if (hd->multicast_ip != 0) {
+                hdhomerun_video_leave_multicast_group(hd->vs);
+        } else {
+                hdhomerun_device_set_tuner_target(hd, "none");
+        }
 }
 
 int hdhomerun_device_channelscan_init(struct hdhomerun_device_t *hd, const char *channelmap)
@@ -823 +1077 @@
 
         hd->scan = channelscan_create(hd, channelmap);
         if (!hd->scan) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_channelscan_init: failed to create scan object\n");
                 return -1;
         }
 
@@ -832 +1087 @@
 int hdhomerun_device_channelscan_advance(struct hdhomerun_device_t *hd, struct hdhomerun_channelscan_result_t *result)
 {
         if (!hd->scan) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_channelscan_advance: scan not initialized\n");
                 return 0;
         }
 
@@ -847 +1103 @@
 int hdhomerun_device_channelscan_detect(struct hdhomerun_device_t *hd, struct hdhomerun_channelscan_result_t *result)
 {
         if (!hd->scan) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_channelscan_detect: scan not initialized\n");
                 return 0;
         }
 
@@ -862 +1119 @@
 uint8_t hdhomerun_device_channelscan_get_progress(struct hdhomerun_device_t *hd)
 {
         if (!hd->scan) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_channelscan_get_progress: scan not initialized\n");
                 return 0;
         }
 
         return channelscan_get_progress(hd->scan);
 }
 
-int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features)
-{
-        uint32_t version;
-        if (hdhomerun_device_get_version(hd, NULL, &version) <= 0) {
-                return -1;
-        }
-
-        if (version < 20070219) {
-                return 0;
-        }
-
-        return 1;
-}
-
 const char *hdhomerun_device_get_model_str(struct hdhomerun_device_t *hd)
 {
         if (*hd->model) {
                 return hd->model;
         }
 
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_model_str: device not set\n");
+                return NULL;
+        }
+
         char *model_str;
         int ret = hdhomerun_control_get(hd->cs, "/sys/model", &model_str, NULL);
         if (ret < 0) {
                 return NULL;
         }
         if (ret == 0) {
-                strncpy(hd->model, "hdhomerun_atsc", sizeof(hd->model) - 1);
-                hd->model[sizeof(hd->model) - 1] = 0;
+                model_str = "hdhomerun_atsc";
         }
-        else
-        {
-                strncpy(hd->model, model_str, sizeof(hd->model) - 1);
-                hd->model[sizeof(hd->model) - 1] = 0;
-        }
 
+        strncpy(hd->model, model_str, sizeof(hd->model) - 1);
+        hd->model[sizeof(hd->model) - 1] = 0;
+
         return hd->model;
 }
 
 int hdhomerun_device_upgrade(struct hdhomerun_device_t *hd, FILE *upgrade_file)
 {
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_upgrade: device not set\n");
+                return -1;
+        }
+
         hdhomerun_control_set(hd->cs, "/tuner0/lockkey", "force", NULL, NULL);
         hdhomerun_control_set(hd->cs, "/tuner0/channel", "none", NULL, NULL);
 
@@ -923 +1174 @@
                 return;
         }
 
-        char name[32];
-        sprintf(name, "/tuner%u/debug", hd->tuner);
+        if (hd->cs) {
+                char name[32];
+                sprintf(name, "/tuner%u/debug", hd->tuner);
 
-        char *debug_str;
-        char *error_str;
-        int ret = hdhomerun_control_get(hd->cs, name, &debug_str, &error_str);
-        if (ret < 0) {
-                hdhomerun_debug_printf(hd->dbg, "video dev: communication error getting debug stats\n");
-                return;
-        }
+                char *debug_str;
+                char *error_str;
+                int ret = hdhomerun_control_get(hd->cs, name, &debug_str, &error_str);
+                if (ret < 0) {
+                        hdhomerun_debug_printf(hd->dbg, "video dev: communication error getting debug stats\n");
+                        return;
+                }
 
-        if (error_str) {
-                hdhomerun_debug_printf(hd->dbg, "video dev: %s\n", error_str);
-        } else {
-                hdhomerun_debug_printf(hd->dbg, "video dev: %s\n", debug_str);
+                if (error_str) {
+                        hdhomerun_debug_printf(hd->dbg, "video dev: %s\n", error_str);
+                } else {
+                        hdhomerun_debug_printf(hd->dbg, "video dev: %s\n", debug_str);
+                }
         }
 
         if (hd->vs) {
@@ -947 +1200 @@
 
 void hdhomerun_device_get_video_stats(struct hdhomerun_device_t *hd, struct hdhomerun_video_stats_t *stats)
 {
+        if (!hd->vs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_stream_flush: video not initialized\n");
+                memset(stats, 0, sizeof(struct hdhomerun_video_stats_t));
+                return;
+        }
+
         hdhomerun_video_get_stats(hd->vs, stats);
 }

libs/libmythhdhomerun/hdhomerun_os_windows.h

@@ -1 +1 @@
 /*
  * hdhomerun_os_windows.h
  *
- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -31 +31 @@
  */
 
 #define _WINSOCKAPI_
-// MinGW lacks wspiapi, so remove dependency by setting minimum WINVER to WinXP
-#define WINVER 0x0501
 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
-//#include <wspiapi.h>
+#include <wspiapi.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
@@ -55 +53 @@
 #endif
 
 typedef int bool_t;
-/* Use MinGW includes instead
 typedef signed __int8 int8_t;
 typedef signed __int16 int16_t;
 typedef signed __int32 int32_t;
@@ -66 +63 @@
 typedef unsigned __int64 uint64_t;
 typedef HANDLE pthread_t;
 typedef HANDLE pthread_mutex_t;
-*/
-#include <stdint.h>
-#include <pthread.h>
 
-// Avoid #define conflicts by limiting scope to non-c++
-#ifndef __cplusplus
-#define socklen_t int
-#define close closesocket
-#define sock_getlasterror WSAGetLastError()
-#define sock_getlasterror_socktimeout (WSAGetLastError() == WSAETIMEDOUT)
-//#define va_copy(x, y) x = y
+#define va_copy(x, y) x = y
 #define atoll _atoi64
 #define strdup _strdup
 #define strcasecmp _stricmp
@@ -85 +73 @@
 #define ftello _ftelli64
 #define THREAD_FUNC_PREFIX DWORD WINAPI
 #define SIGPIPE SIGABRT
+
+#ifdef __cplusplus
+extern "C" {
 #endif
 
-static inline uint64_t getcurrenttime(void)
-{
-        struct timeb tb;
-        ftime(&tb);
-        return ((uint64_t)tb.time * 1000) + tb.millitm;
-}
+extern LIBTYPE uint64_t getcurrenttime(void);
+extern LIBTYPE void msleep_approx(uint64_t ms);
+extern LIBTYPE void msleep_minimum(uint64_t ms);
 
-static inline int msleep(unsigned int ms)
-{
-        uint64_t stop_time = getcurrenttime() + ms;
+extern LIBTYPE int pthread_create(pthread_t *tid, void *attr, LPTHREAD_START_ROUTINE start, void *arg);
+extern LIBTYPE int pthread_join(pthread_t tid, void **value_ptr);
+extern LIBTYPE void pthread_mutex_init(pthread_mutex_t *mutex, void *attr);
+extern LIBTYPE void pthread_mutex_lock(pthread_mutex_t *mutex);
+extern LIBTYPE void pthread_mutex_unlock(pthread_mutex_t *mutex);
 
-        while (1) {
-                uint64_t current_time = getcurrenttime();
-                if (current_time >= stop_time) {
-                        return 0;
-                }
-
-                uint64_t delay_ms = stop_time - current_time;
-                Sleep((DWORD)delay_ms);
-        }
-}
-
-// Avoid a define conflict
-/*static inline int sleep(unsigned int sec)
-{
-        msleep(sec * 1000);
-        return 0;
-}
-*/
-
-static inline int setsocktimeout(int s, int level, int optname, uint64_t timeout)
-{
-        int t = (int)timeout;
-        return setsockopt(s, level, optname, (char *)&t, sizeof(t));
-}
-
-/* MythTV uses pthreads lib instead
-static inline int pthread_create(pthread_t *tid, void *attr, LPTHREAD_START_ROUTINE start, void *arg)
-{
-        *tid = CreateThread(NULL, 0, start, arg, 0, NULL);
-        if (!*tid) {
-                return (int)GetLastError();
-        }
-        return 0;
-}
-
-static inline int pthread_join(pthread_t tid, void **value_ptr)
-{
-        while (1) {
-                DWORD ExitCode = 0;
-                if (!GetExitCodeThread(tid, &ExitCode)) {
-                        return (int)GetLastError();
-                }
-                if (ExitCode != STILL_ACTIVE) {
-                        return 0;
-                }
-        }
-}
-
-static inline void pthread_mutex_init(pthread_mutex_t *mutex, void *attr)
-{
-        *mutex = CreateMutex(NULL, FALSE, NULL);
-}
-
-static inline void pthread_mutex_lock(pthread_mutex_t *mutex)
-{
-        WaitForSingleObject(*mutex, INFINITE);
-}
-
-static inline void pthread_mutex_unlock(pthread_mutex_t *mutex)
-{
-        ReleaseMutex(*mutex);
-}
-*/
-
 /*
  * The console output format should be set to UTF-8, however in XP and Vista this breaks batch file processing.
  * Attempting to restore on exit fails to restore if the program is terminated by the user.
  * Solution - set the output format each printf.
  */
-static inline void console_vprintf(const char *fmt, va_list ap)
-{
-        UINT cp = GetConsoleOutputCP();
-        SetConsoleOutputCP(CP_UTF8);
-        vprintf(fmt, ap);
-        SetConsoleOutputCP(cp);
-}
+extern LIBTYPE void console_vprintf(const char *fmt, va_list ap);
+extern LIBTYPE void console_printf(const char *fmt, ...);
 
-static inline void console_printf(const char *fmt, ...)
-{
-        va_list ap;
-        va_start(ap, fmt);
-        console_vprintf(fmt, ap);
-        va_end(ap);
+#ifdef __cplusplus
 }
+#endif

libs/libmythhdhomerun/hdhomerun_device.h

@@ -90 +90 @@
 extern LIBTYPE uint32_t hdhomerun_device_get_device_ip_requested(struct hdhomerun_device_t *hd);
 extern LIBTYPE unsigned int hdhomerun_device_get_tuner(struct hdhomerun_device_t *hd);
 
-extern LIBTYPE void hdhomerun_device_set_device(struct hdhomerun_device_t *hd, uint32_t device_id, uint32_t device_ip);
-extern LIBTYPE void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner);
+extern LIBTYPE int hdhomerun_device_set_device(struct hdhomerun_device_t *hd, uint32_t device_id, uint32_t device_ip);
+extern LIBTYPE int hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner);
 extern LIBTYPE int hdhomerun_device_set_tuner_from_str(struct hdhomerun_device_t *hd, const char *tuner_str);
 
 /*
@@ -148 +148 @@
 extern LIBTYPE int hdhomerun_device_set_tuner_filter_by_array(struct hdhomerun_device_t *hd, unsigned char filter_array[0x2000]);
 extern LIBTYPE int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, const char *program);
 extern LIBTYPE int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, const char *target);
-extern LIBTYPE int hdhomerun_device_set_tuner_target_to_local_protocol(struct hdhomerun_device_t *hd, const char *protocol);
-extern LIBTYPE int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd);
 extern LIBTYPE int hdhomerun_device_set_ir_target(struct hdhomerun_device_t *hd, const char *target);
 extern LIBTYPE int hdhomerun_device_set_lineup_location(struct hdhomerun_device_t *hd, const char *location);
+extern LIBTYPE int hdhomerun_device_set_sys_dvbc_modulation(struct hdhomerun_device_t *hd, const char *modulation_list);
 
 /*
  * Get/set a named control variable on the device.
@@ -224 +223 @@
  * The hdhomerun_device_stream_stop function tells the device to stop streaming data.
  */
 extern LIBTYPE int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd);
-extern LIBTYPE int hdhomerun_device_stream_refresh_target(struct hdhomerun_device_t *hd);
 extern LIBTYPE uint8_t *hdhomerun_device_stream_recv(struct hdhomerun_device_t *hd, size_t max_size, size_t *pactual_size);
 extern LIBTYPE void hdhomerun_device_stream_flush(struct hdhomerun_device_t *hd);
 extern LIBTYPE void hdhomerun_device_stream_stop(struct hdhomerun_device_t *hd);
@@ -238 +236 @@
 extern LIBTYPE uint8_t hdhomerun_device_channelscan_get_progress(struct hdhomerun_device_t *hd);
 
 /*
- * Check that the device is running the recommended firmware.
- *
- * uint32_t features: Reserved for future use. Set to zero.
- *
- * Returns 1 if the firmware meets the minimum requriements for all operations.
- * Returns 0 if th firmware does not meet the minimum requriements for all operations.
- * Returns -1 if an error occurs.
- */
-extern LIBTYPE int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features);
-
-/*
  * Upload new firmware to the device.
  *
  * FILE *upgrade_file: File pointer to read from. The file must have been opened in binary mode for reading.

libs/libmythhdhomerun/hdhomerun_device_selector.h

@@ -43 +43 @@
 extern LIBTYPE void hdhomerun_device_selector_destroy(struct hdhomerun_device_selector_t *hds, bool_t destroy_devices);
 
 /*
+ * Get the number of devices in the list.
+ */
+extern LIBTYPE int hdhomerun_device_selector_get_device_count(struct hdhomerun_device_selector_t *hds);
+
+/*
  * Populate device selector with devices from given source.
+ * Returns the number of devices populated.
  */
-extern LIBTYPE void hdhomerun_device_selector_load_from_file(struct hdhomerun_device_selector_t *hds, char *filename);
+extern LIBTYPE int hdhomerun_device_selector_load_from_file(struct hdhomerun_device_selector_t *hds, char *filename);
 #if defined(__WINDOWS__)
-extern LIBTYPE void hdhomerun_device_selector_load_from_windows_registry(struct hdhomerun_device_selector_t *hds, wchar_t *wsource);
+extern LIBTYPE int hdhomerun_device_selector_load_from_windows_registry(struct hdhomerun_device_selector_t *hds, wchar_t *wsource);
 #endif
 
 /*

libs/libmythhdhomerun/hdhomerun_control.c

@@ -1 +1 @@
 /*
  * hdhomerun_control.c
  *
- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2010 Silicondust USA Inc. <www.silicondust.com>.
  *
  * This library is free software; you can redistribute it and/or 
  * modify it under the terms of the GNU Lesser General Public
@@ -32 +32 @@
 
 #include "hdhomerun.h"
 
-#define HDHOMERUN_CONTROL_SEND_TIMEOUT 5000
-#define HDHOMERUN_CONTROL_RECV_TIMEOUT 5000
+#define HDHOMERUN_CONTROL_CONNECT_TIMEOUT 2500
+#define HDHOMERUN_CONTROL_SEND_TIMEOUT 2500
+#define HDHOMERUN_CONTROL_RECV_TIMEOUT 2500
 #define HDHOMERUN_CONTROL_UPGRADE_TIMEOUT 20000
 
 struct hdhomerun_control_sock_t {
@@ -49 +50 @@
 
 static void hdhomerun_control_close_sock(struct hdhomerun_control_sock_t *cs)
 {
-        if (cs->sock == -1) {
+        if (cs->sock == HDHOMERUN_SOCK_INVALID) {
                 return;
         }
 
-        close(cs->sock);
-        cs->sock = -1;
+        hdhomerun_sock_destroy(cs->sock);
+        cs->sock = HDHOMERUN_SOCK_INVALID;
 }
 
 void hdhomerun_control_set_device(struct hdhomerun_control_sock_t *cs, uint32_t device_id, uint32_t device_ip)
@@ -76 +77 @@
         }
 
         cs->dbg = dbg;
-        cs->sock = -1;
+        cs->sock = HDHOMERUN_SOCK_INVALID;
         hdhomerun_control_set_device(cs, device_id, device_ip);
 
         return cs;
@@ -90 +91 @@
 
 static bool_t hdhomerun_control_connect_sock(struct hdhomerun_control_sock_t *cs)
 {
-        if (cs->sock != -1) {
+        if (cs->sock != HDHOMERUN_SOCK_INVALID) {
                 return TRUE;
         }
 
@@ -98 +99 @@
                 hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: no device specified\n");
                 return FALSE;
         }
+        if (hdhomerun_discover_is_ip_multicast(cs->desired_device_ip)) {
+                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: cannot use multicast ip address for device operations\n");
+                return FALSE;
+        }
 
         /* Find device. */
         struct hdhomerun_discover_device_t result;
@@ -109 +114 @@
         cs->actual_device_id = result.device_id;
 
         /* Create socket. */
-        cs->sock = (int)socket(AF_INET, SOCK_STREAM, 0);
-        if (cs->sock == -1) {
-                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to create socket (%d)\n", sock_getlasterror);
+        cs->sock = hdhomerun_sock_create_tcp();
+        if (cs->sock == HDHOMERUN_SOCK_INVALID) {
+                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to create socket (%d)\n", hdhomerun_sock_getlasterror());
                 return FALSE;
         }
 
-        /* Set timeouts. */
-        setsocktimeout(cs->sock, SOL_SOCKET, SO_SNDTIMEO, HDHOMERUN_CONTROL_SEND_TIMEOUT);
-        setsocktimeout(cs->sock, SOL_SOCKET, SO_RCVTIMEO, HDHOMERUN_CONTROL_RECV_TIMEOUT);
-
         /* Initiate connection. */
-        struct sockaddr_in sock_addr;
-        memset(&sock_addr, 0, sizeof(sock_addr));
-        sock_addr.sin_family = AF_INET;
-        sock_addr.sin_addr.s_addr = htonl(cs->actual_device_ip);
-        sock_addr.sin_port = htons(HDHOMERUN_CONTROL_TCP_PORT);
-        if (connect(cs->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
-                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to connect (%d)\n", sock_getlasterror);
+        if (!hdhomerun_sock_connect(cs->sock, cs->actual_device_ip, HDHOMERUN_CONTROL_TCP_PORT, HDHOMERUN_CONTROL_CONNECT_TIMEOUT)) {
+                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to connect (%d)\n", hdhomerun_sock_getlasterror());
                 hdhomerun_control_close_sock(cs);
                 return FALSE;
         }
@@ -172 +168 @@
                 return 0;
         }
 
-        struct sockaddr_in sock_addr;
-        socklen_t sockaddr_size = sizeof(sock_addr);
-        if (getsockname(cs->sock, (struct sockaddr*)&sock_addr, &sockaddr_size) != 0) {
-                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_local_addr: getsockname failed (%d)\n", sock_getlasterror);
+        uint32_t addr = hdhomerun_sock_getsockname_addr(cs->sock);
+        if (addr == 0) {
+                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_local_addr: getsockname failed (%d)\n", hdhomerun_sock_getlasterror());
                 return 0;
         }
 
-        return ntohl(sock_addr.sin_addr.s_addr);
+        return addr;
 }
 
-static int hdhomerun_control_send_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt)
+static bool_t hdhomerun_control_send_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt)
 {
-        int length = (int)(tx_pkt->end - tx_pkt->start);
-        if (send(cs->sock, (char *)tx_pkt->start, (int)length, 0) != length) {
-                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_sock: send failed (%d)\n", sock_getlasterror);
+        if (!hdhomerun_sock_send(cs->sock, tx_pkt->start, tx_pkt->end - tx_pkt->start, HDHOMERUN_CONTROL_SEND_TIMEOUT)) {
+                hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_sock: send failed (%d)\n", hdhomerun_sock_getlasterror());
                 hdhomerun_control_close_sock(cs);
-                return -1;
+                return FALSE;
         }
 
-        return 1;
+        return TRUE;
 }
 
-static int hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *rx_pkt, uint16_t *ptype, uint64_t recv_timeout)
+static bool_t hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *rx_pkt, uint16_t *ptype, uint64_t recv_timeout)
 {
         uint64_t stop_time = getcurrenttime() + recv_timeout;
         hdhomerun_pkt_reset(rx_pkt);
 
-        while (getcurrenttime() < stop_time) {
-                struct timeval t;
-                t.tv_sec = 0;
-                t.tv_usec = 250000;
-        
-                fd_set readfds;
-                FD_ZERO(&readfds);
-                FD_SET(cs->sock, &readfds);
-        
-                if (select(cs->sock+1, &readfds, NULL, NULL, &t) < 0) {
-                        hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: select failed (%d)\n", sock_getlasterror);
+        while (1) {
+                uint64_t current_time = getcurrenttime();
+                if (current_time >= stop_time) {
+                        hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: timeout\n");
                         hdhomerun_control_close_sock(cs);
-                        return -1;
+                        return FALSE;
                 }
-        
-                if (!FD_ISSET(cs->sock, &readfds)) {
-                        continue;
-                }
-        
-                int rx_length = recv(cs->sock, (char *)rx_pkt->end, (int)(rx_pkt->limit - rx_pkt->end), 0);
-                if (rx_length <= 0) {
-                        hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: recv failed (%d)\n", sock_getlasterror);
+
+                size_t length = rx_pkt->limit - rx_pkt->end;
+                if (!hdhomerun_sock_recv(cs->sock, rx_pkt->end, &length, stop_time - current_time)) {
+                        hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: recv failed (%d)\n", hdhomerun_sock_getlasterror());
                         hdhomerun_control_close_sock(cs);
-                        return -1;
+                        return FALSE;
                 }
-                rx_pkt->end += rx_length;
 
+                rx_pkt->end += length;
+
                 int ret = hdhomerun_pkt_open_frame(rx_pkt, ptype);
                 if (ret < 0) {
                         hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: frame error\n");
                         hdhomerun_control_close_sock(cs);
-                        return -1;
+                        return FALSE;
                 }
-                if (ret == 0) {
-                        continue;
+                if (ret > 0) {
+                        return TRUE;
                 }
-
-                return 1;
         }
-
-        hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: timeout\n");
-        hdhomerun_control_close_sock(cs);
-        return -1;
 }
 
 static int hdhomerun_control_send_recv_internal(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt, struct hdhomerun_pkt_t *rx_pkt, uint16_t type, uint64_t recv_timeout)
@@ -250 +228 @@
 
         int i;
         for (i = 0; i < 2; i++) {
-                if (cs->sock == -1) {
+                if (cs->sock == HDHOMERUN_SOCK_INVALID) {
                         if (!hdhomerun_control_connect_sock(cs)) {
                                 hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_recv: connect failed\n");
                                 return -1;
                         }
                 }
 
-                if (hdhomerun_control_send_sock(cs, tx_pkt) < 0) {
+                if (!hdhomerun_control_send_sock(cs, tx_pkt)) {
                         continue;
                 }
                 if (!rx_pkt) {
@@ -265 +243 @@
                 }
 
                 uint16_t rsp_type;
-                if (hdhomerun_control_recv_sock(cs, rx_pkt, &rsp_type, recv_timeout) < 0) {
+                if (!hdhomerun_control_recv_sock(cs, rx_pkt, &rsp_type, recv_timeout)) {
                         continue;
                 }
                 if (rsp_type != type + 1) {
@@ -301 +279 @@
         }
         hdhomerun_pkt_write_u8(tx_pkt, HDHOMERUN_TAG_GETSET_NAME);
         hdhomerun_pkt_write_var_length(tx_pkt, name_len);
-        hdhomerun_pkt_write_mem(tx_pkt, (const void *)name, name_len);
+        hdhomerun_pkt_write_mem(tx_pkt, (void *)name, name_len);
 
         if (value) {
                 int value_len = (int)strlen(value) + 1;
@@ -311 +289 @@
                 }
                 hdhomerun_pkt_write_u8(tx_pkt, HDHOMERUN_TAG_GETSET_VALUE);
                 hdhomerun_pkt_write_var_length(tx_pkt, value_len);
-                hdhomerun_pkt_write_mem(tx_pkt, (const void *)value, value_len);
+                hdhomerun_pkt_write_mem(tx_pkt, (void *)value, value_len);
         }
 
         if (lockkey != 0) {