From 1d68aab36702497674cc26907bb48fff5ea8b7ee Mon Sep 17 00:00:00 2001 From: Nick Kelsey Date: Fri, 2 Jun 2017 12:19:44 -0700 Subject: [PATCH] use stdbool --- hdhomerun_channelscan.c | 22 +++---- hdhomerun_config.c | 22 +++---- hdhomerun_control.c | 34 +++++------ hdhomerun_debug.c | 40 ++++++------- hdhomerun_debug.h | 2 +- hdhomerun_device.c | 30 +++++----- hdhomerun_device_selector.c | 36 ++++++------ hdhomerun_device_selector.h | 2 +- hdhomerun_discover.c | 60 +++++++++---------- hdhomerun_discover.h | 14 ++--- hdhomerun_os.h | 8 --- hdhomerun_os_posix.c | 22 +++---- hdhomerun_os_posix.h | 9 +-- hdhomerun_os_windows.c | 18 +++--- hdhomerun_os_windows.h | 6 +- hdhomerun_sock.h | 16 +++--- hdhomerun_sock_posix.c | 92 ++++++++++++++--------------- hdhomerun_sock_windows.c | 112 ++++++++++++++++++------------------ hdhomerun_types.h | 16 +++--- hdhomerun_video.c | 14 ++--- hdhomerun_video.h | 2 +- 21 files changed, 285 insertions(+), 292 deletions(-) diff --git a/hdhomerun_channelscan.c b/hdhomerun_channelscan.c index a077b87..b7a8ee4 100644 --- a/hdhomerun_channelscan.c +++ b/hdhomerun_channelscan.c @@ -127,10 +127,10 @@ static void channelscan_extract_name(struct hdhomerun_channelscan_program_t *pro 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; - *pincomplete = FALSE; + *pchanged = false; + *pincomplete = false; char *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; if (sscanf(line, "tsid=0x%x", &transport_stream_id) == 1) { result->transport_stream_id = transport_stream_id; - result->transport_stream_id_detected = TRUE; + result->transport_stream_id_detected = true; continue; } unsigned int original_network_id; if (sscanf(line, "onid=0x%x", &original_network_id) == 1) { result->original_network_id = original_network_id; - result->original_network_id_detected = TRUE; + result->original_network_id_detected = true; continue; } @@ -194,28 +194,28 @@ static int channelscan_detect_programs(struct hdhomerun_channelscan_t *scan, str program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_ENCRYPTED; } else if (strstr(line, "(no data)")) { program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NODATA; - *pincomplete = TRUE; + *pincomplete = true; } else { program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NORMAL; if ((program.virtual_major == 0) || (program.name[0] == 0)) { - *pincomplete = TRUE; + *pincomplete = true; } } if (memcmp(&result->programs[program_count], &program, sizeof(program)) != 0) { memcpy(&result->programs[program_count], &program, sizeof(program)); - *pchanged = TRUE; + *pchanged = true; } program_count++; } if (program_count == 0) { - *pincomplete = TRUE; + *pincomplete = true; } if (result->program_count != program_count) { result->program_count = program_count; - *pchanged = TRUE; + *pchanged = true; } return 1; @@ -282,7 +282,7 @@ int channelscan_detect(struct hdhomerun_channelscan_t *scan, struct hdhomerun_ch uint64_t complete_time = getcurrenttime() + 1000; while (1) { - bool_t changed, incomplete; + bool changed, incomplete; ret = channelscan_detect_programs(scan, result, &changed, &incomplete); if (ret <= 0) { return ret; diff --git a/hdhomerun_config.c b/hdhomerun_config.c index c9bfa9c..8fb37e1 100644 --- a/hdhomerun_config.c +++ b/hdhomerun_config.c @@ -50,23 +50,23 @@ static void extract_appname(const char *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) { - return TRUE; + return true; } if (*arg++ != '-') { - return FALSE; + return false; } if (*arg++ != '-') { - return FALSE; + return false; } if (strcmp(arg, cmpstr) == 0) { - return TRUE; + return true; } - return FALSE; + return false; } 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); } -static volatile sig_atomic_t sigabort_flag = FALSE; -static volatile sig_atomic_t siginfo_flag = FALSE; +static volatile sig_atomic_t sigabort_flag = false; +static volatile sig_atomic_t siginfo_flag = false; static void sigabort_handler(int arg) { - sigabort_flag = TRUE; + sigabort_flag = true; } 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) @@ -379,7 +379,7 @@ static int cmd_save(const char *tuner_str, const char *filename) if (siginfo_flag) { fprintf(stderr, "\n"); cmd_save_print_stats(); - siginfo_flag = FALSE; + siginfo_flag = false; } size_t actual_size; diff --git a/hdhomerun_control.c b/hdhomerun_control.c index be7ba67..814ad4b 100644 --- a/hdhomerun_control.c +++ b/hdhomerun_control.c @@ -76,26 +76,26 @@ void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *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) { - return TRUE; + return true; } if ((cs->desired_device_id == 0) && (cs->desired_device_ip == 0)) { 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)) { hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: cannot use multicast ip address for device operations\n"); - return FALSE; + return false; } /* Find device. */ 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) { 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_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(); if (!cs->sock) { hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to create socket (%d)\n", hdhomerun_sock_getlasterror()); - return FALSE; + return false; } /* Initiate connection. */ if (!hdhomerun_sock_connect(cs->sock, cs->actual_device_ip, HDHOMERUN_CONTROL_TCP_PORT, HDHOMERUN_CONTROL_CONNECT_TIMEOUT)) { hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to connect (%d)\n", hdhomerun_sock_getlasterror()); hdhomerun_control_close_sock(cs); - return FALSE; + return false; } /* Success. */ - return TRUE; + return true; } 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; } -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)) { hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_sock: send failed (%d)\n", hdhomerun_sock_getlasterror()); 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; 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) { hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: timeout\n"); hdhomerun_control_close_sock(cs); - return FALSE; + return false; } size_t length = rx_pkt->limit - rx_pkt->end; if (!hdhomerun_sock_recv(cs->sock, rx_pkt->end, &length, stop_time - current_time)) { hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: recv failed (%d)\n", hdhomerun_sock_getlasterror()); hdhomerun_control_close_sock(cs); - return FALSE; + return false; } 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) { hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: frame error\n"); hdhomerun_control_close_sock(cs); - return FALSE; + return false; } 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 *rx_pkt = &cs->rx_pkt; - bool_t upload_delay = FALSE; + bool upload_delay = false; uint32_t sequence = 0; /* Special case detection. */ diff --git a/hdhomerun_debug.c b/hdhomerun_debug.c index 95270bc..43b132f 100644 --- a/hdhomerun_debug.c +++ b/hdhomerun_debug.c @@ -49,8 +49,8 @@ struct hdhomerun_debug_message_t struct hdhomerun_debug_t { pthread_t thread; - volatile bool_t enabled; - volatile bool_t terminate; + volatile bool enabled; + volatile bool terminate; char *prefix; pthread_mutex_t print_lock; @@ -95,7 +95,7 @@ void hdhomerun_debug_destroy(struct hdhomerun_debug_t *dbg) return; } - dbg->terminate = TRUE; + dbg->terminate = true; pthread_join(dbg->thread, NULL); if (dbg->prefix) { @@ -206,7 +206,7 @@ void hdhomerun_debug_enable(struct hdhomerun_debug_t *dbg) return; } - dbg->enabled = TRUE; + dbg->enabled = true; } void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg) @@ -215,13 +215,13 @@ void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg) 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) { - return FALSE; + return false; } 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 */ -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) { uint64_t current_time = getcurrenttime(); if (current_time < dbg->connect_delay) { - return FALSE; + return false; } dbg->connect_delay = current_time + 30*1000; dbg->file_fp = fopen(dbg->file_name, "a"); if (!dbg->file_fp) { - return FALSE; + return false; } } fprintf(dbg->file_fp, "%s", message->buffer); fflush(dbg->file_fp); - return TRUE; + return true; } /* 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) { uint64_t current_time = getcurrenttime(); if (current_time < dbg->connect_delay) { - return FALSE; + return false; } dbg->connect_delay = current_time + HDHOMERUN_DEBUG_CONNECT_RETRY_TIME; dbg->sock = hdhomerun_sock_create_tcp(); if (!dbg->sock) { - return FALSE; + return false; } uint32_t remote_addr = hdhomerun_sock_getaddrinfo_addr(dbg->sock, HDHOMERUN_DEBUG_HOST); if (remote_addr == 0) { hdhomerun_debug_close_internal(dbg); - return FALSE; + return false; } if (!hdhomerun_sock_connect(dbg->sock, remote_addr, HDHOMERUN_DEBUG_PORT, HDHOMERUN_DEBUG_CONNECT_TIMEOUT)) { hdhomerun_debug_close_internal(dbg); - return FALSE; + return false; } } size_t length = strlen(message->buffer); if (!hdhomerun_sock_send(dbg->sock, message->buffer, length, HDHOMERUN_DEBUG_SEND_TIMEOUT)) { 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); - bool_t ret; + bool ret; if (dbg->file_name) { ret = hdhomerun_debug_output_message_file(dbg, message); } else { diff --git a/hdhomerun_debug.h b/hdhomerun_debug.h index 5f6a183..1e9a45d 100644 --- a/hdhomerun_debug.h +++ b/hdhomerun_debug.h @@ -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_enable(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_close(struct hdhomerun_debug_t *dbg, uint64_t timeout); diff --git a/hdhomerun_device.c b/hdhomerun_device.c index 80ba123..9f43229 100644 --- a/hdhomerun_device.c +++ b/hdhomerun_device.c @@ -339,7 +339,7 @@ struct hdhomerun_video_sock_t *hdhomerun_device_get_video_sock(struct hdhomerun_ 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); if (!hd->vs) { @@ -372,22 +372,22 @@ static uint32_t hdhomerun_device_get_status_parse(const char *status_str, const 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) { - return TRUE; + return true; } if (strncmp(status->lock_str, "t8", 2) == 0) { - return TRUE; + return true; } if (strncmp(status->lock_str, "t7", 2) == 0) { - return TRUE; + return true; } 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) @@ -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 (status->lock_str[0] == '(') { - status->lock_unsupported = TRUE; + status->lock_unsupported = true; } 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) { - vstatus->not_subscribed = TRUE; + vstatus->not_subscribed = true; } if (strncmp(vstatus->auth, "error", 5) == 0) { - vstatus->not_available = TRUE; + vstatus->not_available = true; } if (strncmp(vstatus->auth, "dialog", 6) == 0) { - vstatus->not_available = TRUE; + vstatus->not_available = true; } if (strncmp(vstatus->cci, "protected", 9) == 0) { - vstatus->copy_protected = TRUE; + vstatus->copy_protected = true; } 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); } -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) { return hdhomerun_sprintf(ptr, end, "0x%04x ", (unsigned int)range_begin); diff --git a/hdhomerun_device_selector.c b/hdhomerun_device_selector.c index a60d3be..ed9296e 100644 --- a/hdhomerun_device_selector.c +++ b/hdhomerun_device_selector.c @@ -39,7 +39,7 @@ struct hdhomerun_device_selector_t *hdhomerun_device_selector_create(struct hdho 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) { size_t index; @@ -313,7 +313,7 @@ int hdhomerun_device_selector_load_from_windows_registry(struct hdhomerun_device } #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); @@ -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); if (ret > 0) { hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name); - return TRUE; + return true; } if (ret < 0) { 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); if (ret < 0) { hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name); - return FALSE; + 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; + return false; } if (strcmp(target, "none") == 0) { 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)) { 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 target_port; 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); - return FALSE; + 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; + 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(); if (!test_sock) { 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); if (inuse) { 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); if (ret < 0) { hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s communication error\n", name); - return FALSE; + 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; + 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); @@ -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); if (ret > 0) { hdhomerun_debug_printf(hds->dbg, "hdhomerun_device_selector_choose_test: device %s chosen\n", name); - return TRUE; + return true; } if (ret < 0) { 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); - 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) diff --git a/hdhomerun_device_selector.h b/hdhomerun_device_selector.h index a66e058..7f3bed6 100644 --- a/hdhomerun_device_selector.h +++ b/hdhomerun_device_selector.h @@ -28,7 +28,7 @@ extern "C" { * 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 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. diff --git a/hdhomerun_discover.c b/hdhomerun_discover.c index edac9b0..fd4748b 100644 --- a/hdhomerun_discover.c +++ b/hdhomerun_discover.c @@ -24,7 +24,7 @@ struct hdhomerun_discover_sock_t { struct hdhomerun_sock_t *sock; - bool_t detected; + bool detected; uint32_t local_ip; uint32_t subnet_mask; }; @@ -37,44 +37,44 @@ struct hdhomerun_discover_t { 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; for (i = 1; i < ds->sock_count; i++) { struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; if ((dss->local_ip == local_ip) && (dss->subnet_mask == subnet_mask)) { - dss->detected = TRUE; - return TRUE; + dss->detected = true; + return true; } } if (ds->sock_count >= HDHOMERUN_DISCOVER_MAX_SOCK_COUNT) { - return FALSE; + return false; } /* Create socket. */ struct hdhomerun_sock_t *sock = hdhomerun_sock_create_udp(); if (!sock) { hdhomerun_debug_printf(ds->dbg, "discover: failed to allocate socket (%d)\n", hdhomerun_sock_getlasterror()); - return FALSE; + return false; } /* 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_sock_destroy(sock); - return FALSE; + return false; } /* Write sock entry. */ struct hdhomerun_discover_sock_t *dss = &ds->socks[ds->sock_count++]; dss->sock = sock; - dss->detected = TRUE; + dss->detected = true; dss->local_ip = local_ip; dss->subnet_mask = subnet_mask; - return TRUE; + return true; } 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; for (i = 1; i < ds->sock_count; 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]; @@ -152,7 +152,7 @@ static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds) ds->sock_count = count; } -static bool_t hdhomerun_discover_send_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, uint32_t target_ip, uint32_t device_type, uint32_t device_id) +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; 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); } -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. @@ -194,9 +194,9 @@ static bool_t hdhomerun_discover_send_wildcard_ip(struct hdhomerun_discover_t *d 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. @@ -226,7 +226,7 @@ static bool_t hdhomerun_discover_send_target_ip(struct hdhomerun_discover_t *ds, 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) { 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) { 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 0x121: /* HDHR-EU */ case 0x122: /* HDHR3-EU */ - return TRUE; + return true; 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+/"; 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; size_t length = rx_pkt->limit - rx_pkt->end; if (!hdhomerun_sock_recvfrom(dss->sock, &remote_addr, &remote_port, rx_pkt->end, &length, 0)) { - return FALSE; + return false; } rx_pkt->end += length; uint16_t type; if (hdhomerun_pkt_open_frame(rx_pkt, &type) <= 0) { - return FALSE; + return false; } if (type != HDHOMERUN_TYPE_DISCOVER_RPY) { - return FALSE; + return false; } 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; for (i = 0; i < ds->sock_count; i++) { struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; 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) @@ -476,7 +476,7 @@ int hdhomerun_discover_find_devices_custom_v2(uint32_t target_ip, uint32_t devic 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}; @@ -494,7 +494,7 @@ bool_t hdhomerun_discover_validate_device_id(uint32_t device_id) 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); } diff --git a/hdhomerun_discover.h b/hdhomerun_discover.h index 4626d55..c929814 100644 --- a/hdhomerun_discover.h +++ b/hdhomerun_discover.h @@ -26,7 +26,7 @@ struct hdhomerun_discover_device_t { uint32_t device_type; uint32_t device_id; uint8_t tuner_count; - bool_t is_legacy; + bool is_legacy; char device_auth[25]; 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 * single-digit errors and two digit transposition errors. * - * Returns TRUE if valid. - * Returns FALSE if not valid. + * Returns true if 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. * - * Returns TRUE if multicast. - * Returns FALSE if zero, unicast, expermental, or broadcast. + * Returns true if multicast. + * 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 } diff --git a/hdhomerun_os.h b/hdhomerun_os.h index f7e1511..07d4ace 100644 --- a/hdhomerun_os.h +++ b/hdhomerun_os.h @@ -23,11 +23,3 @@ #else #include "hdhomerun_os_posix.h" #endif - -#if !defined(TRUE) -#define TRUE 1 -#endif - -#if !defined(FALSE) -#define FALSE 0 -#endif diff --git a/hdhomerun_os_posix.c b/hdhomerun_os_posix.c index 70feab4..13a2cd0 100644 --- a/hdhomerun_os_posix.c +++ b/hdhomerun_os_posix.c @@ -130,7 +130,7 @@ void pthread_mutex_dispose(pthread_mutex_t *mutex) void thread_cond_init(thread_cond_t *cond) { - cond->signaled = FALSE; + cond->signaled = false; pthread_mutex_init(&cond->lock, NULL); pthread_cond_init(&cond->cond, NULL); } @@ -143,7 +143,7 @@ void thread_cond_signal(thread_cond_t *cond) { pthread_mutex_lock(&cond->lock); - cond->signaled = TRUE; + cond->signaled = true; pthread_cond_signal(&cond->cond); pthread_mutex_unlock(&cond->lock); @@ -157,7 +157,7 @@ void thread_cond_wait(thread_cond_t *cond) pthread_cond_wait(&cond->cond, &cond->lock); } - cond->signaled = FALSE; + cond->signaled = false; 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); } - cond->signaled = FALSE; + cond->signaled = false; 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) { - return FALSE; + return false; } int length = vsnprintf(buffer, end - buffer - 1, fmt, ap); if (length < 0) { *buffer = 0; - return FALSE; + return false; } if (buffer + length + 1 > end) { *(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_start(ap, fmt); - bool_t result = hdhomerun_vsprintf(buffer, end, fmt, ap); + bool result = hdhomerun_vsprintf(buffer, end, fmt, ap); va_end(ap); return result; } diff --git a/hdhomerun_os_posix.h b/hdhomerun_os_posix.h index 831a15b..c6898a7 100644 --- a/hdhomerun_os_posix.h +++ b/hdhomerun_os_posix.h @@ -22,6 +22,8 @@ #include #include #include +#include +#include #include #include #include @@ -37,11 +39,10 @@ #include #include -typedef uint8_t bool_t; typedef void (*sig_t)(int); typedef struct { - volatile bool_t signaled; + volatile bool signaled; pthread_mutex_t lock; pthread_cond_t cond; } 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_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_t hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...); +extern LIBHDHOMERUN_API bool hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap); +extern LIBHDHOMERUN_API bool hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...); #ifdef __cplusplus } diff --git a/hdhomerun_os_windows.c b/hdhomerun_os_windows.c index db679b9..8261b7b 100644 --- a/hdhomerun_os_windows.c +++ b/hdhomerun_os_windows.c @@ -97,7 +97,7 @@ int pthread_join(pthread_t tid, void **value_ptr) 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) @@ -117,7 +117,7 @@ void pthread_mutex_unlock(pthread_mutex_t *mutex) 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) @@ -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); } -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) { - return FALSE; + return false; } int length = _vsnprintf(buffer, end - buffer - 1, fmt, ap); if (length < 0) { *buffer = 0; - return FALSE; + return false; } if (buffer + length + 1 > end) { *(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_start(ap, fmt); - bool_t result = hdhomerun_vsprintf(buffer, end, fmt, ap); + bool result = hdhomerun_vsprintf(buffer, end, fmt, ap); va_end(ap); return result; } diff --git a/hdhomerun_os_windows.h b/hdhomerun_os_windows.h index 67a4d78..7420538 100644 --- a/hdhomerun_os_windows.h +++ b/hdhomerun_os_windows.h @@ -40,6 +40,7 @@ #include #include #include +#include #include #include #include @@ -55,7 +56,6 @@ #define LIBHDHOMERUN_API #endif -typedef uint8_t bool_t; typedef void (*sig_t)(int); typedef HANDLE pthread_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_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_t hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...); +extern LIBHDHOMERUN_API bool hdhomerun_vsprintf(char *buffer, char *end, const char *fmt, va_list ap); +extern LIBHDHOMERUN_API bool hdhomerun_sprintf(char *buffer, char *end, const char *fmt, ...); #ifdef __cplusplus } diff --git a/hdhomerun_sock.h b/hdhomerun_sock.h index 405fdbf..5710a5f 100644 --- a/hdhomerun_sock.h +++ b/hdhomerun_sock.h @@ -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_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_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_join_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_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_bind(struct hdhomerun_sock_t *sock, uint32_t local_addr, uint16_t local_port, bool allow_reuse); +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_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_send(struct hdhomerun_sock_t *sock, 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_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_recv(struct hdhomerun_sock_t *sock, 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 } diff --git a/hdhomerun_sock_posix.c b/hdhomerun_sock_posix.c index f81b254..e5ed8b3 100644 --- a/hdhomerun_sock_posix.c +++ b/hdhomerun_sock_posix.c @@ -267,7 +267,7 @@ uint32_t hdhomerun_sock_getaddrinfo_addr(struct hdhomerun_sock_t *sock, const ch 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; 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); 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; 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); 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; 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); 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; 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 ((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; if (poll(&poll_event, 1, (int)timeout) <= 0) { - return FALSE; + return false; } 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; ssize_t ret = send(sock->sock, ptr, length, MSG_NOSIGNAL); if (ret >= (ssize_t)length) { - return TRUE; + return true; } if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { - return FALSE; + return false; } 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; if (poll(&poll_event, 1, (int)timeout) <= 0) { - return FALSE; + return false; } if ((poll_event.revents & POLLOUT) == 0) { - return FALSE; + return false; } ret = send(sock->sock, ptr, length, MSG_NOSIGNAL); if (ret >= (ssize_t)length) { - return TRUE; + return true; } if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { - return FALSE; + return false; } 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(); if (current_time >= stop_time) { - return FALSE; + return false; } 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; 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; ssize_t ret = sendto(sock->sock, ptr, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)); if (ret >= (ssize_t)length) { - return TRUE; + return true; } if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { - return FALSE; + return false; } 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; if (poll(&poll_event, 1, (int)timeout) <= 0) { - return FALSE; + return false; } if ((poll_event.revents & POLLOUT) == 0) { - return FALSE; + return false; } ret = sendto(sock->sock, ptr, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)); if (ret >= (ssize_t)length) { - return TRUE; + return true; } if ((ret < 0) && (errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { - return FALSE; + return false; } 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(); if (current_time >= stop_time) { - return FALSE; + return false; } 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); if (ret > 0) { *length = ret; - return TRUE; + return true; } if (ret == 0) { - return FALSE; + return false; } if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { - return FALSE; + return false; } 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; if (poll(&poll_event, 1, (int)timeout) <= 0) { - return FALSE; + return false; } if ((poll_event.revents & POLLIN) == 0) { - return FALSE; + return false; } ret = recv(sock->sock, data, *length, 0); if (ret > 0) { *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; 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_port = ntohs(sock_addr.sin_port); *length = ret; - return TRUE; + return true; } if (ret == 0) { - return FALSE; + return false; } if ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (errno != EINPROGRESS)) { - return FALSE; + return false; } 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; if (poll(&poll_event, 1, (int)timeout) <= 0) { - return FALSE; + return false; } if ((poll_event.revents & POLLIN) == 0) { - return FALSE; + return false; } 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_port = ntohs(sock_addr.sin_port); *length = ret; - return TRUE; + return true; } - return FALSE; + return false; } diff --git a/hdhomerun_sock_windows.c b/hdhomerun_sock_windows.c index de40955..810c0bc 100644 --- a/hdhomerun_sock_windows.c +++ b/hdhomerun_sock_windows.c @@ -165,7 +165,7 @@ static struct hdhomerun_sock_t *hdhomerun_sock_create_internal(int protocol) } /* Event */ - sock->event = CreateEvent(NULL, FALSE, FALSE, NULL); + sock->event = CreateEvent(NULL, false, false, NULL); if (!sock->event) { hdhomerun_sock_destroy(sock); return NULL; @@ -289,7 +289,7 @@ uint32_t hdhomerun_sock_getaddrinfo_addr(struct hdhomerun_sock_t *sock, const ch 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; 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); 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; 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); 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; 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); 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 (WSAEventSelect(sock->sock, sock->event, events) == SOCKET_ERROR) { - return FALSE; + return false; } sock->events_selected = events; } 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)) { - return FALSE; + return false; } 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 (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) { - return FALSE; + return false; } WSANETWORKEVENTS network_events; if (WSAEnumNetworkEvents(sock->sock, sock->event, &network_events) == SOCKET_ERROR) { - return FALSE; + return false; } if ((network_events.lNetworkEvents & FD_WRITE) == 0) { - return FALSE; + return false; } 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)) { - return FALSE; + return false; } 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) { int ret = send(sock->sock, (char *)ptr, (int)length, 0); if (ret >= (int)length) { - return TRUE; + return true; } if ((ret == SOCKET_ERROR) && (WSAGetLastError() != WSAEWOULDBLOCK)) { - return FALSE; + return false; } 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(); if (current_time >= stop_time) { - return FALSE; + return false; } - if (WaitForSingleObjectEx(sock->event, (DWORD)(stop_time - current_time), FALSE) != WAIT_OBJECT_0) { - return FALSE; + if (WaitForSingleObjectEx(sock->event, (DWORD)(stop_time - current_time), false) != WAIT_OBJECT_0) { + 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)) { - return FALSE; + return false; } 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)); if (ret >= (int)length) { - return TRUE; + return true; } if (ret >= 0) { - return FALSE; + return false; } if (WSAGetLastError() != WSAEWOULDBLOCK) { - return FALSE; + return false; } - if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, FALSE) != WAIT_OBJECT_0) { - return FALSE; + if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, false) != WAIT_OBJECT_0) { + return false; } ret = sendto(sock->sock, (char *)data, (int)length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)); 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)) { - return FALSE; + return false; } int ret = recv(sock->sock, (char *)data, (int)(*length), 0); if (ret > 0) { *length = ret; - return TRUE; + return true; } if (ret == 0) { - return FALSE; + return false; } if (WSAGetLastError() != WSAEWOULDBLOCK) { - return FALSE; + return false; } - if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, FALSE) != WAIT_OBJECT_0) { - return FALSE; + if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, false) != WAIT_OBJECT_0) { + return false; } ret = recv(sock->sock, (char *)data, (int)(*length), 0); if (ret > 0) { *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)) { - return FALSE; + return false; } 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_port = ntohs(sock_addr.sin_port); *length = ret; - return TRUE; + return true; } if (ret == 0) { - return FALSE; + return false; } if (WSAGetLastError() != WSAEWOULDBLOCK) { - return FALSE; + return false; } - if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, FALSE) != WAIT_OBJECT_0) { - return FALSE; + if (WaitForSingleObjectEx(sock->event, (DWORD)timeout, false) != WAIT_OBJECT_0) { + return false; } 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_port = ntohs(sock_addr.sin_port); *length = ret; - return TRUE; + return true; } - return FALSE; + return false; } diff --git a/hdhomerun_types.h b/hdhomerun_types.h index 55992ea..cf98001 100644 --- a/hdhomerun_types.h +++ b/hdhomerun_types.h @@ -29,9 +29,9 @@ struct hdhomerun_device_allocation_t; struct hdhomerun_tuner_status_t { char channel[32]; char lock_str[32]; - bool_t signal_present; - bool_t lock_supported; - bool_t lock_unsupported; + bool signal_present; + bool lock_supported; + bool lock_unsupported; unsigned int signal_strength; unsigned int signal_to_noise_quality; unsigned int symbol_error_quality; @@ -45,9 +45,9 @@ struct hdhomerun_tuner_vstatus_t { char auth[32]; char cci[32]; char cgms[32]; - bool_t not_subscribed; - bool_t not_available; - bool_t copy_protected; + bool not_subscribed; + bool not_available; + bool copy_protected; }; struct hdhomerun_channelscan_program_t { @@ -68,8 +68,8 @@ struct hdhomerun_channelscan_result_t { struct hdhomerun_tuner_status_t status; int program_count; struct hdhomerun_channelscan_program_t programs[HDHOMERUN_CHANNELSCAN_MAX_PROGRAM_COUNT]; - bool_t transport_stream_id_detected; - bool_t original_network_id_detected; + bool transport_stream_id_detected; + bool original_network_id_detected; uint16_t transport_stream_id; uint16_t original_network_id; }; diff --git a/hdhomerun_video.c b/hdhomerun_video.c index 632ce68..48665c5 100644 --- a/hdhomerun_video.c +++ b/hdhomerun_video.c @@ -28,7 +28,7 @@ struct hdhomerun_video_sock_t { uint32_t keepalive_lockkey; uint32_t keepalive_addr; uint16_t keepalive_port; - volatile bool_t keepalive_start; + volatile bool keepalive_start; volatile size_t head; volatile size_t tail; @@ -37,7 +37,7 @@ struct hdhomerun_video_sock_t { size_t advance; pthread_t thread; - volatile bool_t terminate; + volatile bool terminate; volatile uint32_t packet_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); -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. */ 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) { - vs->terminate = TRUE; + vs->terminate = true; pthread_join(vs->thread, NULL); 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; if ((remote_addr != 0) && (remote_port != 0)) { - vs->keepalive_start = TRUE; + vs->keepalive_start = true; } pthread_mutex_unlock(&vs->lock); @@ -188,7 +188,7 @@ static void hdhomerun_video_stats_ts_pkt(struct hdhomerun_video_sock_t *vs, uint return; } - bool_t transport_error = ptr[1] >> 7; + bool transport_error = ptr[1] >> 7; if (transport_error) { vs->transport_error_count++; 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_addr = vs->keepalive_addr; uint16_t keepalive_port = vs->keepalive_port; - vs->keepalive_start = FALSE; + vs->keepalive_start = false; pthread_mutex_unlock(&vs->lock); if ((keepalive_addr == 0) || (keepalive_port == 0)) { diff --git a/hdhomerun_video.h b/hdhomerun_video.h index 2285828..6be4b4f 100644 --- a/hdhomerun_video.h +++ b/hdhomerun_video.h @@ -48,7 +48,7 @@ struct hdhomerun_video_stats_t { * * 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); /*