mirror of
https://github.com/Silicondust/libhdhomerun
synced 2025-07-05 12:36:48 -07:00
use stdbool
This commit is contained in:
Nick Kelsey
parent
1efbcb2b87
commit
1d68aab367
21 changed files with 285 additions and 292 deletions
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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. */
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -22,6 +22,8 @@
|
|||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
|
|
@ -37,11 +39,10 @@
|
|||
#include <netdb.h>
|
||||
#include <pthread.h>
|
||||
|
||||
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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -40,6 +40,7 @@
|
|||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
#include <signal.h>
|
||||
#include <time.h>
|
||||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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)) {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
/*
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue