log_proxy.c

/*
	Copyright Jeroen Vreeken (pe1rxq@amsat.org), 2008
	Copyright Stichting C.A. Muller Radioastronomiestation, 2008

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#define _GNU_SOURCE

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <fcntl.h>
#include <stdbool.h>
#include <time.h>

#include "tcp_listen.h"
#include "tcp_connect.h"

#include "dt_port_numbers.h"
#include "dt_host.h"
#include "command_server.h"
#include "log.h"

char *logfile = NULL;

#define LOG_RING_SIZE	1000
#define LOG_ENTRY_SIZE	1000
#define LOG_ENTRY_LEN	(LOG_ENTRY_SIZE-1)

static struct log_entry {
	bool used;
	char buffer[LOG_ENTRY_SIZE];
	size_t buflen;
} log_ring[LOG_RING_SIZE];

static int ring_wr;
static int ring_rd;
static int entries;

static struct log_entry *log_entry_alloc(void)
{
	int i;
	
	i = ring_wr;
	ring_wr++;
	if (ring_wr >= LOG_RING_SIZE)
		ring_wr = 0;
	
	if (!log_ring[i].used)
		entries++;
	log_ring[i].used = true;
	
	return log_ring + i;
}

static struct log_entry *log_entry_pull(void)
{
	struct log_entry *entry;
	
	if (log_ring[ring_rd].used) {
		entry = log_ring + ring_rd;
		entry->used = false;
		ring_rd++;
		if (ring_rd >= LOG_RING_SIZE)
			ring_rd = 0;
	} else {
		entry = NULL;
	}
	
	return entry;
}

int handle_cmd(char *command)
{
	struct log_entry *entry;
	
	entry = log_entry_alloc();

	strncpy(entry->buffer, command, LOG_ENTRY_LEN);
	entry->buffer[LOG_ENTRY_LEN] = 0;
	entry->buffer[strlen(entry->buffer)] = 0;
	entry->buflen = strlen(entry->buffer);

	printf("Handling command buflen = %zd\n", entry->buflen);

	return 0;
}

int main (int argc, char **argv)
{
	int fd_listen;
	int fd_log;
	int *fd_clients = NULL;
	int nr_clients = 0;
	int fd_logfile = -1;
	struct command_server *cmd_srv;
	
	if (argc != 1 && argc != 2) {
		printf("Usage: %s <logfile>\n", argv[0]);
		printf("\n");
		printf("e.g.: %s\n", argv[0]);
		printf("or:   %s /var/log/controller.log\n", argv[0]);
		return 1;
	}
	if (argc == 2) {
		logfile = argv[1];
	} else {
		char timestamp[100];
		time_t now = time(NULL);
		
		strftime(timestamp, 100, "%FT%TZ", gmtime(&now));
		asprintf(&logfile, "%s/%s.log", dt_host_log_path(), timestamp);
	}
	printf("Log file location: %s\n", logfile);

	fd_listen = tcp_listen(CONSOLE_LOG_PORT, 0, 100);
	if (fd_listen < 0) {
		printf("Could not open listen port\n");
		return 1;
	}

	cmd_srv = command_server_create(CONSOLE_LOG_PORT_IN, 0, 100);
	if (!cmd_srv) {
		printf("Could not open listen port for logging\n");
		return 1;
	} else {
		command_server_handler_raw_set(cmd_srv, handle_cmd);
	}
	
	signal(SIGPIPE, SIG_IGN);
	
	ioctl(fd_listen, FIONBIO, &(int){ 1 });

	fd_log = tcp_connect(dt_host_controller(), CTRL_LOG_PORT);
	
	while (1) {
		int fdnew;
		fd_set fd_rd;
		struct timeval timeout;
		int high = 0;
		struct log_entry *entry;

		timeout.tv_usec = 0;
		timeout.tv_sec = 1;
		
		FD_ZERO(&fd_rd);
		if (fd_log >= 0) {
			FD_SET(fd_log, &fd_rd);
			high = fd_log;
		}
		FD_SET(fd_listen, &fd_rd);
		high = MAX(high, fd_listen);
		command_server_fdset_add(cmd_srv, &fd_rd, &high);

		select(high + 1, &fd_rd, NULL, NULL, &timeout);
		
		if (fd_log < 0) {
			printf("Trying to connect to server.\n");
			fd_log = tcp_connect(dt_host_controller(), CTRL_LOG_PORT);

			if (fd_log >= 0) {
				entry = log_entry_alloc();
				
				log_string(entry->buffer, LOG_ENTRY_LEN, LOG_T_INFO, 
				    "Established connection to controller");
				entry->buffer[strlen(entry->buffer)+1] = 0;
				entry->buffer[strlen(entry->buffer)] = '\n';
				printf(entry->buffer);
				entry->buflen = strlen(entry->buffer);
			}
		} else if (FD_ISSET(fd_log, &fd_rd)) {
			static char s[LOG_ENTRY_SIZE];
			static size_t pos;
			static ssize_t ret;
			
			if (pos >= LOG_ENTRY_LEN)
				pos = 0;
			
			ret = read(fd_log, s+pos, LOG_ENTRY_LEN - pos);
			if (ret > 0) {
				int i = pos;
				
				printf("read %zd bytes\n", ret);
				
				pos += ret;
				
				printf("buffer now at %zd bytes\n", pos);
				
				for (; i < pos; i++) {
					if (s[i] == '\n') {
						printf("enewline at %d\n", i);
						entry = log_entry_alloc();
						strncpy(entry->buffer, s, i+1);
						entry->buffer[i+1] = 0;
						entry->buflen = i+1;
						
						printf("move %zd bytes back\n", pos - i);
						memmove(s, s+i + 1, pos - i - 1);
						pos -= i + 1;
						i = -1;
					}
				}
			}
			
			if (ret == 0 ||
			    (ret < 0 && errno != EAGAIN && errno != EWOULDBLOCK)) {
				printf("Close connection to server\n");
				close(fd_log);
				
				fd_log = -1;

				entry = log_entry_alloc();
				log_string(entry->buffer, LOG_ENTRY_LEN, LOG_T_ERROR, 
				    "Lost connection to controller");
				entry->buffer[strlen(entry->buffer)+1] = 0;
				entry->buffer[strlen(entry->buffer)] = '\n';
				printf(entry->buffer);
				entry->buflen = strlen(entry->buffer);
			}
		}
		command_server_fdset_handle(cmd_srv, &fd_rd);
			
		if (fd_logfile < 0) {
			fd_logfile = open(logfile, 
			    O_WRONLY | O_APPEND | O_CREAT,
			    S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
		}


		fdnew = tcp_accept(fd_listen);
		if (fdnew >= 0) {
			char status[LOG_ENTRY_SIZE];
			int statlen;
			
			nr_clients++;
			fd_clients = realloc(fd_clients, sizeof(int)*nr_clients);
			fd_clients[nr_clients-1] = fdnew;
			ioctl(fdnew, FIONBIO, &(int){ 1 });
			printf("New client. (now at %d)\n", nr_clients);
			
			if (fd_log >= 0) {
				log_string(status, LOG_ENTRY_LEN, LOG_T_INFO, 
				    "New connection to proxy, controller conection is established.");
				status[strlen(status)+1] = 0;
				status[strlen(status)] = '\n';
				statlen = strlen(status); 
			} else {
				log_string(status, LOG_ENTRY_LEN, LOG_T_WARNING, 
				    "New connection to proxy, no connection to controller.");
				status[strlen(status)+1] = 0;
				status[strlen(status)] = '\n';
				statlen = strlen(status); 
			}
			write(fdnew, status, statlen);
		}

		while ((entry = log_entry_pull())) {
			int i;

			if (fd_logfile >= 0) {
				int ret;
				
				ret = write(fd_logfile, entry->buffer, entry->buflen);
				if (ret != 1) {
					close(fd_logfile);
					fd_logfile = -1;
				}
			}

			for (i = 0; i < nr_clients; i++) {
				int ret;
				
				ret = write(fd_clients[i], entry->buffer, entry->buflen);
				if (ret != entry->buflen) {
					int j;
					close(fd_clients[i]);
					for (j = i + 1; j < nr_clients; j++) {
						fd_clients[j-1] = fd_clients[j];
					}
					nr_clients--;
					i--;
					printf("Lost a client. (now at %d)\n",
					    nr_clients);
				}
			}
		}
	}
}