No OneTemporary
Actions

Size

45 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/main.c b/src/main.c
	index 5704ff9..0b5a083 100644
	--- a/src/main.c
	+++ b/src/main.c
	@@ -1,1330 +1,1330 @@
	/*
	* Copyright (C) 2011 Jiaju Zhang <jjzhang@suse.de>
	* Copyright (C) 2013-2014 Philipp Marek <philipp.marek@linbit.com>
	*
	* 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.1 of the License, or (at your option) any later version.
	*
	* This software 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 library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include <stdio.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <sched.h>
	#include <errno.h>
	#include <limits.h>
	#include <sys/file.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/mman.h>
	#include <sys/time.h>
	#include <sys/resource.h>
	#include <sys/socket.h>
	#include <sys/un.h>
	#include <sys/poll.h>
	#include <pacemaker/crm/services.h>
	#include <clplumbing/setproctitle.h>
	#include <fcntl.h>
	#include <string.h>
	#include <assert.h>
	#include <error.h>
	#include <sys/ioctl.h>
	#include <termios.h>
	#include <signal.h>
	#include <netdb.h>
	#include <arpa/inet.h>
	#include <sys/types.h>
	#include "log.h"
	#include "booth.h"
	#include "config.h"
	#include "transport.h"
	#include "inline-fn.h"
	#include "pacemaker.h"
	#include "ticket.h"

	#define RELEASE_VERSION "1.0"

	#define CLIENT_NALLOC 32

	int daemonize = 0;


	/** Structure for "clients".
	* Filehandles with incoming data get registered here (and in pollfds),
	* along with their callbacks.
	* Because these can be reallocated with every new fd, addressing
	* happens _only_ by their numeric index. */
	struct client *clients = NULL;
	struct pollfd *pollfds = NULL;
	static int client_maxi;
	static int client_size = 0;


	static const struct booth_site _no_leader = {
	.addr_string = "none",
	.site_id = NO_ONE,
	};
	struct booth_site no_leader = (struct booth_site)& _no_leader;

	typedef enum
	{
	BOOTHD_STARTED=0,
	BOOTHD_STARTING
	} BOOTH_DAEMON_STATE;

	int poll_timeout = POLL_TIMEOUT;

	typedef enum {
	OP_LIST = 1,
	OP_GRANT,
	OP_REVOKE,
	} operation_t;



	struct booth_config *booth_conf;
	struct command_line cl;

	int do_read(int fd, void *buf, size_t count)
	{
	int rv, off = 0;

	while (off < count) {
	rv = read(fd, (char *)buf + off, count - off);
	if (rv == 0)
	return -1;
	if (rv == -1 && errno == EINTR)
	continue;
	if (rv == -1)
	return -1;
	off += rv;
	}
	return 0;
	}

	int do_write(int fd, void *buf, size_t count)
	{
	int rv, off = 0;

	retry:
	rv = write(fd, (char *)buf + off, count);
	if (rv == -1 && errno == EINTR)
	goto retry;
	/* If we cannot write _any_ data, we'd be in an (potential) loop. */
	if (rv <= 0) {
	log_error("write failed: %s (%d)", strerror(errno), errno);
	return rv;
	}

	if (rv != count) {
	count -= rv;
	off += rv;
	goto retry;
	}
	return 0;
	}


	static void client_alloc(void)
	{
	int i;

	if (!clients) {
	clients = malloc(CLIENT_NALLOC * sizeof(struct client));
	pollfds = malloc(CLIENT_NALLOC * sizeof(struct pollfd));
	} else {
	clients = realloc(clients, (client_size + CLIENT_NALLOC) *
	sizeof(struct client));
	pollfds = realloc(pollfds, (client_size + CLIENT_NALLOC) *
	sizeof(struct pollfd));
	}
	if (!clients \|\| !pollfds) {
	log_error("can't alloc for client array");
	exit(1);
	}

	for (i = client_size; i < client_size + CLIENT_NALLOC; i++) {
	clients[i].workfn = NULL;
	clients[i].deadfn = NULL;
	clients[i].fd = -1;
	pollfds[i].fd = -1;
	pollfds[i].revents = 0;
	}
	client_size += CLIENT_NALLOC;
	}

	static void client_dead(int ci)
	{
	if (clients[ci].fd != -1)
	close(clients[ci].fd);

	clients[ci].fd = -1;
	clients[ci].workfn = NULL;

	pollfds[ci].fd = -1;
	}

	int client_add(int fd, const struct booth_transport *tpt,
	void (*workfn)(int ci),
	void (*deadfn)(int ci))
	{
	int i;
	struct client *c;


	if (client_size + 2 >= client_maxi ) {
	client_alloc();
	}

	for (i = 0; i < client_size; i++) {
	c = clients + i;
	if (c->fd != -1)
	continue;

	c->workfn = workfn;
	if (deadfn)
	c->deadfn = deadfn;
	else
	c->deadfn = client_dead;

	c->transport = tpt;
	c->fd = fd;

	pollfds[i].fd = fd;
	pollfds[i].events = POLLIN;
	if (i > client_maxi)
	client_maxi = i;

	return i;
	}

	assert(!"no client");
	}


	/* Only used for client requests, TCP ???*/
	void process_connection(int ci)
	{
	struct boothc_ticket_msg msg;
	int rv, len, expr, fd;
	void (*deadfn) (int ci);


	fd = clients[ci].fd;
	rv = do_read(fd, &msg.header, sizeof(msg.header));

	if (rv < 0) {
	if (errno == ECONNRESET)
	log_debug("client %d connection reset for fd %d",
	ci, clients[ci].fd);

	goto kill;
	}

	if (check_boothc_header(&msg.header, -1) < 0)
	goto kill;

	/* Basic sanity checks already done. */
	len = ntohl(msg.header.length);
	if (len) {
	if (len != sizeof(msg)) {
	bad_len:
	log_error("got wrong length %u", len);
	return;
	}
	expr = len - sizeof(msg.header);
	rv = do_read(clients[ci].fd, msg.header.data, expr);
	if (rv < 0) {
	log_error("connection %d read data error %d, wanted %d",
	ci, rv, expr);
	goto kill;
	}
	}


	/* For CMD_GRANT and CMD_REVOKE:
	* Don't close connection immediately, but send
	* result a second later? */
	switch (ntohl(msg.header.cmd)) {
	case CMD_LIST:
	ticket_answer_list(fd, &msg);
	goto kill;

	case CMD_GRANT:
	/* Expect boothc_ticket_site_msg. */
	if (len != sizeof(msg))
	goto bad_len;
	ticket_answer_grant(fd, &msg);
	goto kill;

	case CMD_REVOKE:
	/* Expect boothc_ticket_site_msg. */
	if (len != sizeof(msg))
	goto bad_len;

	ticket_answer_revoke(fd, &msg);
	goto kill;

	default:
	log_error("connection %d cmd %x unknown",
	ci, ntohl(msg.header.cmd));
	init_header(&msg.header,CMR_GENERAL, RLT_INVALID_ARG, sizeof(msg.header));
	send_header_only(fd, &msg.header);
	goto kill;
	}

	assert(0);
	return;

	kill:
	deadfn = clients[ci].deadfn;
	if(deadfn) {
	deadfn(ci);
	}
	return;
	}


	/** Callback function for the listening TCP socket. */
	static void process_listener(int ci)
	{
	int fd, i;

	fd = accept(clients[ci].fd, NULL, NULL);
	if (fd < 0) {
	log_error("process_listener: accept error for fd %d: %s (%d)",
	clients[ci].fd, strerror(errno), errno);
	if (clients[ci].deadfn)
	clients[ci].deadfn(ci);
	return;
	}

	i = client_add(fd, clients[ci].transport, process_connection, NULL);

	log_debug("add client connection %d fd %d", i, fd);
	}

	static int setup_config(int type)
	{
	int rv;

	rv = read_config(cl.configfile);
	if (rv < 0)
	goto out;


	/* Set "local" pointer, ignoring errors. */
	if (cl.type == DAEMON && cl.site[0]) {
	if (!find_site_by_name(cl.site, &local, 1)) {
	log_error("Cannot find \"%s\" in the configuration.",
	cl.site);
	return -EINVAL;
	}
	local->local = 1;
	} else
	find_myself(NULL, type == CLIENT);


	rv = check_config(type);
	if (rv < 0)
	goto out;


	/* Per default the PID file name is derived from the
	* configuration name. */
	if (!cl.lockfile[0]) {
	snprintf(cl.lockfile, sizeof(cl.lockfile)-1,
	"%s/%s.pid", BOOTH_RUN_DIR, booth_conf->name);
	}

	out:
	return rv;
	}

	static int setup_transport(void)
	{
	int rv;

	rv = transport()->init(message_recv);
	if (rv < 0) {
	log_error("failed to init booth_transport %s", transport()->name);
	goto out;
	}

	rv = booth_transport[TCP].init(NULL);
	if (rv < 0) {
	log_error("failed to init booth_transport[TCP]");
	goto out;
	}

	out:
	return rv;
	}


	static int write_daemon_state(int fd, int state)
	{
	char buffer[1024];
	int rv, size;

	size = sizeof(buffer) - 1;
	rv = snprintf(buffer, size,
	"booth_pid=%d "
	"booth_state=%s "
	"booth_type=%s "
	"booth_cfg_name='%s' "
	"booth_addr_string='%s' "
	"booth_port=%d\n",
	getpid(),
	( state == BOOTHD_STARTED ? "started" :
	state == BOOTHD_STARTING ? "starting" :
	"invalid"),
	type_to_string(local->type),
	booth_conf->name,
	local->addr_string,
	booth_conf->port);

	if (rv < 0 \|\| rv == size) {
	log_error("Buffer filled up in write_daemon_state().");
	return -1;
	}
	size = rv;


	rv = ftruncate(fd, 0);
	if (rv < 0) {
	log_error("lockfile %s truncate error %d: %s",
	cl.lockfile, errno, strerror(errno));
	return rv;
	}


	rv = lseek(fd, 0, SEEK_SET);
	if (rv < 0) {
	log_error("lseek set fd(%d) offset to 0 error, return(%d), message(%s)",
	fd, rv, strerror(errno));
	rv = -1;
	return rv;
	}


	rv = write(fd, buffer, size);

	if (rv != size) {
	log_error("write to fd(%d, %d) returned %d, errno %d, message(%s)",
	fd, size,
	rv, errno, strerror(errno));
	return -1;
	}

	return 0;
	}

	static int loop(int fd)
	{
	void (*workfn) (int ci);
	void (*deadfn) (int ci);
	int rv, i;

	rv = setup_transport();
	if (rv < 0)
	goto fail;

	rv = setup_ticket();
	if (rv < 0)
	goto fail;


	client_add(local->tcp_fd, booth_transport + TCP,
	process_listener, NULL);


	rv = write_daemon_state(fd, BOOTHD_STARTED);
	if (rv != 0) {
	log_error("write daemon state %d to lockfile error %s: %s",
	BOOTHD_STARTED, cl.lockfile, strerror(errno));
	goto fail;
	}

	if (cl.type == ARBITRATOR)
	log_info("BOOTH arbitrator daemon started");
	else if (cl.type == SITE)
	log_info("BOOTH cluster site daemon started");

	while (1) {
	rv = poll(pollfds, client_maxi + 1, poll_timeout);
	if (rv == -1 && errno == EINTR)
	continue;
	if (rv < 0) {
	log_error("poll failed: %s (%d)", strerror(errno), errno);
	goto fail;
	}

	for (i = 0; i <= client_maxi; i++) {
	if (clients[i].fd < 0)
	continue;

	if (pollfds[i].revents & POLLIN) {
	workfn = clients[i].workfn;
	if (workfn)
	workfn(i);
	}
	if (pollfds[i].revents &
	(POLLERR \| POLLHUP \| POLLNVAL)) {
	deadfn = clients[i].deadfn;
	if (deadfn)
	deadfn(i);
	}
	}

	process_tickets();
	}

	return 0;

	fail:
	return -1;
	}


	static int query_get_string_answer(cmd_request_t cmd)
	{
	struct booth_site *site;
	struct boothc_header reply;
	char *data;
	int data_len;
	int rv;
	struct booth_transport const *tpt;

	data = NULL;
	init_header(&cl.msg.header, cmd, 0, sizeof(cl.msg));

	if (!*cl.site)
	site = local;
	else if (!find_site_by_name(cl.site, &site, 1)) {
	log_error("cannot find site \"%s\"", cl.site);
	rv = ENOENT;
	goto out;
	}

	tpt = booth_transport + TCP;
	rv = tpt->open(site);
	if (rv < 0)
	goto out_free;

	rv = tpt->send(site, &cl.msg, sizeof(cl.msg));
	if (rv < 0)
	goto out_free;

	rv = tpt->recv(site, &reply, sizeof(reply));
	if (rv < 0)
	goto out_free;

	data_len = ntohl(reply.length) - sizeof(reply);

	data = malloc(data_len);
	if (!data) {
	rv = -ENOMEM;
	goto out_free;
	}
	rv = tpt->recv(site, data, data_len);
	if (rv < 0)
	goto out_free;

	do_write(STDOUT_FILENO, data, data_len);
	rv = 0;

	out_free:
	free(data);
	tpt->close(site);
	out:
	return rv;
	}


	static int test_reply(int reply_code, cmd_request_t cmd)
	{
	int rv = 0;

	switch (reply_code) {
	case RLT_OVERGRANT:
	log_info("You're granting a granted ticket. "
	"If you wanted to migrate a ticket, "
	"use revoke first, then use grant.");
	rv = -1;
	break;

	case RLT_ASYNC:
	if (cmd == CMD_GRANT)
	log_info("grant command sent, result will be returned "
	"asynchronously, you can get the result from "
	"the log files");
	else if (cmd == CMD_REVOKE)
	log_info("revoke command sent, result will be returned "
	"asynchronously, you can get the result from "
	"the log files.");
	else
	log_error("internal error reading reply result!");
	rv = 0;
	break;

	case RLT_SYNC_SUCC:
	case RLT_SUCCESS:
	if (cmd == CMD_GRANT)
	log_info("grant succeeded!");
	else if (cmd == CMD_REVOKE)
	log_info("revoke succeeded!");
	rv = 0;
	break;

	case RLT_SYNC_FAIL:
	if (cmd == CMD_GRANT)
	log_info("grant failed!");
	else if (cmd == CMD_REVOKE)
	log_info("revoke failed!");
	rv = -1;
	break;

	case RLT_INVALID_ARG:
	log_error("ticket \"%s\" does not exist",
	cl.msg.ticket.id);
	break;

	case RLT_REDIRECT:
	/* talk to another site */
	rv = 1;
	break;

	default:
	log_error("got an error code: %x", rv);
	rv = -1;
	}
	return rv;
	}

	static int do_command(cmd_request_t cmd)
	{
	struct booth_site *site;
	struct boothc_ticket_msg reply;
	struct booth_transport const *tpt;
	uint32_t leader_id;
	int rv;

	rv = 0;
	site = NULL;

	if (!*cl.site)
	site = local;
	else {
	if (!find_site_by_name(cl.site, &site, 1)) {
	log_error("Site \"%s\" not configured.", cl.site);
	goto out_close;
	}

	if (site->type == ARBITRATOR) {
	log_error("Site \"%s\" is an arbitrator, cannot grant ticket there.", cl.site);
	goto out_close;
	}

	assert(site->type == SITE);
	}

	/* We don't check for existence of ticket, so that asking can be
	* done without local configuration, too.
	* Although, that means that the UDP port has to be specified, too. */
	if (!cl.msg.ticket.id[0]) {
	/* If the loaded configuration has only a single ticket defined, use that. */
	if (booth_conf->ticket_count == 1) {
	strcpy(cl.msg.ticket.id, booth_conf->ticket[0].name);
	} else {
	log_error("No ticket given.");
	goto out_close;
	}
	}

	redirect:
	init_header(&cl.msg.header, cmd, 0, sizeof(cl.msg));

	/* Always use TCP for client - at least for now. */
	tpt = booth_transport + TCP;
	rv = tpt->open(site);
	if (rv < 0)
	goto out_close;

	rv = tpt->send(site, &cl.msg, sizeof(cl.msg));
	if (rv < 0)
	goto out_close;

	rv = tpt->recv(site, &reply, sizeof(reply));
	if (rv < 0)
	goto out_close;

	rv = test_reply(ntohl(reply.header.result), cmd);
	if (rv == 1) {
	local_transport->close(site);
	leader_id = ntohl(reply.ticket.leader);
	if (!find_site_by_id(leader_id, &site)) {
	log_error("Message with unknown redirect site %x received", leader_id);
	return rv;
	}
	goto redirect;
	}

	out_close:
	if (site)
	local_transport->close(site);
	return rv;
	}

	static int do_grant(void)
	{
	return do_command(CMD_GRANT);
	}

	static int do_revoke(void)
	{
	return do_command(CMD_REVOKE);
	}



	static int _lockfile(int mode, int fdp, pid_t locked_by)
	{
	struct flock lock;
	int fd, rv;


	/* After reboot the directory may not yet exist.
	* Try to create it, but ignore errors. */
	if (strncmp(cl.lockfile, BOOTH_RUN_DIR,
	strlen(BOOTH_RUN_DIR)) == 0)
	mkdir(BOOTH_RUN_DIR, 0775);


	if (locked_by)
	*locked_by = 0;

	*fdp = -1;
	fd = open(cl.lockfile, mode, 0664);
	if (fd < 0)
	return errno;

	*fdp = fd;

	lock.l_type = F_WRLCK;
	lock.l_start = 0;
	lock.l_whence = SEEK_SET;
	lock.l_len = 0;
	lock.l_pid = 0;


	if (fcntl(fd, F_SETLK, &lock) == 0)
	return 0;

	rv = errno;

	if (locked_by)
	if (fcntl(fd, F_GETLK, &lock) == 0)
	*locked_by = lock.l_pid;

	return rv;
	}


	static inline int is_root(void)
	{
	/* TODO: getuid()? Better way to check? */
	return geteuid() == 0;
	}


	static int create_lockfile(void)
	{
	int rv, fd;

	fd = -1;
	rv = _lockfile(O_CREAT \| O_WRONLY, &fd, NULL);

	if (fd == -1) {
	log_error("lockfile %s open error %d: %s",
	cl.lockfile, rv, strerror(rv));
	return -1;
	}

	if (rv < 0) {
	log_error("lockfile %s setlk error %d: %s",
	cl.lockfile, rv, strerror(rv));
	goto fail;
	}

	rv = write_daemon_state(fd, BOOTHD_STARTING);
	if (rv != 0) {
	log_error("write daemon state %d to lockfile error %s: %s",
	BOOTHD_STARTING, cl.lockfile, strerror(errno));
	goto fail;
	}

	if (is_root()) {
	if (fchown(fd, booth_conf->uid, booth_conf->gid) < 0)
	log_error("fchown() on lockfile said %d: %s",
	errno, strerror(errno));
	}

	return fd;

	fail:
	close(fd);
	return -1;
	}

	static void unlink_lockfile(int fd)
	{
	unlink(cl.lockfile);
	close(fd);
	}

	static void print_usage(void)
	{
	printf("Usages:\n");
	printf(" booth daemon [-c config] [-D]\n");
	printf(" booth [client] {list\|grant\|revoke} [options]\n");
	printf(" booth status [-c config] [-D]\n");
	printf("\n");
	printf("Client operations:\n");
	printf(" list: List all the tickets\n");
	printf(" grant: Grant ticket to site\n");
	printf(" revoke: Revoke ticket from site\n");
	printf("\n");
	printf("Options:\n");
	printf(" -c FILE Specify config file [default " BOOTH_DEFAULT_CONF "]\n");
	printf(" Can be a path or a name without \".conf\" suffix\n");
	printf(" -D Enable debugging to stderr and don't fork\n");
	printf(" -S Systemd mode (no forking)\n");
	printf(" -t ticket name\n");
	printf(" -s site name\n");
	printf(" -l LOCKFILE Specify lock file path (daemon only)\n");
	printf(" -h Print this help, then exit\n");
	printf("\n");
	printf("Please see the man page for details.\n");
	}

	#define OPTION_STRING "c:Dl:t:s:hS"


	void safe_copy(char dest, char value, size_t buflen, const char *description) {
	int content_len = buflen - 1;

	if (strlen(value) >= content_len) {
	fprintf(stderr, "'%s' exceeds maximum %s length of %d\n",
	value, description, content_len);
	exit(EXIT_FAILURE);
	}
	strncpy(dest, value, content_len);
	dest[content_len] = 0;
	}

	static int host_convert(char hostname, char ip_str, size_t ip_size)
	{
	struct addrinfo *result = NULL, hints = {0};
	int re = -1;

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = BOOTH_PROTO_FAMILY;
	hints.ai_socktype = SOCK_DGRAM;

	re = getaddrinfo(hostname, NULL, &hints, &result);

	if (re == 0) {
	struct in_addr addr = ((struct sockaddr_in *)result->ai_addr)->sin_addr;
	const char *re_ntop = inet_ntop(BOOTH_PROTO_FAMILY, &addr, ip_str, ip_size);
	if (re_ntop == NULL) {
	re = -1;
	}
	}

	freeaddrinfo(result);
	return re;
	}

	static int read_arguments(int argc, char **argv)
	{
	int optchar;
	char *arg1 = argv[1];
	char *op = NULL;
	char *cp;
	char site_arg[INET_ADDRSTRLEN] = {0};
	int left;

	if (argc < 2 \|\| !strcmp(arg1, "help") \|\| !strcmp(arg1, "--help") \|\|
	!strcmp(arg1, "-h")) {
	print_usage();
	exit(EXIT_SUCCESS);
	}

	if (!strcmp(arg1, "version") \|\| !strcmp(arg1, "--version") \|\|
	!strcmp(arg1, "-V")) {
	printf("%s %s (built %s %s)\n",
	argv[0], RELEASE_VERSION, __DATE__, __TIME__);
	exit(EXIT_SUCCESS);
	}

	if (strcmp(arg1, "arbitrator") == 0 \|\|
	strcmp(arg1, "site") == 0 \|\|
	strcmp(arg1, "start") == 0 \|\|
	strcmp(arg1, "daemon") == 0) {
	cl.type = DAEMON;
	optind = 2;
	} else if (strcmp(arg1, "status") == 0) {
	cl.type = STATUS;
	optind = 2;
	} else if (strcmp(arg1, "client") == 0) {
	cl.type = CLIENT;
	if (argc < 3) {
	print_usage();
	exit(EXIT_FAILURE);
	}
	op = argv[2];
	optind = 3;
	} else {
	cl.type = CLIENT;
	op = argv[1];
	optind = 2;
	}

	if (cl.type == CLIENT) {
	if (!strcmp(op, "list"))
	cl.op = OP_LIST;
	else if (!strcmp(op, "grant"))
	cl.op = OP_GRANT;
	else if (!strcmp(op, "revoke"))
	cl.op = OP_REVOKE;
	else {
	fprintf(stderr, "client operation \"%s\" is unknown\n",
	op);
	exit(EXIT_FAILURE);
	}
	}

	while (optind < argc) {
	optchar = getopt(argc, argv, OPTION_STRING);

	switch (optchar) {
	case 'c':
	if (strchr(optarg, '/')) {
	safe_copy(cl.configfile, optarg,
	sizeof(cl.configfile), "config file");
	} else {
	/* If no "/" in there, use with default directory. */
	strcpy(cl.configfile, BOOTH_DEFAULT_CONF_DIR);
	cp = cl.configfile + strlen(BOOTH_DEFAULT_CONF_DIR);
	assert(cp > cl.configfile);
	assert(*(cp-1) == '/');

	/* Write at the \0, ie. after the "/" */
	safe_copy(cp, optarg,
	(sizeof(cl.configfile) -
	(cp - cl.configfile) -
	strlen(BOOTH_DEFAULT_CONF_EXT)),
	"config name");

	/* If no extension, append ".conf".
	* Space is available, see -strlen() above. */
	if (!strchr(cp, '.'))
	strcat(cp, BOOTH_DEFAULT_CONF_EXT);
	}
	break;
	case 'D':
	debug_level++;
	/* Fall through */
	case 'S':
	daemonize = 1;
	break;

	case 'l':
	safe_copy(cl.lockfile, optarg, sizeof(cl.lockfile), "lock file");
	break;
	case 't':
	if (cl.op == OP_GRANT \|\| cl.op == OP_REVOKE) {
	safe_copy(cl.msg.ticket.id, optarg,
	sizeof(cl.msg.ticket.id), "ticket name");
	} else {
	print_usage();
	exit(EXIT_FAILURE);
	}
	break;

	case 's':
	/* For testing and debugging: allow "-s site" also for
	* daemon start, so that the address that should be used
	* can be set manually.
	* This makes it easier to start multiple processes
	* on one machine. */
	if (cl.type == CLIENT \|\|
	(cl.type == DAEMON && debug_level)) {
	int re = host_convert(optarg, site_arg, INET_ADDRSTRLEN);
	if (re == 0) {
	safe_copy(cl.site, site_arg, sizeof(cl.site), "site name");
	} else {
	safe_copy(cl.site, optarg, sizeof(cl.site), "site name");
	}
	} else {
	log_error("\"-s\" not allowed in daemon mode.");
	exit(EXIT_FAILURE);
	}
	break;

	case 'h':
	print_usage();
	exit(EXIT_SUCCESS);
	break;

	case ':':
	case '?':
	fprintf(stderr, "Please use '-h' for usage.\n");
	exit(EXIT_FAILURE);
	break;

	case -1:
	/* No more parameters on cmdline, only arguments. */
	goto extra_args;

	default:
	goto unknown;
	};
	}

	return 0;



	extra_args:
	if (cl.type == CLIENT && !cl.msg.ticket.id[0]) {
	/* Use additional argument as ticket name. */
	safe_copy(cl.msg.ticket.id,
	argv[optind],
	sizeof(cl.msg.ticket.id),
	"ticket name");
	optind++;
	}

	if (optind == argc)
	return 0;


	left = argc - optind;
	fprintf(stderr, "Superfluous argument%s: %s%s\n",
	left == 1 ? "" : "s",
	argv[optind],
	left == 1 ? "" : "...");
	exit(EXIT_FAILURE);

	unknown:
	fprintf(stderr, "unknown option: %s\n", argv[optind]);
	exit(EXIT_FAILURE);
	}


	static void set_scheduler(void)
	{
	struct sched_param sched_param;
	struct rlimit rlimit;
	int rv;

	rlimit.rlim_cur = RLIM_INFINITY;
	rlimit.rlim_max = RLIM_INFINITY;
	setrlimit(RLIMIT_MEMLOCK, &rlimit);
	rv = mlockall(MCL_CURRENT \| MCL_FUTURE);
	if (rv < 0) {
	log_error("mlockall failed");
	}

	rv = sched_get_priority_max(SCHED_RR);
	if (rv != -1) {
	sched_param.sched_priority = rv;
	rv = sched_setscheduler(0, SCHED_RR, &sched_param);
	if (rv == -1)
	log_error("could not set SCHED_RR priority %d: %s (%d)",
	sched_param.sched_priority,
	strerror(errno), errno);
	} else {
	log_error("could not get maximum scheduler priority err %d",
	errno);
	}
	}

	static void set_oom_adj(int val)
	{
	FILE *fp;

	fp = fopen("/proc/self/oom_adj", "w");
	if (!fp)
	return;

	fprintf(fp, "%i", val);
	fclose(fp);
	}

	static int do_status(int type)
	{
	pid_t pid;
	int rv, lock_fd, ret;
	const char *reason = NULL;
	char lockfile_data[1024], *cp;


	ret = PCMK_OCF_NOT_RUNNING;
	/* TODO: query all, and return quit only if it's _cleanly_ not
	* running, ie. _neither_ of port/lockfile/process is available?
	*
	* Currently a single failure says "not running", even if "only" the
	* lockfile has been removed. */

	rv = setup_config(type);
	if (rv) {
	reason = "Error reading configuration.";
	ret = PCMK_OCF_UNKNOWN_ERROR;
	goto quit;
	}


	if (!local) {
	reason = "No Service IP active here.";
	goto quit;
	}


	rv = _lockfile(O_RDWR, &lock_fd, &pid);
	if (rv == 0) {
	reason = "PID file not locked.";
	goto quit;
	}
	if (lock_fd == -1) {
	reason = "No PID file.";
	goto quit;
	}

	if (pid) {
	fprintf(stdout, "booth_lockpid=%d ", pid);
	fflush(stdout);
	}


	rv = read(lock_fd, lockfile_data, sizeof(lockfile_data) - 1);
	if (rv < 4) {
	reason = "Cannot read lockfile data.";
	ret = PCMK_LSB_UNKNOWN_ERROR;
	goto quit;

	}
	lockfile_data[rv] = 0;

	if (lock_fd != -1)
	close(lock_fd);


	/* Make sure it's only a single line */
	cp = strchr(lockfile_data, '\r');
	if (cp)
	*cp = 0;
	cp = strchr(lockfile_data, '\n');
	if (cp)
	*cp = 0;



	- rv = setup_udp_server(1);
	+ rv = setup_tcp_listener(1);
	if (rv == 0) {
	- reason = "UDP port not in use.";
	+ reason = "TCP port not in use.";
	goto quit;
	}


	fprintf(stdout, "booth_lockfile='%s' %s\n",
	cl.lockfile, lockfile_data);
	if (daemonize)
	fprintf(stderr, "Booth at %s port %d seems to be running.\n",
	local->addr_string, booth_conf->port);
	return 0;


	quit:
	log_debug("not running: %s", reason);
	/* Ie. "DEBUG" */
	if (daemonize)
	fprintf(stderr, "not running: %s\n", reason);
	return ret;
	}


	static int limit_this_process(void)
	{
	int rv;
	if (!is_root())
	return 0;

	if (setregid(booth_conf->gid, booth_conf->gid) < 0) {
	rv = errno;
	log_error("setregid() didn't work: %s", strerror(rv));
	return rv;
	}

	if (setreuid(booth_conf->uid, booth_conf->uid) < 0) {
	rv = errno;
	log_error("setreuid() didn't work: %s", strerror(rv));
	return rv;
	}

	/* TODO: ulimits? But that would restrict crm_ticket and handler
	* scripts, too! */
	return 0;
	}


	static int do_server(int type)
	{
	int lock_fd = -1;
	int rv = -1;
	static char log_ent[128] = DAEMON_NAME "-";

	rv = setup_config(type);
	if (rv < 0)
	goto out;


	if (!local) {
	log_error("Cannot find myself in the configuration.");
	exit(EXIT_FAILURE);
	}

	if (!daemonize) {
	if (daemon(0, 0) < 0) {
	perror("daemon error");
	exit(EXIT_FAILURE);
	}
	}

	/* The lockfile must be written to _after_ the call to daemon(), so
	* that the lockfile contains the pid of the daemon, not the parent. */
	lock_fd = create_lockfile();
	if (lock_fd < 0)
	return lock_fd;

	strcat(log_ent, type_to_string(local->type));
	cl_log_set_entity(log_ent);
	cl_log_enable_stderr(debug_level ? TRUE : FALSE);
	cl_log_set_facility(HA_LOG_FACILITY);
	cl_inherit_logging_environment(0);


	log_info("BOOTH %s daemon is starting, node id is 0x%08X (%d).",
	type_to_string(local->type),
	local->site_id, local->site_id);

	signal(SIGUSR1, (__sighandler_t)tickets_log_info);

	set_scheduler();
	set_oom_adj(-16);
	set_proc_title("%s %s for [%s]:%d",
	DAEMON_NAME,
	type_to_string(local->type),
	local->addr_string,
	booth_conf->port);

	rv = limit_this_process();
	if (rv)
	return rv;


	rv = loop(lock_fd);

	out:
	if (lock_fd >= 0) {
	/* We might not be able to delete it, but at least
	* make it empty. */
	rv = ftruncate(lock_fd, 0);
	(void)rv;
	unlink_lockfile(lock_fd);
	}

	return rv;
	}

	static int do_client(void)
	{
	int rv = -1;

	rv = setup_config(CLIENT);
	if (rv < 0) {
	log_error("cannot read config");
	goto out;
	}

	switch (cl.op) {
	case OP_LIST:
	rv = query_get_string_answer(CMD_LIST);
	break;

	case OP_GRANT:
	rv = do_grant();
	break;

	case OP_REVOKE:
	rv = do_revoke();
	break;
	}

	out:
	return rv;
	}

	int main(int argc, char argv[], char envp[])
	{
	int rv;

	init_set_proc_title(argc, argv, envp);

	memset(&cl, 0, sizeof(cl));
	strncpy(cl.configfile,
	BOOTH_DEFAULT_CONF, BOOTH_PATH_LEN - 1);
	cl.lockfile[0] = 0;
	debug_level = 0;
	cl_log_set_entity("booth");
	cl_log_enable_stderr(TRUE);
	cl_log_set_facility(0);


	rv = read_arguments(argc, argv);
	if (rv < 0)
	goto out;


	switch (cl.type) {
	case STATUS:
	rv = do_status(cl.type);
	break;

	case ARBITRATOR:
	case DAEMON:
	case SITE:
	rv = do_server(cl.type);
	break;

	case CLIENT:
	rv = do_client();
	break;
	}

	out:
	/* Normalize values. 0x100 would be seen as "OK" by waitpid(). */
	return (rv >= 0 && rv < 0x70) ? rv : 1;
	}
	diff --git a/src/transport.c b/src/transport.c
	index cb4b3a5..fe96f34 100644
	--- a/src/transport.c
	+++ b/src/transport.c
	@@ -1,732 +1,733 @@
	/*
	* Copyright (C) 2011 Jiaju Zhang <jjzhang@suse.de>
	* Copyright (C) 2013-2014 Philipp Marek <philipp.marek@linbit.com>
	*
	* 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.1 of the License, or (at your option) any later version.
	*
	* This software 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 library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include <string.h>
	#include <stdlib.h>
	#include <net/if.h>
	#include <asm/types.h>
	#include <linux/rtnetlink.h>
	#include <arpa/inet.h>
	#include <netinet/in.h>
	#include <netinet/tcp.h>
	#include <assert.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <errno.h>
	#include <poll.h>
	#include "booth.h"
	#include "inline-fn.h"
	#include "log.h"
	#include "config.h"
	#include "ticket.h"
	#include "transport.h"

	#define BOOTH_IPADDR_LEN (sizeof(struct in6_addr))

	#define NETLINK_BUFSIZE 16384
	#define SOCKET_BUFFER_SIZE 160000
	#define FRAME_SIZE_MAX 10000



	struct booth_site *local = NULL;


	static int (deliver_fn) (void msg, int msglen);


	static void parse_rtattr(struct rtattr *tb[],
	int max, struct rtattr *rta, int len)
	{
	while (RTA_OK(rta, len)) {
	if (rta->rta_type <= max)
	tb[rta->rta_type] = rta;
	rta = RTA_NEXT(rta,len);
	}
	}


	static int find_address(unsigned char ipaddr[BOOTH_IPADDR_LEN],
	int family, int prefixlen,
	int fuzzy_allowed,
	struct booth_site **me,
	int *address_bits_matched)
	{
	int i;
	struct booth_site *node;
	int bytes, bits_left, mask;
	unsigned char node_bits, ip_bits;
	uint8_t *n_a;
	int matched, did_match;


	bytes = prefixlen / 8;
	bits_left = prefixlen % 8;
	/* One bit left to check means ignore 7 lowest bits. */
	mask = ~( (1 << (8 - bits_left)) -1);
	did_match = 0;

	for (i = 0; i < booth_conf->site_count; i++) {
	node = booth_conf->site + i;
	if (family != node->family)
	continue;
	n_a = node_to_addr_pointer(node);

	for(matched = 0; matched < node->addrlen; matched++)
	if (ipaddr[matched] != n_a[matched])
	break;


	if (matched == node->addrlen) {
	/* Full match. */
	address_bits_matched = matched 8;
	found:
	*me = node;
	did_match = 1;
	continue;
	}

	if (!fuzzy_allowed)
	continue;


	/* Check prefix, whole bytes */
	if (matched < bytes)
	continue;
	if (matched * 8 < *address_bits_matched)
	continue;
	if (!bits_left)
	goto found;

	node_bits = n_a[bytes];
	ip_bits = ipaddr[bytes];
	if (((node_bits ^ ip_bits) & mask) == 0) {
	/* _At_least_ prefixlen bits matched. */
	*address_bits_matched = prefixlen;
	goto found;
	}
	}

	return did_match;
	}


	int _find_myself(int family, struct booth_site **mep, int fuzzy_allowed);
	int _find_myself(int family, struct booth_site **mep, int fuzzy_allowed)
	{
	int fd;
	struct sockaddr_nl nladdr;
	struct booth_site *me;
	unsigned char ipaddr[BOOTH_IPADDR_LEN];
	static char rcvbuf[NETLINK_BUFSIZE];
	struct {
	struct nlmsghdr nlh;
	struct rtgenmsg g;
	} req;
	int address_bits_matched;


	if (local)
	goto found;


	me = NULL;
	address_bits_matched = 0;
	if (mep)
	*mep = NULL;
	fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
	if (fd < 0) {
	log_error("failed to create netlink socket");
	return 0;
	}

	setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf));

	memset(&nladdr, 0, sizeof(nladdr));
	nladdr.nl_family = AF_NETLINK;

	memset(&req, 0, sizeof(req));
	req.nlh.nlmsg_len = sizeof(req);
	req.nlh.nlmsg_type = RTM_GETADDR;
	req.nlh.nlmsg_flags = NLM_F_ROOT\|NLM_F_MATCH\|NLM_F_REQUEST;
	req.nlh.nlmsg_pid = 0;
	req.nlh.nlmsg_seq = 1;
	req.g.rtgen_family = family;

	if (sendto(fd, (void *)&req, sizeof(req), 0,
	(struct sockaddr*)&nladdr, sizeof(nladdr)) < 0) {
	close(fd);
	log_error("failed to send data to netlink socket");
	return 0;
	}

	while (1) {
	int status;
	struct nlmsghdr *h;
	struct iovec iov = { rcvbuf, sizeof(rcvbuf) };
	struct msghdr msg = {
	(void *)&nladdr, sizeof(nladdr),
	&iov, 1,
	NULL, 0,
	0
	};

	status = recvmsg(fd, &msg, 0);
	if (!status) {
	close(fd);
	log_error("failed to recvmsg from netlink socket");
	return 0;
	}

	h = (struct nlmsghdr *)rcvbuf;
	if (h->nlmsg_type == NLMSG_DONE)
	break;

	if (h->nlmsg_type == NLMSG_ERROR) {
	close(fd);
	log_error("netlink socket recvmsg error");
	return 0;
	}

	while (NLMSG_OK(h, status)) {
	if (h->nlmsg_type == RTM_NEWADDR) {
	struct ifaddrmsg *ifa = NLMSG_DATA(h);
	struct rtattr *tb[IFA_MAX+1];
	int len = h->nlmsg_len
	- NLMSG_LENGTH(sizeof(*ifa));

	memset(tb, 0, sizeof(tb));
	parse_rtattr(tb, IFA_MAX, IFA_RTA(ifa), len);
	memset(ipaddr, 0, BOOTH_IPADDR_LEN);
	/* prefer IFA_LOCAL if it exists, for p-t-p
	* interfaces, otherwise use IFA_ADDRESS */
	if (tb[IFA_LOCAL]) {
	memcpy(ipaddr, RTA_DATA(tb[IFA_LOCAL]),
	BOOTH_IPADDR_LEN);
	} else {
	memcpy(ipaddr, RTA_DATA(tb[IFA_ADDRESS]),
	BOOTH_IPADDR_LEN);
	}

	/* First try with exact addresses, then optionally with subnet matching. */
	if (ifa->ifa_prefixlen > address_bits_matched)
	find_address(ipaddr,
	ifa->ifa_family, ifa->ifa_prefixlen,
	fuzzy_allowed, &me, &address_bits_matched);
	}
	h = NLMSG_NEXT(h, status);
	}
	}

	close(fd);

	if (!me)
	return 0;

	me->local = 1;
	local = me;
	found:
	if (mep)
	*mep = local;
	return 1;
	}

	int find_myself(struct booth_site **mep, int fuzzy_allowed)
	{
	return _find_myself(AF_INET6, mep, fuzzy_allowed) \|\|
	_find_myself(AF_INET, mep, fuzzy_allowed);
	}


	/** Checks the header fields for validity.
	* cf. init_header().
	* For @len_incl_data < 0 the length is not checked.
	* Return <0 if error, else bytes read. */
	int check_boothc_header(struct boothc_header *h, int len_incl_data)
	{
	int l;

	if (h->magic != htonl(BOOTHC_MAGIC)) {
	log_error("magic error %x", ntohl(h->magic));
	return -EINVAL;
	}
	if (h->version != htonl(BOOTHC_VERSION)) {
	log_error("version error %x", ntohl(h->version));
	return -EINVAL;
	}


	l = ntohl(h->length);
	if (l < sizeof(*h)) {
	log_error("length %d out of range", l);
	return -EINVAL;
	}


	if (len_incl_data < 0)
	return 0;

	if (l != len_incl_data) {
	log_error("length error - got %d, wanted %d",
	l, len_incl_data);
	return -EINVAL;
	}

	return len_incl_data;
	}


	static void process_tcp_listener(int ci)
	{
	int fd, i, one = 1;
	socklen_t addrlen = sizeof(struct sockaddr);
	struct sockaddr addr;

	fd = accept(clients[ci].fd, &addr, &addrlen);
	if (fd < 0) {
	log_error("process_tcp_listener: accept error %d %d",
	fd, errno);
	return;
	}
	setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&one, sizeof(one));


	i = client_add(fd, clients[ci].transport,
	process_connection, NULL);

	log_debug("client connection %d fd %d", i, fd);
	}

	-static int setup_tcp_listener(void)
	+int setup_tcp_listener(int test_only)
	{
	int s, rv;
	int one = 1;

	s = socket(local->family, SOCK_STREAM, 0);
	if (s == -1) {
	log_error("failed to create tcp socket %s", strerror(errno));
	return s;
	}

	rv = setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
	if (rv == -1) {
	log_error("failed to set the SO_REUSEADDR option");
	return rv;
	}

	rv = bind(s, &local->sa6, local->saddrlen);
	+ if (test_only) {
	+ rv = (rv == -1) ? errno : 0;
	+ close(s);
	+ return rv;
	+ }
	+
	if (rv == -1) {
	log_error("failed to bind socket %s", strerror(errno));
	return rv;
	}

	rv = listen(s, 5);
	if (rv == -1) {
	log_error("failed to listen on socket %s", strerror(errno));
	return rv;
	}

	return s;
	}

	static int booth_tcp_init(void * unused __attribute__((unused)))
	{
	int rv;

	if (get_local_id() < 0)
	return -1;

	- rv = setup_tcp_listener();
	+ rv = setup_tcp_listener(0);
	if (rv < 0)
	return rv;

	client_add(rv, booth_transport + TCP,
	process_tcp_listener, NULL);

	return 0;
	}

	static int connect_nonb(int sockfd, const struct sockaddr *saptr,
	socklen_t salen, int sec)
	{
	int flags, n, error;
	socklen_t len;
	fd_set rset, wset;
	struct timeval tval;

	flags = fcntl(sockfd, F_GETFL, 0);
	fcntl(sockfd, F_SETFL, flags \| O_NONBLOCK);

	error = 0;
	if ( (n = connect(sockfd, saptr, salen)) < 0)
	if (errno != EINPROGRESS)
	return -1;

	if (n == 0)
	goto done; /* connect completed immediately */

	FD_ZERO(&rset);
	FD_SET(sockfd, &rset);
	wset = rset;
	tval.tv_sec = sec;
	tval.tv_usec = 0;

	if ((n = select(sockfd + 1, &rset, &wset, NULL,
	sec ? &tval : NULL)) == 0) {
	/* leave outside function to close */
	/* timeout */
	/* close(sockfd); */
	errno = ETIMEDOUT;
	return -1;
	}

	if (FD_ISSET(sockfd, &rset) \|\| FD_ISSET(sockfd, &wset)) {
	len = sizeof(error);
	if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
	return -1; /* Solaris pending error */
	} else {
	log_error("select error: sockfd not set");
	return -1;
	}

	done:
	fcntl(sockfd, F_SETFL, flags); /* restore file status flags */

	if (error) {
	/* leave outside function to close */
	/* close(sockfd); */
	errno = error;
	return -1;
	}

	return 0;
	}

	int booth_tcp_open(struct booth_site *to)
	{
	int s, rv;

	if (to->tcp_fd >= STDERR_FILENO)
	goto found;

	s = socket(to->family, SOCK_STREAM, 0);
	if (s == -1) {
	log_error("cannot create socket of family %d", to->family);
	return -1;
	}


	rv = connect_nonb(s, (struct sockaddr *)&to->sa6, to->saddrlen, 10);
	if (rv == -1) {
	if( errno == ETIMEDOUT)
	log_error("connect to \"%s\" got a timeout", to->addr_string);
	else
	log_error("connect to \"%s\" got an error: %s", to->addr_string,
	strerror(errno));
	goto error;
	}

	to->tcp_fd = s;

	found:
	return 1;

	error:
	if (s >= 0)
	close(s);
	return -1;
	}

	int booth_tcp_send(struct booth_site to, void buf, int len)
	{
	return do_write(to->tcp_fd, buf, len);
	}

	static int booth_tcp_recv(struct booth_site from, void buf, int len)
	{
	int got;
	/* Needs timeouts! */
	got = do_read(from->tcp_fd, buf, len);
	if (got < 0)
	return got;
	return len;
	}

	static int booth_tcp_close(struct booth_site *to)
	{
	if (to) {
	if (to->tcp_fd > STDERR_FILENO)
	close(to->tcp_fd);
	to->tcp_fd = -1;
	}
	return 0;
	}

	static int booth_tcp_exit(void)
	{
	return 0;
	}

	-int setup_udp_server(int try_only)
	+static int setup_udp_server(void)
	{
	int rv, fd;
	int one = 1;
	unsigned int recvbuf_size;

	fd = socket(local->family, SOCK_DGRAM, 0);
	if (fd == -1) {
	log_error("failed to create UDP socket %s", strerror(errno));
	goto ex;
	}

	rv = fcntl(fd, F_SETFL, O_NONBLOCK);
	if (rv == -1) {
	log_error("failed to set non-blocking operation "
	"on UDP socket: %s", strerror(errno));
	goto ex;
	}

	rv = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *)&one, sizeof(one));
	if (rv == -1) {
	log_error("failed to set the SO_REUSEADDR option");
	goto ex;
	}

	rv = bind(fd, (struct sockaddr *)&local->sa6, local->saddrlen);
	- if (try_only) {
	- rv = (rv == -1) ? errno : 0;
	- close(fd);
	- return rv;
	- }

	if (rv == -1) {
	log_error("failed to bind UDP socket to [%s]:%d: %s",
	local->addr_string, booth_conf->port,
	strerror(errno));
	goto ex;
	}

	recvbuf_size = SOCKET_BUFFER_SIZE;
	rv = setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
	&recvbuf_size, sizeof(recvbuf_size));
	if (rv == -1) {
	log_error("failed to set recvbuf size");
	goto ex;
	}

	local->udp_fd = fd;
	return 0;

	ex:
	if (fd >= 0)
	close(fd);
	return -1;
	}


	/* Receive/process callback for UDP */
	static void process_recv(int ci)
	{
	struct sockaddr_storage sa;
	int rv;
	socklen_t sa_len;
	char buffer[256];
	/* Used for unit tests */
	struct boothc_ticket_msg *msg;


	sa_len = sizeof(sa);
	msg = (void*)buffer;
	rv = recvfrom(clients[ci].fd,
	buffer, sizeof(buffer),
	MSG_NOSIGNAL \| MSG_DONTWAIT,
	(struct sockaddr *)&sa, &sa_len);
	if (rv == -1)
	return;

	deliver_fn(msg, rv);
	}

	static int booth_udp_init(void *f)
	{
	int rv;

	- rv = setup_udp_server(0);
	+ rv = setup_udp_server();
	if (rv < 0)
	return rv;

	deliver_fn = f;
	client_add(local->udp_fd,
	booth_transport + UDP,
	process_recv, NULL);

	return 0;
	}

	int booth_udp_send(struct booth_site to, void buf, int len)
	{
	int rv;

	rv = sendto(local->udp_fd, buf, len, MSG_NOSIGNAL,
	(struct sockaddr *)&to->sa6, to->saddrlen);
	if (rv == len) {
	rv = 0;
	} else if (rv < 0) {
	rv = errno;
	log_error("Cannot send to \"%s\": %d %s",
	to->addr_string,
	errno,
	strerror(errno));
	} else {
	rv = EBUSY;
	log_error("Packet sent to \"%s\" got truncated",
	to->addr_string);
	}

	return rv;
	}

	static int booth_udp_broadcast(void *buf, int len)
	{
	int i, rv, rvs;
	struct booth_site *site;


	if (!booth_conf \|\| !booth_conf->site_count)
	return -1;

	rvs = 0;
	foreach_node(i, site) {
	if (site != local) {
	rv = booth_udp_send(site, buf, len);
	if (!rvs)
	rvs = rv;
	}
	}

	return rvs;
	}

	static int booth_udp_exit(void)
	{
	return 0;
	}

	/* SCTP transport layer has not been developed yet */
	static int booth_sctp_init(void *f __attribute__((unused)))
	{
	return 0;
	}

	static int booth_sctp_send(struct booth_site * to __attribute__((unused)),
	void *buf __attribute__((unused)),
	int len __attribute__((unused)))
	{
	return 0;
	}

	static int booth_sctp_broadcast(void *buf __attribute__((unused)),
	int len __attribute__((unused)))
	{
	return 0;
	}

	static int return_0_booth_site(struct booth_site *v __attribute((unused)))
	{
	return 0;
	}

	static int return_0(void)
	{
	return 0;
	}
	const struct booth_transport booth_transport[TRANSPORT_ENTRIES] = {
	[TCP] = {
	.name = "TCP",
	.init = booth_tcp_init,
	.open = booth_tcp_open,
	.send = booth_tcp_send,
	.recv = booth_tcp_recv,
	.close = booth_tcp_close,
	.exit = booth_tcp_exit
	},
	[UDP] = {
	.name = "UDP",
	.init = booth_udp_init,
	.open = return_0_booth_site,
	.send = booth_udp_send,
	.close = return_0_booth_site,
	.broadcast = booth_udp_broadcast,
	.exit = booth_udp_exit
	},
	[SCTP] = {
	.name = "SCTP",
	.init = booth_sctp_init,
	.open = return_0_booth_site,
	.send = booth_sctp_send,
	.broadcast = booth_sctp_broadcast,
	.exit = return_0,
	}
	};

	const struct booth_transport *local_transport = booth_transport+TCP;



	int send_header_only(int fd, struct boothc_header *hdr)
	{
	int rv;

	rv = do_write(fd, hdr, sizeof(*hdr));

	return rv;
	}


	int send_ticket_msg(int fd, struct boothc_ticket_msg *msg)
	{
	int rv;

	rv = do_write(fd, msg, sizeof(*msg));

	return rv;
	}


	int send_header_plus(int fd, struct boothc_header hdr, void data, int len)
	{
	int rv;
	int l;

	if (data == hdr->data) {
	l = sizeof(*hdr) + len;
	assert(l == ntohl(hdr->length));

	/* One struct */
	rv = do_write(fd, hdr, l);
	} else {
	/* Header and data in two locations */
	rv = send_header_only(fd, hdr);

	if (rv >= 0 && len)
	rv = do_write(fd, data, len);
	}

	return rv;
	}
	diff --git a/src/transport.h b/src/transport.h
	index 9130bab..a5ae0ea 100644
	--- a/src/transport.h
	+++ b/src/transport.h
	@@ -1,77 +1,77 @@
	/*
	* Copyright (C) 2011 Jiaju Zhang <jjzhang@suse.de>
	* Copyright (C) 2013 Philipp Marek <philipp.marek@linbit.com>
	*
	* 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.1 of the License, or (at your option) any later version.
	*
	* This software 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 library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#ifndef _TRANSPORT_H
	#define _TRANSPORT_H

	#include "booth.h"

	typedef enum {
	TCP = 1,
	UDP,
	SCTP,
	TRANSPORT_ENTRIES,
	} transport_layer_t;

	typedef enum {
	ARBITRATOR = 0x50,
	SITE,
	CLIENT,
	DAEMON,
	STATUS,
	} action_t;

	struct booth_transport {
	const char *name;
	int (init) (void );
	int (open) (struct booth_site );
	int (send) (struct booth_site , void *, int);
	int (recv) (struct booth_site , void *, int);
	int (broadcast) (void , int);
	int (close) (struct booth_site );
	int (*exit) (void);
	};

	extern const struct booth_transport booth_transport[TRANSPORT_ENTRIES];
	int find_myself(struct booth_site **me, int fuzzy_allowed);

	int check_boothc_header(struct boothc_header *data, int len_incl_data);

	-int setup_udp_server(int try_only);
	+int setup_tcp_listener(int test_only);
	int booth_udp_send(struct booth_site to, void buf, int len);

	int booth_tcp_open(struct booth_site *to);
	int booth_tcp_send(struct booth_site to, void buf, int len);

	inline static void * node_to_addr_pointer(struct booth_site *node) {
	switch (node->family) {
	case AF_INET: return &node->sa4.sin_addr;
	case AF_INET6: return &node->sa6.sin6_addr;
	}
	return NULL;
	}

	extern const struct booth_transport *local_transport;

	int send_header_only(int fd, struct boothc_header *hdr);
	int send_header_plus(int fd, struct boothc_header hdr, void data, int len);
	int send_ticket_msg(int fd, struct boothc_ticket_msg *msg);


	#endif /* _TRANSPORT_H */

File Metadata

Mime Type: text/x-diff
Expires: Tue, Feb 25, 2:00 AM (1 d, 7 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1464596
Default Alt Text: (45 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions