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;
}
static int hdhomerun_device_selector_load_from_str_discover(struct hdhomerun_device_selector_t *hds, uint32_t target_ip, uint32_t device_id)
{
struct hdhomerun_discover_device_t result;
int discover_count = hdhomerun_discover_find_devices_custom_v2(target_ip, HDHOMERUN_DEVICE_TYPE_TUNER, device_id, &result, 1);
if (discover_count != 1) {
return 0;
}
int count = 0;
unsigned int tuner_index;
for (tuner_index = 0; tuner_index < result.tuner_count; tuner_index++) {
struct hdhomerun_device_t *hd = hdhomerun_device_create(result.device_id, result.ip_addr, tuner_index, hds->dbg);
if (!hd) {
continue;
}
hdhomerun_device_selector_add_device(hds, hd);
count++;
}
return count;
}
void hdhomerun_device_selector_load_from_file(struct hdhomerun_device_selector_t *hds, char *filename)
{
FILE *fp = fopen(filename, "r");
if (!fp) {
return;
}
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);
}
int hdhomerun_device_selector_load_from_str(struct hdhomerun_device_selector_t *hds, char *device_str)
{
/*
* IP address based device_str.
*/
unsigned int a[4];
if (sscanf(device_str, "%u.%u.%u.%u", &a[0], &a[1], &a[2], &a[3]) == 4) {
uint32_t ip_addr = (uint32_t)((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0));
/*
* Multicast IP address.
*/
unsigned int port;
if (sscanf(device_str, "%u.%u.%u.%u:%u", &a[0], &a[1], &a[2], &a[3], &port) == 5) {
struct hdhomerun_device_t *hd = hdhomerun_device_create_multicast(ip_addr, port, hds->dbg);
if (!hd) {
return 0;
}
hdhomerun_device_selector_add_device(hds, hd);
return 1;
}
/*
* IP address + tuner number.
*/
unsigned int tuner;
if (sscanf(device_str, "%u.%u.%u.%u-%u", &a[0], &a[1], &a[2], &a[3], &tuner) == 5) {
struct hdhomerun_device_t *hd = hdhomerun_device_create(HDHOMERUN_DEVICE_ID_WILDCARD, ip_addr, tuner, hds->dbg);
if (!hd) {
return 0;
}
hdhomerun_device_selector_add_device(hds, hd);
return 1;
}
/*
* IP address only - discover and add tuners.
*/
return hdhomerun_device_selector_load_from_str_discover(hds, ip_addr, HDHOMERUN_DEVICE_ID_WILDCARD);
}
/*
* Device ID based device_str.
*/
char *end;
uint32_t device_id = (uint32_t)strtoul(device_str, &end, 16);
if ((end == device_str + 8) && hdhomerun_discover_validate_device_id(device_id)) {
/*
* IP address + tuner number.
*/
if (*end == '-') {
unsigned int tuner = (unsigned int)strtoul(end + 1, NULL, 10);
struct hdhomerun_device_t *hd = hdhomerun_device_create(device_id, 0, tuner, hds->dbg);
if (!hd) {
return 0;
}
hdhomerun_device_selector_add_device(hds, hd);
return 1;
}
/*
* Device ID only - discover and add tuners.
*/
return hdhomerun_device_selector_load_from_str_discover(hds, 0, device_id);
}
/*
* DNS based device_str.
*/
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(device_str, "65001", &hints, &sock_info) != 0) {
return 0;
}
struct sockaddr_in *sock_addr = (struct sockaddr_in *)sock_info->ai_addr;
uint32_t ip_addr = (uint32_t)ntohl(sock_addr->sin_addr.s_addr);
freeaddrinfo(sock_info);
if (ip_addr == 0) {
return 0;
}
return hdhomerun_device_selector_load_from_str_discover(hds, ip_addr, HDHOMERUN_DEVICE_ID_WILDCARD);
}
