Ticket #8387: libmythhdhomerun.2.patch

hdhomerun_control.h

@@ -1 +1 @@
 /*
  * hdhomerun_control.h
  *
- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006 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

hdhomerun.h

@@ -1 @@
-#ifndef __HDHOMERUN_INCLUDES__
-#define __HDHOMERUN_INCLUDES__
 /*
  * 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 +33 @@
 #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"
@@ -43 +42 @@
 #include "hdhomerun_channelscan.h"
 #include "hdhomerun_device.h"
 #include "hdhomerun_device_selector.h"
-
-#endif /* __HDHOMERUN_INCLUDES__ */

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;
                 }
 

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_debug.h     hdhomerun_device.h       hdhomerun_device_selector.h
 HEADERS += hdhomerun_discover.h  hdhomerun_pkt.h          hdhomerun_video.h 
-HEADERS += hdhomerun_device_selector.h
 
 SOURCES += hdhomerun_channels.c  hdhomerun_channelscan.c  hdhomerun_control.c
-SOURCES += hdhomerun_debug.c     hdhomerun_device.c       hdhomerun_dhcp.c
+SOURCES += hdhomerun_debug.c     hdhomerun_device.c       hdhomerun_device_selector.c
 SOURCES += hdhomerun_discover.c  hdhomerun_pkt.c          hdhomerun_video.c
-SOURCES += hdhomerun_device_selector.c
 
+unix {
+    HEADERS += hdhomerun_os_posix.h  hdhomerun_sock_posix.h
+    SOURCES += hdhomerun_os_posix.c hdhomerun_sock_posix.c
+}
+
 mingw {
-    HEADERS += hdhomerun_os_windows.h
+    HEADERS += hdhomerun_os_windows.h hdhomerun_sock_windows.h
+    SOURCES += hdhomerun_os_windows.c hdhomerun_sock_windows.c
     LIBS += -lws2_32 -liphlpapi -lpthread
 }
 

hdhomerun_debug.h

@@ -1 +1 @@
 /*
  * hdhomerun_debug.h
  *
- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006 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

hdhomerun_os_posix.c

@@ +1 @@
+/*
+ * hdhomerun_os_posix.c
+ *
+ * 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
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * As a special exception to the GNU Lesser General Public License,
+ * you may link, statically or dynamically, an application with a
+ * publicly distributed version of the Library to produce an
+ * executable file containing portions of the Library, and
+ * distribute that executable file under terms of your choice,
+ * without any of the additional requirements listed in clause 4 of
+ * the GNU Lesser General Public License.
+ * 
+ * By "a publicly distributed version of the Library", we mean
+ * either the unmodified Library as distributed by Silicondust, or a
+ * modified version of the Library that is distributed under the
+ * conditions defined in the GNU Lesser General Public License.
+ */
+
+#include "hdhomerun_os.h"
+
+uint64_t getcurrenttime(void)
+{
+        static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+        static uint64_t result = 0;
+        static uint64_t previous_time = 0;
+
+        pthread_mutex_lock(&lock);
+
+#if defined(CLOCK_MONOTONIC)
+        struct timespec tp;
+        clock_gettime(CLOCK_MONOTONIC, &tp);
+        uint64_t current_time = ((uint64_t)tp.tv_sec * 1000) + (tp.tv_nsec / 1000000);
+#else
+        struct timeval t;
+        gettimeofday(&t, NULL);
+        uint64_t current_time = ((uint64_t)t.tv_sec * 1000) + (t.tv_usec / 1000);
+#endif
+
+        if (current_time > previous_time) {
+                result += current_time - previous_time;
+        }
+
+        previous_time = current_time;
+
+        pthread_mutex_unlock(&lock);
+        return result;
+}
+
+void msleep_approx(uint64_t ms)
+{
+        unsigned int delay_s = ms / 1000;
+        if (delay_s > 0) {
+                sleep(delay_s);
+                ms -= delay_s * 1000;
+        }
+
+        unsigned int delay_us = ms * 1000;
+        if (delay_us > 0) {
+                usleep(delay_us);
+        }
+}
+
+void msleep_minimum(uint64_t ms)
+{
+        uint64_t stop_time = getcurrenttime() + ms;
+
+        while (1) {
+                uint64_t current_time = getcurrenttime();
+                if (current_time >= stop_time) {
+                        return;
+                }
+
+                msleep_approx(stop_time - current_time);
+        }
+}

hdhomerun_sock.h

@@ +1 @@
+/*
+ * hdhomerun_sock.h
+ *
+ * Copyright © 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
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * As a special exception to the GNU Lesser General Public License,
+ * you may link, statically or dynamically, an application with a
+ * publicly distributed version of the Library to produce an
+ * executable file containing portions of the Library, and
+ * distribute that executable file under terms of your choice,
+ * without any of the additional requirements listed in clause 4 of
+ * the GNU Lesser General Public License.
+ * 
+ * By "a publicly distributed version of the Library", we mean
+ * either the unmodified Library as distributed by Silicondust, or a
+ * modified version of the Library that is distributed under the
+ * conditions defined in the GNU Lesser General Public License.
+ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HDHOMERUN_SOCK_INVALID -1
+
+typedef int hdhomerun_sock_t;
+
+extern LIBTYPE hdhomerun_sock_t hdhomerun_sock_create_udp(void);
+extern LIBTYPE hdhomerun_sock_t hdhomerun_sock_create_tcp(void);
+extern LIBTYPE void hdhomerun_sock_destroy(hdhomerun_sock_t sock);
+
+extern LIBTYPE int hdhomerun_sock_getlasterror(void);
+extern LIBTYPE uint32_t hdhomerun_sock_getsockname_addr(hdhomerun_sock_t sock);
+extern LIBTYPE uint16_t hdhomerun_sock_getsockname_port(hdhomerun_sock_t sock);
+extern LIBTYPE uint32_t hdhomerun_sock_getpeername_addr(hdhomerun_sock_t sock);
+extern LIBTYPE uint32_t hdhomerun_sock_getaddrinfo_addr(hdhomerun_sock_t sock, const char *name);
+
+extern LIBTYPE bool_t hdhomerun_sock_bind(hdhomerun_sock_t sock, uint32_t local_addr, uint16_t local_port);
+extern LIBTYPE bool_t hdhomerun_sock_connect(hdhomerun_sock_t sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout);
+
+extern LIBTYPE bool_t hdhomerun_sock_send(hdhomerun_sock_t sock, const void *data, size_t length, uint64_t timeout);
+extern LIBTYPE bool_t hdhomerun_sock_sendto(hdhomerun_sock_t sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout);
+
+extern LIBTYPE bool_t hdhomerun_sock_recv(hdhomerun_sock_t sock, void *data, size_t *length, uint64_t timeout);
+extern LIBTYPE bool_t hdhomerun_sock_recvfrom(hdhomerun_sock_t sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout);
+
+
+#ifdef __cplusplus
+}
+#endif

hdhomerun_config.c

@@ -1 +1 @@
 /*
  * hdhomerun_config.c
  *
- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2008 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
@@ -202 +202 @@
         return cmd_set_internal(item, value);
 }
 
-static bool_t sigabort = FALSE;
+static volatile sig_atomic_t sigabort_flag = FALSE;
+static volatile sig_atomic_t siginfo_flag = FALSE;
+ 
+static void sigabort_handler(int arg)
+{
+        sigabort_flag = TRUE;
+}
 
-static void signal_abort(int arg)
+static void siginfo_handler(int arg)
 {
-        sigabort = TRUE;
+        siginfo_flag = TRUE;
 }
 
+static void register_signal_handlers(sig_t sigpipe_handler, sig_t sigint_handler, sig_t siginfo_handler)
+{
+#if defined(SIGPIPE)
+        signal(SIGPIPE, sigpipe_handler);
+#endif
+#if defined(SIGINT)
+        signal(SIGINT, sigint_handler);
+#endif
+#if defined(SIGINFO)
+        signal(SIGINFO, siginfo_handler);
+#endif
+}
+
 static void cmd_scan_printf(FILE *fp, const char *fmt, ...)
 {
         va_list ap;
@@ -274 +293 @@
                 }
         }
 
-        signal(SIGINT, signal_abort);
-        signal(SIGPIPE, signal_abort);
+        register_signal_handlers(sigabort_handler, sigabort_handler, siginfo_handler);
 
         int ret = 0;
-        while (!sigabort) {
+        while (!sigabort_flag) {
                 struct hdhomerun_channelscan_result_t result;
                 ret = hdhomerun_device_channelscan_advance(hd, &result);
                 if (ret <= 0) {
@@ -286 +304 @@
                 }
 
                 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);
@@ -321 +339 @@
         return ret;
 }
 
+static void cmd_save_print_stats(void)
+{
+        struct hdhomerun_video_stats_t stats;
+        hdhomerun_device_get_video_stats(hd, &stats);
+
+        fprintf(stderr, "%u packets received, %u overflow errors, %u network errors, %u transport errors, %u sequence errors\n",
+                (unsigned int)stats.packet_count, 
+                (unsigned int)stats.overflow_error_count,
+                (unsigned int)stats.network_error_count, 
+                (unsigned int)stats.transport_error_count, 
+                (unsigned int)stats.sequence_error_count
+        );
+}
+
 static int cmd_save(const char *tuner_str, const char *filename)
 {
         if (hdhomerun_device_set_tuner_from_str(hd, tuner_str) <= 0) {
@@ -350 +382 @@
                 return ret;
         }
 
-        signal(SIGINT, signal_abort);
-        signal(SIGPIPE, signal_abort);
+        register_signal_handlers(sigabort_handler, sigabort_handler, siginfo_handler);
 
         struct hdhomerun_video_stats_t stats_old, stats_cur;
         hdhomerun_device_get_video_stats(hd, &stats_old);
 
         uint64_t next_progress = getcurrenttime() + 1000;
 
-        while (!sigabort) {
+        while (!sigabort_flag) {
                 uint64_t loop_start_time = getcurrenttime();
 
+                if (siginfo_flag) {
+                        fprintf(stderr, "\n");
+                        cmd_save_print_stats();
+                        siginfo_flag = FALSE;
+                }
+
                 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 +418 @@
                                 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 +447 @@
                         continue;
                 }
 
-                msleep(delay);
+                msleep_approx(delay);
         }
 
         if (fp) {
@@ -412 +455 @@
         }
 
         hdhomerun_device_stream_stop(hd);
-        hdhomerun_device_get_video_stats(hd, &stats_cur);
 
         fprintf(stderr, "\n");
         fprintf(stderr, "-- Video statistics --\n");
-        fprintf(stderr, "%u packets received, %u overflow errors, %u network errors, %u transport errors, %u sequence errors\n",
-                (unsigned int)stats_cur.packet_count, 
-                (unsigned int)stats_cur.overflow_error_count,
-                (unsigned int)stats_cur.network_error_count, 
-                (unsigned int)stats_cur.transport_error_count, 
-                (unsigned int)stats_cur.sequence_error_count);
+        cmd_save_print_stats();
 
         return 0;
 }
@@ -440 +477 @@
                 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 +497 @@
                         return -1;
                 }
 
-                sleep(1);
+                msleep_minimum(1000);
         }
 
         printf("upgrade complete - now running firmware %s\n", version_str);

hdhomerun_video.c

@@ -1 +1 @@
 /*
  * hdhomerun_video.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
@@ -34 +34 @@
 
 struct hdhomerun_video_sock_t {
         pthread_mutex_t lock;
+        struct hdhomerun_debug_t *dbg;
+
+        hdhomerun_sock_t 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);
 }
 
+hdhomerun_sock_t hdhomerun_video_get_sock(struct hdhomerun_video_sock_t *vs)
+{
+        return vs->sock;
+}
+
 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 +208 @@
                 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 +232 @@
         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 +265 @@
                 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 +278 @@
                 }
 
                 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 +312 @@
                         continue;
                 }
 
-                /* Atomic update. */
                 vs->head = head;
 
                 pthread_mutex_unlock(&vs->lock);
@@ -291 +333 @@
                         tail -= vs->buffer_size;
                 }
         
-                /* Atomic update. */
                 vs->tail = tail;
         }
 
@@ -334 +375 @@
         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 +396 @@
         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
         );
 }
 

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
@@ -38 +38 @@
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <signal.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/timeb.h>
 #include <sys/wait.h>
-#include <sys/signal.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <pthread.h>
 
 typedef int bool_t;
+typedef void (*sig_t)(int);
 
 #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

hdhomerun_sock_windows.c

@@ +1 @@
+/*
+ * hdhomerun_sock_windows.c
+ *
+ * Copyright © 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
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * As a special exception to the GNU Lesser General Public License,
+ * you may link, statically or dynamically, an application with a
+ * publicly distributed version of the Library to produce an
+ * executable file containing portions of the Library, and
+ * distribute that executable file under terms of your choice,
+ * without any of the additional requirements listed in clause 4 of
+ * the GNU Lesser General Public License.
+ * 
+ * By "a publicly distributed version of the Library", we mean
+ * either the unmodified Library as distributed by Silicondust, or a
+ * modified version of the Library that is distributed under the
+ * conditions defined in the GNU Lesser General Public License.
+ */
+
+/*
+ * Implementation notes:
+ *
+ * API specifies timeout for each operation (or zero for non-blocking).
+ *
+ * It is not possible to rely on the OS socket timeout as this will fail to
+ * detect the command-response situation where data is sent successfully and
+ * the other end chooses not to send a response (other than the TCP ack).
+ *
+ * Windows supports select() however native WSA events are used to:
+ * - avoid problems with socket numbers above 1024.
+ * - wait without allowing other events handlers to run (important for use
+ *   with win7 WMC).
+ */
+
+#include "hdhomerun.h"
+
+hdhomerun_sock_t hdhomerun_sock_create_udp(void)
+{
+        /* Create socket. */
+        hdhomerun_sock_t sock = (hdhomerun_sock_t)socket(AF_INET, SOCK_DGRAM, 0);
+        if (sock == -1) {
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Set non-blocking */
+        unsigned long mode = 1;
+        if (ioctlsocket(sock, FIONBIO, &mode) != 0) {
+                closesocket(sock);
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Allow broadcast. */
+        int sock_opt = 1;
+        setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&sock_opt, sizeof(sock_opt));
+
+        /* Success. */
+        return sock;
+}
+
+hdhomerun_sock_t hdhomerun_sock_create_tcp(void)
+{
+        /* Create socket. */
+        hdhomerun_sock_t sock = (hdhomerun_sock_t)socket(AF_INET, SOCK_STREAM, 0);
+        if (sock == -1) {
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Set non-blocking */
+        unsigned long mode = 1;
+        if (ioctlsocket(sock, FIONBIO, &mode) != 0) {
+                closesocket(sock);
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Success. */
+        return sock;
+}
+
+void hdhomerun_sock_destroy(hdhomerun_sock_t sock)
+{
+        closesocket(sock);
+}
+
+int hdhomerun_sock_getlasterror(void)
+{
+        return WSAGetLastError();
+}
+
+uint32_t hdhomerun_sock_getsockname_addr(hdhomerun_sock_t sock)
+{
+        struct sockaddr_in sock_addr;
+        int sockaddr_size = sizeof(sock_addr);
+
+        if (getsockname(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) != 0) {
+                return 0;
+        }
+
+        return ntohl(sock_addr.sin_addr.s_addr);
+}
+
+uint16_t hdhomerun_sock_getsockname_port(hdhomerun_sock_t sock)
+{
+        struct sockaddr_in sock_addr;
+        int sockaddr_size = sizeof(sock_addr);
+
+        if (getsockname(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) != 0) {
+                return 0;
+        }
+
+        return ntohs(sock_addr.sin_port);
+}
+
+uint32_t hdhomerun_sock_getpeername_addr(hdhomerun_sock_t sock)
+{
+        struct sockaddr_in sock_addr;
+        int sockaddr_size = sizeof(sock_addr);
+
+        if (getpeername(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) != 0) {
+                return 0;
+        }
+
+        return ntohl(sock_addr.sin_addr.s_addr);
+}
+
+uint32_t hdhomerun_sock_getaddrinfo_addr(hdhomerun_sock_t sock, const char *name)
+{
+        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(name, "", &hints, &sock_info) != 0) {
+                return 0;
+        }
+
+        struct sockaddr_in *sock_addr = (struct sockaddr_in *)sock_info->ai_addr;
+        uint32_t addr = ntohl(sock_addr->sin_addr.s_addr);
+
+        freeaddrinfo(sock_info);
+        return addr;
+}
+
+bool_t hdhomerun_sock_bind(hdhomerun_sock_t sock, uint32_t local_addr, uint16_t local_port)
+{
+        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_addr);
+        sock_addr.sin_port = htons(local_port);
+
+        if (bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
+                return FALSE;
+        }
+
+        return TRUE;
+}
+
+bool_t hdhomerun_sock_connect(hdhomerun_sock_t sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout)
+{
+        WSAEVENT wsa_event = WSACreateEvent();
+        if (wsa_event == WSA_INVALID_EVENT) {
+                return FALSE;
+        }
+
+        if (WSAEventSelect(sock, wsa_event, FD_CONNECT) == SOCKET_ERROR) {
+                WSACloseEvent(wsa_event);
+                return FALSE;
+        }
+
+        /* Connect (non-blocking). */
+        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(remote_addr);
+        sock_addr.sin_port = htons(remote_port);
+
+        if (connect(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
+                if (WSAGetLastError() != WSAEWOULDBLOCK) {
+                        WSACloseEvent(wsa_event);
+                        return FALSE;
+                }
+        }
+
+        /* Wait for connect to complete (both success and failure will signal). */
+        DWORD ret = WaitForSingleObjectEx(wsa_event, (DWORD)timeout, FALSE);
+        WSACloseEvent(wsa_event);
+
+        if (ret != WAIT_OBJECT_0) {
+                return FALSE;
+        }
+
+        /* Detect success/failure. */
+        int sockaddr_size = sizeof(sock_addr);
+        if (getpeername(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) != 0) {
+                return FALSE;
+        }
+
+        return TRUE;
+}
+
+static bool_t hdhomerun_sock_wait_for_event(hdhomerun_sock_t sock, long event_type, uint64_t stop_time)
+{
+        uint64_t current_time = getcurrenttime();
+        if (current_time >= stop_time) {
+                return FALSE;
+        }
+
+        WSAEVENT wsa_event = WSACreateEvent();
+        if (wsa_event == WSA_INVALID_EVENT) {
+                return FALSE;
+        }
+
+        if (WSAEventSelect(sock, wsa_event, event_type) == SOCKET_ERROR) {
+                WSACloseEvent(wsa_event);
+                return FALSE;
+        }
+
+        DWORD ret = WaitForSingleObjectEx(wsa_event, (DWORD)(stop_time - current_time), FALSE);
+        WSACloseEvent(wsa_event);
+
+        if (ret != WAIT_OBJECT_0) {
+                return FALSE;
+        }
+
+        return TRUE;
+}
+
+bool_t hdhomerun_sock_send(hdhomerun_sock_t sock, const void *data, size_t length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+        const uint8_t *ptr = (uint8_t *)data;
+
+        while (1) {
+                int ret = send(sock, (char *)ptr, (int)length, 0);
+                if (ret >= (int)length) {
+                        return TRUE;
+                }
+
+                if (ret > 0) {
+                        ptr += ret;
+                        length -= ret;
+                }
+
+                if (WSAGetLastError() != WSAEWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_event(sock, FD_WRITE | FD_CLOSE, stop_time)) {
+                        return FALSE;
+                }
+        }
+}
+
+bool_t hdhomerun_sock_sendto(hdhomerun_sock_t sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+        const uint8_t *ptr = (uint8_t *)data;
+
+        while (1) {
+                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(remote_addr);
+                sock_addr.sin_port = htons(remote_port);
+
+                int ret = sendto(sock, (char *)ptr, (int)length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
+                if (ret >= (int)length) {
+                        return TRUE;
+                }
+
+                if (ret > 0) {
+                        ptr += ret;
+                        length -= ret;
+                }
+
+                if (WSAGetLastError() != WSAEWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_event(sock, FD_WRITE | FD_CLOSE, stop_time)) {
+                        return FALSE;
+                }
+        }
+}
+
+bool_t hdhomerun_sock_recv(hdhomerun_sock_t sock, void *data, size_t *length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+
+        while (1) {
+                int ret = recv(sock, (char *)data, (int)(*length), 0);
+                if (ret > 0) {
+                        *length = ret;
+                        return TRUE;
+                }
+
+                if (WSAGetLastError() != WSAEWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_event(sock, FD_READ | FD_CLOSE, stop_time)) {
+                        return FALSE;
+                }
+        }
+}
+
+bool_t hdhomerun_sock_recvfrom(hdhomerun_sock_t sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+
+        while (1) {
+                struct sockaddr_in sock_addr;
+                memset(&sock_addr, 0, sizeof(sock_addr));
+                int sockaddr_size = sizeof(sock_addr);
+
+                int ret = recvfrom(sock, (char *)data, (int)(*length), 0, (struct sockaddr *)&sock_addr, &sockaddr_size);
+                if (ret > 0) {
+                        *remote_addr = ntohl(sock_addr.sin_addr.s_addr);
+                        *remote_port = ntohs(sock_addr.sin_port);
+                        *length = ret;
+                        return TRUE;
+                }
+
+                if (WSAGetLastError() != WSAEWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_event(sock, FD_READ | FD_CLOSE, stop_time)) {
+                        return FALSE;
+                }
+        }
+}

hdhomerun_video.h

@@ -1 +1 @@
 /*
  * hdhomerun_video.h
  *
- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006 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
@@ -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.
@@ -100 +106 @@
 extern LIBTYPE void hdhomerun_video_debug_print_stats(struct hdhomerun_video_sock_t *vs);
 extern LIBTYPE void hdhomerun_video_get_stats(struct hdhomerun_video_sock_t *vs, struct hdhomerun_video_stats_t *stats);
 
+/*
+ * Internal use only.
+ */
+extern LIBTYPE hdhomerun_sock_t hdhomerun_video_get_sock(struct hdhomerun_video_sock_t *vs);
+
 #ifdef __cplusplus
 }
 #endif

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. */

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);
+}

hdhomerun_dhcp.c

@@ -1 @@
-/*
- * hdhomerun_dhcp.c
- *
- * Copyright © 2006-2007 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
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
- * 
- * As a special exception to the GNU Lesser General Public License,
- * you may link, statically or dynamically, an application with a
- * publicly distributed version of the Library to produce an
- * executable file containing portions of the Library, and
- * distribute that executable file under terms of your choice,
- * without any of the additional requirements listed in clause 4 of
- * the GNU Lesser General Public License.
- * 
- * By "a publicly distributed version of the Library", we mean
- * either the unmodified Library as distributed by Silicondust, or a
- * modified version of the Library that is distributed under the
- * conditions defined in the GNU Lesser General Public License.
- */
-
-#include "hdhomerun.h"
-#include "hdhomerun_dhcp.h"
-
-struct dhcp_hdr_t {
-        uint8_t bootp_message_type;
-        uint8_t hardware_type;
-        uint8_t hardware_address_length;
-        uint8_t hops;
-        uint32_t transaction_id;
-        uint16_t seconds_elapsed;
-        uint16_t bootp_flags;
-        uint32_t client_ip;
-        uint32_t your_ip;
-        uint32_t next_server_ip;
-        uint32_t relay_agent_ip;
-        uint8_t client_mac[16];
-        uint8_t server_host_name[64];
-        uint8_t boot_file_name[128];
-        uint32_t magic_cookie;
-};
-
-struct hdhomerun_dhcp_t {
-        int sock;
-        uint32_t local_address;
-        pthread_t thread;
-        volatile bool_t terminate;
-};
-
-static THREAD_FUNC_PREFIX hdhomerun_dhcp_thread_execute(void *arg);
-
-struct hdhomerun_dhcp_t *hdhomerun_dhcp_create(uint32_t bind_address)
-{
-        if (bind_address != 0) {
-                if ((bind_address & 0xFFFF0000) != 0xA9FE0000) {
-                        return NULL;
-                }
-        }
-
-        /* Create socket. */
-        int sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
-        if (sock == -1) {
-                return NULL;
-        }
-
-        /* Set timeout. */
-        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));
-
-        /* Allow reuse. */
-        sock_opt = 1;
-        setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (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(bind_address);
-        sock_addr.sin_port = htons(67);
-        if (bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
-                close(sock);
-                return NULL;
-        }
-
-        /* Allocate object. */
-        struct hdhomerun_dhcp_t *dhcp = (struct hdhomerun_dhcp_t *)calloc(1, sizeof(struct hdhomerun_dhcp_t));
-        if (!dhcp) {
-                close(sock);
-                return NULL;
-        }
-
-        dhcp->sock = sock;
-
-        if (bind_address != 0) {
-                dhcp->local_address = bind_address;
-        } else {
-                dhcp->local_address = 0xA9FEFFFF;
-        }
-
-        /* Spawn thread. */
-        if (pthread_create(&dhcp->thread, NULL, &hdhomerun_dhcp_thread_execute, dhcp) != 0) {
-                close(sock);
-                free(dhcp);
-                return NULL;
-        }
-
-        /* Success. */
-        return dhcp;
-}
-
-void hdhomerun_dhcp_destroy(struct hdhomerun_dhcp_t *dhcp)
-{
-        dhcp->terminate = TRUE;
-        pthread_join(dhcp->thread, NULL);
-
-        close(dhcp->sock);
-        free(dhcp);
-}
-
-static void hdhomerun_dhcp_send(struct hdhomerun_dhcp_t *dhcp, uint8_t message_type, struct hdhomerun_pkt_t *pkt)
-{
-        pkt->pos = pkt->start;
-        struct dhcp_hdr_t *hdr = (struct dhcp_hdr_t *)pkt->pos;
-        pkt->pos += sizeof(struct dhcp_hdr_t);
-        pkt->end = pkt->pos;
-
-        uint32_t remote_addr = 0xA9FE0000;
-        remote_addr |= (uint32_t)hdr->client_mac[4] << 8;
-        remote_addr |= (uint32_t)hdr->client_mac[5] << 0;
-        if ((remote_addr == 0xA9FE0000) || (remote_addr == 0xA9FEFFFF)) {
-                remote_addr = 0xA9FE8080;
-        }
-
-        hdr->bootp_message_type = 0x02;
-        hdr->your_ip = htonl(remote_addr);
-        hdr->next_server_ip = htonl(0x00000000);
-
-        hdhomerun_pkt_write_u8(pkt, 53);
-        hdhomerun_pkt_write_u8(pkt, 1);
-        hdhomerun_pkt_write_u8(pkt, message_type);
-
-        hdhomerun_pkt_write_u8(pkt, 54);
-        hdhomerun_pkt_write_u8(pkt, 4);
-        hdhomerun_pkt_write_u32(pkt, dhcp->local_address);
-
-        hdhomerun_pkt_write_u8(pkt, 51);
-        hdhomerun_pkt_write_u8(pkt, 4);
-        hdhomerun_pkt_write_u32(pkt, 7*24*60*60);
-
-        hdhomerun_pkt_write_u8(pkt, 1);
-        hdhomerun_pkt_write_u8(pkt, 4);
-        hdhomerun_pkt_write_u32(pkt, 0xFFFF0000);
-
-        hdhomerun_pkt_write_u8(pkt, 0xFF);
-
-        while (pkt->pos < pkt->start + 300) {
-                hdhomerun_pkt_write_u8(pkt, 0x00);
-        }
-
-        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(0xFFFFFFFF);
-        sock_addr.sin_port = htons(68);
-
-        sendto(dhcp->sock, (char *)pkt->start, (int)(pkt->end - pkt->start), 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
-}
-
-static void hdhomerun_dhcp_recv(struct hdhomerun_dhcp_t *dhcp, struct hdhomerun_pkt_t *pkt)
-{
-        pkt->pos = pkt->start;
-        struct dhcp_hdr_t *hdr = (struct dhcp_hdr_t *)pkt->pos;
-        pkt->pos += sizeof(struct dhcp_hdr_t);
-        if (pkt->pos > pkt->end) {
-                return;
-        }
-
-        if (ntohl(hdr->magic_cookie) != 0x63825363) {
-                return;
-        }
-
-        static uint8_t vendor[3] = {0x00, 0x18, 0xDD};
-        if (memcmp(hdr->client_mac, vendor, 3) != 0) {
-                return;
-        }
-
-        if (pkt->pos + 3 > pkt->end) {
-                return;
-        }
-        if (hdhomerun_pkt_read_u8(pkt) != 53) {
-                return;
-        }
-        if (hdhomerun_pkt_read_u8(pkt) != 1) {
-                return;
-        }
-        uint8_t message_type_val = hdhomerun_pkt_read_u8(pkt);
-
-        switch (message_type_val) {
-        case 0x01:
-                hdhomerun_dhcp_send(dhcp, 0x02, pkt);
-                break;
-        case 0x03:
-                hdhomerun_dhcp_send(dhcp, 0x05, pkt);
-                break;
-        default:
-                return;
-        }
-}
-
-static THREAD_FUNC_PREFIX hdhomerun_dhcp_thread_execute(void *arg)
-{
-        struct hdhomerun_dhcp_t *dhcp = (struct hdhomerun_dhcp_t *)arg;
-        struct hdhomerun_pkt_t pkt_inst;
-
-        while (1) {
-                if (dhcp->terminate) {
-                        return NULL;
-                }
-
-                struct hdhomerun_pkt_t *pkt = &pkt_inst;
-                hdhomerun_pkt_reset(pkt);
-
-                int rx_length = recv(dhcp->sock, (char *)pkt->end, (int)(pkt->limit - pkt->end), 0);
-                if (rx_length <= 0) {
-                        if (!sock_getlasterror_socktimeout) {
-#if defined(__WINDOWS__)
-                               msleep(1000);
-#else
-                               sleep(1);
-#endif
-                        }
-                        continue;
-                }
-                pkt->end += rx_length;
-
-                hdhomerun_dhcp_recv(dhcp, pkt);
-        }
-}

hdhomerun_channelscan.h

@@ -1 +1 @@
 /*
  * hdhomerun_channelscan.h
  *
- * Copyright © 2007-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2007-2008 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

hdhomerun_discover.h

@@ -1 +1 @@
 /*
  * hdhomerun_discover.h
  *
- * Copyright © 2006-2007 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2007 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 @@
  *
  * 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 target_ip to zero to auto-detect the 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

hdhomerun_dhcp.h

@@ -1 @@
-/*
- * hdhomerun_dhcp.h
- *
- * Copyright © 2006 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
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
- * 
- * As a special exception to the GNU Lesser General Public License,
- * you may link, statically or dynamically, an application with a
- * publicly distributed version of the Library to produce an
- * executable file containing portions of the Library, and
- * distribute that executable file under terms of your choice,
- * without any of the additional requirements listed in clause 4 of
- * the GNU Lesser General Public License.
- * 
- * By "a publicly distributed version of the Library", we mean
- * either the unmodified Library as distributed by Silicondust, or a
- * modified version of the Library that is distributed under the
- * conditions defined in the GNU Lesser General Public License.
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-struct hdhomerun_dhcp_t;
-
-extern LIBTYPE struct hdhomerun_dhcp_t *hdhomerun_dhcp_create(uint32_t bind_address);
-extern LIBTYPE void hdhomerun_dhcp_destroy(struct hdhomerun_dhcp_t *dhcp);
-
-#ifdef __cplusplus
-}
-#endif

hdhomerun_os.h

@@ -1 +1 @@
 /*
  * hdhomerun_os.h
  *
- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2008 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

hdhomerun_os_windows.c

@@ +1 @@
+/*
+ * hdhomerun_os_windows.c
+ *
+ * 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
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * As a special exception to the GNU Lesser General Public License,
+ * you may link, statically or dynamically, an application with a
+ * publicly distributed version of the Library to produce an
+ * executable file containing portions of the Library, and
+ * distribute that executable file under terms of your choice,
+ * without any of the additional requirements listed in clause 4 of
+ * the GNU Lesser General Public License.
+ * 
+ * By "a publicly distributed version of the Library", we mean
+ * either the unmodified Library as distributed by Silicondust, or a
+ * modified version of the Library that is distributed under the
+ * conditions defined in the GNU Lesser General Public License.
+ */
+
+#include "hdhomerun_os.h"
+
+uint64_t getcurrenttime(void)
+{
+        static pthread_mutex_t lock = INVALID_HANDLE_VALUE;
+        static uint64_t result = 0;
+        static uint32_t previous_time = 0;
+
+        /* Initialization is not thread safe. */
+        if (lock == INVALID_HANDLE_VALUE) {
+                pthread_mutex_init(&lock, NULL);
+        }
+
+        pthread_mutex_lock(&lock);
+
+        uint32_t current_time = GetTickCount();
+
+        if (current_time > previous_time) {
+                result += current_time - previous_time;
+        }
+
+        previous_time = current_time;
+
+        pthread_mutex_unlock(&lock);
+        return result;
+}
+
+void msleep_approx(uint64_t ms)
+{
+        Sleep((DWORD)ms);
+}
+
+void msleep_minimum(uint64_t ms)
+{
+        uint64_t stop_time = getcurrenttime() + ms;
+
+        while (1) {
+                uint64_t current_time = getcurrenttime();
+                if (current_time >= stop_time) {
+                        return;
+                }
+
+                msleep_approx(stop_time - current_time);
+        }
+}
+
+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;
+}
+
+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;
+                }
+        }
+}
+
+void pthread_mutex_init(pthread_mutex_t *mutex, void *attr)
+{
+        *mutex = CreateMutex(NULL, FALSE, NULL);
+}
+
+void pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+        WaitForSingleObject(*mutex, INFINITE);
+}
+
+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.
+ */
+void console_vprintf(const char *fmt, va_list ap)
+{
+        UINT cp = GetConsoleOutputCP();
+        SetConsoleOutputCP(CP_UTF8);
+        vprintf(fmt, ap);
+        SetConsoleOutputCP(cp);
+}
+
+void console_printf(const char *fmt, ...)
+{
+        va_list ap;
+        va_start(ap, fmt);
+        console_vprintf(fmt, ap);
+        va_end(ap);
+}

hdhomerun_channels.c

@@ -1 +1 @@
 /*
  * hdhomerun_channels.c
  *
- * Copyright © 2007-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2007-2008 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
@@ -55 +55 @@
 };
 
 struct hdhomerun_channelmap_record_t {
-        const char *channelmap_prefix;
         const char *channelmap;
         const struct hdhomerun_channelmap_range_t *range_list;
         const char *channelmap_scan_group;
@@ -140 +139 @@
 };
 
 static const struct hdhomerun_channelmap_record_t hdhomerun_channelmap_table[] = {
-        {"au", "au-bcast", hdhomerun_channelmap_range_au_bcast, "au-bcast",               "AU"},
-        {"au", "au-cable", hdhomerun_channelmap_range_au_cable, "au-cable",               "AU"},
-        {"eu", "eu-bcast", hdhomerun_channelmap_range_eu_bcast, "eu-bcast",               "EU"},
-        {"eu", "eu-cable", hdhomerun_channelmap_range_eu_cable, "eu-cable",               "EU"},
-        {"tw", "tw-bcast", hdhomerun_channelmap_range_us_bcast, "tw-bcast",               "TW"},
-        {"tw", "tw-cable", hdhomerun_channelmap_range_us_cable, "tw-cable",               "TW"},
-        {"us", "us-bcast", hdhomerun_channelmap_range_us_bcast, "us-bcast",               "CA US"},
-        {"us", "us-cable", hdhomerun_channelmap_range_us_cable, "us-cable us-hrc us-irc", "CA US"},
-        {"us", "us-hrc",   hdhomerun_channelmap_range_us_hrc  , "us-cable us-hrc us-irc", "CA US"},
-        {"us", "us-irc",   hdhomerun_channelmap_range_us_irc,   "us-cable us-hrc us-irc", "CA US"},
-        {NULL, NULL,       NULL,                                NULL,                     NULL}
+        {"au-bcast", hdhomerun_channelmap_range_au_bcast, "au-bcast",               "AU"},
+        {"au-cable", hdhomerun_channelmap_range_au_cable, "au-cable",               "AU"},
+        {"eu-bcast", hdhomerun_channelmap_range_eu_bcast, "eu-bcast",               "EU PA"},
+        {"eu-cable", hdhomerun_channelmap_range_eu_cable, "eu-cable",               "EU"},
+        {"tw-bcast", hdhomerun_channelmap_range_us_bcast, "tw-bcast",               "TW"},
+        {"tw-cable", hdhomerun_channelmap_range_us_cable, "tw-cable",               "TW"},
+
+        {"us-bcast", hdhomerun_channelmap_range_us_bcast, "us-bcast",               "CA US"},
+        {"us-cable", hdhomerun_channelmap_range_us_cable, "us-cable us-hrc us-irc", "CA PA US"},
+        {"us-hrc",   hdhomerun_channelmap_range_us_hrc  , "us-cable us-hrc us-irc", "CA PA US"},
+        {"us-irc",   hdhomerun_channelmap_range_us_irc,   "us-cable us-hrc us-irc", "CA PA US"},
+
+        {NULL,       NULL,                                NULL,                     NULL}
 };
 
-const char *hdhomerun_channelmap_convert_countrycode_to_channelmap_prefix(const char *countrycode)
+const char *hdhomerun_channelmap_get_channelmap_from_country_source(const char *countrycode, const char *source)
 {
+        bool_t country_found = FALSE;
+
         const struct hdhomerun_channelmap_record_t *record = hdhomerun_channelmap_table;
         while (record->channelmap) {
-                if (strstr(record->countrycodes, countrycode)) {
-                        return record->channelmap_prefix;
+                if (!strstr(record->countrycodes, countrycode)) {
+                        record++;
+                        continue;
                 }
+
+                if (strstr(record->channelmap, source)) {
+                        return record->channelmap;
+                }
+
+                country_found = TRUE;
                 record++;
         }
 
-        return "eu";
+        if (!country_found) {
+                return hdhomerun_channelmap_get_channelmap_from_country_source("EU", source);
+        }
+
+        return NULL;
 }
 
 const char *hdhomerun_channelmap_get_channelmap_scan_group(const char *channelmap)

hdhomerun_pkt.c

@@ -1 +1 @@
 /*
  * hdhomerun_pkt.c
  *
- * Copyright © 2005-2006 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2005-2006 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

hdhomerun_device.c

@@ -1 +1 @@
 /*
  * hdhomerun_device.c
  *
- * 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
@@ -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) {
@@ -544 +695 @@
         return 1;
 }
 
+int hdhomerun_device_get_supported(struct hdhomerun_device_t *hd, char *prefix, char **pstr)
+{
+        if (!hd->cs) {
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_set_tuner_channel: device not set\n");
+                return -1;
+        }
+
+        char *features;
+        int ret = hdhomerun_control_get(hd->cs, "/sys/features", &features, NULL);
+        if (ret <= 0) {
+                return ret;
+        }
+
+        if (!prefix) {
+                *pstr = features;
+                return 1;
+        }
+
+        char *ptr = strstr(features, prefix);
+        if (!ptr) {
+                return 0;
+        }
+
+        ptr += strlen(prefix);
+        *pstr = ptr;
+
+        ptr = strchr(ptr, '\n');
+        if (ptr) {
+                *ptr = 0;
+        }
+
+        return 1;
+}
+
 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 +743 @@
 
 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 +755 @@
 
 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 +835 @@
 
 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 +847 @@
 
 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 +882 @@
         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 +962 @@
 
 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 +984 @@
 
 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 +1002 @@
 
 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 +1034 @@
                         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 +1111 @@
 
         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 +1121 @@
 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 +1137 @@
 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 +1153 @@
 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) {
@@ -896 +1179 @@
         if (ret == 0) {
                 strncpy(hd->model, "hdhomerun_atsc", sizeof(hd->model) - 1);
                 hd->model[sizeof(hd->model) - 1] = 0;
+                return hd->model;
         }
-        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 +1209 @@
                 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 +1235 @@
 
 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);
 }

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;
         }

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;
@@ -64 +61 @@
 typedef unsigned __int16 uint16_t;
 typedef unsigned __int32 uint32_t;
 typedef unsigned __int64 uint64_t;
+typedef void (*sig_t)(int);
 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
@@ -84 +73 @@
 #define fseeko _fseeki64
 #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

hdhomerun_channels.h

@@ -1 +1 @@
 /*
  * hdhomerun_channels.h
  *
- * Copyright © 2007-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2007-2008 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
@@ -37 +37 @@
 struct hdhomerun_channel_entry_t;
 struct hdhomerun_channel_list_t;
 
-extern LIBTYPE const char *hdhomerun_channelmap_convert_countrycode_to_channelmap_prefix(const char *countrycode);
+extern LIBTYPE const char *hdhomerun_channelmap_get_channelmap_from_country_source(const char *countrycode, const char *source);
 extern LIBTYPE const char *hdhomerun_channelmap_get_channelmap_scan_group(const char *channelmap);
 
 extern LIBTYPE uint8_t hdhomerun_channel_entry_channel_number(struct hdhomerun_channel_entry_t *entry);

hdhomerun_pkt.h

@@ -1 +1 @@
 /*
  * hdhomerun_pkt.h
  *
- * Copyright © 2005-2006 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2005-2006 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

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
 
 /*

hdhomerun_device.h

@@ -1 +1 @@
 /*
  * hdhomerun_device.h
  *
- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2006-2008 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
@@ -51 +51 @@
  * GUI feedback to the user of the selected tuner might use 5 device objects: 4 for streaming video
  * (one per thread) and one for the GUI display that can switch between tuners.
  *
- * This function will not attempt to connect to the device.
- * The connection will be established when first used.
+ * This function will not attempt to connect to the device. The connection will be established when first used.
  *
  * uint32_t device_id = 32-bit device id of device. Set to HDHOMERUN_DEVICE_ID_WILDCARD to match any device ID.
  * uint32_t device_ip = IP address of device. Set to 0 to auto-detect.
@@ -68 +67 @@
  *     <device id>
  *     <device id>-<tuner index>
  *     <ip address>
- * If the tuner index is not included in the device_str then it is set to zero.
- * Use hdhomerun_device_set_tuner or hdhomerun_device_set_tuner_from_str to set the tuner.
+ * If the tuner index is not included in the device_str then it is set to zero. Use hdhomerun_device_set_tuner
+ * or hdhomerun_device_set_tuner_from_str to set the tuner.
  *
  * The hdhomerun_device_set_tuner_from_str function sets the tuner from the given tuner_str.
  * The tuner_str parameter can be any of the following forms:
@@ -90 +89 @@
 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);
 
 /*
@@ -126 +125 @@
 extern LIBTYPE int hdhomerun_device_get_ir_target(struct hdhomerun_device_t *hd, char **ptarget);
 extern LIBTYPE int hdhomerun_device_get_lineup_location(struct hdhomerun_device_t *hd, char **plocation);
 extern LIBTYPE int hdhomerun_device_get_version(struct hdhomerun_device_t *hd, char **pversion_str, uint32_t *pversion_num);
+extern LIBTYPE int hdhomerun_device_get_supported(struct hdhomerun_device_t *hd, char *prefix, char **pstr);
 
 extern LIBTYPE uint32_t hdhomerun_device_get_tuner_status_ss_color(struct hdhomerun_tuner_status_t *status);
 extern LIBTYPE uint32_t hdhomerun_device_get_tuner_status_snq_color(struct hdhomerun_tuner_status_t *status);
@@ -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.
@@ -219 +218 @@
  * Returns -1 if a communication error occurs.
  *
  * The hdhomerun_device_stream_recv function should be called periodically to receive the stream data.
- * The buffer can losslessly store 1 second of data, however a more typical call rate would be every 64ms.
+ * The buffer can losslessly store 1 second of data, however a more typical call rate would be every 15ms.
  *
  * 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.

hdhomerun_types.h

@@ -1 +1 @@
 /*
  * hdhomerun_types.h
  *
- * Copyright © 2008-2009 Silicondust USA Inc. <www.silicondust.com>.
+ * Copyright © 2008-2009 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

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 {
@@ -41 +42 @@
         uint32_t desired_device_ip;
         uint32_t actual_device_id;
         uint32_t actual_device_ip;
-        int sock;
+        hdhomerun_sock_t sock;
         struct hdhomerun_debug_t *dbg;
         struct hdhomerun_pkt_t tx_pkt;
         struct hdhomerun_pkt_t rx_pkt;
@@ -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) {

hdhomerun_sock_posix.c

@@ +1 @@
+/*
+ * hdhomerun_sock_posix.c
+ *
+ * Copyright © 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
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * As a special exception to the GNU Lesser General Public License,
+ * you may link, statically or dynamically, an application with a
+ * publicly distributed version of the Library to produce an
+ * executable file containing portions of the Library, and
+ * distribute that executable file under terms of your choice,
+ * without any of the additional requirements listed in clause 4 of
+ * the GNU Lesser General Public License.
+ * 
+ * By "a publicly distributed version of the Library", we mean
+ * either the unmodified Library as distributed by Silicondust, or a
+ * modified version of the Library that is distributed under the
+ * conditions defined in the GNU Lesser General Public License.
+ */
+
+/*
+ * Implementation notes:
+ *
+ * API specifies timeout for each operation (or zero for non-blocking).
+ *
+ * It is not possible to rely on the OS socket timeout as this will fail to
+ * detect the command-response situation where data is sent successfully and
+ * the other end chooses not to send a response (other than the TCP ack).
+ *
+ * The select() cannot be used with high socket numbers (typically max 1024)
+ * so the code works as follows:
+ * - Use non-blocking sockets to allow operation without select.
+ * - Use select where safe (low socket numbers).
+ * - Poll with short sleep when select cannot be used safely.
+ */
+
+#include "hdhomerun.h"
+
+hdhomerun_sock_t hdhomerun_sock_create_udp(void)
+{
+        /* Create socket. */
+        hdhomerun_sock_t sock = (hdhomerun_sock_t)socket(AF_INET, SOCK_DGRAM, 0);
+        if (sock == -1) {
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Set non-blocking */
+        if (fcntl(sock, F_SETFL, O_NONBLOCK) != 0) {
+                close(sock);
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Allow broadcast. */
+        int sock_opt = 1;
+        setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&sock_opt, sizeof(sock_opt));
+
+        /* Success. */
+        return sock;
+}
+
+hdhomerun_sock_t hdhomerun_sock_create_tcp(void)
+{
+        /* Create socket. */
+        hdhomerun_sock_t sock = (hdhomerun_sock_t)socket(AF_INET, SOCK_STREAM, 0);
+        if (sock == -1) {
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Set non-blocking */
+        if (fcntl(sock, F_SETFL, O_NONBLOCK) != 0) {
+                close(sock);
+                return HDHOMERUN_SOCK_INVALID;
+        }
+
+        /* Success. */
+        return sock;
+}
+
+void hdhomerun_sock_destroy(hdhomerun_sock_t sock)
+{
+        close(sock);
+}
+
+int hdhomerun_sock_getlasterror(void)
+{
+        return errno;
+}
+
+uint32_t hdhomerun_sock_getsockname_addr(hdhomerun_sock_t sock)
+{
+        struct sockaddr_in sock_addr;
+        socklen_t sockaddr_size = sizeof(sock_addr);
+
+        if (getsockname(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) != 0) {
+                return 0;
+        }
+
+        return ntohl(sock_addr.sin_addr.s_addr);
+}
+
+uint16_t hdhomerun_sock_getsockname_port(hdhomerun_sock_t sock)
+{
+        struct sockaddr_in sock_addr;
+        socklen_t sockaddr_size = sizeof(sock_addr);
+
+        if (getsockname(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) != 0) {
+                return 0;
+        }
+
+        return ntohs(sock_addr.sin_port);
+}
+
+uint32_t hdhomerun_sock_getpeername_addr(hdhomerun_sock_t sock)
+{
+        struct sockaddr_in sock_addr;
+        socklen_t sockaddr_size = sizeof(sock_addr);
+
+        if (getpeername(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) != 0) {
+                return 0;
+        }
+
+        return ntohl(sock_addr.sin_addr.s_addr);
+}
+
+#if defined(__CYGWIN__)
+uint32_t hdhomerun_sock_getaddrinfo_addr(hdhomerun_sock_t sock, const char *name)
+{
+        return 0;
+}
+#else
+uint32_t hdhomerun_sock_getaddrinfo_addr(hdhomerun_sock_t sock, const char *name)
+{
+        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(name, "", &hints, &sock_info) != 0) {
+                return 0;
+        }
+
+        struct sockaddr_in *sock_addr = (struct sockaddr_in *)sock_info->ai_addr;
+        uint32_t addr = ntohl(sock_addr->sin_addr.s_addr);
+
+        freeaddrinfo(sock_info);
+        return addr;
+}
+#endif
+
+bool_t hdhomerun_sock_bind(hdhomerun_sock_t sock, uint32_t local_addr, uint16_t local_port)
+{
+        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_addr);
+        sock_addr.sin_port = htons(local_port);
+
+        if (bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
+                return FALSE;
+        }
+
+        return TRUE;
+}
+
+static bool_t hdhomerun_sock_wait_for_read_event(hdhomerun_sock_t sock, uint64_t stop_time)
+{
+        uint64_t current_time = getcurrenttime();
+        if (current_time >= stop_time) {
+                return FALSE;
+        }
+
+        if (sock < FD_SETSIZE) {
+                uint64_t timeout = stop_time - current_time;
+                struct timeval t;
+                t.tv_sec = timeout / 1000;
+                t.tv_usec = (timeout % 1000) * 1000;
+
+                fd_set readfds;
+                FD_ZERO(&readfds);
+                FD_SET(sock, &readfds);
+
+                fd_set errorfds;
+                FD_ZERO(&errorfds);
+                FD_SET(sock, &errorfds);
+
+                if (select(sock + 1, &readfds, NULL, &errorfds, &t) <= 0) {
+                        return FALSE;
+                }
+                if (!FD_ISSET(sock, &readfds)) {
+                        return FALSE;
+                }
+        } else {
+                uint64_t delay = stop_time - current_time;
+                if (delay > 5) {
+                        delay = 5;
+                }
+
+                msleep_approx(delay);
+        }
+
+        return TRUE;
+}
+
+static bool_t hdhomerun_sock_wait_for_write_event(hdhomerun_sock_t sock, uint64_t stop_time)
+{
+        uint64_t current_time = getcurrenttime();
+        if (current_time >= stop_time) {
+                return FALSE;
+        }
+
+        if (sock < FD_SETSIZE) {
+                uint64_t timeout = stop_time - current_time;
+                struct timeval t;
+                t.tv_sec = timeout / 1000;
+                t.tv_usec = (timeout % 1000) * 1000;
+
+                fd_set writefds;
+                FD_ZERO(&writefds);
+                FD_SET(sock, &writefds);
+
+                fd_set errorfds;
+                FD_ZERO(&errorfds);
+                FD_SET(sock, &errorfds);
+
+                if (select(sock + 1, NULL, &writefds, &errorfds, &t) <= 0) {
+                        return FALSE;
+                }
+                if (!FD_ISSET(sock, &writefds)) {
+                        return FALSE;
+                }
+        } else {
+                uint64_t delay = stop_time - current_time;
+                if (delay > 5) {
+                        delay = 5;
+                }
+
+                msleep_approx(delay);
+        }
+
+        return TRUE;
+}
+
+bool_t hdhomerun_sock_connect(hdhomerun_sock_t sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout)
+{
+        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(remote_addr);
+        sock_addr.sin_port = htons(remote_port);
+
+        if (connect(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) == 0) {
+                return TRUE;
+        }
+
+        uint64_t stop_time = getcurrenttime() + timeout;
+
+        /*
+         * getpeername() is used to detect if connect succeeded. Bug - cygwin
+         * will return getpeername success even if the connect process hasn't
+         * completed. This first call to select is used to work around the
+         * problem (at least for low numbered sockets where select is used).
+         */
+        if (!hdhomerun_sock_wait_for_write_event(sock, stop_time)) {
+                return FALSE;
+        }
+
+        while (1) {
+                struct sockaddr_in sock_addr;
+                socklen_t sockaddr_size = sizeof(sock_addr);
+                if (getpeername(sock, (struct sockaddr *)&sock_addr, &sockaddr_size) == 0) {
+                        return TRUE;
+                }
+
+                if (errno != ENOTCONN) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_write_event(sock, stop_time)) {
+                        return FALSE;
+                }
+        }
+}
+
+bool_t hdhomerun_sock_send(hdhomerun_sock_t sock, const void *data, size_t length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+        const uint8_t *ptr = (const uint8_t *)data;
+
+        while (1) {
+                int ret = send(sock, ptr, length, 0);
+                if (ret >= (int)length) {
+                        return TRUE;
+                }
+
+                if (ret > 0) {
+                        ptr += ret;
+                        length -= ret;
+                }
+
+                if (errno == EINPROGRESS) {
+                        errno = EWOULDBLOCK;
+                }
+                if (errno != EWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_write_event(sock, stop_time)) {
+                        return FALSE;
+                }
+        }
+}
+
+bool_t hdhomerun_sock_sendto(hdhomerun_sock_t sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+        const uint8_t *ptr = (const uint8_t *)data;
+
+        while (1) {
+                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(remote_addr);
+                sock_addr.sin_port = htons(remote_port);
+
+                int ret = sendto(sock, ptr, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
+                if (ret >= (int)length) {
+                        return TRUE;
+                }
+
+                if (ret > 0) {
+                        ptr += ret;
+                        length -= ret;
+                }
+
+                if (errno == EINPROGRESS) {
+                        errno = EWOULDBLOCK;
+                }
+                if (errno != EWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_write_event(sock, stop_time)) {
+                        return FALSE;
+                }
+        }
+}
+
+bool_t hdhomerun_sock_recv(hdhomerun_sock_t sock, void *data, size_t *length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+
+        while (1) {
+                int ret = recv(sock, data, *length, 0);
+                if (ret > 0) {
+                        *length = ret;
+                        return TRUE;
+                }
+
+                if (errno == EINPROGRESS) {
+                        errno = EWOULDBLOCK;
+                }
+                if (errno != EWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_read_event(sock, stop_time)) {
+                        return FALSE;
+                }
+        }
+}
+
+bool_t hdhomerun_sock_recvfrom(hdhomerun_sock_t sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout)
+{
+        uint64_t stop_time = getcurrenttime() + timeout;
+
+        while (1) {
+                struct sockaddr_in sock_addr;
+                memset(&sock_addr, 0, sizeof(sock_addr));
+                socklen_t sockaddr_size = sizeof(sock_addr);
+
+                int ret = recvfrom(sock, data, *length, 0, (struct sockaddr *)&sock_addr, &sockaddr_size);
+                if (ret > 0) {
+                        *remote_addr = ntohl(sock_addr.sin_addr.s_addr);
+                        *remote_port = ntohs(sock_addr.sin_port);
+                        *length = ret;
+                        return TRUE;
+                }
+
+                if (errno == EINPROGRESS) {
+                        errno = EWOULDBLOCK;
+                }
+                if (errno != EWOULDBLOCK) {
+                        return FALSE;
+                }
+
+                if (!hdhomerun_sock_wait_for_read_event(sock, stop_time)) {
+                        return FALSE;
+                }
+        }
+}