libdhcputil/common/dhcpmsg.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 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#include <stdarg.h>
#include <errno.h>
#include <stdio.h>
#include <syslog.h>
#include <libintl.h>
#include <string.h>
#include <limits.h>

#include "dhcpmsg.h"

static boolean_t    is_daemon  = B_FALSE;
static boolean_t    is_verbose = B_FALSE;
static char     program[PATH_MAX] = "<unknown>";
static int      debug_level;

static const char   *err_to_string(int);
static int      err_to_syslog(int);

/*
 * dhcpmsg(): logs a message to the console or to syslog
 *
 *   input: int: the level to log the message at
 *      const char *: a printf-like format string
 *      ...: arguments to the format string
 *  output: void
 */

void
dhcpmsg(int errlevel, const char *fmt, ...)
{
    va_list     ap;
    char        buf[512];
    char        *errmsg;

    if ((errlevel == MSG_DEBUG2 && (debug_level < 2)) ||
        (errlevel == MSG_DEBUG && (debug_level < 1)) ||
        (errlevel == MSG_VERBOSE && !is_verbose))
        return;

    va_start(ap, fmt);

    /*
     * either log to stderr, or log to syslog.  print out unix
     * error message if errlevel is MSG_ERR and errno is set
     */

    if (is_daemon) {
        (void) snprintf(buf, sizeof (buf), (errlevel == MSG_ERR &&
            errno != 0) ? "%s: %%m\n" : "%s\n", gettext(fmt));
        (void) vsyslog(err_to_syslog(errlevel), buf, ap);
    } else {
        errmsg = strerror(errno);
        if (errmsg == NULL)
            errmsg = dgettext(TEXT_DOMAIN, "<unknown error>");

        (void) snprintf(buf, sizeof (buf), (errlevel == MSG_ERR &&
            errno != 0) ? "%s: %s: %s: %s\n" : "%s: %s: %s\n", program,
            dgettext(TEXT_DOMAIN, err_to_string(errlevel)),
            gettext(fmt), errmsg);

        (void) vfprintf(stderr, buf, ap);
    }

    va_end(ap);
}

/*
 * dhcpmsg_init(): opens and initializes the DHCP messaging facility
 *
 *   input: const char *: the name of the executable
 *      boolean_t: whether the executable is a daemon
 *      boolean_t: whether the executable is running "verbosely"
 *      int: the debugging level the executable is being run at
 *  output: void
 */

void
dhcpmsg_init(const char *program_name, boolean_t daemon, boolean_t verbose,
    int level)
{
    (void) strlcpy(program, program_name, sizeof (program));

    debug_level = level;
    is_verbose = verbose;

    if (daemon) {
        is_daemon = B_TRUE;
        (void) openlog(program, LOG_PID, LOG_DAEMON);
        if (is_verbose) {
            syslog(err_to_syslog(MSG_VERBOSE), "%s",
                dgettext(TEXT_DOMAIN, "Daemon started"));
        }
    }
}

/*
 * dhcpmsg_fini(): closes the DHCP messaging facility.
 *
 *   input: void
 *  output: void
 */

void
dhcpmsg_fini(void)
{
    if (is_daemon) {
        if (is_verbose) {
            syslog(err_to_syslog(MSG_VERBOSE), "%s",
                dgettext(TEXT_DOMAIN, "Daemon terminated"));
        }
        closelog();
    }
}

/*
 * err_to_syslog(): converts a dhcpmsg log level into a syslog log level
 *
 *   input: int: the dhcpmsg log level
 *  output: int: the syslog log level
 */

static int
err_to_syslog(int errlevel)
{
    switch (errlevel) {

    case MSG_DEBUG:
    case MSG_DEBUG2:
        return (LOG_DEBUG);

    case MSG_ERROR:
    case MSG_ERR:
        return (LOG_ERR);

    case MSG_WARNING:
        return (LOG_WARNING);

    case MSG_NOTICE:
        return (LOG_NOTICE);

    case MSG_CRIT:
        return (LOG_CRIT);

    case MSG_VERBOSE:
    case MSG_INFO:
        return (LOG_INFO);
    }

    return (LOG_INFO);
}

/*
 * err_to_string(): converts a log level into a string
 *
 *   input: int: the log level
 *  output: const char *: the stringified log level
 */

static const char *
err_to_string(int errlevel)
{
    switch (errlevel) {

    case MSG_DEBUG:
    case MSG_DEBUG2:
        return ("debug");

    case MSG_ERR:
    case MSG_ERROR:
        return ("error");

    case MSG_WARNING:
        return ("warning");

    case MSG_NOTICE:
        return ("notice");

    case MSG_CRIT:
        return ("CRITICAL");

    case MSG_VERBOSE:
    case MSG_INFO:
        return ("info");
    }

    return ("<unknown>");
}