hdhomerun_device_selector.c

Go to the documentation of this file.

/*
 * hdhomerun_device_selector.c
 *
 * 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
 * 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"

struct hdhomerun_device_selector_t {
        struct hdhomerun_device_t **hd_list;
        size_t hd_count;
        struct hdhomerun_debug_t *dbg;
};

struct hdhomerun_device_selector_t *hdhomerun_device_selector_create(struct hdhomerun_debug_t *dbg)
{
        struct hdhomerun_device_selector_t *hds = (struct hdhomerun_device_selector_t *)calloc(1, sizeof(struct hdhomerun_device_selector_t));
        if (!hds) {
                hdhomerun_debug_printf(dbg, "hdhomerun_device_selector_create: failed to allocate selector object\n");
                return NULL;
        }

        hds->dbg = dbg;

        return hds;
}

void hdhomerun_device_selector_destroy(struct hdhomerun_device_selector_t *hds, bool_t destroy_devices)
{
        if (destroy_devices) {
                size_t index;
                for (index = 0; index < hds->hd_count; index++) {
                        struct hdhomerun_device_t *entry = hds->hd_list[index];
                        hdhomerun_device_destroy(entry);
                }
        }

        if (hds->hd_list) {
                free(hds->hd_list);
        }

        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;
        for (index = 0; index < hds->hd_count; index++) {
                struct hdhomerun_device_t *entry = hds->hd_list[index];
                if (entry == hd) {
                        return;
                }
        }

        hds->hd_list = (struct hdhomerun_device_t **)realloc(hds->hd_list, (hds->hd_count + 1) * sizeof(struct hdhomerun_device_selector_t *));
        if (!hds->hd_list) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_add_device: failed to allocate device list\n");
                return;
        }

        hds->hd_list[hds->hd_count++] = hd;
}

void hdhomerun_device_selector_remove_device(struct hdhomerun_device_selector_t *hds, struct hdhomerun_device_t *hd)
{
        size_t index = 0;
        while (1) {
                if (index >= hds->hd_count) {
                        return;
                }

                struct hdhomerun_device_t *entry = hds->hd_list[index];
                if (entry == hd) {
                        break;
                }

                index++;
        }

        while (index + 1 < hds->hd_count) {
                hds->hd_list[index] = hds->hd_list[index + 1];
                index++;
        }

        hds->hd_list[index] = NULL;
        hds->hd_count--;
}

struct hdhomerun_device_t *hdhomerun_device_selector_find_device(struct hdhomerun_device_selector_t *hds, uint32_t device_id, unsigned int tuner_index)
{
        size_t index;
        for (index = 0; index < hds->hd_count; index++) {
                struct hdhomerun_device_t *entry = hds->hd_list[index];
                if (hdhomerun_device_get_device_id(entry) != device_id) {
                        continue;
                }
                if (hdhomerun_device_get_tuner(entry) != tuner_index) {
                        continue;
                }
                return entry;
        }

        return NULL;
}

int hdhomerun_device_selector_load_from_file(struct hdhomerun_device_selector_t *hds, char *filename)
{
        FILE *fp = fopen(filename, "r");
        if (!fp) {
                return 0;
        }

        while(1) {
                char device_name[32];
                if (!fgets(device_name, sizeof(device_name), fp)) {
                        break;
                }

                struct hdhomerun_device_t *hd = hdhomerun_device_create_from_str(device_name, hds->dbg);
                if (!hd) {
                        continue;
                }

                hdhomerun_device_selector_add_device(hds, hd);
        }

        fclose(fp);
        return (int)hds->hd_count;
}

#if defined(__WINDOWS__)
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", (long)ret);
                return 0;
        }

        DWORD index = 0;
        while (1) {
                /* Next tuner device. */
                wchar_t wdevice_name[32];
                DWORD size = sizeof(wdevice_name);
                ret = RegEnumKeyEx(tuners_key, index++, wdevice_name, &size, NULL, NULL, NULL, NULL);
                if (ret != ERROR_SUCCESS) {
                        break;
                }

                /* Check device configuation. */
                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, (long)ret);
                        continue;
                }

                wchar_t wsource_test[32];
                size = sizeof(wsource_test);
                if (RegQueryValueEx(device_key, L"Source", NULL, NULL, (LPBYTE)&wsource_test, &size) != ERROR_SUCCESS) {
                        wsprintf(wsource_test, L"Unknown");
                }

                RegCloseKey(device_key);

                if (_wcsicmp(wsource_test, wsource) != 0) {
                        continue;
                }

                /* Create and add device. */
                char device_name[32];
                sprintf(device_name, "%S", wdevice_name);

                struct hdhomerun_device_t *hd = hdhomerun_device_create_from_str(device_name, hds->dbg);
                if (!hd) {
                        hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_load_from_windows_registry: invalid device name '%s' / failed to create device object\n", device_name);
                        continue;
                }

                hdhomerun_device_selector_add_device(hds, hd);
        }

        RegCloseKey(tuners_key);
        return (int)hds->hd_count;
}
#endif

static bool_t hdhomerun_device_selector_choose_test(struct hdhomerun_device_selector_t *hds, struct hdhomerun_device_t *test_hd)
{
        const char *name = hdhomerun_device_get_name(test_hd);

        /*
         * Attempt to aquire lock.
         */
        char *error;
        int ret = hdhomerun_device_tuner_lockkey_request(test_hd, &error);
        if (ret > 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name);
                return TRUE;
        }
        if (ret < 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
                return FALSE;
        }

        /*
         * In use - check target.
         */
        char *target;
        ret = hdhomerun_device_get_tuner_target(test_hd, &target);
        if (ret < 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
                return FALSE;
        }
        if (ret == 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, failed to read target\n", name);
                return FALSE;
        }

        char *ptr = strstr(target, "//");
        if (ptr) {
                target = ptr + 2;
        }
        ptr = strchr(target, ' ');
        if (ptr) {
                *ptr = 0;
        }

        unsigned long a[4];
        unsigned long target_port;
        if (sscanf(target, "%lu.%lu.%lu.%lu:%lu", &a[0], &a[1], &a[2], &a[3], &target_port) != 5) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, no target set (%s)\n", name, target);
                return FALSE;
        }

        uint32_t target_ip = (uint32_t)((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0));
        uint32_t local_ip = hdhomerun_device_get_local_machine_addr(test_hd);
        if (target_ip != local_ip) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by %s\n", name, target);
                return FALSE;
        }

        /*
         * Test local port.
         */
        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;
        }

        bool_t inuse = (hdhomerun_sock_bind(test_sock, INADDR_ANY, (uint16_t)target_port, FALSE) == FALSE);
        hdhomerun_sock_destroy(test_sock);

        if (inuse) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by local machine\n", name);
                return FALSE;
        }

        /*
         * Dead local target, force clear lock.
         */
        ret = hdhomerun_device_tuner_lockkey_force(test_hd);
        if (ret < 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
                return FALSE;
        }
        if (ret == 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by local machine, dead target, failed to force release lockkey\n", name);
                return FALSE;
        }

        hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by local machine, dead target, lockkey force successful\n", name);

        /*
         * Attempt to aquire lock.
         */
        ret = hdhomerun_device_tuner_lockkey_request(test_hd, &error);
        if (ret > 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name);
                return TRUE;
        }
        if (ret < 0) {
                hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
                return FALSE;
        }

        hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s still in use after lockkey force (%s)\n", name, error);
        return FALSE;
}

struct hdhomerun_device_t *hdhomerun_device_selector_choose_and_lock(struct hdhomerun_device_selector_t *hds, struct hdhomerun_device_t *prefered)
{
        /* Test prefered device first. */
        if (prefered) {
                if (hdhomerun_device_selector_choose_test(hds, prefered)) {
                        return prefered;
                }
        }

        /* Test other tuners. */
        size_t index;
        for (index = 0; index < hds->hd_count; index++) {
                struct hdhomerun_device_t *entry = hds->hd_list[index];
                if (entry == prefered) {
                        continue;
                }

                if (hdhomerun_device_selector_choose_test(hds, entry)) {
                        return entry;
                }
        }

        hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_and_lock: no devices available\n");
        return NULL;
}