rsyslog/tests/uxsockrcvr.c

/* receives messages from a specified unix sockets and writes
 * output to specfied file.
 *
 * Command line options:
 * -s name of socket (required)
 * -o name of output file (stdout if not given)
 * -l add newline after each message received (default: do not add anything)
 * -t timeout in seconds (default 60)
 *
 * Part of the testbench for rsyslog.
 *
 * Copyright 2010 Rainer Gerhards and Adiscon GmbH.
 *
 * This file is part of rsyslog.
 *
 * Rsyslog 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.
 *
 * Rsyslog 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 Rsyslog.  If not, see <http://www.gnu.org/licenses/>.
 *
 * A copy of the GPL can be found in the file "COPYING" in this distribution.
 */
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#if defined(_AIX)
	#include <sys/types.h>
	#include  <unistd.h>
	#include <sys/socket.h>
	#include <sys/socketvar.h>
#else
	#include <getopt.h>
#endif
#include <sys/un.h>
#include <netdb.h>
#include <poll.h>
#include <errno.h>
#if defined(__FreeBSD__)
#include <sys/socket.h>
#endif

#define DFLT_TIMEOUT 60

char *sockName = NULL;
int sock;
int addNL = 0;


/* called to clean up on exit
 */
void
cleanup(void)
{
	unlink(sockName);
	close(sock);
}


void
doTerm(int __attribute__((unused)) signum)
{
	exit(1);
}


void
usage(void)
{
	fprintf(stderr, "usage: uxsockrcvr -s /socket/name -o /output/file -l\n"
			"-l adds newline after each message received\n"
			"-s MUST be specified\n"
			"if -o ist not specified, stdout is used\n");
	exit(1);
}


int
main(int argc, char *argv[])
{
	int opt;
	int rlen;
	int timeout = DFLT_TIMEOUT;
	FILE *fp = stdout;
	unsigned char data[128*1024];
	struct  sockaddr_un addr; /* address of server */
	struct  sockaddr from;
	socklen_t fromlen;
	struct pollfd fds[1];

	if(argc < 2) {
		fprintf(stderr, "error: too few arguments!\n");
		usage();
	}

	while((opt = getopt(argc, argv, "s:o:lt:")) != EOF) {
		switch((char)opt) {
		case 'l':
			addNL = 1;
			break;
		case 's':
			sockName = optarg;
			break;
		case 'o':
			if((fp = fopen(optarg, "w")) == NULL) {
				perror(optarg);
				exit(1);
			}
			break;
		case 't':
			timeout = atoi(optarg);
			break;
		default:usage();
		}
	}

	timeout = timeout * 1000;

	if(sockName == NULL) {
		fprintf(stderr, "error: -s /socket/name must be specified!\n");
		exit(1);
	}

	if(signal(SIGTERM, doTerm) == SIG_ERR) {
		perror("signal(SIGTERM, ...)");
		exit(1);
	}
	if(signal(SIGINT, doTerm) == SIG_ERR) {
		perror("signal(SIGINT, ...)");
		exit(1);
	}

	/*      Create a UNIX datagram socket for server        */
	if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
		perror("server: socket");
		exit(1);
	}

	atexit(cleanup);

	/*      Set up address structure for server socket      */
	memset(&addr, 0, sizeof(addr));
	addr.sun_family = AF_UNIX;
	strcpy(addr.sun_path, sockName);

	if (bind(sock, (struct sockaddr*) &addr, sizeof(addr)) < 0) {
		close(sock);
		perror("server: bind");
		exit(1);
	}

	fds[0].fd = sock;
	fds[0].events = POLLIN;

	/* we now run in an endless loop. We do not check who sends us
	 * data. This should be no problem for our testbench use.
	 */

	while(1) {
		fromlen = sizeof(from);
		rlen = poll(fds, 1, timeout);
		if(rlen == -1) {
			perror("uxsockrcvr : poll\n");
			exit(1);
		} else if(rlen == 0) {
			fprintf(stderr, "Socket timed out - nothing to receive\n");
			exit(1);
		} else {
			rlen = recvfrom(sock, data, 2000, 0, &from, &fromlen);
			if(rlen == -1) {
				perror("uxsockrcvr : recv\n");
				exit(1);
			} else {
				fwrite(data, 1, rlen, fp);
				if(addNL)
					fputc('\n', fp);
			}
		}
	}

	return 0;
}