libteamdctl/cli_usock.c

/*
 *   cli_usock.c - Teamd daemon control library teamd Unix Domain socket client
 *   Copyright (C) 2013-2015 Jiri Pirko <jiri@resnulli.us>
 *
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser 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 library 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
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <teamdctl.h>
#include "teamdctl_private.h"
#include "../teamd/teamd_usock_common.h"

/* \cond HIDDEN_SYMBOLS */
struct cli_usock_priv {
	int sock;
};
/* \endcond */

static int cli_usock_process_msg(struct teamdctl *tdc, char *msg,
				 char **p_replystr)
{
	char *str;
	char *rest = msg;

	str = teamd_usock_msg_getline(&rest);
	if (!str) {
		err(tdc, "usock: Incomplete message.\n");
		return -EINVAL;;
	}

	if (!strcmp(TEAMD_USOCK_REPLY_SUCC_PREFIX, str)) {
		*p_replystr = rest;
	} else if (!strcmp(TEAMD_USOCK_REPLY_ERR_PREFIX, str)) {
		str = teamd_usock_msg_getline(&rest);
		if (!str) {
			err(tdc, "usock: Incomplete message.\n");
			return -EINVAL;;
		}
		err(tdc, "usock: Error message received: \"%s\"", str);
		str = teamd_usock_msg_getline(&rest);
		if (!str) {
			err(tdc, "usock: Incomplete message.\n");
			return -EINVAL;;
		}
		err(tdc, "usock: Error message content: \"%s\"", str);
		return -EINVAL;;
	} else {
		err(tdc, "usock: Unsupported message type.\n");
		return -EINVAL;
	}
	return 0;
}

static int cli_usock_send(int sock, char *msg)
{
	int err;

	err = send(sock, msg, strlen(msg), MSG_NOSIGNAL);
	if (err == -1)
		return -errno;
	return 0;
}

#define WAIT_SEC (TEAMDCTL_REPLY_TIMEOUT / 1000)
#define WAIT_USEC (TEAMDCTL_REPLY_TIMEOUT % 1000 * 1000)

static int cli_usock_wait_recv(int sock)
{
	fd_set rfds;
	int fdmax;
	int ret;
	struct timeval tv;

	tv.tv_sec = WAIT_SEC;
	tv.tv_usec = WAIT_USEC;
	FD_ZERO(&rfds);
	FD_SET(sock, &rfds);
	fdmax = sock + 1;
	ret = select(fdmax, &rfds, NULL, NULL, &tv);
	if (ret == -1)
		return -errno;
	if (!FD_ISSET(sock, &rfds))
		return -ETIMEDOUT;
	return 0;
}

static int myasprintf(char **p_str, const char *fmt, ...)
{
	char *newstr;
	va_list ap;
	int ret;

	va_start(ap, fmt);
	ret = vasprintf(&newstr, fmt, ap);
	va_end(ap);
	if (ret == -1)
		return -ENOMEM;
	free(*p_str);
	*p_str = newstr;
	return 0;
}

char *__strencode(char *str)
{
	char *newstr;
	int i, j;
	size_t len = strlen(str);

	for (i = 0; i < strlen(str); i++) {
		switch (str[i]) {
		case '\n':
		case '\\':
			len++;
		}
	}
	newstr = malloc(sizeof(char) * (len + 1));
	if (!newstr)
		return NULL;
	j = 0;
	for (i = 0; i <= strlen(str); i++) {
		switch (str[i]) {
		case '\n':
			newstr[j++] = '\\';
			newstr[j++] = 'n';
			break;
		case '\\':
			newstr[j++] = '\\';
			newstr[j++] = '\\';
			break;
		default:
			newstr[j++] = str[i];
		}
	}
	return newstr;
}

static int cli_usock_method_call(struct teamdctl *tdc, const char *method_name,
				 char **p_reply, void *priv,
				 const char *fmt, va_list ap)
{
	struct cli_usock_priv *cli_usock = priv;
	char *str;
	char *msg = NULL;
	char *recv_message = NULL; /* gcc needs this initialized */
	char *replystr;
	int err;

	dbg(tdc, "usock: Calling method \"%s\"", method_name);
	err= myasprintf(&msg, "%s\n%s\n", TEAMD_USOCK_REQUEST_PREFIX,
					  method_name);
	if (err)
		return err;
	while (*fmt) {
		switch (*fmt++) {
		case 's': /* string */
			str = __strencode(va_arg(ap, char *));
			if (!str) {
				err = -ENOMEM;
				goto free_msg;
			}
			err = myasprintf(&msg, "%s%s\n", msg, str);
			free(str);
			if (err)
				goto free_msg;
			break;
		default:
			err(tdc, "usock: Unknown argument type requested.");
			err = -EINVAL;
			goto free_msg;
		}
	}

	err = cli_usock_send(cli_usock->sock, msg);
	if (err)
		goto free_msg;

	err = cli_usock_wait_recv(cli_usock->sock);
	if (err) {
		if (err == -ETIMEDOUT)
			dbg(tdc, "usock: Wait for reply timed-out.");
		goto free_msg;
	}

	err = teamd_usock_recv_msg(cli_usock->sock, &recv_message);
	if (err)
		goto free_msg;

	err = cli_usock_process_msg(tdc, recv_message, &replystr);
	if (err)
		goto free_recv_message;

	if (p_reply) {
		replystr = strdup(replystr);
		if (!replystr) {
			err = -ENOMEM;
			goto free_recv_message;
		}
		*p_reply = replystr;
	}

free_recv_message:
	free(recv_message);
free_msg:
	free(msg);
	return err;
}

static int cli_usock_init(struct teamdctl *tdc, const char *team_name,
			  void *priv)
{
	struct cli_usock_priv *cli_usock = priv;
	struct sockaddr_un addr;
	int err;

	memset(&addr, 0, sizeof(addr));
	addr.sun_family = AF_UNIX;
	teamd_usock_get_sockpath(addr.sun_path, sizeof(addr.sun_path),
				 team_name);

	cli_usock->sock = socket(AF_UNIX, SOCK_SEQPACKET, 0);
	if (cli_usock->sock == -1) {
		err(tdc, "usock: Failed to create socket.");
		return -errno;
	}

	err = connect(cli_usock->sock, (struct sockaddr *) &addr,
		      strlen(addr.sun_path) + sizeof(addr.sun_family));
	if (err == -1) {
		err(tdc, "usock: Failed to connect socket (%s).",
		    addr.sun_path);
		close(cli_usock->sock);
		return -errno;
	}
	return 0;
}

void cli_usock_fini(struct teamdctl *tdc, void *priv)
{
	struct cli_usock_priv *cli_usock = priv;

	close(cli_usock->sock);
}

static const struct teamdctl_cli cli_usock = {
	.name = "usock",
	.init = cli_usock_init,
	.fini = cli_usock_fini,
	.method_call = cli_usock_method_call,
	.priv_size = sizeof(struct cli_usock_priv),
};

const struct teamdctl_cli *teamdctl_cli_usock_get(void)
{
	return &cli_usock;
}