path: root/usr/src/cmd/cmd-inet/usr.lib/inetd/util.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * General utility routines.
 */

#include <syslog.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <strings.h>
#include <time.h>
#include <errno.h>
#include <libintl.h>
#include <unistd.h>
#include "inetd_impl.h"


/* size of buffer used in msg() to expand printf() like messages into */
#define	MSG_BUF_SIZE		1024

/* number of pollfd we grow the pollfd array by at a time in set_pollfd() */
#define	POLLFDS_GROWTH_SIZE	16

/* enumeration of message types supported by msg() */
typedef enum {
	MT_ERROR,
	MT_DEBUG,
	MT_WARN
} si_msg_type_t;

/*
 * Collection of information for each method type.
 * NOTE:  This table is indexed into using the instance_method_t
 * enumeration, so the ordering needs to be kept in synch.
 */
method_type_info_t methods[] = {
	{IM_START, START_METHOD_NAME, IIS_NONE},
	{IM_ONLINE, ONLINE_METHOD_NAME, IIS_ONLINE},
	{IM_OFFLINE, OFFLINE_METHOD_NAME, IIS_OFFLINE},
	{IM_DISABLE, DISABLE_METHOD_NAME, IIS_DISABLED},
	{IM_REFRESH, REFRESH_METHOD_NAME, IIS_ONLINE},
	{IM_NONE, "none", IIS_NONE}
};

struct pollfd	*poll_fds = NULL;
nfds_t		num_pollfds;

boolean_t	syslog_open = B_FALSE;
boolean_t	debug_enabled = B_FALSE;

void
msg_init(void)
{
	openlog(SYSLOG_IDENT, LOG_PID|LOG_CONS, LOG_DAEMON);
	syslog_open = B_TRUE;
}

void
msg_fini(void)
{
	syslog_open = B_FALSE;
	closelog();
}

/*
 * Outputs a msg. If 'type' is set tp MT_ERROR or MT_WARN the message goes
 * to syslog with severitys LOG_ERROR and LOG_WARN respectively. For all
 * values of 'type' the message is written to the debug log file, if it
 * was openable when inetd started.
 */
static void
msg(si_msg_type_t type, const char *format, va_list ap)
{
	/*
	 * Use a stack buffer so we stand more chance of reporting a
	 * memory shortage failure.
	 */
	char		buf[MSG_BUF_SIZE];

	if (!syslog_open)
		return;

	(void) vsnprintf(buf, sizeof (buf), format, ap);

	/*
	 * Log error and warning messages to syslog with appropriate severity.
	 */
	if (type == MT_ERROR) {
		syslog(LOG_ERR, "%s", buf);
	} else if (type == MT_WARN) {
		syslog(LOG_WARNING, "%s", buf);
	} else if (debug_enabled && type == MT_DEBUG) {
		syslog(LOG_DEBUG, "%s", buf);
	}
}

/*
 * Output a warning message. Unlike error_msg(), syslog doesn't get told
 * to log to the console if syslogd isn't around.
 */
void
warn_msg(const char *format, ...)
{
	va_list ap;

	closelog();
	openlog(SYSLOG_IDENT, LOG_PID, LOG_DAEMON);

	va_start(ap, format);
	msg(MT_WARN, format, ap);
	va_end(ap);

	closelog();
	openlog(SYSLOG_IDENT, LOG_PID|LOG_CONS, LOG_DAEMON);
}

void
debug_msg(const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	msg(MT_DEBUG, format, ap);
	va_end(ap);
}

void
error_msg(const char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	msg(MT_ERROR, format, ap);
	va_end(ap);
}

void
poll_fini(void)
{
	if (poll_fds != NULL) {
		free(poll_fds);
		poll_fds = NULL;
	}
}

struct pollfd *
find_pollfd(int fd)
{
	nfds_t n;

	for (n = 0; n < num_pollfds; n++) {
		if (poll_fds[n].fd == fd)
			return (&(poll_fds[n]));
	}
	return (NULL);
}

int
set_pollfd(int fd, uint16_t events)
{
	struct pollfd	*p;
	int		i;

	p = find_pollfd(fd);
	if ((p == NULL) && ((p = find_pollfd(-1)) == NULL)) {
		if ((p = realloc(poll_fds,
		    ((num_pollfds + POLLFDS_GROWTH_SIZE) *
		    sizeof (struct pollfd)))) == NULL) {
			return (-1);
		}
		poll_fds = p;

		for (i = 1; i < POLLFDS_GROWTH_SIZE; i++)
			poll_fds[num_pollfds + i].fd = -1;

		p = &poll_fds[num_pollfds];
		num_pollfds += POLLFDS_GROWTH_SIZE;
	}

	p->fd = fd;
	p->events = events;
	p->revents = 0;

	return (0);
}

void
clear_pollfd(int fd)
{
	struct pollfd *p;

	if ((p = find_pollfd(fd)) != NULL) {
		p->fd = -1;
		p->events = 0;
		p->revents = 0;
	}
}

boolean_t
isset_pollfd(int fd)
{
	struct pollfd *p = find_pollfd(fd);

	return ((p != NULL) && (p->revents & POLLIN));
}

/*
 * An extension of read() that keeps retrying until either the full request has
 * completed, the other end of the connection/pipe is closed, no data is
 * readable for a non-blocking socket/pipe, or an unexpected error occurs.
 * Returns 0 if the data is successfully read, 1 if the other end of the pipe/
 * socket is closed or there's nothing to read from a non-blocking socket/pipe,
 * else -1 if an unexpected error occurs.
 */
int
safe_read(int fd, void *buf, size_t sz)
{
	int	ret;
	size_t  cnt = 0;
	char    *cp = (char *)buf;

	if (sz == 0)
		return (0);

	do {
		switch (ret = read(fd, cp + cnt, sz - cnt)) {
		case 0:			/* other end of pipe/socket closed */
			return (1);
		case -1:
			if (errno == EAGAIN) {		/* nothing to read */
				return (1);
			} else if (errno != EINTR) {
				error_msg(gettext("Unexpected read error: %s"),
				    strerror(errno));
				return (-1);
			}
			break;

		default:
			cnt += ret;
		}
	} while (cnt != sz);

	return (0);
}

/*
 * Return B_TRUE if instance 'inst' has exceeded its configured maximum
 * concurrent copies limit, else B_FALSE.
 */
boolean_t
copies_limit_exceeded(instance_t *inst)
{
	/* any value <=0 means that copies limits are disabled */
	return ((inst->config->basic->max_copies > 0) &&
	    (inst->copies >= inst->config->basic->max_copies));
}

/*
 * Cancel the method/con-rate offline timer associated with the instance.
 */
void
cancel_inst_timer(instance_t *inst)
{
	(void) iu_cancel_timer(timer_queue, inst->timer_id, NULL);
	inst->timer_id = -1;
}

/*
 * Cancel the bind retry timer associated with the instance.
 */
void
cancel_bind_timer(instance_t *inst)
{
	(void) iu_cancel_timer(timer_queue, inst->bind_timer_id, NULL);
	inst->bind_timer_id = -1;
}

void
enable_blocking(int fd)
{
	int flags = fcntl(fd, F_GETFL, 0);
	(void) fcntl(fd, F_SETFL, (flags & ~O_NONBLOCK));
}

void
disable_blocking(int fd)
{
	int flags = fcntl(fd, F_GETFL, 0);
	(void) fcntl(fd, F_SETFL, (flags | O_NONBLOCK));
}