/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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
 */
/*
 * PPPoE Server-mode daemon log file support.
 *
 * Copyright (c) 2000-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#include <stdio.h>
#include <unistd.h>
#include <stdarg.h>
#include <alloca.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <syslog.h>
#include <assert.h>
#include <sys/types.h>

#include "common.h"
#include "logging.h"

/* Not all functions are used by all applications.  Let lint know this. */
/*LINTLIBRARY*/

const char *prog_name = "none"; /* Subsystem name for syslog */
int log_level;                  /* Higher number for more detail. */

static int curlogfd = -1;       /* Current log file */
static const char *curfname;    /* Name of current log file */
static const char *stderr_name = "stderr";

#define SMALLSTR        254     /* Don't allocate for most strings. */

/*
 * Returns -1 on error (with errno set), 0 on blocked write (file
 * system full), or N (buffer length) on success.
 */
static int
dowrite(int fd, const void *buf, int len)
{
        int retv;
        const uint8_t *bp = (uint8_t *)buf;

        while (len > 0) {
                retv = write(fd, bp, len);
                if (retv == 0) {
                        break;
                }
                if (retv == -1) {
                        if (errno != EINTR)
                                break;
                } else {
                        bp += retv;
                        len -= retv;
                }
        }
        if (len <= 0)
                return (bp - (uint8_t *)buf);
        return (retv);
}

/* A close that avoids closing stderr */
static int
doclose(void)
{
        int     retval = 0;

        if (curlogfd == -1)
                return (0);
        if ((curlogfd != STDERR_FILENO) || (curfname != stderr_name))
                retval = close(curlogfd);
        curlogfd = -1;
        return (retval);
}

/*
 * Log levels are 0 for no messages, 1 for errors, 2 for warnings, 3
 * for informational messages, and 4 for debugging messages.
 */
static void
vlogat(int loglev, const char *fmt, va_list args)
{
        char timbuf[64];
        char regbuf[SMALLSTR+2];
        char *ostr;
        int timlen;
        int slen;
        char *nstr;
        int err1, err2;
        int sloglev;
        int retv;
        va_list args2;
        static int xlate_loglev[] = {
                LOG_ERR, LOG_WARNING, LOG_INFO, LOG_DEBUG
        };

        if (loglev >= log_level)
                return;

        timbuf[0] = '\0';
        timlen = 0;
        if (curlogfd >= 0) {
                time_t now = time(NULL);

                /*
                 * Form a time/date string for file (non-syslog) logging.
                 * Caution: string broken in two so that SCCS doesn't mangle
                 * the %-T-% sequence.
                 */
                timlen = strftime(timbuf, sizeof (timbuf), "%Y/%m/%d %T"
                    "%Z: ", localtime(&now));
        }

        /* Try formatting once into the small buffer. */
        va_copy(args2, args);
        slen = vsnprintf(regbuf, SMALLSTR, fmt, args);
        if (slen < SMALLSTR) {
                ostr = regbuf;
        } else {
                /*
                 * Length returned by vsnprintf doesn't include null,
                 * and may also be missing a terminating \n.
                 */
                ostr = alloca(slen + 2);
                slen = vsnprintf(ostr, slen + 1, fmt, args2);
        }

        /* Don't bother logging empty lines. */
        if (slen <= 0)
                return;

        /* Tack on a \n if needed. */
        if (ostr[slen - 1] != '\n') {
                ostr[slen++] = '\n';
                ostr[slen] = '\0';
        }

        /* Translate our log levels into syslog standard values */
        assert(loglev >= 0 && loglev < Dim(xlate_loglev));
        sloglev = xlate_loglev[loglev];

        /* Log each line separately */
        for (; *ostr != '\0'; ostr = nstr + 1) {
                nstr = strchr(ostr, '\n');

                /* Ignore zero-length lines. */
                if (nstr == ostr)
                        continue;

                slen = nstr - ostr + 1;

                /*
                 * If we're supposed to be logging to a file, then try
                 * that first.  Ditch the file and revert to syslog if
                 * any errors occur.
                 */
                if (curlogfd >= 0) {
                        if ((retv = dowrite(curlogfd, timbuf, timlen)) > 0)
                                retv = dowrite(curlogfd, ostr, slen);

                        /*
                         * If we've successfully logged this line,
                         * then go do the next one.
                         */
                        if (retv > 0)
                                continue;

                        /* Save errno (if any) and close log file */
                        err1 = errno;
                        if (doclose() == -1)
                                err2 = errno;
                        else
                                err2 = 0;

                        /*
                         * Recursion is safe here because we cleared
                         * out curlogfd above.
                         */
                        if (retv == -1)
                                logerr("write log %s: %s", curfname,
                                    mystrerror(err1));
                        else
                                logerr("cannot write %s", curfname);
                        if (err2 == 0)
                                logdbg("closed log %s", curfname);
                        else
                                logerr("closing log %s: %s", curfname,
                                    mystrerror(err2));
                }
                syslog(sloglev, "%.*s", slen, ostr);
        }
}

/* Log at debug level */
void
logdbg(const char *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vlogat(LOGLVL_DBG, fmt, args);
        va_end(args);
}

/* Log informational messages */
void
loginfo(const char *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vlogat(LOGLVL_INFO, fmt, args);
        va_end(args);
}

/* Log warning messages */
void
logwarn(const char *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vlogat(LOGLVL_WARN, fmt, args);
        va_end(args);
}

/* Log error messages */
void
logerr(const char *fmt, ...)
{
        va_list args;

        va_start(args, fmt);
        vlogat(LOGLVL_ERR, fmt, args);
        va_end(args);
}

/* Log a strerror message */
void
logstrerror(const char *emsg)
{
        logerr("%s: %s\n", emsg, mystrerror(errno));
}

void
log_to_stderr(int dbglvl)
{
        log_level = dbglvl;
        if (curlogfd >= 0)
                close_log_files();
        curlogfd = STDERR_FILENO;
        curfname = stderr_name;
}

/*
 * Set indicated log file and debug level.
 */
void
log_for_service(const char *fname, int dbglvl)
{
        int err1, err2;
        boolean_t closed;

        log_level = dbglvl;
        if (fname != NULL &&
            (*fname == '\0' || strcasecmp(fname, "syslog") == 0))
                fname = NULL;
        if (fname == NULL && curfname == NULL)
                return;
        err1 = err2 = 0;
        closed = B_FALSE;
        if (curlogfd >= 0) {
                if (fname == curfname ||
                    (fname != NULL && strcmp(fname, curfname) == 0)) {
                        curfname = fname;
                        return;
                }
                if (doclose() == -1)
                        err1 = errno;
                closed = B_TRUE;
        }
        if (fname != NULL) {
                curlogfd = open(fname, O_WRONLY|O_APPEND|O_CREAT, 0600);
                if (curlogfd == -1)
                        err2 = errno;
        }
        if (closed) {
                if (err1 == 0)
                        logdbg("closed log %s", curfname);
                else
                        logerr("closing log %s: %s", curfname,
                            mystrerror(err1));
        }
        if (fname != NULL) {
                if (err2 == 0)
                        logdbg("opened log %s", fname);
                else
                        logerr("opening log %s: %s", fname, mystrerror(err2));
        }
        curfname = fname;
}

/*
 * Close any open log file.  This is used for SIGHUP (to support log
 * file rotation) and when execing.
 */
void
close_log_files(void)
{
        int err = 0;

        if (curlogfd >= 0) {
                if (doclose() == -1)
                        err = errno;
                if (err == 0)
                        logdbg("closed log %s", curfname);
                else
                        logerr("closing log %s: %s", curfname,
                            mystrerror(err));
        }
}

/*
 * Reopen syslog connection; in case it was closed.
 */
void
reopen_log(void)
{
        openlog(prog_name, LOG_PID | LOG_NDELAY | LOG_NOWAIT, LOG_DAEMON);
        /* I control the log level */
        (void) setlogmask(LOG_UPTO(LOG_DEBUG));
}