sipwise
/
rtpengine
mirror of https://github.com/sipwise/rtpengine.git
1
0
Fork 0
Code Issues Releases Wiki Activity

MT#55283 update kernel.c to bool types

Browse Source 
... and change return type to void where unused

Change-Id: I443fa55cd5ce75dca6fcb697bc07a8810d382d12
pull/1802/head
Richard Fuchs 1 year ago
parent 8458652d5f
commit 1e1f00412e
4 changed files with 53 additions and 57 deletions
Show Stats Download Patch File Download Diff File

86
daemon/kernel.c
Unescape View File

@ -18,7 +18,7 @@
struct kernel_interface kernel;
static int kernel_action_table(const char *action, unsigned int id) {
static bool kernel_action_table(const char *action, unsigned int id) {
char s[64];
int saved_errno;
int fd;
@ -27,7 +27,7 @@ static int kernel_action_table(const char *action, unsigned int id) {
fd = open(PREFIX "/control", O_WRONLY | O_TRUNC);
if (fd == -1)
return -1;
return false;
i = snprintf(s, sizeof(s), "%s %u\n", action, id);
if (i >= sizeof(s))
goto fail;
@ -36,20 +36,20 @@ static int kernel_action_table(const char *action, unsigned int id) {
goto fail;
close(fd);
return 0;
return true;
fail:
saved_errno = errno;
close(fd);
errno = saved_errno;
return -1;
return false;
}
static int kernel_create_table(unsigned int id) {
static bool kernel_create_table(unsigned int id) {
return kernel_action_table("add", id);
}
static int kernel_delete_table(unsigned int id) {
static bool kernel_delete_table(unsigned int id) {
return kernel_action_table("del", id);
}
@ -99,34 +99,34 @@ fail:
return -1;
}
int kernel_setup_table(unsigned int id) {
bool kernel_setup_table(unsigned int id) {
if (kernel.is_wanted)
abort();
kernel.is_wanted = 1;
kernel.is_wanted = true;
if (kernel_delete_table(id) && errno != ENOENT) {
if (!kernel_delete_table(id) && errno != ENOENT) {
ilog(LOG_ERR, "FAILED TO DELETE KERNEL TABLE %i (%s), KERNEL FORWARDING DISABLED",
id, strerror(errno));
return -1;
return false;
}
if (kernel_create_table(id)) {
if (!kernel_create_table(id)) {
ilog(LOG_ERR, "FAILED TO CREATE KERNEL TABLE %i (%s), KERNEL FORWARDING DISABLED",
id, strerror(errno));
return -1;
return false;
}
int fd = kernel_open_table(id);
if (fd == -1) {
ilog(LOG_ERR, "FAILED TO OPEN KERNEL TABLE %i (%s), KERNEL FORWARDING DISABLED",
id, strerror(errno));
return -1;
return false;
}
kernel.fd = fd;
kernel.table = id;
kernel.is_open = 1;
kernel.is_open = true;
return 0;
return true;
}
void kernel_shutdown_table(void) {
@ -138,57 +138,55 @@ void kernel_shutdown_table(void) {
}
int kernel_add_stream(struct rtpengine_target_info *mti) {
void kernel_add_stream(struct rtpengine_target_info *mti) {
struct rtpengine_command_add_target cmd;
ssize_t ret;
if (!kernel.is_open)
return -1;
return;
cmd.cmd = REMG_ADD_TARGET;
cmd.target = *mti;
ret = write(kernel.fd, &cmd, sizeof(cmd));
if (ret > 0)
return 0;
if (ret == sizeof(cmd))
return;
ilog(LOG_ERROR, "Failed to push relay stream to kernel: %s", strerror(errno));
return -1;
}
int kernel_add_destination(struct rtpengine_destination_info *mdi) {
void kernel_add_destination(struct rtpengine_destination_info *mdi) {
struct rtpengine_command_destination cmd;
ssize_t ret;
if (!kernel.is_open)
return -1;
return;
cmd.cmd = REMG_ADD_DESTINATION;
cmd.destination = *mdi;
ret = write(kernel.fd, &cmd, sizeof(cmd));
if (ret > 0)
return 0;
if (ret == sizeof(cmd))
return;
ilog(LOG_ERROR, "Failed to push relay stream destination to kernel: %s", strerror(errno));
return -1;
}
int kernel_del_stream_stats(struct rtpengine_command_del_target_stats *cmd) {
bool kernel_del_stream_stats(struct rtpengine_command_del_target_stats *cmd) {
ssize_t ret;
if (!kernel.is_open)
return -1;
return false;
cmd->cmd = REMG_DEL_TARGET_STATS;
ret = read(kernel.fd, cmd, sizeof(*cmd));
if (ret > 0)
return 0;
if (ret == sizeof(*cmd))
return true;
ilog(LOG_ERROR, "Failed to delete relay stream from kernel: %s", strerror(errno));
return -1;
return false;
}
kernel_slist *kernel_get_list(void) {
@ -237,20 +235,21 @@ unsigned int kernel_add_call(const char *id) {
return cmd.call.call_idx;
}
int kernel_del_call(unsigned int idx) {
void kernel_del_call(unsigned int idx) {
struct rtpengine_command_del_call cmd;
ssize_t ret;
if (!kernel.is_open)
return -1;
return;
cmd.cmd = REMG_DEL_CALL;
cmd.call_idx = idx;
ret = write(kernel.fd, &cmd, sizeof(cmd));
if (ret != sizeof(cmd))
return -1;
return 0;
if (ret == sizeof(cmd))
return;
ilog(LOG_ERROR, "Failed to delete intercept call from kernel: %s", strerror(errno));
}
unsigned int kernel_add_intercept_stream(unsigned int call_idx, const char *id) {
@ -271,26 +270,26 @@ unsigned int kernel_add_intercept_stream(unsigned int call_idx, const char *id)
}
// cmd->local must be filled in
int kernel_update_stats(struct rtpengine_command_stats *cmd) {
bool kernel_update_stats(struct rtpengine_command_stats *cmd) {
ssize_t ret;
if (!kernel.is_open)
return -1;
return false;
cmd->cmd = REMG_GET_RESET_STATS;
ret = read(kernel.fd, cmd, sizeof(*cmd));
if (ret <= 0) {
if (ret != sizeof(*cmd)) {
ilog(LOG_ERROR, "Failed to get stream stats from kernel: %s", strerror(errno));
return -1;
return false;
}
return 0;
return true;
}
int kernel_send_rtcp(struct rtpengine_send_packet_info *info, const char *buf, size_t len) {
void kernel_send_rtcp(struct rtpengine_send_packet_info *info, const char *buf, size_t len) {
if (!kernel.is_open)
return -1;
return;
size_t total_len = len + sizeof(struct rtpengine_command_send_packet);
struct rtpengine_command_send_packet *cmd = alloca(total_len);
@ -306,8 +305,5 @@ int kernel_send_rtcp(struct rtpengine_send_packet_info *info, const char *buf, s
else
ilog(LOG_ERR, "Failed to send RTCP via kernel interface (%zi != %zu)",
ret, total_len);
return -1;
}
return 0;
}

2
daemon/main.c
Unescape View File

@ -1236,7 +1236,7 @@ static void create_everything(void) {
if (err)
die("Failed to create nftables chains or rules: %s (%s)", err, strerror(errno));
#endif
if (kernel_setup_table(rtpe_config.kernel_table)) {
if (!kernel_setup_table(rtpe_config.kernel_table)) {
if (rtpe_config.no_fallback)
die("Userspace fallback disallowed - exiting");
goto no_kernel;

4
daemon/media_socket.c
Unescape View File

@ -1848,7 +1848,7 @@ static void __stream_update_stats(struct packet_stream *ps, bool have_in_lock) {
struct rtpengine_command_stats stats_info;
__re_address_translate_ep(&stats_info.local, &ps->selected_sfd->socket.local);
if (kernel_update_stats(&stats_info)) {
if (!kernel_update_stats(&stats_info)) {
if (!have_in_lock)
mutex_unlock(&ps->in_lock);
return;
@ -1877,7 +1877,7 @@ void __unkernelize(struct packet_stream *p, const char *reason) {
reason);
struct rtpengine_command_del_target_stats cmd;
__re_address_translate_ep(&cmd.local, &p->selected_sfd->socket.local);
if (kernel_del_stream_stats(&cmd) == 0)
if (kernel_del_stream_stats(&cmd))
__stream_consume_stats(p, &cmd.stats);
}

18
include/kernel.h
Unescape View File

@ -20,8 +20,8 @@ struct rtpengine_ssrc_stats;
struct kernel_interface {
unsigned int table;
int fd;
int is_open;
int is_wanted;
bool is_open;
bool is_wanted;
};
extern struct kernel_interface kernel;
@ -29,21 +29,21 @@ TYPED_GQUEUE(kernel, struct rtpengine_list_entry)
int kernel_setup_table(unsigned int);
bool kernel_setup_table(unsigned int);
void kernel_shutdown_table(void);
int kernel_add_stream(struct rtpengine_target_info *);
int kernel_add_destination(struct rtpengine_destination_info *);
int kernel_del_stream_stats(struct rtpengine_command_del_target_stats *);
void kernel_add_stream(struct rtpengine_target_info *);
void kernel_add_destination(struct rtpengine_destination_info *);
bool kernel_del_stream_stats(struct rtpengine_command_del_target_stats *);
kernel_slist *kernel_get_list(void);
int kernel_update_stats(struct rtpengine_command_stats *);
bool kernel_update_stats(struct rtpengine_command_stats *);
unsigned int kernel_add_call(const char *id);
int kernel_del_call(unsigned int);
void kernel_del_call(unsigned int);
unsigned int kernel_add_intercept_stream(unsigned int call_idx, const char *id);
int kernel_send_rtcp(struct rtpengine_send_packet_info *info, const char *buf, size_t len);
void kernel_send_rtcp(struct rtpengine_send_packet_info *info, const char *buf, size_t len);

Write Preview
Loading…
Cancel
Save