static void
control_connection_update_watches(ControlConnection *self)
{
if (self->output_buffer->len > self->pos)
{
iv_fd_set_handler_out(&self->control_io, control_connection_io_output);
iv_fd_set_handler_in(&self->control_io, NULL);
}
else
{
iv_fd_set_handler_out(&self->control_io, NULL);
iv_fd_set_handler_in(&self->control_io, control_connection_io_input);
}
}
void
control_connection_update_watches(ControlConnection *s)
{
ControlConnectionUnix *self = (ControlConnectionUnix *)s;
if (s->output_buffer->len > s->pos)
{
iv_fd_set_handler_out(&self->control_io, s->handle_output);
iv_fd_set_handler_in(&self->control_io, NULL);
}
else
{
iv_fd_set_handler_out(&self->control_io, NULL);
iv_fd_set_handler_in(&self->control_io, s->handle_input);
}
}
static void
log_writer_update_fd_callbacks(LogWriter *self, GIOCondition cond)
{
main_loop_assert_main_thread();
if (self->pollable_state > 0)
{
if (self->flags & LW_DETECT_EOF && (cond & G_IO_IN) == 0 && (cond & G_IO_OUT))
{
/* if output is enabled, and we're in DETECT_EOF mode, and input is
* not needed by the log protocol, install the eof check callback to
* destroy the connection if an EOF is received. */
iv_fd_set_handler_in(&self->fd_watch, log_writer_io_check_eof);
}
else if (cond & G_IO_IN)
{
/* in case the protocol requested G_IO_IN, it means that it needs to
* invoke read in the flush code, so just install the flush_output
* handler for input */
iv_fd_set_handler_in(&self->fd_watch, log_writer_io_flush_output);
}
else
{
/* otherwise we're not interested in input */
iv_fd_set_handler_in(&self->fd_watch, NULL);
}
if (cond & G_IO_OUT)
iv_fd_set_handler_out(&self->fd_watch, log_writer_io_flush_output);
else
iv_fd_set_handler_out(&self->fd_watch, NULL);
iv_fd_set_handler_err(&self->fd_watch, log_writer_io_error);
}
else
{
/* fd is not pollable, assume it is always writable */
if (cond & G_IO_OUT)
{
if (!iv_task_registered(&self->immed_io_task))
iv_task_register(&self->immed_io_task);
}
else if (iv_task_registered(&self->immed_io_task))
{
iv_task_unregister(&self->immed_io_task);
}
}
}
static void
poll_fd_events_update_watches(PollEvents *s, GIOCondition cond)
{
PollFdEvents *self = (PollFdEvents *) s;
if (cond & G_IO_IN)
iv_fd_set_handler_in(&self->fd_watch, IV_FD_CALLBACK(poll_events_invoke_callback));
else
iv_fd_set_handler_in(&self->fd_watch, NULL);
if (cond & G_IO_OUT)
iv_fd_set_handler_out(&self->fd_watch, IV_FD_CALLBACK(poll_events_invoke_callback));
else
iv_fd_set_handler_out(&self->fd_watch, NULL);
if (cond & (G_IO_IN + G_IO_OUT))
iv_fd_set_handler_err(&self->fd_watch, IV_FD_CALLBACK(poll_events_invoke_callback));
else
iv_fd_set_handler_err(&self->fd_watch, NULL);
}
void
control_server_start(ControlServer *s)
{
ControlServerUnix *self = (ControlServerUnix *)s;
GSockAddr *saddr;
saddr = g_sockaddr_unix_new(self->super.control_socket_name);
self->control_socket = socket(PF_UNIX, SOCK_STREAM, 0);
if (self->control_socket == -1)
{
msg_error("Error opening control socket, external controls will not be available",
evt_tag_str("socket", self->super.control_socket_name),
NULL);
return;
}
if (g_bind(self->control_socket, saddr) != G_IO_STATUS_NORMAL)
{
msg_error("Error opening control socket, bind() failed",
evt_tag_str("socket", self->super.control_socket_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
if (listen(self->control_socket, 255) < 0)
{
msg_error("Error opening control socket, listen() failed",
evt_tag_str("socket", self->super.control_socket_name),
evt_tag_errno("error", errno),
NULL);
goto error;
}
self->control_listen.fd = self->control_socket;
self->control_listen.cookie = self;
iv_fd_register(&self->control_listen);
iv_fd_set_handler_in(&self->control_listen, control_socket_accept);
g_sockaddr_unref(saddr);
return;
error:
if (self->control_socket != -1)
{
close(self->control_socket);
self->control_socket = -1;
}
g_sockaddr_unref(saddr);
return;
}
static void connect_successful(struct http_client_request *req)
{
struct iovec iov[9];
int ret;
req->response_code = -1;
req->entity_ptr = 0;
req->read_ptr = 0;
req->parse_ptr = 0;
iov[0].iov_base = req->method;
iov[0].iov_len = strlen(req->method);
iov[1].iov_base = " ";
iov[1].iov_len = 1;
iov[2].iov_base = req->redirect_url;
iov[2].iov_len = strlen(req->redirect_url);
iov[3].iov_base = req->params;
iov[3].iov_len = strlen(req->params);
iov[4].iov_base = " HTTP/1.0\r\nHost: ";
iov[4].iov_len = 17;
iov[5].iov_base = req->redirect_hostname;
iov[5].iov_len = strlen(req->redirect_hostname);
iov[6].iov_base = "\r\nUser-Agent: http_client"
"\r\nConnection: close\r\n";
iov[6].iov_len = 46;
iov[7].iov_base = req->headers;
iov[7].iov_len = strlen(req->headers);
iov[8].iov_base = "\r\n";
iov[8].iov_len = 2;
ret = writev(req->fd.fd, iov, 9);
if (ret != iov[0].iov_len + iov[1].iov_len + iov[2].iov_len +
iov[3].iov_len + iov[4].iov_len + iov[5].iov_len +
iov[6].iov_len + iov[7].iov_len + iov[8].iov_len) {
req->state = ret < 0 ? errno : EINVAL;
abort_me(req, 1, 1);
return;
}
iv_fd_set_handler_in(&req->fd, got_data);
if (req->entity_length && req->entity_body != NULL)
iv_fd_set_handler_out(&req->fd, got_output_space);
else
iv_fd_set_handler_out(&req->fd, NULL);
}
static void
log_reader_update_watches(LogReader *self)
{
gint fd;
GIOCondition cond;
gboolean free_to_send;
main_loop_assert_main_thread();
self->suspended = FALSE;
free_to_send = log_source_free_to_send(&self->super);
if (!free_to_send ||
self->immediate_check ||
log_proto_prepare(self->proto, &fd, &cond))
{
/* we disable all I/O related callbacks here because we either know
* that we can continue (e.g. immediate_check == TRUE) or we know
* that we can't continue even if data would be available (e.g.
* free_to_send == FALSE)
*/
self->immediate_check = FALSE;
if (iv_fd_registered(&self->fd_watch))
{
iv_fd_set_handler_in(&self->fd_watch, NULL);
iv_fd_set_handler_out(&self->fd_watch, NULL);
/* we disable the error handler too, as it might be
* triggered even when we don't want to read data
* (e.g. log_source_free_to_send() is FALSE).
*
* And at least on Linux, it may happen that EPOLLERR is
* set, while there's still data in the socket buffer. Thus
* in reaction to an EPOLLERR, we could possibly send
* further messages without validating the
* log_source_free_to_send() would allow us to, potentially
* overflowing our window (and causing a failed assertion in
* log_source_queue().
*/
iv_fd_set_handler_err(&self->fd_watch, NULL);
}
if (iv_timer_registered(&self->follow_timer))
iv_timer_unregister(&self->follow_timer);
if (free_to_send)
{
/* we have data in our input buffer, we need to start working
* on it immediately, without waiting for I/O events */
if (!iv_task_registered(&self->restart_task))
{
iv_task_register(&self->restart_task);
}
}
else
{
self->suspended = TRUE;
}
return;
}
if (iv_fd_registered(&self->fd_watch))
{
/* this branch is executed when our fd is connected to a non-file
* source (e.g. TCP, UDP socket). We set up I/O callbacks here.
* files cannot be polled using epoll, as it causes an I/O error
* (thus abort in ivykis).
*/
if (cond & G_IO_IN)
iv_fd_set_handler_in(&self->fd_watch, log_reader_io_process_input);
else
iv_fd_set_handler_in(&self->fd_watch, NULL);
if (cond & G_IO_OUT)
iv_fd_set_handler_out(&self->fd_watch, log_reader_io_process_input);
else
iv_fd_set_handler_out(&self->fd_watch, NULL);
if (cond & (G_IO_IN + G_IO_OUT))
iv_fd_set_handler_err(&self->fd_watch, log_reader_io_process_input);
else
iv_fd_set_handler_err(&self->fd_watch, NULL);
}
else
{
if (self->options->follow_freq > 0)
{
if (iv_timer_registered(&self->follow_timer))
iv_timer_unregister(&self->follow_timer);
iv_validate_now();
self->follow_timer.expires = iv_now;
timespec_add_msec(&self->follow_timer.expires, self->options->follow_freq);
iv_timer_register(&self->follow_timer);
}
else
{
/* NOTE: we don't need to unregister the timer here as follow_freq
* never changes during runtime, thus if ever it was registered that
* also means that we go into the if branch above. */
}
}
}
