alertik/syslog.c
2024-08-06 22:57:23 -03:00

237 lines
5.3 KiB
C

/*
* Alertik: a tiny 'syslog' server & notification tool for Mikrotik routers.
* This is free and unencumbered software released into the public domain.
*/
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <time.h>
#include "events.h"
#include "log.h"
#include "syslog.h"
/*
* UDP message handling and FIFO.
*/
/* Forward server data. */
static struct addrinfo *fwd_addr_info;
static int fwd_fd;
/* Circular message buffer. */
static struct circ_buffer {
int head;
int tail;
struct log_event log_ev [FIFO_MAX];
} circ_buffer = {0};
/* Sync. */
static pthread_mutex_t fifo_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t fifo_new_log_entry = PTHREAD_COND_INITIALIZER;
static int syslog_push_msg_into_fifo(const char *, time_t);
/**
* @brief Create an UDP socket to read from.
*
* @return Returns the UDP socket fd if success.
*/
int syslog_create_udp_socket(void)
{
struct sockaddr_in svaddr;
int yes;
int fd;
fd = socket(AF_INET, SOCK_DGRAM, 0);
if (fd < 0)
panic_errno("Unable to create UDP socket...");
memset(&svaddr, 0, sizeof(svaddr));
svaddr.sin_family = AF_INET;
svaddr.sin_addr.s_addr = INADDR_ANY;
svaddr.sin_port = SYSLOG_PORT;
if (bind(fd, (const struct sockaddr *)&svaddr, sizeof(svaddr)) < 0)
panic_errno("Unable to bind...");
yes = 1;
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void*)&yes,
sizeof(yes)) < 0) {
panic_errno("Unable to reuse address...");
}
return fd;
}
/**
* @brief Initializes the forwarding to the syslog server if
* the required environment vars were informed.
*
* @return Returns 0.
*/
int syslog_init_forward(void)
{
struct addrinfo hints, *results, *try;
char *host, *port;
int sock = 0;
/* Check if we should forward messages. */
host = getenv("FORWARD_HOST");
port = getenv("FORWARD_PORT");
if (!host && !port) {
log_msg("Forward Mode: disabled\n\n");
return 0;
}
if (!host || !port)
panic("FORWARD_ADDR and FORWARD_PORT must be specified!\n");
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if (getaddrinfo(host, port, &hints, &results) != 0)
panic_errno("Unable to getaddrinfo...");
/* Iterate over results. */
for (try = results; try != NULL; try = try->ai_next) {
sock = socket(try->ai_family, try->ai_socktype, try->ai_protocol);
if (sock < 0)
continue;
break;
}
if (sock < 0)
panic("Unable to create a socket for forward...\n");
fwd_fd = sock;
fwd_addr_info = try;
log_msg("Forward Mode: enabled:\n");
log_msg("----------------------\n");
log_msg("FORWARD_HOST: %s\n", host);
log_msg("FORWARD_PORT: %s\n\n", port);
return 0;
}
/**
* @brief Sends a message @p msg of length @p len to the
* configured syslog server.
*/
static int syslog_fwd_msg(const char *msg, size_t len) {
return (
sendto(fwd_fd, msg, len, 0, fwd_addr_info->ai_addr,
fwd_addr_info->ai_addrlen)
);
}
/**
* @brief Receives a new UDP message and then adds it
* to the message queue. Additionally, also forwards
* the message to a previously configured syslog server.
*
* @param fd UDP file descriptor to receive from.
*
* @return Returns 0 if success, -1 otherwise.
*/
int syslog_enqueue_new_upd_msg(int fd)
{
struct sockaddr_storage cli = {0};
char msg[MSG_MAX] = {0};
socklen_t clilen;
ssize_t ret;
clilen = sizeof(cli);
ret = recvfrom(fd, msg, sizeof msg - 1, 0, (struct sockaddr*)&cli,
&clilen);
if (ret < 0)
return -1;
/* Forward message if forwarding was configured. */
if (fwd_fd) {
if (syslog_fwd_msg(msg, ret) < 0)
log_errno("Unable to forward message...\n");
}
if (syslog_push_msg_into_fifo(msg, time(NULL)) < 0)
panic("Circular buffer full! (size: %d)\n", FIFO_MAX);
return 0;
}
///////////////////////////////// FIFO ////////////////////////////////////////
/**
* @brief For a given message @p msg and a timestamp @p timestamp,
* adds both to the message queue and then wakes up the waiting
* thread.
*
* @param msg Read message from UDP.
* @param timestamp Current timestamp.
*
* @return Returns 0 if success, -1 otherwise.
*/
static int syslog_push_msg_into_fifo(const char *msg, time_t timestamp)
{
int next;
int head;
pthread_mutex_lock(&fifo_mutex);
head = circ_buffer.head;
next = head + 1;
if (next >= FIFO_MAX)
next = 0;
if (next == circ_buffer.tail) {
pthread_mutex_unlock(&fifo_mutex);
return -1;
}
memcpy(circ_buffer.log_ev[head].msg, msg, MSG_MAX);
circ_buffer.log_ev[head].timestamp = timestamp;
circ_buffer.head = next;
pthread_cond_signal(&fifo_new_log_entry);
pthread_mutex_unlock(&fifo_mutex);
return 0;
}
/**
* @brief Pops a single message from the message queue (if any),
* and saves it into @p ev.
*
* @param ev Target buffer to the retrieved log event.
*
* @return Returns 0.
*/
int syslog_pop_msg_from_fifo(struct log_event *ev)
{
int next;
int tail;
pthread_mutex_lock(&fifo_mutex);
while (circ_buffer.head == circ_buffer.tail) {
pthread_cond_wait(&fifo_new_log_entry, &fifo_mutex);
}
next = circ_buffer.tail + 1;
if (next >= FIFO_MAX)
next = 0;
tail = circ_buffer.tail;
ev->timestamp = circ_buffer.log_ev[tail].timestamp;
memcpy(ev->msg, circ_buffer.log_ev[tail].msg, MSG_MAX);
circ_buffer.tail = next;
pthread_mutex_unlock(&fifo_mutex);
return 0;
}