github/libhdhomerun
1
0
Fork 0
mirror of https://github.com/Silicondust/libhdhomerun synced 2025-07-05 20:42:17 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

use stdbool

Browse source
This commit is contained in:
Nick Kelsey 2017-06-02 12:19:44 -07:00
parent 1efbcb2b87
commit 1d68aab367
21 changed files with 285 additions and 292 deletions
Download patch file Download diff file Expand all files Collapse all files

22
hdhomerun_channelscan.c
View file

@ -127,10 +127,10 @@ static void channelscan_extract_name(struct hdhomerun_channelscan_program_t *pro
program->name[length] = 0; program->name[length] = 0;
} }
static int channelscan_detect_programs(struct hdhomerun_channelscan_t *scan, struct hdhomerun_channelscan_result_t *result, bool_t *pchanged, bool_t *pincomplete) static int channelscan_detect_programs(struct hdhomerun_channelscan_t *scan, struct hdhomerun_channelscan_result_t *result, bool *pchanged, bool *pincomplete)
{ {
*pchanged = FALSE; *pchanged = false;
*pincomplete = FALSE; *pincomplete = false;
char *streaminfo; char *streaminfo;
int ret = hdhomerun_device_get_tuner_streaminfo(scan->hd, &streaminfo); int ret = hdhomerun_device_get_tuner_streaminfo(scan->hd, &streaminfo);
@ -153,14 +153,14 @@ static int channelscan_detect_programs(struct hdhomerun_channelscan_t *scan, str
unsigned int transport_stream_id; unsigned int transport_stream_id;
if (sscanf(line, "tsid=0x%x", &transport_stream_id) == 1) { if (sscanf(line, "tsid=0x%x", &transport_stream_id) == 1) {
result->transport_stream_id = transport_stream_id; result->transport_stream_id = transport_stream_id;
result->transport_stream_id_detected = TRUE; result->transport_stream_id_detected = true;
continue; continue;
} }
unsigned int original_network_id; unsigned int original_network_id;
if (sscanf(line, "onid=0x%x", &original_network_id) == 1) { if (sscanf(line, "onid=0x%x", &original_network_id) == 1) {
result->original_network_id = original_network_id; result->original_network_id = original_network_id;
result->original_network_id_detected = TRUE; result->original_network_id_detected = true;
continue; continue;
} }
@ -194,28 +194,28 @@ static int channelscan_detect_programs(struct hdhomerun_channelscan_t *scan, str
program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_ENCRYPTED; program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_ENCRYPTED;
} else if (strstr(line, "(no data)")) { } else if (strstr(line, "(no data)")) {
program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NODATA; program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NODATA;
*pincomplete = TRUE; *pincomplete = true;
} else { } else {
program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NORMAL; program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NORMAL;
if ((program.virtual_major == 0) || (program.name[0] == 0)) { if ((program.virtual_major == 0) || (program.name[0] == 0)) {
*pincomplete = TRUE; *pincomplete = true;
} }
} }
if (memcmp(&result->programs[program_count], &program, sizeof(program)) != 0) { if (memcmp(&result->programs[program_count], &program, sizeof(program)) != 0) {
memcpy(&result->programs[program_count], &program, sizeof(program)); memcpy(&result->programs[program_count], &program, sizeof(program));
*pchanged = TRUE; *pchanged = true;
} }
program_count++; program_count++;
} }
if (program_count == 0) { if (program_count == 0) {
*pincomplete = TRUE; *pincomplete = true;
} }
if (result->program_count != program_count) { if (result->program_count != program_count) {
result->program_count = program_count; result->program_count = program_count;
*pchanged = TRUE; *pchanged = true;
} }
return 1; return 1;
@ -282,7 +282,7 @@ int channelscan_detect(struct hdhomerun_channelscan_t *scan, struct hdhomerun_ch
uint64_t complete_time = getcurrenttime() + 1000; uint64_t complete_time = getcurrenttime() + 1000;
while (1) { while (1) {
bool_t changed, incomplete; bool changed, incomplete;
ret = channelscan_detect_programs(scan, result, &changed, &incomplete); ret = channelscan_detect_programs(scan, result, &changed, &incomplete);
if (ret <= 0) { if (ret <= 0) {
return ret; return ret;

22
hdhomerun_config.c
View file

@ -50,23 +50,23 @@ static void extract_appname(const char *argv0)
appname = argv0; appname = argv0;
} }
static bool_t contains(const char *arg, const char *cmpstr) static bool contains(const char *arg, const char *cmpstr)
{ {
if (strcmp(arg, cmpstr) == 0) { if (strcmp(arg, cmpstr) == 0) {
return TRUE; return true;
} }
if (*arg++ != '-') { if (*arg++ != '-') {
return FALSE; return false;
} }
if (*arg++ != '-') { if (*arg++ != '-') {
return FALSE; return false;
} }
if (strcmp(arg, cmpstr) == 0) { if (strcmp(arg, cmpstr) == 0) {
return TRUE; return true;
} }
return FALSE; return false;
} }
static uint32_t parse_ip_addr(const char *str) static uint32_t parse_ip_addr(const char *str)
@ -180,17 +180,17 @@ static int cmd_set(const char *item, const char *value)
return cmd_set_internal(item, value); return cmd_set_internal(item, value);
} }
static volatile sig_atomic_t sigabort_flag = FALSE; static volatile sig_atomic_t sigabort_flag = false;
static volatile sig_atomic_t siginfo_flag = FALSE; static volatile sig_atomic_t siginfo_flag = false;
static void sigabort_handler(int arg) static void sigabort_handler(int arg)
{ {
sigabort_flag = TRUE; sigabort_flag = true;
} }
static void siginfo_handler(int arg) static void siginfo_handler(int arg)
{ {
siginfo_flag = TRUE; siginfo_flag = true;
} }
static void register_signal_handlers(sig_t sigpipe_handler, sig_t sigint_handler, sig_t siginfo_handler) static void register_signal_handlers(sig_t sigpipe_handler, sig_t sigint_handler, sig_t siginfo_handler)
@ -379,7 +379,7 @@ static int cmd_save(const char *tuner_str, const char *filename)
if (siginfo_flag) { if (siginfo_flag) {
fprintf(stderr, "\n"); fprintf(stderr, "\n");
cmd_save_print_stats(); cmd_save_print_stats();
siginfo_flag = FALSE; siginfo_flag = false;
} }
size_t actual_size; size_t actual_size;

34
hdhomerun_control.c
View file

@ -76,26 +76,26 @@ void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *cs)
free(cs); free(cs);
} }
static bool_t hdhomerun_control_connect_sock(struct hdhomerun_control_sock_t *cs) static bool hdhomerun_control_connect_sock(struct hdhomerun_control_sock_t *cs)
{ {
if (cs->sock) { if (cs->sock) {
return TRUE; return true;
} }
if ((cs->desired_device_id == 0) && (cs->desired_device_ip == 0)) { if ((cs->desired_device_id == 0) && (cs->desired_device_ip == 0)) {
hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: no device specified\n"); hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: no device specified\n");
return FALSE; return false;
} }
if (hdhomerun_discover_is_ip_multicast(cs->desired_device_ip)) { 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"); hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: cannot use multicast ip address for device operations\n");
return FALSE; return false;
} }
/* Find device. */ /* Find device. */
struct hdhomerun_discover_device_t result; struct hdhomerun_discover_device_t result;
if (hdhomerun_discover_find_devices_custom_v2(cs->desired_device_ip, HDHOMERUN_DEVICE_TYPE_WILDCARD, cs->desired_device_id, &result, 1) <= 0) { if (hdhomerun_discover_find_devices_custom_v2(cs->desired_device_ip, HDHOMERUN_DEVICE_TYPE_WILDCARD, cs->desired_device_id, &result, 1) <= 0) {
hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: device not found\n"); hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: device not found\n");
return FALSE; return false;
} }
cs->actual_device_ip = result.ip_addr; cs->actual_device_ip = result.ip_addr;
cs->actual_device_id = result.device_id; cs->actual_device_id = result.device_id;
@ -104,18 +104,18 @@ static bool_t hdhomerun_control_connect_sock(struct hdhomerun_control_sock_t *cs
cs->sock = hdhomerun_sock_create_tcp(); cs->sock = hdhomerun_sock_create_tcp();
if (!cs->sock) { if (!cs->sock) {
hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to create socket (%d)\n", hdhomerun_sock_getlasterror()); hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to create socket (%d)\n", hdhomerun_sock_getlasterror());
return FALSE; return false;
} }
/* Initiate connection. */ /* Initiate connection. */
if (!hdhomerun_sock_connect(cs->sock, cs->actual_device_ip, HDHOMERUN_CONTROL_TCP_PORT, HDHOMERUN_CONTROL_CONNECT_TIMEOUT)) { 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_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to connect (%d)\n", hdhomerun_sock_getlasterror());
hdhomerun_control_close_sock(cs); hdhomerun_control_close_sock(cs);
return FALSE; return false;
} }
/* Success. */ /* Success. */
return TRUE; return true;
} }
uint32_t hdhomerun_control_get_device_id(struct hdhomerun_control_sock_t *cs) uint32_t hdhomerun_control_get_device_id(struct hdhomerun_control_sock_t *cs)
@ -164,18 +164,18 @@ uint32_t hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs)
return addr; return addr;
} }
static bool_t hdhomerun_control_send_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt) static bool hdhomerun_control_send_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt)
{ {
if (!hdhomerun_sock_send(cs->sock, tx_pkt->start, tx_pkt->end - tx_pkt->start, HDHOMERUN_CONTROL_SEND_TIMEOUT)) { 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_debug_printf(cs->dbg, "hdhomerun_control_send_sock: send failed (%d)\n", hdhomerun_sock_getlasterror());
hdhomerun_control_close_sock(cs); hdhomerun_control_close_sock(cs);
return FALSE; return false;
} }
return TRUE; return true;
} }
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) static bool 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; uint64_t stop_time = getcurrenttime() + recv_timeout;
hdhomerun_pkt_reset(rx_pkt); hdhomerun_pkt_reset(rx_pkt);
@ -185,14 +185,14 @@ static bool_t hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, s
if (current_time >= stop_time) { if (current_time >= stop_time) {
hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: timeout\n"); hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: timeout\n");
hdhomerun_control_close_sock(cs); hdhomerun_control_close_sock(cs);
return FALSE; return false;
} }
size_t length = rx_pkt->limit - rx_pkt->end; size_t length = rx_pkt->limit - rx_pkt->end;
if (!hdhomerun_sock_recv(cs->sock, rx_pkt->end, &length, stop_time - current_time)) { 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_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: recv failed (%d)\n", hdhomerun_sock_getlasterror());
hdhomerun_control_close_sock(cs); hdhomerun_control_close_sock(cs);
return FALSE; return false;
} }
rx_pkt->end += length; rx_pkt->end += length;
@ -201,10 +201,10 @@ static bool_t hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, s
if (ret < 0) { if (ret < 0) {
hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: frame error\n"); hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: frame error\n");
hdhomerun_control_close_sock(cs); hdhomerun_control_close_sock(cs);
return FALSE; return false;
} }
if (ret > 0) { if (ret > 0) {
return TRUE; return true;
} }
} }
} }
@ -355,7 +355,7 @@ int hdhomerun_control_upgrade(struct hdhomerun_control_sock_t *cs, FILE *upgrade
{ {
struct hdhomerun_pkt_t *tx_pkt = &cs->tx_pkt; struct hdhomerun_pkt_t *tx_pkt = &cs->tx_pkt;
struct hdhomerun_pkt_t *rx_pkt = &cs->rx_pkt; struct hdhomerun_pkt_t *rx_pkt = &cs->rx_pkt;
bool_t upload_delay = FALSE; bool upload_delay = false;
uint32_t sequence = 0; uint32_t sequence = 0;
/* Special case detection. */ /* Special case detection. */

40
hdhomerun_debug.c
View file

@ -49,8 +49,8 @@ struct hdhomerun_debug_message_t
struct hdhomerun_debug_t struct hdhomerun_debug_t
{ {
pthread_t thread; pthread_t thread;
volatile bool_t enabled; volatile bool enabled;
volatile bool_t terminate; volatile bool terminate;
char *prefix; char *prefix;
pthread_mutex_t print_lock; pthread_mutex_t print_lock;
@ -95,7 +95,7 @@ void hdhomerun_debug_destroy(struct hdhomerun_debug_t *dbg)
return; return;
} }
dbg->terminate = TRUE; dbg->terminate = true;
pthread_join(dbg->thread, NULL); pthread_join(dbg->thread, NULL);
if (dbg->prefix) { if (dbg->prefix) {
@ -206,7 +206,7 @@ void hdhomerun_debug_enable(struct hdhomerun_debug_t *dbg)
return; return;
} }
dbg->enabled = TRUE; dbg->enabled = true;
} }
void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg) void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg)
@ -215,13 +215,13 @@ void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg)
return; return;
} }
dbg->enabled = FALSE; dbg->enabled = false;
} }
bool_t hdhomerun_debug_enabled(struct hdhomerun_debug_t *dbg) bool hdhomerun_debug_enabled(struct hdhomerun_debug_t *dbg)
{ {
if (!dbg) { if (!dbg) {
return FALSE; return false;
} }
return dbg->enabled; return dbg->enabled;
@ -327,68 +327,68 @@ void hdhomerun_debug_vprintf(struct hdhomerun_debug_t *dbg, const char *fmt, va_
} }
/* Send lock held by caller */ /* Send lock held by caller */
static bool_t hdhomerun_debug_output_message_file(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message) static bool hdhomerun_debug_output_message_file(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
{ {
if (!dbg->file_fp) { if (!dbg->file_fp) {
uint64_t current_time = getcurrenttime(); uint64_t current_time = getcurrenttime();
if (current_time < dbg->connect_delay) { if (current_time < dbg->connect_delay) {
return FALSE; return false;
} }
dbg->connect_delay = current_time + 30*1000; dbg->connect_delay = current_time + 30*1000;
dbg->file_fp = fopen(dbg->file_name, "a"); dbg->file_fp = fopen(dbg->file_name, "a");
if (!dbg->file_fp) { if (!dbg->file_fp) {
return FALSE; return false;
} }
} }
fprintf(dbg->file_fp, "%s", message->buffer); fprintf(dbg->file_fp, "%s", message->buffer);
fflush(dbg->file_fp); fflush(dbg->file_fp);
return TRUE; return true;
} }
/* Send lock held by caller */ /* Send lock held by caller */
static bool_t hdhomerun_debug_output_message_sock(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message) static bool hdhomerun_debug_output_message_sock(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
{ {
if (!dbg->sock) { if (!dbg->sock) {
uint64_t current_time = getcurrenttime(); uint64_t current_time = getcurrenttime();
if (current_time < dbg->connect_delay) { if (current_time < dbg->connect_delay) {
return FALSE; return false;
} }
dbg->connect_delay = current_time + HDHOMERUN_DEBUG_CONNECT_RETRY_TIME; dbg->connect_delay = current_time + HDHOMERUN_DEBUG_CONNECT_RETRY_TIME;
dbg->sock = hdhomerun_sock_create_tcp(); dbg->sock = hdhomerun_sock_create_tcp();
if (!dbg->sock) { if (!dbg->sock) {
return FALSE; return false;
} }
uint32_t remote_addr = hdhomerun_sock_getaddrinfo_addr(dbg->sock, HDHOMERUN_DEBUG_HOST); uint32_t remote_addr = hdhomerun_sock_getaddrinfo_addr(dbg->sock, HDHOMERUN_DEBUG_HOST);
if (remote_addr == 0) { if (remote_addr == 0) {
hdhomerun_debug_close_internal(dbg); hdhomerun_debug_close_internal(dbg);
return FALSE; return false;
} }
if (!hdhomerun_sock_connect(dbg->sock, remote_addr, HDHOMERUN_DEBUG_PORT, HDHOMERUN_DEBUG_CONNECT_TIMEOUT)) { if (!hdhomerun_sock_connect(dbg->sock, remote_addr, HDHOMERUN_DEBUG_PORT, HDHOMERUN_DEBUG_CONNECT_TIMEOUT)) {
hdhomerun_debug_close_internal(dbg); hdhomerun_debug_close_internal(dbg);
return FALSE; return false;
} }
} }
size_t length = strlen(message->buffer); size_t length = strlen(message->buffer);
if (!hdhomerun_sock_send(dbg->sock, message->buffer, length, HDHOMERUN_DEBUG_SEND_TIMEOUT)) { if (!hdhomerun_sock_send(dbg->sock, message->buffer, length, HDHOMERUN_DEBUG_SEND_TIMEOUT)) {
hdhomerun_debug_close_internal(dbg); hdhomerun_debug_close_internal(dbg);
return FALSE; return false;
} }
return TRUE; return true;
} }
static bool_t hdhomerun_debug_output_message(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message) static bool hdhomerun_debug_output_message(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
{ {
pthread_mutex_lock(&dbg->send_lock); pthread_mutex_lock(&dbg->send_lock);
bool_t ret; bool ret;
if (dbg->file_name) { if (dbg->file_name) {
ret = hdhomerun_debug_output_message_file(dbg, message); ret = hdhomerun_debug_output_message_file(dbg, message);
} else { } else {

2
hdhomerun_debug.h
View file

@ -39,7 +39,7 @@ extern LIBHDHOMERUN_API void hdhomerun_debug_set_prefix(struct hdhomerun_debug_t
extern LIBHDHOMERUN_API void hdhomerun_debug_set_filename(struct hdhomerun_debug_t *dbg, const char *filename); extern LIBHDHOMERUN_API void hdhomerun_debug_set_filename(struct hdhomerun_debug_t *dbg, const char *filename);
extern LIBHDHOMERUN_API void hdhomerun_debug_enable(struct hdhomerun_debug_t *dbg); extern LIBHDHOMERUN_API void hdhomerun_debug_enable(struct hdhomerun_debug_t *dbg);
extern LIBHDHOMERUN_API void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg); extern LIBHDHOMERUN_API void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg);
extern LIBHDHOMERUN_API bool_t hdhomerun_debug_enabled(struct hdhomerun_debug_t *dbg); extern LIBHDHOMERUN_API bool hdhomerun_debug_enabled(struct hdhomerun_debug_t *dbg);
extern LIBHDHOMERUN_API void hdhomerun_debug_flush(struct hdhomerun_debug_t *dbg, uint64_t timeout); extern LIBHDHOMERUN_API void hdhomerun_debug_flush(struct hdhomerun_debug_t *dbg, uint64_t timeout);
extern LIBHDHOMERUN_API void hdhomerun_debug_close(struct hdhomerun_debug_t *dbg, uint64_t timeout); extern LIBHDHOMERUN_API void hdhomerun_debug_close(struct hdhomerun_debug_t *dbg, uint64_t timeout);

30
hdhomerun_device.c
View file

@ -339,7 +339,7 @@ struct hdhomerun_video_sock_t *hdhomerun_device_get_video_sock(struct hdhomerun_
return hd->vs; return hd->vs;
} }
bool_t allow_port_reuse = (hd->multicast_port != 0); bool allow_port_reuse = (hd->multicast_port != 0);
hd->vs = hdhomerun_video_create(hd->multicast_port, allow_port_reuse, VIDEO_DATA_BUFFER_SIZE_1S * 2, hd->dbg); hd->vs = hdhomerun_video_create(hd->multicast_port, allow_port_reuse, VIDEO_DATA_BUFFER_SIZE_1S * 2, hd->dbg);
if (!hd->vs) { if (!hd->vs) {
@ -372,22 +372,22 @@ static uint32_t hdhomerun_device_get_status_parse(const char *status_str, const
return (uint32_t)value; return (uint32_t)value;
} }
static bool_t hdhomerun_device_get_tuner_status_lock_is_bcast(struct hdhomerun_tuner_status_t *status) static bool hdhomerun_device_get_tuner_status_lock_is_bcast(struct hdhomerun_tuner_status_t *status)
{ {
if (strcmp(status->lock_str, "8vsb") == 0) { if (strcmp(status->lock_str, "8vsb") == 0) {
return TRUE; return true;
} }
if (strncmp(status->lock_str, "t8", 2) == 0) { if (strncmp(status->lock_str, "t8", 2) == 0) {
return TRUE; return true;
} }
if (strncmp(status->lock_str, "t7", 2) == 0) { if (strncmp(status->lock_str, "t7", 2) == 0) {
return TRUE; return true;
} }
if (strncmp(status->lock_str, "t6", 2) == 0) { if (strncmp(status->lock_str, "t6", 2) == 0) {
return TRUE; return true;
} }
return FALSE; return false;
} }
uint32_t hdhomerun_device_get_tuner_status_ss_color(struct hdhomerun_tuner_status_t *status) uint32_t hdhomerun_device_get_tuner_status_ss_color(struct hdhomerun_tuner_status_t *status)
@ -481,9 +481,9 @@ int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, char **psta
if (strcmp(status->lock_str, "none") != 0) { if (strcmp(status->lock_str, "none") != 0) {
if (status->lock_str[0] == '(') { if (status->lock_str[0] == '(') {
status->lock_unsupported = TRUE; status->lock_unsupported = true;
} else { } else {
status->lock_supported = TRUE; status->lock_supported = true;
} }
} }
} }
@ -579,21 +579,21 @@ int hdhomerun_device_get_tuner_vstatus(struct hdhomerun_device_t *hd, char **pvs
} }
if (strncmp(vstatus->auth, "not-subscribed", 14) == 0) { if (strncmp(vstatus->auth, "not-subscribed", 14) == 0) {
vstatus->not_subscribed = TRUE; vstatus->not_subscribed = true;
} }
if (strncmp(vstatus->auth, "error", 5) == 0) { if (strncmp(vstatus->auth, "error", 5) == 0) {
vstatus->not_available = TRUE; vstatus->not_available = true;
} }
if (strncmp(vstatus->auth, "dialog", 6) == 0) { if (strncmp(vstatus->auth, "dialog", 6) == 0) {
vstatus->not_available = TRUE; vstatus->not_available = true;
} }
if (strncmp(vstatus->cci, "protected", 9) == 0) { if (strncmp(vstatus->cci, "protected", 9) == 0) {
vstatus->copy_protected = TRUE; vstatus->copy_protected = true;
} }
if (strncmp(vstatus->cgms, "protected", 9) == 0) { if (strncmp(vstatus->cgms, "protected", 9) == 0) {
vstatus->copy_protected = TRUE; vstatus->copy_protected = true;
} }
} }
@ -885,7 +885,7 @@ int hdhomerun_device_set_tuner_filter(struct hdhomerun_device_t *hd, const char
return hdhomerun_control_set_with_lockkey(hd->cs, name, filter, hd->lockkey, NULL, NULL); return hdhomerun_control_set_with_lockkey(hd->cs, name, filter, hd->lockkey, NULL, NULL);
} }
static bool_t hdhomerun_device_set_tuner_filter_by_array_append(char *ptr, char *end, uint16_t range_begin, uint16_t range_end) static bool hdhomerun_device_set_tuner_filter_by_array_append(char *ptr, char *end, uint16_t range_begin, uint16_t range_end)
{ {
if (range_begin == range_end) { if (range_begin == range_end) {
return hdhomerun_sprintf(ptr, end, "0x%04x ", (unsigned int)range_begin); return hdhomerun_sprintf(ptr, end, "0x%04x ", (unsigned int)range_begin);

36
hdhomerun_device_selector.c
View file

@ -39,7 +39,7 @@ struct hdhomerun_device_selector_t *hdhomerun_device_selector_create(struct hdho
return hds; return hds;
} }
void hdhomerun_device_selector_destroy(struct hdhomerun_device_selector_t *hds, bool_t destroy_devices) void hdhomerun_device_selector_destroy(struct hdhomerun_device_selector_t *hds, bool destroy_devices)
{ {
if (destroy_devices) { if (destroy_devices) {
size_t index; size_t index;
@ -313,7 +313,7 @@ int hdhomerun_device_selector_load_from_windows_registry(struct hdhomerun_device
} }
#endif #endif
static bool_t hdhomerun_device_selector_choose_test(struct hdhomerun_device_selector_t *hds, struct hdhomerun_device_t *test_hd) static bool 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); const char *name = hdhomerun_device_get_name(test_hd);
@ -324,11 +324,11 @@ static bool_t hdhomerun_device_selector_choose_test(struct hdhomerun_device_sele
int ret = hdhomerun_device_tuner_lockkey_request(test_hd, &error); int ret = hdhomerun_device_tuner_lockkey_request(test_hd, &error);
if (ret > 0) { if (ret > 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name);
return TRUE; return true;
} }
if (ret < 0) { if (ret < 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
return FALSE; return false;
} }
/* /*
@ -338,35 +338,35 @@ static bool_t hdhomerun_device_selector_choose_test(struct hdhomerun_device_sele
ret = hdhomerun_device_get_tuner_target(test_hd, &target); ret = hdhomerun_device_get_tuner_target(test_hd, &target);
if (ret < 0) { if (ret < 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
return FALSE; return false;
} }
if (ret == 0) { if (ret == 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, failed to read target\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, failed to read target\n", name);
return FALSE; return false;
} }
if (strcmp(target, "none") == 0) { if (strcmp(target, "none") == 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, no target set\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, no target set\n", name);
return FALSE; return false;
} }
if ((strncmp(target, "udp://", 6) != 0) && (strncmp(target, "rtp://", 6) != 0)) { if ((strncmp(target, "udp://", 6) != 0) && (strncmp(target, "rtp://", 6) != 0)) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by %s\n", name, target); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by %s\n", name, target);
return FALSE; return false;
} }
unsigned int a[4]; unsigned int a[4];
unsigned int target_port; unsigned int target_port;
if (sscanf(target + 6, "%u.%u.%u.%u:%u", &a[0], &a[1], &a[2], &a[3], &target_port) != 5) { if (sscanf(target + 6, "%u.%u.%u.%u:%u", &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, unexpected target set (%s)\n", name, target); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, unexpected target set (%s)\n", name, target);
return FALSE; return false;
} }
uint32_t target_ip = (uint32_t)((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0)); 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); uint32_t local_ip = hdhomerun_device_get_local_machine_addr(test_hd);
if (target_ip != local_ip) { if (target_ip != local_ip) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by %s\n", name, target); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by %s\n", name, target);
return FALSE; return false;
} }
/* /*
@ -375,15 +375,15 @@ static bool_t hdhomerun_device_selector_choose_test(struct hdhomerun_device_sele
struct hdhomerun_sock_t *test_sock = hdhomerun_sock_create_udp(); struct hdhomerun_sock_t *test_sock = hdhomerun_sock_create_udp();
if (!test_sock) { if (!test_sock) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, failed to create test sock\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use, failed to create test sock\n", name);
return FALSE; return false;
} }
bool_t inuse = (hdhomerun_sock_bind(test_sock, INADDR_ANY, (uint16_t)target_port, FALSE) == FALSE); bool inuse = (hdhomerun_sock_bind(test_sock, INADDR_ANY, (uint16_t)target_port, false) == false);
hdhomerun_sock_destroy(test_sock); hdhomerun_sock_destroy(test_sock);
if (inuse) { if (inuse) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by local machine\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by local machine\n", name);
return FALSE; return false;
} }
/* /*
@ -392,11 +392,11 @@ static bool_t hdhomerun_device_selector_choose_test(struct hdhomerun_device_sele
ret = hdhomerun_device_tuner_lockkey_force(test_hd); ret = hdhomerun_device_tuner_lockkey_force(test_hd);
if (ret < 0) { if (ret < 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
return FALSE; return false;
} }
if (ret == 0) { 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); 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; 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); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s in use by local machine, dead target, lockkey force successful\n", name);
@ -407,15 +407,15 @@ static bool_t hdhomerun_device_selector_choose_test(struct hdhomerun_device_sele
ret = hdhomerun_device_tuner_lockkey_request(test_hd, &error); ret = hdhomerun_device_tuner_lockkey_request(test_hd, &error);
if (ret > 0) { if (ret > 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name);
return TRUE; return true;
} }
if (ret < 0) { if (ret < 0) {
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name);
return FALSE; return false;
} }
hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s still in use after lockkey force (%s)\n", name, error); hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s still in use after lockkey force (%s)\n", name, error);
return FALSE; return false;
} }
struct hdhomerun_device_t *hdhomerun_device_selector_choose_and_lock(struct hdhomerun_device_selector_t *hds, struct hdhomerun_device_t *prefered) struct hdhomerun_device_t *hdhomerun_device_selector_choose_and_lock(struct hdhomerun_device_selector_t *hds, struct hdhomerun_device_t *prefered)

2
hdhomerun_device_selector.h
View file

@ -28,7 +28,7 @@ extern "C" {
* The dbg parameter may be null. * The dbg parameter may be null.
*/ */
extern LIBHDHOMERUN_API struct hdhomerun_device_selector_t *hdhomerun_device_selector_create(struct hdhomerun_debug_t *dbg); extern LIBHDHOMERUN_API struct hdhomerun_device_selector_t *hdhomerun_device_selector_create(struct hdhomerun_debug_t *dbg);
extern LIBHDHOMERUN_API void hdhomerun_device_selector_destroy(struct hdhomerun_device_selector_t *hds, bool_t destroy_devices); extern LIBHDHOMERUN_API void hdhomerun_device_selector_destroy(struct hdhomerun_device_selector_t *hds, bool destroy_devices);
/* /*
* Get the number of devices in the list. * Get the number of devices in the list.

60
hdhomerun_discover.c
View file

@ -24,7 +24,7 @@
struct hdhomerun_discover_sock_t { struct hdhomerun_discover_sock_t {
struct hdhomerun_sock_t *sock; struct hdhomerun_sock_t *sock;
bool_t detected; bool detected;
uint32_t local_ip; uint32_t local_ip;
uint32_t subnet_mask; uint32_t subnet_mask;
}; };
@ -37,44 +37,44 @@ struct hdhomerun_discover_t {
struct hdhomerun_debug_t *dbg; struct hdhomerun_debug_t *dbg;
}; };
static bool_t hdhomerun_discover_sock_add(struct hdhomerun_discover_t *ds, uint32_t local_ip, uint32_t subnet_mask) static bool hdhomerun_discover_sock_add(struct hdhomerun_discover_t *ds, uint32_t local_ip, uint32_t subnet_mask)
{ {
unsigned int i; unsigned int i;
for (i = 1; i < ds->sock_count; i++) { for (i = 1; i < ds->sock_count; i++) {
struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
if ((dss->local_ip == local_ip) && (dss->subnet_mask == subnet_mask)) { if ((dss->local_ip == local_ip) && (dss->subnet_mask == subnet_mask)) {
dss->detected = TRUE; dss->detected = true;
return TRUE; return true;
} }
} }
if (ds->sock_count >= HDHOMERUN_DISCOVER_MAX_SOCK_COUNT) { if (ds->sock_count >= HDHOMERUN_DISCOVER_MAX_SOCK_COUNT) {
return FALSE; return false;
} }
/* Create socket. */ /* Create socket. */
struct hdhomerun_sock_t *sock = hdhomerun_sock_create_udp(); struct hdhomerun_sock_t *sock = hdhomerun_sock_create_udp();
if (!sock) { if (!sock) {
hdhomerun_debug_printf(ds->dbg, "discover: failed to allocate socket (%d)\n", hdhomerun_sock_getlasterror()); hdhomerun_debug_printf(ds->dbg, "discover: failed to allocate socket (%d)\n", hdhomerun_sock_getlasterror());
return FALSE; return false;
} }
/* Bind socket. */ /* Bind socket. */
if (!hdhomerun_sock_bind(sock, local_ip, 0, FALSE)) { if (!hdhomerun_sock_bind(sock, local_ip, 0, false)) {
hdhomerun_debug_printf(ds->dbg, "discover: failed to bind to %u.%u.%u.%u:0\n", (unsigned int)(local_ip >> 24) & 0xFF, (unsigned int)(local_ip >> 16) & 0xFF, (unsigned int)(local_ip >> 8) & 0xFF, (unsigned int)(local_ip >> 0) & 0xFF); hdhomerun_debug_printf(ds->dbg, "discover: failed to bind to %u.%u.%u.%u:0\n", (unsigned int)(local_ip >> 24) & 0xFF, (unsigned int)(local_ip >> 16) & 0xFF, (unsigned int)(local_ip >> 8) & 0xFF, (unsigned int)(local_ip >> 0) & 0xFF);
hdhomerun_sock_destroy(sock); hdhomerun_sock_destroy(sock);
return FALSE; return false;
} }
/* Write sock entry. */ /* Write sock entry. */
struct hdhomerun_discover_sock_t *dss = &ds->socks[ds->sock_count++]; struct hdhomerun_discover_sock_t *dss = &ds->socks[ds->sock_count++];
dss->sock = sock; dss->sock = sock;
dss->detected = TRUE; dss->detected = true;
dss->local_ip = local_ip; dss->local_ip = local_ip;
dss->subnet_mask = subnet_mask; dss->subnet_mask = subnet_mask;
return TRUE; return true;
} }
struct hdhomerun_discover_t *hdhomerun_discover_create(struct hdhomerun_debug_t *dbg) struct hdhomerun_discover_t *hdhomerun_discover_create(struct hdhomerun_debug_t *dbg)
@ -112,7 +112,7 @@ static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds)
unsigned int i; unsigned int i;
for (i = 1; i < ds->sock_count; i++) { for (i = 1; i < ds->sock_count; i++) {
struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
dss->detected = FALSE; dss->detected = false;
} }
struct hdhomerun_local_ip_info_t ip_info_list[HDHOMERUN_DISCOVER_MAX_SOCK_COUNT]; struct hdhomerun_local_ip_info_t ip_info_list[HDHOMERUN_DISCOVER_MAX_SOCK_COUNT];
@ -152,7 +152,7 @@ static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds)
ds->sock_count = count; 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) static bool 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)
{ {
struct hdhomerun_pkt_t *tx_pkt = &ds->tx_pkt; struct hdhomerun_pkt_t *tx_pkt = &ds->tx_pkt;
hdhomerun_pkt_reset(tx_pkt); hdhomerun_pkt_reset(tx_pkt);
@ -168,9 +168,9 @@ static bool_t hdhomerun_discover_send_internal(struct hdhomerun_discover_t *ds,
return hdhomerun_sock_sendto(dss->sock, target_ip, HDHOMERUN_DISCOVER_UDP_PORT, tx_pkt->start, tx_pkt->end - tx_pkt->start, 0); 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) static bool hdhomerun_discover_send_wildcard_ip(struct hdhomerun_discover_t *ds, uint32_t device_type, uint32_t device_id)
{ {
bool_t result = FALSE; bool result = false;
/* /*
* Send subnet broadcast using each local ip socket. * Send subnet broadcast using each local ip socket.
@ -194,9 +194,9 @@ static bool_t hdhomerun_discover_send_wildcard_ip(struct hdhomerun_discover_t *d
return result; return result;
} }
static bool_t hdhomerun_discover_send_target_ip(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id) static bool hdhomerun_discover_send_target_ip(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id)
{ {
bool_t result = FALSE; bool result = false;
/* /*
* Send targeted packet from any local ip that is in the same subnet. * Send targeted packet from any local ip that is in the same subnet.
@ -226,7 +226,7 @@ static bool_t hdhomerun_discover_send_target_ip(struct hdhomerun_discover_t *ds,
return result; return result;
} }
static bool_t hdhomerun_discover_send(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id) static bool 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); return hdhomerun_discover_send_wildcard_ip(ds, device_type, device_id);
@ -235,7 +235,7 @@ static bool_t hdhomerun_discover_send(struct hdhomerun_discover_t *ds, uint32_t
} }
} }
static bool_t hdhomerun_discover_is_legacy(uint32_t device_id) static bool hdhomerun_discover_is_legacy(uint32_t device_id)
{ {
switch (device_id >> 20) { switch (device_id >> 20) {
case 0x100: /* TECH-US/TECH3-US */ case 0x100: /* TECH-US/TECH3-US */
@ -250,14 +250,14 @@ static bool_t hdhomerun_discover_is_legacy(uint32_t device_id)
case 0x111: /* HDHR3-DT */ case 0x111: /* HDHR3-DT */
case 0x121: /* HDHR-EU */ case 0x121: /* HDHR-EU */
case 0x122: /* HDHR3-EU */ case 0x122: /* HDHR3-EU */
return TRUE; return true;
default: default:
return FALSE; return false;
} }
} }
static bool_t hdhomerun_discover_recv_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, struct hdhomerun_discover_device_t *result) static bool hdhomerun_discover_recv_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, struct hdhomerun_discover_device_t *result)
{ {
static char hdhomerun_discover_recv_base64_encode_table[64 + 1] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; static char hdhomerun_discover_recv_base64_encode_table[64 + 1] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
struct hdhomerun_pkt_t *rx_pkt = &ds->rx_pkt; struct hdhomerun_pkt_t *rx_pkt = &ds->rx_pkt;
@ -267,17 +267,17 @@ static bool_t hdhomerun_discover_recv_internal(struct hdhomerun_discover_t *ds,
uint16_t remote_port; uint16_t remote_port;
size_t length = rx_pkt->limit - rx_pkt->end; size_t length = rx_pkt->limit - rx_pkt->end;
if (!hdhomerun_sock_recvfrom(dss->sock, &remote_addr, &remote_port, rx_pkt->end, &length, 0)) { if (!hdhomerun_sock_recvfrom(dss->sock, &remote_addr, &remote_port, rx_pkt->end, &length, 0)) {
return FALSE; return false;
} }
rx_pkt->end += length; rx_pkt->end += length;
uint16_t type; uint16_t type;
if (hdhomerun_pkt_open_frame(rx_pkt, &type) <= 0) { if (hdhomerun_pkt_open_frame(rx_pkt, &type) <= 0) {
return FALSE; return false;
} }
if (type != HDHOMERUN_TYPE_DISCOVER_RPY) { if (type != HDHOMERUN_TYPE_DISCOVER_RPY) {
return FALSE; return false;
} }
memset(result, 0, sizeof(struct hdhomerun_discover_device_t)); memset(result, 0, sizeof(struct hdhomerun_discover_device_t));
@ -377,21 +377,21 @@ static bool_t hdhomerun_discover_recv_internal(struct hdhomerun_discover_t *ds,
} }
} }
return TRUE; return true;
} }
static bool_t hdhomerun_discover_recv(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_device_t *result) static bool hdhomerun_discover_recv(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_device_t *result)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < ds->sock_count; i++) { for (i = 0; i < ds->sock_count; i++) {
struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; struct hdhomerun_discover_sock_t *dss = &ds->socks[i];
if (hdhomerun_discover_recv_internal(ds, dss, result)) { if (hdhomerun_discover_recv_internal(ds, dss, result)) {
return TRUE; return true;
} }
} }
return FALSE; return false;
} }
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) 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)
@ -476,7 +476,7 @@ int hdhomerun_discover_find_devices_custom_v2(uint32_t target_ip, uint32_t devic
return ret; return ret;
} }
bool_t hdhomerun_discover_validate_device_id(uint32_t device_id) bool hdhomerun_discover_validate_device_id(uint32_t device_id)
{ {
static uint8_t lookup_table[16] = {0xA, 0x5, 0xF, 0x6, 0x7, 0xC, 0x1, 0xB, 0x9, 0x2, 0x8, 0xD, 0x4, 0x3, 0xE, 0x0}; static uint8_t lookup_table[16] = {0xA, 0x5, 0xF, 0x6, 0x7, 0xC, 0x1, 0xB, 0x9, 0x2, 0x8, 0xD, 0x4, 0x3, 0xE, 0x0};
@ -494,7 +494,7 @@ bool_t hdhomerun_discover_validate_device_id(uint32_t device_id)
return (checksum == 0); return (checksum == 0);
} }
bool_t hdhomerun_discover_is_ip_multicast(uint32_t ip_addr) bool hdhomerun_discover_is_ip_multicast(uint32_t ip_addr)
{ {
return (ip_addr >= 0xE0000000) && (ip_addr < 0xF0000000); return (ip_addr >= 0xE0000000) && (ip_addr < 0xF0000000);
} }

14
hdhomerun_discover.h
View file

@ -26,7 +26,7 @@ struct hdhomerun_discover_device_t {
uint32_t device_type; uint32_t device_type;
uint32_t device_id; uint32_t device_id;
uint8_t tuner_count; uint8_t tuner_count;
bool_t is_legacy; bool is_legacy;
char device_auth[25]; char device_auth[25];
char base_url[29]; char base_url[29];
}; };
@ -60,18 +60,18 @@ extern LIBHDHOMERUN_API int hdhomerun_discover_find_devices_v2(struct hdhomerun_
* The device ID contains a self-check sequence that detects common user input errors including * The device ID contains a self-check sequence that detects common user input errors including
* single-digit errors and two digit transposition errors. * single-digit errors and two digit transposition errors.
* *
* Returns TRUE if valid. * Returns true if valid.
* Returns FALSE if not valid. * Returns false if not valid.
*/ */
extern LIBHDHOMERUN_API bool_t hdhomerun_discover_validate_device_id(uint32_t device_id); extern LIBHDHOMERUN_API bool hdhomerun_discover_validate_device_id(uint32_t device_id);
/* /*
* Detect if an IP address is multicast. * Detect if an IP address is multicast.
* *
* Returns TRUE if multicast. * Returns true if multicast.
* Returns FALSE if zero, unicast, expermental, or broadcast. * Returns false if zero, unicast, expermental, or broadcast.
*/ */
extern LIBHDHOMERUN_API bool_t hdhomerun_discover_is_ip_multicast(uint32_t ip_addr); extern LIBHDHOMERUN_API bool hdhomerun_discover_is_ip_multicast(uint32_t ip_addr);
#ifdef __cplusplus #ifdef __cplusplus
} }

8
hdhomerun_os.h
View file

@ -23,11 +23,3 @@
#else #else
#include "hdhomerun_os_posix.h" #include "hdhomerun_os_posix.h"
#endif #endif
#if !defined(TRUE)
#define TRUE 1
#endif
#if !defined(FALSE)
#define FALSE 0
#endif

22
hdhomerun_os_posix.c
View file

@ -130,7 +130,7 @@ void pthread_mutex_dispose(pthread_mutex_t *mutex)
void thread_cond_init(thread_cond_t *cond) void thread_cond_init(thread_cond_t *cond)
{ {
cond->signaled = FALSE; cond->signaled = false;
pthread_mutex_init(&cond->lock, NULL); pthread_mutex_init(&cond->lock, NULL);
pthread_cond_init(&cond->cond, NULL); pthread_cond_init(&cond->cond, NULL);
} }
@ -143,7 +143,7 @@ void thread_cond_signal(thread_cond_t *cond)
{ {
pthread_mutex_lock(&cond->lock); pthread_mutex_lock(&cond->lock);
cond->signaled = TRUE; cond->signaled = true;
pthread_cond_signal(&cond->cond); pthread_cond_signal(&cond->cond);
pthread_mutex_unlock(&cond->lock); pthread_mutex_unlock(&cond->lock);
@ -157,7 +157,7 @@ void thread_cond_wait(thread_cond_t *cond)
pthread_cond_wait(&cond->cond, &cond->lock); pthread_cond_wait(&cond->cond, &cond->lock);
} }
cond->signaled = FALSE; cond->signaled = false;
pthread_mutex_unlock(&cond->lock); pthread_mutex_unlock(&cond->lock);
} }
@ -176,36 +176,36 @@ void thread_cond_wait_with_timeout(thread_cond_t *cond, uint64_t max_wait_time)
pthread_cond_timedwait(&cond->cond, &cond->lock, &ts); pthread_cond_timedwait(&cond->cond, &cond->lock, &ts);
} }
cond->signaled = FALSE; cond->signaled = false;
pthread_mutex_unlock(&cond->lock); pthread_mutex_unlock(&cond->lock);
} }
bool_t hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap) bool hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap)
{ {
if (buffer >= end) { if (buffer >= end) {
return FALSE; return false;
} }
int length = vsnprintf(buffer, end - buffer - 1, fmt, ap); int length = vsnprintf(buffer, end - buffer - 1, fmt, ap);
if (length < 0) { if (length < 0) {
*buffer = 0; *buffer = 0;
return FALSE; return false;
} }
if (buffer + length + 1 > end) { if (buffer + length + 1 > end) {
*(end - 1) = 0; *(end - 1) = 0;
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...) bool hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...)
{ {
va_list ap; va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
bool_t result = hdhomerun_vsprintf(buffer, end, fmt, ap); bool result = hdhomerun_vsprintf(buffer, end, fmt, ap);
va_end(ap); va_end(ap);
return result; return result;
} }

9
hdhomerun_os_posix.h
View file

@ -22,6 +22,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <errno.h> #include <errno.h>
@ -37,11 +39,10 @@
#include <netdb.h> #include <netdb.h>
#include <pthread.h> #include <pthread.h>
typedef uint8_t bool_t;
typedef void (*sig_t)(int); typedef void (*sig_t)(int);
typedef struct { typedef struct {
volatile bool_t signaled; volatile bool signaled;
pthread_mutex_t lock; pthread_mutex_t lock;
pthread_cond_t cond; pthread_cond_t cond;
} thread_cond_t; } thread_cond_t;
@ -67,8 +68,8 @@ extern LIBHDHOMERUN_API void thread_cond_signal(thread_cond_t *cond);
extern LIBHDHOMERUN_API void thread_cond_wait(thread_cond_t *cond); extern LIBHDHOMERUN_API void thread_cond_wait(thread_cond_t *cond);
extern LIBHDHOMERUN_API void thread_cond_wait_with_timeout(thread_cond_t *cond, uint64_t max_wait_time); extern LIBHDHOMERUN_API void thread_cond_wait_with_timeout(thread_cond_t *cond, uint64_t max_wait_time);
extern LIBHDHOMERUN_API bool_t hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap); extern LIBHDHOMERUN_API bool hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap);
extern LIBHDHOMERUN_API bool_t hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...); extern LIBHDHOMERUN_API bool hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...);
#ifdef __cplusplus #ifdef __cplusplus
} }

18
hdhomerun_os_windows.c
View file

@ -97,7 +97,7 @@ int pthread_join(pthread_t tid, void **value_ptr)
void pthread_mutex_init(pthread_mutex_t *mutex, void *attr) void pthread_mutex_init(pthread_mutex_t *mutex, void *attr)
{ {
*mutex = CreateMutex(NULL, FALSE, NULL); *mutex = CreateMutex(NULL, false, NULL);
} }
void pthread_mutex_dispose(pthread_mutex_t *mutex) void pthread_mutex_dispose(pthread_mutex_t *mutex)
@ -117,7 +117,7 @@ void pthread_mutex_unlock(pthread_mutex_t *mutex)
void thread_cond_init(thread_cond_t *cond) void thread_cond_init(thread_cond_t *cond)
{ {
*cond = CreateEvent(NULL, FALSE, FALSE, NULL); *cond = CreateEvent(NULL, false, false, NULL);
} }
void thread_cond_dispose(thread_cond_t *cond) void thread_cond_dispose(thread_cond_t *cond)
@ -140,32 +140,32 @@ void thread_cond_wait_with_timeout(thread_cond_t *cond, uint64_t max_wait_time)
WaitForSingleObject(*cond, (DWORD)max_wait_time); WaitForSingleObject(*cond, (DWORD)max_wait_time);
} }
bool_t hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap) bool hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap)
{ {
if (buffer >= end) { if (buffer >= end) {
return FALSE; return false;
} }
int length = _vsnprintf(buffer, end - buffer - 1, fmt, ap); int length = _vsnprintf(buffer, end - buffer - 1, fmt, ap);
if (length < 0) { if (length < 0) {
*buffer = 0; *buffer = 0;
return FALSE; return false;
} }
if (buffer + length + 1 > end) { if (buffer + length + 1 > end) {
*(end - 1) = 0; *(end - 1) = 0;
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...) bool hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...)
{ {
va_list ap; va_list ap;
va_start(ap, fmt); va_start(ap, fmt);
bool_t result = hdhomerun_vsprintf(buffer, end, fmt, ap); bool result = hdhomerun_vsprintf(buffer, end, fmt, ap);
va_end(ap); va_end(ap);
return result; return result;
} }

6
hdhomerun_os_windows.h
View file

@ -40,6 +40,7 @@
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdint.h> #include <stdint.h>
#include <stdbool.h>
#include <string.h> #include <string.h>
#include <signal.h> #include <signal.h>
#include <time.h> #include <time.h>
@ -55,7 +56,6 @@
#define LIBHDHOMERUN_API #define LIBHDHOMERUN_API
#endif #endif
typedef uint8_t bool_t;
typedef void (*sig_t)(int); typedef void (*sig_t)(int);
typedef HANDLE pthread_t; typedef HANDLE pthread_t;
typedef HANDLE pthread_mutex_t; typedef HANDLE pthread_mutex_t;
@ -96,8 +96,8 @@ extern LIBHDHOMERUN_API void thread_cond_signal(thread_cond_t *cond);
extern LIBHDHOMERUN_API void thread_cond_wait(thread_cond_t *cond); extern LIBHDHOMERUN_API void thread_cond_wait(thread_cond_t *cond);
extern LIBHDHOMERUN_API void thread_cond_wait_with_timeout(thread_cond_t *cond, uint64_t max_wait_time); extern LIBHDHOMERUN_API void thread_cond_wait_with_timeout(thread_cond_t *cond, uint64_t max_wait_time);
extern LIBHDHOMERUN_API bool_t hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap); extern LIBHDHOMERUN_API bool hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap);
extern LIBHDHOMERUN_API bool_t hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...); extern LIBHDHOMERUN_API bool hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...);
#ifdef __cplusplus #ifdef __cplusplus
} }

16
hdhomerun_sock.h
View file

@ -46,17 +46,17 @@ extern LIBHDHOMERUN_API uint16_t hdhomerun_sock_getsockname_port(struct hdhomeru
extern LIBHDHOMERUN_API uint32_t hdhomerun_sock_getpeername_addr(struct hdhomerun_sock_t *sock); extern LIBHDHOMERUN_API uint32_t hdhomerun_sock_getpeername_addr(struct hdhomerun_sock_t *sock);
extern LIBHDHOMERUN_API uint32_t hdhomerun_sock_getaddrinfo_addr(struct hdhomerun_sock_t *sock, const char *name); extern LIBHDHOMERUN_API uint32_t hdhomerun_sock_getaddrinfo_addr(struct hdhomerun_sock_t *sock, const char *name);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip); extern LIBHDHOMERUN_API bool hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip); extern LIBHDHOMERUN_API bool hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, uint16_t local_port, bool_t allow_reuse); extern LIBHDHOMERUN_API bool hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, uint16_t local_port, bool allow_reuse);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout); extern LIBHDHOMERUN_API bool hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size_t length, uint64_t timeout); extern LIBHDHOMERUN_API bool hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size_t length, uint64_t timeout);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout); extern LIBHDHOMERUN_API bool hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_recv(struct hdhomerun_sock_t *sock, void *data, size_t *length, uint64_t timeout); extern LIBHDHOMERUN_API bool hdhomerun_sock_recv(struct hdhomerun_sock_t *sock, void *data, size_t *length, uint64_t timeout);
extern LIBHDHOMERUN_API bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout); extern LIBHDHOMERUN_API bool hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout);
#ifdef __cplusplus #ifdef __cplusplus
} }

92
hdhomerun_sock_posix.c
View file

@ -267,7 +267,7 @@ uint32_t hdhomerun_sock_getaddrinfo_addr(struct hdhomerun_sock_t *sock, const ch
return addr; return addr;
} }
bool_t hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip) bool hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip)
{ {
struct ip_mreq imr; struct ip_mreq imr;
memset(&imr, 0, sizeof(imr)); memset(&imr, 0, sizeof(imr));
@ -275,13 +275,13 @@ bool_t hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32
imr.imr_interface.s_addr = htonl(local_ip); imr.imr_interface.s_addr = htonl(local_ip);
if (setsockopt(sock->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) { if (setsockopt(sock->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip) bool hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip)
{ {
struct ip_mreq imr; struct ip_mreq imr;
memset(&imr, 0, sizeof(imr)); memset(&imr, 0, sizeof(imr));
@ -289,13 +289,13 @@ bool_t hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint3
imr.imr_interface.s_addr = htonl(local_ip); imr.imr_interface.s_addr = htonl(local_ip);
if (setsockopt(sock->sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) { if (setsockopt(sock->sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, uint16_t local_port, bool_t allow_reuse) bool hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, uint16_t local_port, bool allow_reuse)
{ {
int sock_opt = allow_reuse; int sock_opt = allow_reuse;
setsockopt(sock->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&sock_opt, sizeof(sock_opt)); setsockopt(sock->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&sock_opt, sizeof(sock_opt));
@ -307,13 +307,13 @@ bool_t hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, u
sock_addr.sin_port = htons(local_port); sock_addr.sin_port = htons(local_port);
if (bind(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { if (bind(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout) bool hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout)
{ {
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr)); memset(&sock_addr, 0, sizeof(sock_addr));
@ -323,7 +323,7 @@ bool_t hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_add
if (connect(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { if (connect(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
return FALSE; return false;
} }
} }
@ -333,26 +333,26 @@ bool_t hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_add
poll_event.revents = 0; poll_event.revents = 0;
if (poll(&poll_event, 1, (int)timeout) <= 0) { if (poll(&poll_event, 1, (int)timeout) <= 0) {
return FALSE; return false;
} }
if ((poll_event.revents & POLLOUT) == 0) { if ((poll_event.revents & POLLOUT) == 0) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size_t length, uint64_t timeout) bool hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size_t length, uint64_t timeout)
{ {
const uint8_t *ptr = (const uint8_t *)data; const uint8_t *ptr = (const uint8_t *)data;
ssize_t ret = send(sock->sock, ptr, length, MSG_NOSIGNAL); ssize_t ret = send(sock->sock, ptr, length, MSG_NOSIGNAL);
if (ret >= (ssize_t)length) { if (ret >= (ssize_t)length) {
return TRUE; return true;
} }
if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
return FALSE; return false;
} }
if (ret > 0) { if (ret > 0) {
@ -369,20 +369,20 @@ bool_t hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size
poll_event.revents = 0; poll_event.revents = 0;
if (poll(&poll_event, 1, (int)timeout) <= 0) { if (poll(&poll_event, 1, (int)timeout) <= 0) {
return FALSE; return false;
} }
if ((poll_event.revents & POLLOUT) == 0) { if ((poll_event.revents & POLLOUT) == 0) {
return FALSE; return false;
} }
ret = send(sock->sock, ptr, length, MSG_NOSIGNAL); ret = send(sock->sock, ptr, length, MSG_NOSIGNAL);
if (ret >= (ssize_t)length) { if (ret >= (ssize_t)length) {
return TRUE; return true;
} }
if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
return FALSE; return false;
} }
if (ret > 0) { if (ret > 0) {
@ -392,14 +392,14 @@ bool_t hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size
uint64_t current_time = getcurrenttime(); uint64_t current_time = getcurrenttime();
if (current_time >= stop_time) { if (current_time >= stop_time) {
return FALSE; return false;
} }
timeout = stop_time - current_time; timeout = stop_time - current_time;
} }
} }
bool_t hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout) bool hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout)
{ {
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr)); memset(&sock_addr, 0, sizeof(sock_addr));
@ -410,11 +410,11 @@ bool_t hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr
const uint8_t *ptr = (const uint8_t *)data; const uint8_t *ptr = (const uint8_t *)data;
ssize_t ret = sendto(sock->sock, ptr, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)); ssize_t ret = sendto(sock->sock, ptr, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
if (ret >= (ssize_t)length) { if (ret >= (ssize_t)length) {
return TRUE; return true;
} }
if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
return FALSE; return false;
} }
if (ret > 0) { if (ret > 0) {
@ -431,20 +431,20 @@ bool_t hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr
poll_event.revents = 0; poll_event.revents = 0;
if (poll(&poll_event, 1, (int)timeout) <= 0) { if (poll(&poll_event, 1, (int)timeout) <= 0) {
return FALSE; return false;
} }
if ((poll_event.revents & POLLOUT) == 0) { if ((poll_event.revents & POLLOUT) == 0) {
return FALSE; return false;
} }
ret = sendto(sock->sock, ptr, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)); ret = sendto(sock->sock, ptr, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
if (ret >= (ssize_t)length) { if (ret >= (ssize_t)length) {
return TRUE; return true;
} }
if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
return FALSE; return false;
} }
if (ret > 0) { if (ret > 0) {
@ -454,26 +454,26 @@ bool_t hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr
uint64_t current_time = getcurrenttime(); uint64_t current_time = getcurrenttime();
if (current_time >= stop_time) { if (current_time >= stop_time) {
return FALSE; return false;
} }
timeout = stop_time - current_time; timeout = stop_time - current_time;
} }
} }
bool_t hdhomerun_sock_recv(struct hdhomerun_sock_t *sock, void *data, size_t *length, uint64_t timeout) bool hdhomerun_sock_recv(struct hdhomerun_sock_t *sock, void *data, size_t *length, uint64_t timeout)
{ {
ssize_t ret = recv(sock->sock, data, *length, 0); ssize_t ret = recv(sock->sock, data, *length, 0);
if (ret > 0) { if (ret > 0) {
*length = ret; *length = ret;
return TRUE; return true;
} }
if (ret == 0) { if (ret == 0) {
return FALSE; return false;
} }
if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
return FALSE; return false;
} }
struct pollfd poll_event; struct pollfd poll_event;
@ -482,23 +482,23 @@ bool_t hdhomerun_sock_recv(struct hdhomerun_sock_t *sock, void *data, size_t *le
poll_event.revents = 0; poll_event.revents = 0;
if (poll(&poll_event, 1, (int)timeout) <= 0) { if (poll(&poll_event, 1, (int)timeout) <= 0) {
return FALSE; return false;
} }
if ((poll_event.revents & POLLIN) == 0) { if ((poll_event.revents & POLLIN) == 0) {
return FALSE; return false;
} }
ret = recv(sock->sock, data, *length, 0); ret = recv(sock->sock, data, *length, 0);
if (ret > 0) { if (ret > 0) {
*length = ret; *length = ret;
return TRUE; return true;
} }
return FALSE; return false;
} }
bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout) bool hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout)
{ {
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
memset(&sock_addr, 0, sizeof(sock_addr)); memset(&sock_addr, 0, sizeof(sock_addr));
@ -509,14 +509,14 @@ bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_a
*remote_addr = ntohl(sock_addr.sin_addr.s_addr); *remote_addr = ntohl(sock_addr.sin_addr.s_addr);
*remote_port = ntohs(sock_addr.sin_port); *remote_port = ntohs(sock_addr.sin_port);
*length = ret; *length = ret;
return TRUE; return true;
} }
if (ret == 0) { if (ret == 0) {
return FALSE; return false;
} }
if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
return FALSE; return false;
} }
struct pollfd poll_event; struct pollfd poll_event;
@ -525,11 +525,11 @@ bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_a
poll_event.revents = 0; poll_event.revents = 0;
if (poll(&poll_event, 1, (int)timeout) <= 0) { if (poll(&poll_event, 1, (int)timeout) <= 0) {
return FALSE; return false;
} }
if ((poll_event.revents & POLLIN) == 0) { if ((poll_event.revents & POLLIN) == 0) {
return FALSE; return false;
} }
ret = recvfrom(sock->sock, data, *length, 0, (struct sockaddr *)&sock_addr, &sockaddr_size); ret = recvfrom(sock->sock, data, *length, 0, (struct sockaddr *)&sock_addr, &sockaddr_size);
@ -537,8 +537,8 @@ bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_a
*remote_addr = ntohl(sock_addr.sin_addr.s_addr); *remote_addr = ntohl(sock_addr.sin_addr.s_addr);
*remote_port = ntohs(sock_addr.sin_port); *remote_port = ntohs(sock_addr.sin_port);
*length = ret; *length = ret;
return TRUE; return true;
} }
return FALSE; return false;
} }

112
hdhomerun_sock_windows.c
View file

@ -165,7 +165,7 @@ static struct hdhomerun_sock_t *hdhomerun_sock_create_internal(int protocol)
} }
/* Event */ /* Event */
sock->event = CreateEvent(NULL, FALSE, FALSE, NULL); sock->event = CreateEvent(NULL, false, false, NULL);
if (!sock->event) { if (!sock->event) {
hdhomerun_sock_destroy(sock); hdhomerun_sock_destroy(sock);
return NULL; return NULL;
@ -289,7 +289,7 @@ uint32_t hdhomerun_sock_getaddrinfo_addr(struct hdhomerun_sock_t *sock, const ch
return addr; return addr;
} }
bool_t hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip) bool hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip)
{ {
struct ip_mreq imr; struct ip_mreq imr;
memset(&imr, 0, sizeof(imr)); memset(&imr, 0, sizeof(imr));
@ -297,13 +297,13 @@ bool_t hdhomerun_sock_join_multicast_group(struct hdhomerun_sock_t *sock, uint32
imr.imr_interface.s_addr = htonl(local_ip); imr.imr_interface.s_addr = htonl(local_ip);
if (setsockopt(sock->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) { if (setsockopt(sock->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip) bool hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint32_t multicast_ip, uint32_t local_ip)
{ {
struct ip_mreq imr; struct ip_mreq imr;
memset(&imr, 0, sizeof(imr)); memset(&imr, 0, sizeof(imr));
@ -311,13 +311,13 @@ bool_t hdhomerun_sock_leave_multicast_group(struct hdhomerun_sock_t *sock, uint3
imr.imr_interface.s_addr = htonl(local_ip); imr.imr_interface.s_addr = htonl(local_ip);
if (setsockopt(sock->sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) { if (setsockopt(sock->sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, (const char *)&imr, sizeof(imr)) != 0) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, uint16_t local_port, bool_t allow_reuse) bool hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, uint16_t local_port, bool allow_reuse)
{ {
int sock_opt = allow_reuse; int sock_opt = allow_reuse;
setsockopt(sock->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&sock_opt, sizeof(sock_opt)); setsockopt(sock->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&sock_opt, sizeof(sock_opt));
@ -329,29 +329,29 @@ bool_t hdhomerun_sock_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, u
sock_addr.sin_port = htons(local_port); sock_addr.sin_port = htons(local_port);
if (bind(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { if (bind(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_event_select(struct hdhomerun_sock_t *sock, long events) bool hdhomerun_sock_event_select(struct hdhomerun_sock_t *sock, long events)
{ {
if (sock->events_selected != events) { if (sock->events_selected != events) {
if (WSAEventSelect(sock->sock, sock->event, events) == SOCKET_ERROR) { if (WSAEventSelect(sock->sock, sock->event, events) == SOCKET_ERROR) {
return FALSE; return false;
} }
sock->events_selected = events; sock->events_selected = events;
} }
ResetEvent(sock->event); ResetEvent(sock->event);
return TRUE; return true;
} }
bool_t hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout) bool hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, uint64_t timeout)
{ {
if (!hdhomerun_sock_event_select(sock, FD_WRITE | FD_CLOSE)) { if (!hdhomerun_sock_event_select(sock, FD_WRITE | FD_CLOSE)) {
return FALSE; return false;
} }
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
@ -362,33 +362,33 @@ bool_t hdhomerun_sock_connect(struct hdhomerun_sock_t *sock, uint32_t remote_add
if (connect(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { if (connect(sock->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
if (WSAGetLastError() != WSAEWOULDBLOCK) { if (WSAGetLastError() != WSAEWOULDBLOCK) {
return FALSE; return false;
} }
} }
DWORD wait_ret = WaitForSingleObjectEx(sock->event, (DWORD)timeout, FALSE); DWORD wait_ret = WaitForSingleObjectEx(sock->event, (DWORD)timeout, false);
if (wait_ret != WAIT_OBJECT_0) { if (wait_ret != WAIT_OBJECT_0) {
return FALSE; return false;
} }
WSANETWORKEVENTS network_events; WSANETWORKEVENTS network_events;
if (WSAEnumNetworkEvents(sock->sock, sock->event, &network_events) == SOCKET_ERROR) { if (WSAEnumNetworkEvents(sock->sock, sock->event, &network_events) == SOCKET_ERROR) {
return FALSE; return false;
} }
if ((network_events.lNetworkEvents & FD_WRITE) == 0) { if ((network_events.lNetworkEvents & FD_WRITE) == 0) {
return FALSE; return false;
} }
if (network_events.lNetworkEvents & FD_CLOSE) { if (network_events.lNetworkEvents & FD_CLOSE) {
return FALSE; return false;
} }
return TRUE; return true;
} }
bool_t hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size_t length, uint64_t timeout) bool hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size_t length, uint64_t timeout)
{ {
if (!hdhomerun_sock_event_select(sock, FD_WRITE | FD_CLOSE)) { if (!hdhomerun_sock_event_select(sock, FD_WRITE | FD_CLOSE)) {
return FALSE; return false;
} }
uint64_t stop_time = getcurrenttime() + timeout; uint64_t stop_time = getcurrenttime() + timeout;
@ -397,11 +397,11 @@ bool_t hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size
while (1) { while (1) {
int ret = send(sock->sock, (char *)ptr, (int)length, 0); int ret = send(sock->sock, (char *)ptr, (int)length, 0);
if (ret >= (int)length) { if (ret >= (int)length) {
return TRUE; return true;
} }
if ((ret == SOCKET_ERROR) && (WSAGetLastError() != WSAEWOULDBLOCK)) { if ((ret == SOCKET_ERROR) && (WSAGetLastError() != WSAEWOULDBLOCK)) {
return FALSE; return false;
} }
if (ret > 0) { if (ret > 0) {
@ -411,19 +411,19 @@ bool_t hdhomerun_sock_send(struct hdhomerun_sock_t *sock, const void *data, size
uint64_t current_time = getcurrenttime(); uint64_t current_time = getcurrenttime();
if (current_time >= stop_time) { if (current_time >= stop_time) {
return FALSE; return false;
} }
if (WaitForSingleObjectEx(sock->event, (DWORD)(stop_time - current_time), FALSE) != WAIT_OBJECT_0) { if (WaitForSingleObjectEx(sock->event, (DWORD)(stop_time - current_time), false) != WAIT_OBJECT_0) {
return FALSE; return false;
} }
} }
} }
bool_t hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout) bool hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr, uint16_t remote_port, const void *data, size_t length, uint64_t timeout)
{ {
if (!hdhomerun_sock_event_select(sock, FD_WRITE | FD_CLOSE)) { if (!hdhomerun_sock_event_select(sock, FD_WRITE | FD_CLOSE)) {
return FALSE; return false;
} }
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
@ -434,64 +434,64 @@ bool_t hdhomerun_sock_sendto(struct hdhomerun_sock_t *sock, uint32_t remote_addr
int ret = sendto(sock->sock, (char *)data, (int)length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)); int ret = sendto(sock->sock, (char *)data, (int)length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
if (ret >= (int)length) { if (ret >= (int)length) {
return TRUE; return true;
} }
if (ret >= 0) { if (ret >= 0) {
return FALSE; return false;
} }
if (WSAGetLastError() != WSAEWOULDBLOCK) { if (WSAGetLastError() != WSAEWOULDBLOCK) {
return FALSE; return false;
} }
if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, FALSE) != WAIT_OBJECT_0) { if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, false) != WAIT_OBJECT_0) {
return FALSE; return false;
} }
ret = sendto(sock->sock, (char *)data, (int)length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)); ret = sendto(sock->sock, (char *)data, (int)length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
if (ret >= (int)length) { if (ret >= (int)length) {
return TRUE; return true;
} }
return FALSE; return false;
} }
bool_t hdhomerun_sock_recv(struct hdhomerun_sock_t *sock, void *data, size_t *length, uint64_t timeout) bool hdhomerun_sock_recv(struct hdhomerun_sock_t *sock, void *data, size_t *length, uint64_t timeout)
{ {
if (!hdhomerun_sock_event_select(sock, FD_READ | FD_CLOSE)) { if (!hdhomerun_sock_event_select(sock, FD_READ | FD_CLOSE)) {
return FALSE; return false;
} }
int ret = recv(sock->sock, (char *)data, (int)(*length), 0); int ret = recv(sock->sock, (char *)data, (int)(*length), 0);
if (ret > 0) { if (ret > 0) {
*length = ret; *length = ret;
return TRUE; return true;
} }
if (ret == 0) { if (ret == 0) {
return FALSE; return false;
} }
if (WSAGetLastError() != WSAEWOULDBLOCK) { if (WSAGetLastError() != WSAEWOULDBLOCK) {
return FALSE; return false;
} }
if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, FALSE) != WAIT_OBJECT_0) { if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, false) != WAIT_OBJECT_0) {
return FALSE; return false;
} }
ret = recv(sock->sock, (char *)data, (int)(*length), 0); ret = recv(sock->sock, (char *)data, (int)(*length), 0);
if (ret > 0) { if (ret > 0) {
*length = ret; *length = ret;
return TRUE; return true;
} }
return FALSE; return false;
} }
bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout) bool hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_addr, uint16_t *remote_port, void *data, size_t *length, uint64_t timeout)
{ {
if (!hdhomerun_sock_event_select(sock, FD_READ | FD_CLOSE)) { if (!hdhomerun_sock_event_select(sock, FD_READ | FD_CLOSE)) {
return FALSE; return false;
} }
struct sockaddr_in sock_addr; struct sockaddr_in sock_addr;
@ -503,18 +503,18 @@ bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_a
*remote_addr = ntohl(sock_addr.sin_addr.s_addr); *remote_addr = ntohl(sock_addr.sin_addr.s_addr);
*remote_port = ntohs(sock_addr.sin_port); *remote_port = ntohs(sock_addr.sin_port);
*length = ret; *length = ret;
return TRUE; return true;
} }
if (ret == 0) { if (ret == 0) {
return FALSE; return false;
} }
if (WSAGetLastError() != WSAEWOULDBLOCK) { if (WSAGetLastError() != WSAEWOULDBLOCK) {
return FALSE; return false;
} }
if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, FALSE) != WAIT_OBJECT_0) { if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, false) != WAIT_OBJECT_0) {
return FALSE; return false;
} }
ret = recvfrom(sock->sock, (char *)data, (int)(*length), 0, (struct sockaddr *)&sock_addr, &sockaddr_size); ret = recvfrom(sock->sock, (char *)data, (int)(*length), 0, (struct sockaddr *)&sock_addr, &sockaddr_size);
@ -522,8 +522,8 @@ bool_t hdhomerun_sock_recvfrom(struct hdhomerun_sock_t *sock, uint32_t *remote_a
*remote_addr = ntohl(sock_addr.sin_addr.s_addr); *remote_addr = ntohl(sock_addr.sin_addr.s_addr);
*remote_port = ntohs(sock_addr.sin_port); *remote_port = ntohs(sock_addr.sin_port);
*length = ret; *length = ret;
return TRUE; return true;
} }
return FALSE; return false;
} }

16
hdhomerun_types.h
View file

@ -29,9 +29,9 @@ struct hdhomerun_device_allocation_t;
struct hdhomerun_tuner_status_t { struct hdhomerun_tuner_status_t {
char channel[32]; char channel[32];
char lock_str[32]; char lock_str[32];
bool_t signal_present; bool signal_present;
bool_t lock_supported; bool lock_supported;
bool_t lock_unsupported; bool lock_unsupported;
unsigned int signal_strength; unsigned int signal_strength;
unsigned int signal_to_noise_quality; unsigned int signal_to_noise_quality;
unsigned int symbol_error_quality; unsigned int symbol_error_quality;
@ -45,9 +45,9 @@ struct hdhomerun_tuner_vstatus_t {
char auth[32]; char auth[32];
char cci[32]; char cci[32];
char cgms[32]; char cgms[32];
bool_t not_subscribed; bool not_subscribed;
bool_t not_available; bool not_available;
bool_t copy_protected; bool copy_protected;
}; };
struct hdhomerun_channelscan_program_t { struct hdhomerun_channelscan_program_t {
@ -68,8 +68,8 @@ struct hdhomerun_channelscan_result_t {
struct hdhomerun_tuner_status_t status; struct hdhomerun_tuner_status_t status;
int program_count; int program_count;
struct hdhomerun_channelscan_program_t programs[HDHOMERUN_CHANNELSCAN_MAX_PROGRAM_COUNT]; struct hdhomerun_channelscan_program_t programs[HDHOMERUN_CHANNELSCAN_MAX_PROGRAM_COUNT];
bool_t transport_stream_id_detected; bool transport_stream_id_detected;
bool_t original_network_id_detected; bool original_network_id_detected;
uint16_t transport_stream_id; uint16_t transport_stream_id;
uint16_t original_network_id; uint16_t original_network_id;
}; };

14
hdhomerun_video.c
View file

@ -28,7 +28,7 @@ struct hdhomerun_video_sock_t {
uint32_t keepalive_lockkey; uint32_t keepalive_lockkey;
uint32_t keepalive_addr; uint32_t keepalive_addr;
uint16_t keepalive_port; uint16_t keepalive_port;
volatile bool_t keepalive_start; volatile bool keepalive_start;
volatile size_t head; volatile size_t head;
volatile size_t tail; volatile size_t tail;
@ -37,7 +37,7 @@ struct hdhomerun_video_sock_t {
size_t advance; size_t advance;
pthread_t thread; pthread_t thread;
volatile bool_t terminate; volatile bool terminate;
volatile uint32_t packet_count; volatile uint32_t packet_count;
volatile uint32_t transport_error_count; volatile uint32_t transport_error_count;
@ -51,7 +51,7 @@ struct hdhomerun_video_sock_t {
static THREAD_FUNC_PREFIX hdhomerun_video_thread_execute(void *arg); static THREAD_FUNC_PREFIX hdhomerun_video_thread_execute(void *arg);
struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, bool_t allow_port_reuse, size_t buffer_size, struct hdhomerun_debug_t *dbg) struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, bool allow_port_reuse, size_t buffer_size, struct hdhomerun_debug_t *dbg)
{ {
/* Create object. */ /* Create object. */
struct hdhomerun_video_sock_t *vs = (struct hdhomerun_video_sock_t *)calloc(1, sizeof(struct hdhomerun_video_sock_t)); struct hdhomerun_video_sock_t *vs = (struct hdhomerun_video_sock_t *)calloc(1, sizeof(struct hdhomerun_video_sock_t));
@ -123,7 +123,7 @@ error:
void hdhomerun_video_destroy(struct hdhomerun_video_sock_t *vs) void hdhomerun_video_destroy(struct hdhomerun_video_sock_t *vs)
{ {
vs->terminate = TRUE; vs->terminate = true;
pthread_join(vs->thread, NULL); pthread_join(vs->thread, NULL);
hdhomerun_sock_destroy(vs->sock); hdhomerun_sock_destroy(vs->sock);
@ -142,7 +142,7 @@ void hdhomerun_video_set_keepalive(struct hdhomerun_video_sock_t *vs, uint32_t r
vs->keepalive_lockkey = lockkey; vs->keepalive_lockkey = lockkey;
if ((remote_addr != 0) && (remote_port != 0)) { if ((remote_addr != 0) && (remote_port != 0)) {
vs->keepalive_start = TRUE; vs->keepalive_start = true;
} }
pthread_mutex_unlock(&vs->lock); pthread_mutex_unlock(&vs->lock);
@ -188,7 +188,7 @@ static void hdhomerun_video_stats_ts_pkt(struct hdhomerun_video_sock_t *vs, uint
return; return;
} }
bool_t transport_error = ptr[1] >> 7; bool transport_error = ptr[1] >> 7;
if (transport_error) { if (transport_error) {
vs->transport_error_count++; vs->transport_error_count++;
vs->sequence[packet_identifier] = 0xFF; vs->sequence[packet_identifier] = 0xFF;
@ -248,7 +248,7 @@ static void hdhomerun_video_thread_send_keepalive(struct hdhomerun_video_sock_t
uint32_t keepalive_lockkey = vs->keepalive_lockkey; uint32_t keepalive_lockkey = vs->keepalive_lockkey;
uint32_t keepalive_addr = vs->keepalive_addr; uint32_t keepalive_addr = vs->keepalive_addr;
uint16_t keepalive_port = vs->keepalive_port; uint16_t keepalive_port = vs->keepalive_port;
vs->keepalive_start = FALSE; vs->keepalive_start = false;
pthread_mutex_unlock(&vs->lock); pthread_mutex_unlock(&vs->lock);
if ((keepalive_addr == 0) || (keepalive_port == 0)) { if ((keepalive_addr == 0) || (keepalive_port == 0)) {

2
hdhomerun_video.h
View file

@ -48,7 +48,7 @@ struct hdhomerun_video_stats_t {
* *
* When no longer needed, the socket should be destroyed by calling hdhomerun_control_destroy. * When no longer needed, the socket should be destroyed by calling hdhomerun_control_destroy.
*/ */
extern LIBHDHOMERUN_API struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, bool_t allow_port_reuse, size_t buffer_size, struct hdhomerun_debug_t *dbg); extern LIBHDHOMERUN_API struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, bool allow_port_reuse, size_t buffer_size, struct hdhomerun_debug_t *dbg);
extern LIBHDHOMERUN_API void hdhomerun_video_destroy(struct hdhomerun_video_sock_t *vs); extern LIBHDHOMERUN_API void hdhomerun_video_destroy(struct hdhomerun_video_sock_t *vs);
/* /*