xref: /onnv-gate/usr/src/cmd/sendmail/libmilter/comm.c (revision 11440:802724e2906a)

/*
 *  Copyright (c) 1999-2004, 2009 Sendmail, Inc. and its suppliers.
 *	All rights reserved.
 *
 * By using this file, you agree to the terms and conditions set
 * forth in the LICENSE file which can be found at the top level of
 * the sendmail distribution.
 *
 */

#include <sm/gen.h>
SM_RCSID("@(#)$Id: comm.c,v 8.70 2009/12/16 16:33:48 ca Exp $")

#include "libmilter.h"
#include <sm/errstring.h>
#include <sys/uio.h>

static ssize_t	retry_writev __P((socket_t, struct iovec *, int, struct timeval *));
static size_t Maxdatasize = MILTER_MAX_DATA_SIZE;

/*
**  SMFI_SETMAXDATASIZE -- set limit for milter data read/write.
**
**	Parameters:
**		sz -- new limit.
**
**	Returns:
**		old limit
*/

size_t
smfi_setmaxdatasize(sz)
	size_t sz;
{
	size_t old;

	old = Maxdatasize;
	Maxdatasize = sz;
	return old;
}

/*
**  MI_RD_CMD -- read a command
**
**	Parameters:
**		sd -- socket descriptor
**		timeout -- maximum time to wait
**		cmd -- single character command read from sd
**		rlen -- pointer to length of result
**		name -- name of milter
**
**	Returns:
**		buffer with rest of command
**		(malloc()ed here, should be free()d)
**		hack: encode error in cmd
*/

char *
mi_rd_cmd(sd, timeout, cmd, rlen, name)
	socket_t sd;
	struct timeval *timeout;
	char *cmd;
	size_t *rlen;
	char *name;
{
	ssize_t len;
	mi_int32 expl;
	ssize_t i;
	FD_RD_VAR(rds, excs);
	int ret;
	int save_errno;
	char *buf;
	char data[MILTER_LEN_BYTES + 1];

	*cmd = '\0';
	*rlen = 0;

	i = 0;
	for (;;)
	{
		FD_RD_INIT(sd, rds, excs);
		ret = FD_RD_READY(sd, rds, excs, timeout);
		if (ret == 0)
			break;
		else if (ret < 0)
		{
			if (errno == EINTR)
				continue;
			break;
		}
		if (FD_IS_RD_EXC(sd, rds, excs))
		{
			*cmd = SMFIC_SELECT;
			return NULL;
		}

		len = MI_SOCK_READ(sd, data + i, sizeof data - i);
		if (MI_SOCK_READ_FAIL(len))
		{
			smi_log(SMI_LOG_ERR,
				"%s, mi_rd_cmd: read returned %d: %s",
				name, (int) len, sm_errstring(errno));
			*cmd = SMFIC_RECVERR;
			return NULL;
		}
		if (len == 0)
		{
			*cmd = SMFIC_EOF;
			return NULL;
		}
		if (len >= (ssize_t) sizeof data - i)
			break;
		i += len;
	}
	if (ret == 0)
	{
		*cmd = SMFIC_TIMEOUT;
		return NULL;
	}
	else if (ret < 0)
	{
		smi_log(SMI_LOG_ERR,
			"%s: mi_rd_cmd: %s() returned %d: %s",
			name, MI_POLLSELECT, ret, sm_errstring(errno));
		*cmd = SMFIC_RECVERR;
		return NULL;
	}

	*cmd = data[MILTER_LEN_BYTES];
	data[MILTER_LEN_BYTES] = '\0';
	(void) memcpy((void *) &expl, (void *) &(data[0]), MILTER_LEN_BYTES);
	expl = ntohl(expl) - 1;
	if (expl <= 0)
		return NULL;
	if (expl > Maxdatasize)
	{
		*cmd = SMFIC_TOOBIG;
		return NULL;
	}
#if _FFR_ADD_NULL
	buf = malloc(expl + 1);
#else /* _FFR_ADD_NULL */
	buf = malloc(expl);
#endif /* _FFR_ADD_NULL */
	if (buf == NULL)
	{
		*cmd = SMFIC_MALLOC;
		return NULL;
	}

	i = 0;
	for (;;)
	{
		FD_RD_INIT(sd, rds, excs);
		ret = FD_RD_READY(sd, rds, excs, timeout);
		if (ret == 0)
			break;
		else if (ret < 0)
		{
			if (errno == EINTR)
				continue;
			break;
		}
		if (FD_IS_RD_EXC(sd, rds, excs))
		{
			*cmd = SMFIC_SELECT;
			free(buf);
			return NULL;
		}
		len = MI_SOCK_READ(sd, buf + i, expl - i);
		if (MI_SOCK_READ_FAIL(len))
		{
			smi_log(SMI_LOG_ERR,
				"%s: mi_rd_cmd: read returned %d: %s",
				name, (int) len, sm_errstring(errno));
			ret = -1;
			break;
		}
		if (len == 0)
		{
			*cmd = SMFIC_EOF;
			free(buf);
			return NULL;
		}
		if (len > expl - i)
		{
			*cmd = SMFIC_RECVERR;
			free(buf);
			return NULL;
		}
		if (len >= expl - i)
		{
			*rlen = expl;
#if _FFR_ADD_NULL
			/* makes life simpler for common string routines */
			buf[expl] = '\0';
#endif /* _FFR_ADD_NULL */
			return buf;
		}
		i += len;
	}

	save_errno = errno;
	free(buf);

	/* select returned 0 (timeout) or < 0 (error) */
	if (ret == 0)
	{
		*cmd = SMFIC_TIMEOUT;
		return NULL;
	}
	if (ret < 0)
	{
		smi_log(SMI_LOG_ERR,
			"%s: mi_rd_cmd: %s() returned %d: %s",
			name, MI_POLLSELECT, ret, sm_errstring(save_errno));
		*cmd = SMFIC_RECVERR;
		return NULL;
	}
	*cmd = SMFIC_UNKNERR;
	return NULL;
}

/*
**  RETRY_WRITEV -- Keep calling the writev() system call
**	until all the data is written out or an error occurs.
**
**	Parameters:
**		fd -- socket descriptor
**		iov -- io vector
**		iovcnt -- number of elements in io vector
**			must NOT exceed UIO_MAXIOV.
**		timeout -- maximum time to wait
**
**	Returns:
**		success: number of bytes written
**		otherwise: MI_FAILURE
*/

static ssize_t
retry_writev(fd, iov, iovcnt, timeout)
	socket_t fd;
	struct iovec *iov;
	int iovcnt;
	struct timeval *timeout;
{
	int i;
	ssize_t n, written;
	FD_WR_VAR(wrs);

	written = 0;
	for (;;)
	{
		while (iovcnt > 0 && iov[0].iov_len == 0)
		{
			iov++;
			iovcnt--;
		}
		if (iovcnt <= 0)
			return written;

		/*
		**  We don't care much about the timeout here,
		**  it's very long anyway; correct solution would be
		**  to take the time before the loop and reduce the
		**  timeout after each invocation.
		**  FD_SETSIZE is checked when socket is created.
		*/

		FD_WR_INIT(fd, wrs);
		i = FD_WR_READY(fd, wrs, timeout);
		if (i == 0)
			return MI_FAILURE;
		if (i < 0)
		{
			if (errno == EINTR || errno == EAGAIN)
				continue;
			return MI_FAILURE;
		}
		n = writev(fd, iov, iovcnt);
		if (n == -1)
		{
			if (errno == EINTR || errno == EAGAIN)
				continue;
			return MI_FAILURE;
		}

		written += n;
		for (i = 0; i < iovcnt; i++)
		{
			if (iov[i].iov_len > (unsigned int) n)
			{
				iov[i].iov_base = (char *)iov[i].iov_base + n;
				iov[i].iov_len -= (unsigned int) n;
				break;
			}
			n -= (int) iov[i].iov_len;
			iov[i].iov_len = 0;
		}
		if (i == iovcnt)
			return written;
	}
}

/*
**  MI_WR_CMD -- write a cmd to sd
**
**	Parameters:
**		sd -- socket descriptor
**		timeout -- maximum time to wait
**		cmd -- single character command to write
**		buf -- buffer with further data
**		len -- length of buffer (without cmd!)
**
**	Returns:
**		MI_SUCCESS/MI_FAILURE
*/

int
mi_wr_cmd(sd, timeout, cmd, buf, len)
	socket_t sd;
	struct timeval *timeout;
	int cmd;
	char *buf;
	size_t len;
{
	size_t sl;
	ssize_t l;
	mi_int32 nl;
	int iovcnt;
	struct iovec iov[2];
	char data[MILTER_LEN_BYTES + 1];

	if (len > Maxdatasize || (len > 0 && buf == NULL))
		return MI_FAILURE;

	nl = htonl(len + 1);	/* add 1 for the cmd char */
	(void) memcpy(data, (void *) &nl, MILTER_LEN_BYTES);
	data[MILTER_LEN_BYTES] = (char) cmd;
	sl = MILTER_LEN_BYTES + 1;

	/* set up the vector for the size / command */
	iov[0].iov_base = (void *) data;
	iov[0].iov_len  = sl;
	iovcnt = 1;
	if (len >= 0 && buf != NULL)
	{
		iov[1].iov_base = (void *) buf;
		iov[1].iov_len  = len;
		iovcnt = 2;
	}

	l = retry_writev(sd, iov, iovcnt, timeout);
	if (l == MI_FAILURE)
		return MI_FAILURE;
	return MI_SUCCESS;
}