/usr/src/cmd/rcap/common/utils.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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/param.h>
#include <libintl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <syslog.h>
#include <unistd.h>
#include <errno.h>

#include "utils.h"

static char ERRNO_FMT[] = ": %s";

static char *pname = NULL;
static rcm_level_t message_priority = RCM_WARN;
static rcm_dst_t message_dst = RCD_STD;

static void dmesg(int level, char *msg);

/*PRINTFLIKE2*/
void
dprintfe(int level, char *format, ...)
{
	va_list alist;

	va_start(alist, format);
	vdprintfe(level, format, alist);
	va_end(alist);
}

/*PRINTFLIKE2*/
void
vdprintfe(int level, const char *format, va_list alist)
{
	char buf[LINELEN];
	char *c;
	int err = errno;

	*buf = 0;

	if ((strlen(buf) + 1) < LINELEN)
		(void) vsnprintf(buf + strlen(buf), LINELEN - 1 - strlen(buf),
		    format, alist);
	if ((c = strchr(buf, '\n')) == NULL) {
		if ((strlen(buf) + 1) < LINELEN)
			(void) snprintf(buf + strlen(buf), LINELEN - 1 -
			    strlen(buf), gettext(ERRNO_FMT), strerror(err));
	} else
		*c = 0;

	dmesg(level, buf);
}

#ifdef DEBUG_MSG
/*PRINTFLIKE1*/
void
debug(char *format, ...)
{
	va_list alist;

	if (get_message_priority() < RCM_DEBUG)
		return;

	va_start(alist, format);
	vdprintfe(RCM_DEBUG, format, alist);
	va_end(alist);
}

/*PRINTFLIKE1*/
void
debug_high(char *format, ...)
{
	va_list alist;

	if (get_message_priority() < RCM_DEBUG_HIGH)
		return;

	va_start(alist, format);
	vdprintfe(RCM_DEBUG_HIGH, format, alist);
	va_end(alist);
}
#endif /* DEBUG_MSG */

/*PRINTFLIKE1*/
void
warn(const char *format, ...)
{
	va_list alist;

	if (get_message_priority() < RCM_WARN)
		return;

	va_start(alist, format);
	vdprintfe(RCM_WARN, format, alist);
	va_end(alist);
}

/*PRINTFLIKE1*/
void
die(char *format, ...)
{
	va_list alist;

	if (get_message_priority() < RCM_ERR)
		return;

	va_start(alist, format);
	vdprintfe(RCM_ERR, format, alist);
	va_end(alist);

	exit(E_ERROR);
}

/*PRINTFLIKE1*/
void
info(char *format, ...)
{
	va_list alist;

	if (get_message_priority() < RCM_INFO)
		return;

	va_start(alist, format);
	vdprintfe(RCM_INFO, format, alist);
	va_end(alist);
}

char *
setpname(char *arg0)
{
	char *p = strrchr(arg0, '/');

	if (p == NULL)
		p = arg0;
	else
		p++;
	pname = p;
	return (pname);
}

/*
 * Output a message to the controlling tty or log, depending on which is
 * configured.  The message should contain no newlines.
 */
static void
dmesg(int level, char *msg)
{
	if (message_priority >= level) {
		FILE *fp;
		int syslog_severity = -1;

		switch (message_dst) {
		case RCD_STD:
			fp = level >= RCM_DEBUG ? stderr : stdout;

			if (pname != NULL) {
				(void) fputs(pname, fp);
				(void) fputs(": ", fp);
			}
			(void) fputs(msg, fp);
			(void) fputc('\n', fp);
			(void) fflush(fp);
			break;
		case RCD_SYSLOG:
			switch (level) {
			case RCM_ERR:
				syslog_severity = LOG_ERR;
				break;
			case RCM_WARN:
				syslog_severity = LOG_WARNING;
				break;
			case RCM_INFO:
				syslog_severity = LOG_INFO;
				break;
			case RCM_DEBUG:
				syslog_severity = LOG_DEBUG;
				break;
			}
			if (syslog_severity >= 0)
				(void) syslog(syslog_severity, "%s", msg);
			break;
		}
	}
}

rcm_level_t
get_message_priority(void)
{
	return (message_priority);
}

rcm_level_t
set_message_priority(rcm_level_t new_priority)
{
	rcm_level_t old_priority = message_priority;

	message_priority = new_priority;
	return (old_priority);
}

rcm_dst_t
set_message_destination(rcm_dst_t new_dst)
{
	rcm_dst_t old_dst = message_dst;

	if ((message_dst = new_dst) == RCD_SYSLOG)
		openlog(pname, LOG_ODELAY | LOG_PID, LOG_DAEMON);

	return (old_dst);
}

void
hrt2ts(hrtime_t hrt, timestruc_t *tsp)
{
	tsp->tv_sec = hrt / NANOSEC;
	tsp->tv_nsec = hrt % NANOSEC;
}

int
xatoi(char *p)
{
	int i;
	char *q;

	errno = 0;
	i = (int)strtol(p, &q, 10);
	if (errno != 0 || q == p || i < 0 || *q != '\0') {
		warn(gettext("illegal argument -- %s\n"), p);
		return (-1);
	} else {
		return (i);
	}
}

/*
 * get_running_zones() calls zone_list(2) to find out how many zones are
 * running.  It then calls zone_list(2) again to fetch the list of running
 * zones (stored in *zents).
 */
int
get_running_zones(uint_t *nzents, zone_entry_t **zents)
{
	zoneid_t *zids;
	uint_t nzents_saved;
	int i;
	zone_entry_t *zentp;
	zone_state_t zstate;

	*zents = NULL;
	if (zone_list(NULL, nzents) != 0) {
		warn(gettext("could not get zoneid list\n"));
		return (E_ERROR);
	}

again:
	if (*nzents == 0)
		return (E_SUCCESS);

	if ((zids = (zoneid_t *)calloc(*nzents, sizeof (zoneid_t))) == NULL) {
		warn(gettext("out of memory: zones will not be capped\n"));
		return (E_ERROR);
	}

	nzents_saved = *nzents;

	if (zone_list(zids, nzents) != 0) {
		warn(gettext("could not get zone list\n"));
		free(zids);
		return (E_ERROR);
	}
	if (*nzents != nzents_saved) {
		/* list changed, try again */
		free(zids);
		goto again;
	}

	*zents = calloc(*nzents, sizeof (zone_entry_t));
	if (*zents == NULL) {
		warn(gettext("out of memory: zones will not be capped\n"));
		free(zids);
		return (E_ERROR);
	}

	zentp = *zents;
	for (i = 0; i < *nzents; i++) {
		char name[ZONENAME_MAX];

		if (getzonenamebyid(zids[i], name, sizeof (name)) < 0) {
			warn(gettext("could not get name for "
			    "zoneid %d\n"), zids[i]);
			continue;
		}

		(void) strlcpy(zentp->zname, name, sizeof (zentp->zname));
		zentp->zid = zids[i];
		if (zone_get_state(name, &zstate) != Z_OK ||
		    zstate != ZONE_STATE_RUNNING)
			continue;


		zentp++;
	}
	*nzents = zentp - *zents;

	free(zids);
	return (E_SUCCESS);
}