control_socket.h File Reference

#include <string>

Include dependency graph for control_socket.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DEFAULT_CONTROL_PORT   5054

Functions
int	control_audio_ch_report_count (struct control_state *state)
void	control_done (struct control_state *s)
int	control_init (int port, int connection_type, struct control_state **state, struct module *root_module, int force_ip_version)
void	control_report_event (struct control_state *state, const std::string &event_line)
void	control_report_stats (struct control_state *state, const std::string &stat_line)
void	control_start (struct control_state *state)
bool	control_stats_enabled (struct control_state *state)

Detailed Description

Author

Martin Pulec marti.nosp@m.n.pu.nosp@m.lec@c.nosp@m.esne.nosp@m.t.cz

Definition in file control_socket.h.

Macro Definition Documentation

DEFAULT_CONTROL_PORT

#define DEFAULT_CONTROL_PORT   5054

Definition at line 41 of file control_socket.h.

Referenced by usage().

Function Documentation

control_audio_ch_report_count()

int control_audio_ch_report_count

(

struct control_state *

state

)

Definition at line 1021 of file control_socket.cpp.

                                                              {
        return state ? state->audio_channel_report_count : 0;
}

References state.

Referenced by decode_audio_frame().

control_done()

void control_done

(

struct control_state *

s

)

Definition at line 953 of file control_socket.cpp.

{
        if(!s) {
                return;
        }
 
        module_done(&s->mod);
 
        if(s->started) {
                s->stats_lock.lock();
                s->stat_event_queue.push({});
                s->stats_lock.unlock();
                s->stat_event_cv.notify_one();
                s->stat_event_thread_id.join();
 
                int ret = write_all(s->internal_fd[1], "quit\r\n", 6);
                if (ret > 0) {
                        s->control_thread_id.join();
                        platform_pipe_close(s->internal_fd[1]);
                } else {
                        fprintf(stderr, "Cannot exit control thread!\n");
                }
        }
        if(s->connection_type == SERVER && s->socket_fd != INVALID_SOCKET) {
                // for client, the socket has already been closed
                // by the time of control_thread exit
                CLOSESOCKET(s->socket_fd);
        }
 
        delete s;
}

References CLOSESOCKET, control_state::connection_type, control_state::control_thread_id, control_state::internal_fd, INVALID_SOCKET, control_state::mod, module_done(), platform_pipe_close(), SERVER, control_state::socket_fd, control_state::started, control_state::stat_event_cv, control_state::stat_event_queue, control_state::stat_event_thread_id, control_state::stats_lock, and write_all().

Referenced by hd_rum_translator_deinit(), and main().

Here is the call graph for this function:

control_init()

int control_init	(	int	port,
		int	connection_type,
		struct control_state **	state,
		struct module *	root_module,
		int	force_ip_version )

Parameters

[in]

force_ip_version

IP version to force (4 or 6). Use 0 to use default (both 4 and 6 if available)

Return values

0	if success

Definition at line 159 of file control_socket.cpp.

{
        control_state *s = new control_state();
 
        s->root_module = root_module;
        s->started = false;
 
        module_init_default(&s->mod);
        s->mod.cls = MODULE_CLASS_CONTROL;
        s->mod.new_message = new_message;
        s->mod.priv_data = s;
 
        if(connection_type == 0) {
                s->network_port = port;
                s->connection_type = SERVER;
        } else {
                s->network_port = port;
                s->connection_type = CLIENT;
        }
 
        if(s->connection_type == SERVER) {
                int ip_version = 6;
                if (force_ip_version != 4) {
                        s->socket_fd = socket(AF_INET6, SOCK_STREAM, 0);
                        if (s->socket_fd == INVALID_SOCKET) {
                                socket_error("Control socket - IPv6 not available");
                        }
                }
                if (force_ip_version == 4 || (force_ip_version == 0 && s->socket_fd == INVALID_SOCKET && errno == EAFNOSUPPORT)) { // try IPv4
                        ip_version = 4;
                        s->socket_fd = socket(AF_INET, SOCK_STREAM, 0);
                }
                if (s->socket_fd == INVALID_SOCKET) {
                        socket_error("Control socket - socket");
                        goto error;
                }
                int val = 1;
                int rc;
                rc = setsockopt(s->socket_fd, SOL_SOCKET, SO_REUSEADDR,
                                (sso_val_type) &val, sizeof(val));
                if (rc != 0) {
                        socket_error("Control socket - setsockopt");
                }
 
                int ipv6only = 0;
                if (ip_version == 6 && setsockopt(s->socket_fd, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&ipv6only,
                                        sizeof(ipv6only)) != 0) {
                        socket_error("setsockopt IPV6_V6ONLY");
                }
 
                /* setting address to in6addr_any allows connections to be established
                 * from both IPv4 and IPv6 hosts. This behavior can be modified
                 * using the IPPROTO_IPV6 level socket option IPV6_V6ONLY if required.*/
                struct sockaddr_storage ss{};
                socklen_t s_len = 0;
                if (ip_version == 4) {
                        auto *s_in = reinterpret_cast<struct sockaddr_in *>(&ss);
                        s_in->sin_family = AF_INET;
                        s_in->sin_addr.s_addr = htonl(INADDR_ANY);
                        s_in->sin_port = htons(s->network_port);
                        s_len = sizeof *s_in;
                } else {
                        auto *s_in6 = reinterpret_cast<struct sockaddr_in6 *>(&ss);
                        s_in6->sin6_family = AF_INET6;
                        s_in6->sin6_addr = in6addr_any;
                        s_in6->sin6_port = htons(s->network_port);
                        s_len = sizeof *s_in6;
                }
 
                rc = ::bind(s->socket_fd, reinterpret_cast<const struct sockaddr *>(&ss), s_len);
                if (rc != 0) {
                        socket_error("Control socket - bind");
                        goto error;
                } else {
                        rc = listen(s->socket_fd, MAX_CLIENTS);
                        if (rc != 0) {
                                socket_error("Control socket - listen");
                                goto error;
                        }
                }
        } else {
                if (force_ip_version == 6) {
                        log_msg(LOG_LEVEL_ERROR, "Control socket: IPv6 unimplemented in client mode!\n");
                        goto error;
                }
                s->socket_fd = socket(AF_INET, SOCK_STREAM, 0);
                assert(s->socket_fd != INVALID_SOCKET);
                struct addrinfo hints, *res, *res0;
                int err;
 
                memset(&hints, 0, sizeof(hints));
                hints.ai_family = AF_INET;
                hints.ai_socktype = SOCK_STREAM;
                char port_str[10];
                snprintf(port_str, 10, "%d", s->network_port);
                err = getaddrinfo("127.0.0.1", port_str, &hints, &res0);
 
                if(err) {
                        fprintf(stderr, "Unable to get address: %s\n", gai_strerror(err));
                        goto error;
                }
                bool connected = false;
 
                for (res = res0; res; res = res->ai_next) {
                    if(connect(s->socket_fd, res->ai_addr, res->ai_addrlen) == -1) {
                        continue;
                    }
                    connected = true;
                    break; /* okay we got one */
                }
 
                freeaddrinfo(res0);
 
                if(!connected) {
                        fprintf(stderr, "Unable to connect to localhost:%d\n", s->network_port);
                        goto error;
                }
        }
 
 
        module_register(&s->mod, root_module);
 
        if (const char *val = get_commandline_param("control-report-audio-ch-count")) {
                s->audio_channel_report_count = strtoll(val, NULL, 0);
        }
 
        *state = s;
        return 0;
 
error:
        if (s->socket_fd != INVALID_SOCKET) {
                CLOSESOCKET(s->socket_fd);
        }
        delete s;
        return -1;
}

References control_state::audio_channel_report_count, CLIENT, CLOSESOCKET, module::cls, control_state::connection_type, get_commandline_param(), INVALID_SOCKET, LOG_LEVEL_ERROR, log_msg(), MAX_CLIENTS, control_state::mod, MODULE_CLASS_CONTROL, module_init_default(), module_register(), control_state::network_port, module::new_message, new_message(), module::priv_data, control_state::root_module, SERVER, socket_error, control_state::socket_fd, control_state::started, state, and val.

Referenced by main(), and main().

Here is the call graph for this function:

control_report_event()

void control_report_event	(	struct control_state *	state,
		const std::string &	event_line )

Definition at line 1007 of file control_socket.cpp.

{
        if (!s) {
                return;
        }
 
        control_report_stats_event(s, "event " + report_line + "\r\n");
}

References control_report_stats_event().

Here is the call graph for this function:

control_report_stats()

void control_report_stats	(	struct control_state *	state,
		const std::string &	stat_line )

Definition at line 998 of file control_socket.cpp.

{
        if (!s || !s->stats_on) {
                return;
        }
 
        control_report_stats_event(s, "stats " + report_line + "\r\n");
}

References control_report_stats_event(), and control_state::stats_on.

Referenced by decode_audio_frame(), filter(), and report_stats().

Here is the call graph for this function:

control_start()

void control_start

(

struct control_state *

state

)

Definition at line 296 of file control_socket.cpp.

{
        if (s == NULL) {
                return;
        }
 
        platform_pipe_init(s->internal_fd);
 
        s->control_thread_id = thread(control_thread, s);
        s->stat_event_thread_id = thread(stat_event_thread, s);
 
        log_msg(LOG_LEVEL_NOTICE, "Control socket listening on port %d\n",
                        socket_get_recv_port(s->socket_fd));
        s->started = true;
}

References control_thread(), control_state::control_thread_id, control_state::internal_fd, LOG_LEVEL_NOTICE, log_msg(), platform_pipe_init(), control_state::socket_fd, socket_get_recv_port(), control_state::started, stat_event_thread(), and control_state::stat_event_thread_id.

Referenced by main(), and main().

Here is the call graph for this function:

control_stats_enabled()

bool control_stats_enabled

(

struct control_state *

state

)

Definition at line 1016 of file control_socket.cpp.

{
        return s && s->stats_on;
}

References control_state::stats_on.

Referenced by decode_audio_frame(), filter(), and report_stats().