/*
 *  ax25mond.c - Wrapper for offering AX.25 traffic to non-root processes
 *
 *  Copyright (C) 1998-1999 Johann Hanne, DH3MB. All rights reserved.
 *
 *  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 2 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, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*--------------------------------------------------------------------------*/

#define VERSION "1.0"
#define CONFFILE "/etc/ax25/ax25mond.conf"
#define MAX_SOCKETS  5
#define MAX_CONNECTS 50

/*--------------------------------------------------------------------------*/

#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <netdb.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <syslog.h>
#include <sys/time.h>
#include <sys/un.h>
#include <sys/socket.h>
#include <sys/fcntl.h>
#include <sys/signal.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <netinet/if_ether.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// For older kernels
#ifndef PF_PACKET
#define PF_PACKET PF_INET
#endif

/*--------------------------------------------------------------------------*/

static union {
	struct sockaddr sa;
	struct sockaddr_in si;
	struct sockaddr_un su;
} addr;

/*--------------------------------------------------------------------------*/

int sock_list[MAX_SOCKETS];
char sock_monmode[MAX_SOCKETS];
char sock_filename[MAX_SOCKETS][100];
int sock_num = 0;
int conn_list[MAX_CONNECTS];
struct sockaddr conn_addr[MAX_CONNECTS];
int conn_addrlen[MAX_CONNECTS];
char conn_monmode[MAX_CONNECTS];
int conn_num = 0;
int highest_sock_fd;
int end = 0;

/*--------------------------------------------------------------------------*/

/* from buildsaddr.c */
struct sockaddr *build_sockaddr(const char *name, int *addrlen)
{
	char *host_name;
	char *serv_name;
	char buf[1024];

	memset((char *) &addr, 0, sizeof(addr));
	*addrlen = 0;

	host_name = strcpy(buf, name);
	serv_name = strchr(buf, ':');
	if (!serv_name)
		return 0;
	*serv_name++ = 0;
	if (!*host_name || !*serv_name)
		return 0;

	if (!strcmp(host_name, "local") || !strcmp(host_name, "unix")) {
		addr.su.sun_family = AF_UNIX;
		*addr.su.sun_path = 0;
		strcat(addr.su.sun_path, serv_name);
		*addrlen = sizeof(struct sockaddr_un);
		return &addr.sa;
	}

	addr.si.sin_family = AF_INET;

	if (!strcmp(host_name, "*")) {
		addr.si.sin_addr.s_addr = INADDR_ANY;
	} else if (!strcmp(host_name, "loopback")) {
		addr.si.sin_addr.s_addr = inet_addr("127.0.0.1");
	} else if ((addr.si.sin_addr.s_addr = inet_addr(host_name)) == -1L) {
		struct hostent *hp = gethostbyname(host_name);
		endhostent();
		if (!hp)
			return 0;
		addr.si.sin_addr.s_addr =
		    ((struct in_addr *) (hp->h_addr))->s_addr;
	}

	if (isdigit(*serv_name & 0xff)) {
		addr.si.sin_port = htons(atoi(serv_name));
	} else {
		struct servent *sp = getservbyname(serv_name, (char *) 0);
		endservent();
		if (!sp)
			return 0;
		addr.si.sin_port = sp->s_port;
	}

	*addrlen = sizeof(struct sockaddr_in);
	return &addr.sa;
}

/*--------------------------------------------------------------------------*/

void add_socket(char *sockname, char monmode)
{
	struct sockaddr *saddr;
	int saddrlen;

	if (sock_num == MAX_SOCKETS - 1) {
		fprintf(stderr,
			"WARNING: Too many sockets defined - only %d are "
			"allowed\n", MAX_SOCKETS);
		return;
	}

	if (!(saddr = build_sockaddr(sockname, &saddrlen))) {
		fprintf(stderr, "WARNING: Invalid socket name: \"%s\"\n",
			sockname);
		return;
	}

	if (saddr->sa_family == AF_UNIX)
		strcpy(sock_filename[sock_num], strchr(sockname, ':') + 1);
	else
		sock_filename[sock_num][0] = 0;

	if ((sock_list[sock_num] =
	     socket(saddr->sa_family, SOCK_STREAM, 0)) < 0) {
		fprintf(stderr,
			"WARNING: Error opening socket \"%s\": %s\n",
			sockname, strerror(errno));
		return;
	}

	if (bind(sock_list[sock_num], saddr, saddrlen) < 0) {
		fprintf(stderr,
			"WARNING: Error binding socket \"%s\": %s\n",
			sockname, strerror(errno));
		return;
	}

	if (listen(sock_list[sock_num], 5) < 0) {
		fprintf(stderr,
			"WARNING: Error listening on socket \"%s\": %s\n",
			sockname, strerror(errno));
		return;
	}

	fcntl(sock_list[sock_num], F_SETFL, O_NONBLOCK);

	if (sock_list[sock_num] > highest_sock_fd)
		highest_sock_fd = sock_list[sock_num];

	sock_monmode[sock_num] = monmode;
	sock_num++;
}

/*--------------------------------------------------------------------------*/

void close_sockets()
{
	int i;

	for (i = 0; i < sock_num; i++) {
		close(sock_list[i]);

		if (sock_filename[i][0])
			unlink(sock_filename[i]);
	}
}

/*--------------------------------------------------------------------------*/

void quit_handler(int dummy)
{
	end = 1;
}

/*--------------------------------------------------------------------------*/

int main(int argc, char *argv[])
{
	fd_set monavail;
	int monrx_fd, monrxtx_fd;
	struct sockaddr monfrom;
	int monfromlen;
	fd_set conn_request;
	struct timeval tv;
	char buf[500];
	int size;
	int i;
	struct ifreq ifr;
	FILE *conffile;
	char confline[100];
	char *mode;
	char *sockname;

	if (argc > 1) {
		if (argc == 2 &&
		    (strcmp(argv[1], "-v") == 0
		     || strcmp(argv[1], "--version") == 0)) {
			printf("%s: Version " VERSION "\n\n", argv[0]);
			printf
			    ("Copyright (C) 1998-1999 Johann Hanne, DH3MB. All rights reserved.\n"
			     "This program is free software; you can redistribute it and/or modify\n"
			     "it under the terms of the GNU General Public License as published by\n"
			     "the Free Software Foundation; either version 2 of the License, or\n"
			     "(at your option) any later version.\n\n"
			     "This program is distributed in the hope that it will be useful,\n"
			     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
			     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
			exit(1);
		} else {
			printf("Usage: %s [-v|--version]\n", argv[0]);
			exit(0);
		}
	}
	// At first, read the configuration file
	if (!(conffile = fopen(CONFFILE, "r"))) {
		fprintf(stderr, "Unable to open " CONFFILE ".\n");
		exit(1);
	}
	while (fgets(confline, 100, conffile)) {
		if (confline[0] == '#')	// Comment
			continue;

		confline[strlen(confline) - 1] = 0;	// Cut the LF

		if (!(sockname = strchr(confline, ' '))) {
			fprintf(stderr,
				"WARNING: The following configuration line includes "
				"one or more errors:\n%s\n", confline);
			continue;
		}

		*(sockname++) = 0;
		mode = confline;
		if (strcasecmp(mode, "RX") == 0)
			add_socket(sockname, 0);
		else if (strcasecmp(mode, "RXTX") == 0)
			add_socket(sockname, 1);
		else
			fprintf(stderr,
				"WARNING: Mode \"%s\" not supported\n",
				mode);

	}
	fclose(conffile);

	if (sock_num == 0) {
		fprintf(stderr, "FATAL: No usable socket found\n");
		exit(1);
	}
	// Fork into background
	if (fork())
		exit(0);

	// Close stdout, stderr and stdin
	fclose(stdout);
	fclose(stderr);
	fclose(stdin);

	// Set some signal handlers
	signal(SIGPIPE, SIG_IGN);
	signal(SIGTERM, quit_handler);

	openlog("ax25mond", LOG_PID, LOG_DAEMON);

	// Open AX.25 socket for monitoring RX traffic only
	if ((monrx_fd =
	     socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_AX25))) < 0) {
		syslog(LOG_ERR, "Error opening monitor socket: %s\n",
		       strerror(errno));
		exit(1);
	}
	fcntl(monrx_fd, F_SETFL, O_NONBLOCK);

	// Open AX.25 socket for monitoring RX and TX traffic
	if ((monrxtx_fd =
	     socket(PF_PACKET, SOCK_PACKET, htons(ETH_P_ALL))) < 0) {
		syslog(LOG_ERR, "Error opening monitor socket: %s\n",
		       strerror(errno));
		exit(1);
	}
	fcntl(monrxtx_fd, F_SETFL, O_NONBLOCK);

	while (!end) {

		// Look for incoming connects on all open sockets
		FD_ZERO(&conn_request);
		for (i = 0; i < sock_num; i++)
			FD_SET(sock_list[i], &conn_request);
		tv.tv_sec = 0;
		tv.tv_usec = 0;
		select(highest_sock_fd + 1, &conn_request, 0, 0, &tv);
		for (i = 0; i < sock_num; i++)
			if (FD_ISSET(sock_list[i], &conn_request)) {
				conn_list[conn_num] = accept(sock_list[i],
							     &conn_addr
							     [conn_num],
							     &conn_addrlen
							     [conn_num]);
				conn_monmode[conn_num] = sock_monmode[i];
				conn_num++;
			}
		// Check if there is new data on the RX-only monitor socket
		FD_ZERO(&monavail);
		FD_SET(monrx_fd, &monavail);
		tv.tv_sec = 0;
		tv.tv_usec = 10;
		select(monrx_fd + 1, &monavail, 0, 0, &tv);
		if (FD_ISSET(monrx_fd, &monavail)) {
			monfromlen = sizeof(monfrom);
			size =
			    recvfrom(monrx_fd, buf, sizeof(buf), 0,
				     &monfrom, &monfromlen);
			// Send the packet to all connected sockets
			for (i = 0; i < conn_num; i++) {
				if (conn_monmode[i] == 0)
					if (send
					    (conn_list[i], buf, size,
					     0) < 0)
						if (errno != EAGAIN) {
							syslog(LOG_ERR,
							       "Error sending monitor data: %s\n",
							       strerror
							       (errno));
							close(conn_list
							      [i]);
							conn_list[i] =
							    conn_list
							    [conn_num - 1];
							conn_num--;
						}
			}
		}
		// Check if there is new data on the RX+TX monitor socket
		FD_ZERO(&monavail);
		FD_SET(monrxtx_fd, &monavail);
		tv.tv_sec = 0;
		tv.tv_usec = 10;
		select(monrxtx_fd + 1, &monavail, 0, 0, &tv);
		if (FD_ISSET(monrxtx_fd, &monavail)) {
			monfromlen = sizeof(monfrom);
			size =
			    recvfrom(monrxtx_fd, buf, sizeof(buf), 0,
				     &monfrom, &monfromlen);
			// Check, if we have received a AX.25-packet
			strcpy(ifr.ifr_name, monfrom.sa_data);
			ioctl(monrxtx_fd, SIOCGIFHWADDR, &ifr);
			if (ifr.ifr_hwaddr.sa_family == AF_AX25)
				// Send the packet to all connected sockets
				for (i = 0; i < conn_num; i++) {
					if (conn_monmode[i] == 1)
						if (send
						    (conn_list[i], buf,
						     size, 0) < 0)
							if (errno !=
							    EAGAIN) {
								syslog
								    (LOG_ERR,
								     "Error sending monitor data: %s\n",
								     strerror
								     (errno));
								close
								    (conn_list
								     [i]);
								conn_list
								    [i] =
								    conn_list
								    [conn_num
								     - 1];
								conn_num--;
							}
				}
		}

	}

	for (i = 0; i < conn_num; i++)
		close(conn_list[i]);
	close_sockets();
	close(monrx_fd);
	close(monrxtx_fd);
	closelog();
	return 0;
}