/******************************************************************************
 *
 * utils.c
 *
 * Description:  Central utility functions that may be frequently needed
 *               accross the application.
 *
 * Copyright (c) 1997-2000 Messaging Direct Ltd.
 * All rights reserved.
 *
 * Portions Copyright (c) 2003 Jeremy Rumpf
 * jrumpf@heavyload.net
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY MESSAGING DIRECT LTD. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL MESSAGING DIRECT LTD. OR
 * ITS EMPLOYEES OR AGENTS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 *
 * HISTORY
 *
 *
 * This source file created using 8 space tabs.
 *
 *****************************************************************************/

#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <unistd.h>

#include "utils.h"
#include "globals.h"


/****************************************
 * flags     global from saslauthd-main.c
 *****************************************/

/*************************************************************
 * Variadic logging function to simplify printing of log
 * messages
 **************************************************************/
void logger(int priority, const char *function, const char *format, ...) {
        va_list 	arg_list;
        char    	buffer[1024];
	static int	have_syslog = 0;

        va_start(arg_list, format);
        vsnprintf(buffer, 1023, format, arg_list);
	va_end(arg_list);

        buffer[1023] = '\0';

        if (flags & LOG_USE_STDERR)
                fprintf(stderr, L_STDERR_FORMAT, getpid(), function, buffer);

        if (flags & LOG_USE_SYSLOG) {
		if (!have_syslog) {
			openlog("saslauthd", LOG_PID|LOG_NDELAY, LOG_AUTH);
			have_syslog = 1;
		}

                syslog(priority, "%-16s: %s", function, buffer);
	}
}


/**************************************************************
 * I/O wrapper to attempt to ensure a full record gets
 * transmitted. If the function returns anything less than
 * bytesrequested, it should be considered a failure.
 **************************************************************/
ssize_t tx_rec(int filefd, void *prebuff, size_t bytesrequested) {
	int		rc;
        ssize_t		bytesio = 0;
        size_t		bytesleft = 0;
        void		*buff;

        bytesleft = bytesrequested;
        buff = prebuff;

        while (bytesleft > 0) {
                bytesio = write(filefd, buff, bytesleft);
		rc = errno;

                if (bytesio < 0) {
			logger(L_ERR, L_FUNC, "write failure");
			logger(L_ERR, L_FUNC, "write: %s", strerror(rc));
                        return(bytesio);
		}

                if (bytesio == 0 && errno != EINTR)
                        return(bytesrequested - bytesleft);

                bytesleft -= bytesio;
                buff = (void *)((char *)buff + bytesio);

        }

        return(bytesrequested);
}


/**************************************************************
 * I/O wrapper to attempt to read in the specified amount of
 * data, without any guarantees. If the function returns 
 * anything less than bytesrequested, it should be considered
 * a failure.
 **************************************************************/
ssize_t rx_rec(int filefd, void *prebuff, size_t bytesrequested) {
	int		rc;
        ssize_t		bytesio = 0;
        size_t		bytesleft = 0;
        void		*buff;

        bytesleft = bytesrequested;
        buff = prebuff;

        while (bytesleft > 0) {
                bytesio = read(filefd, buff, bytesleft);
		rc = errno;

                if (bytesio < 0) {
			logger(L_ERR, L_FUNC, "read failure");
			logger(L_ERR, L_FUNC, "read: %s", strerror(rc));
                        return(bytesio);
		}

                if (bytesio == 0 && errno != EINTR)
                        return(bytesrequested - bytesleft);

                bytesleft -= bytesio;
                buff = (void *)((char *)buff + bytesio);

        }

        return(bytesrequested);
}


/**************************************************************
 * I/O wrapper to attempt to write out the specified vector.
 * data, without any guarantees. If the function returns 
 * -1, the vector wasn't completely written.
 **************************************************************/
int retry_writev(int fd, struct iovec *iov, int iovcnt) {
	int n;               /* return value from writev() */
	int i;               /* loop counter */
	int written;         /* bytes written so far */
	static int iov_max;  /* max number of iovec entries */

#ifdef MAXIOV
	iov_max = MAXIOV;
#else 
# ifdef IOV_MAX
	iov_max = IOV_MAX;
# else 
	iov_max = 8192;
# endif 
#endif

	written = 0;

	for (;;) {

		while (iovcnt && iov[0].iov_len == 0) {
			iov++;
			iovcnt--;
		}

		if (!iovcnt) {
			return written;
		}

		n = writev(fd, iov, iovcnt > iov_max ? iov_max : iovcnt);

		if (n == -1) {
			if (errno == EINVAL && iov_max > 10) {
				iov_max /= 2;
				continue;
			}

			if (errno == EINTR) {
				continue;
			}

			return -1;

		} else {
			written += n;
		}

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

			n -= iov[i].iov_len;
			iov[i].iov_len = 0;
		}

		if (i == iovcnt) {
			return written;
		}
	}
}

#ifndef HAVE_STRLCPY
/* strlcpy -- copy string smartly.
 *
 * i believe/hope this is compatible with the BSD strlcpy(). 
 */
size_t saslauthd_strlcpy(char *dst, const char *src, size_t len)
{
	size_t n;

	if (len <= 0) {
		/* we can't do anything ! */
		return strlen(src);
	}

	/* assert(len >= 1); */
	for (n = 0; n < len-1; n++) {
		if ((dst[n] = src[n]) == '\0') break;
	}
	if (n >= len-1) {
		/* ran out of space */
		dst[n] = '\0';
		while(src[n]) n++;
	}
	return n;
}
#endif

#ifndef HAVE_STRLCAT
size_t saslauthd_strlcat(char *dst, const char *src, size_t len)
{
	size_t i, j, o;

	o = strlen(dst);
	if (len < o + 1)
		return o + strlen(src);
	len -= o + 1;
	for (i = 0, j = o; i < len; i++, j++) {
		if ((dst[j] = src[i]) == '\0') break;
	}
	dst[j] = '\0';
	if (src[i] == '\0') {
		return j;
	} else {
		return j + strlen(src + i);
	}
}
#endif