aolserver/nslog/nslog.c

/*
 * The contents of this file are subject to the AOLserver Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://aolserver.com/.
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is AOLserver Code and related documentation
 * distributed by AOL.
 * 
 * The Initial Developer of the Original Code is America Online,
 * Inc. Portions created by AOL are Copyright (C) 1999 America Online,
 * Inc. All Rights Reserved.
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the GNU General Public License (the "GPL"), in which case the
 * provisions of GPL are applicable instead of those above.  If you wish
 * to allow use of your version of this file only under the terms of the
 * GPL and not to allow others to use your version of this file under the
 * License, indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by the GPL.
 * If you do not delete the provisions above, a recipient may use your
 * version of this file under either the License or the GPL.
 */


/* 
 * nslog.c --
 *
 *      This file implements the access log using NCSA Common <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> format.
 */

static const char *RCSID = "@(#) $Header: /cvsroot-fuse/aolserver/aolserver/nslog/nslog.c,v 1.17 2010/09/09 12:14:23 gneumann Exp $, compiled: " __DATE__ " " __TIME__;

#include "ns.h"
#include <sys/stat.h>   /* mkdir */
#include <ctype.h>      /* isspace */

#define LOG_COMBINED    1
#define LOG_FMTTIME     2
#define LOG_REQTIME     4

typedef struct {
    char           *module;
    Ns_Mutex        lock;
    int             fd;
    char           *file;
    char           *rollfmt;
    int             flags;
    int             maxbackup;
    int             maxlines;
    int             curlines;
    int             suppressquery;
    Ns_DString      buffer;
    char          **extheaders;
} <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a>;


/*
 * Local functions defined in this file
 */
static Ns_Callback <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRollCallback">LogRollCallback</a>;
static Ns_Callback <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCloseCallback">LogCloseCallback</a>;
static Ns_TraceProc <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogTrace">LogTrace</a>;
static int <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogFlush">LogFlush</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr, Ns_DString *dsPtr);
static int <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogOpen">LogOpen</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr);
static int <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRoll">LogRoll</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr);
static int <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogClose">LogClose</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr);
static void <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogConfigExtHeaders">LogConfigExtHeaders</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr, char *path);
static Ns_ArgProc <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogArg">LogArg</a>;
static Tcl_CmdProc <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCmd">LogCmd</a>;
static Ns_TclInterpInitProc <a href="/cvs/aolserver/nsopenssl/tclcmds.c#A_AddCmds">AddCmds</a>;


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_NsLog_ModInit">NsLog_ModInit</a> --
 *
 *      Module initialization routine.
 *
 * Results:
 *      NS_OK.
 *
 * Side effects:
 *      <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> file is opened, trace routine is registered, and, if
 *      configured, log file roll signal and scheduled procedures 
 *      are registered.
 *
 *----------------------------------------------------------------------
 */

int
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_NsLog_ModInit">NsLog_ModInit</a>(char *server, char *module)
{
    char        *path;
    int          opt, hour;
    <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a>         *logPtr;
    static int   first = 1;

    /*
     * Register the info callbacks just once.
     */

    if (first) {
        <a href="/cvs/aolserver/aolserver/nsd/proc.c#A_Ns_RegisterProcInfo">Ns_RegisterProcInfo</a>((void *)<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRollCallback">LogRollCallback</a>, "logroll", <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogArg">LogArg</a>);
        <a href="/cvs/aolserver/aolserver/nsd/proc.c#A_Ns_RegisterProcInfo">Ns_RegisterProcInfo</a>((void *)<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCloseCallback">LogCloseCallback</a>, "logclose", <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogArg">LogArg</a>);
        first = 0;
    }

    /*
     * Initialize the log buffer.
     */

    logPtr = ns_calloc(1, sizeof(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a>));
    logPtr->fd = -1;
    logPtr->module = module;
    Ns_MutexInit(&logPtr->lock);
    Ns_MutexSetName2(&logPtr->lock, "nslog", server);
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&logPtr->buffer);

    /*
     * Determine the log file name which, if not
     * absolute, is expected to exist in the module
     * specific directory.  The module directory is
     * created if necessary.
     */

    path = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetPath">Ns_ConfigGetPath</a>(server, module, NULL);
    logPtr->file = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "file");
    if (logPtr->file == NULL) {
        logPtr->file = "access.log";
    }
    if (<a href="/cvs/aolserver/aolserver/nsd/pathname.c#A_Ns_PathIsAbsolute">Ns_PathIsAbsolute</a>(logPtr->file) == NS_FALSE) {
        Ns_DString       ds;

        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
        <a href="/cvs/aolserver/aolserver/nsd/pathname.c#A_Ns_ModulePath">Ns_ModulePath</a>(&ds, server, module, NULL, NULL);
        if (mkdir(ds.string, 0755) != 0 && errno != EEXIST
            && errno != EISDIR) {
            <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "nslog: mkdir(%s) failed: %s", 
                   ds.string, strerror(errno));
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
            return NS_ERROR;
        }
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringTrunc">Ns_DStringTrunc</a>(&ds, 0);
        <a href="/cvs/aolserver/aolserver/nsd/pathname.c#A_Ns_ModulePath">Ns_ModulePath</a>(&ds, server, module, logPtr->file, NULL);
        logPtr->file = <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringExport">Ns_DStringExport</a>(&ds);
    }

    /*
     * Get parameters from configuration file
     */

    logPtr->rollfmt = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "rollfmt");
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetInt">Ns_ConfigGetInt</a>(path, "maxbuffer", &logPtr->maxlines)) {
        logPtr->maxlines = 0;
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetInt">Ns_ConfigGetInt</a>(path, "maxbackup", &logPtr->maxbackup) || logPtr->maxbackup < 1) {
        logPtr->maxbackup = 100;
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "formattedTime", &opt)) {
        opt = 1;
    }
    if (opt) {
        logPtr->flags |= LOG_FMTTIME;
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "logcombined", &opt)) {
        opt = 1;
    }
    if (opt) {
        logPtr->flags |= LOG_COMBINED;
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "logreqtime", &opt)) {
        opt = 0;
    }
    if (opt) {
        logPtr->flags |= LOG_REQTIME;
    }


    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "suppressquery", &logPtr->suppressquery)) {
        logPtr->suppressquery = 0;
    }

    /*
     * Schedule various log roll and shutdown options.
     */

    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetInt">Ns_ConfigGetInt</a>(path, "rollhour", &hour) ||
        hour < 0 || hour > 23) {
        hour = 0;
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "rolllog", &opt)) {
        opt = 1;
    }
    if (opt) {
        <a href="/cvs/aolserver/aolserver/nsd/sched.c#A_Ns_ScheduleDaily">Ns_ScheduleDaily</a>((Ns_SchedProc *) <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRollCallback">LogRollCallback</a>, logPtr, 0, hour, 0, NULL);
    }
    if (!<a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetBool">Ns_ConfigGetBool</a>(path, "rollonsignal", &opt)) {
        opt = 0;;
    }
    if (opt) {
        <a href="/cvs/aolserver/aolserver/nsd/callbacks.c#A_Ns_RegisterAtSignal">Ns_RegisterAtSignal</a>(<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRollCallback">LogRollCallback</a>, logPtr);
    }

    <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogConfigExtHeaders">LogConfigExtHeaders</a>(logPtr, path);

    /*
     * Open the log and register the trace.
     */

    if (<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogOpen">LogOpen</a>(logPtr) != NS_OK) {
        return NS_ERROR;
    }
    <a href="/cvs/aolserver/aolserver/nsd/filter.c#A_Ns_RegisterServerTrace">Ns_RegisterServerTrace</a>(server, <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogTrace">LogTrace</a>, logPtr);
    <a href="/cvs/aolserver/aolserver/nsd/callbacks.c#A_Ns_RegisterAtShutdown">Ns_RegisterAtShutdown</a>(<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCloseCallback">LogCloseCallback</a>, logPtr);
    <a href="/cvs/aolserver/aolserver/nsd/tclinit.c#A_Ns_TclInitInterps">Ns_TclInitInterps</a>(server, <a href="/cvs/aolserver/nsopenssl/tclcmds.c#A_AddCmds">AddCmds</a>, logPtr);
    return NS_OK;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogTrace">LogTrace</a> --
 *
 *      Trace routine for appending the log with the current connection
 *      results.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Entry is appended to the open log.
 *
 *----------------------------------------------------------------------
 */

static void 
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogTrace">LogTrace</a>(void *arg, Ns_Conn *conn)
{
    Ns_DString     ds;
    register char *p;
    int            quote, n, status, i;
    char           buf[100];
    <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a>           *logPtr = arg;
     
    Ns_Time        now, diff;

    /*
     * Compute the request's elapsed time.
     */

    if (logPtr->flags & LOG_REQTIME) {

        Ns_GetTime(&now);
        Ns_DiffTime(&now, <a href="/cvs/aolserver/aolserver/nsd/conn.c#A_Ns_ConnStartTime">Ns_ConnStartTime</a>(conn), &diff);
    }

    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);

    /*
     * Append the peer address and auth user (if any).
     * Watch for users comming from proxy servers. 
     */

    if (conn->headers && (p = <a href="/cvs/aolserver/aolserver/nsd/set.c#A_Ns_SetIGet">Ns_SetIGet</a>(conn->headers, "X-Forwarded-For"))) {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, p);
    } else {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, <a href="/cvs/aolserver/aolserver/nsd/conn.c#A_Ns_ConnPeer">Ns_ConnPeer</a>(conn));
    }
    if (conn->authUser == NULL) {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, " - - ");
    } else {
        p = conn->authUser;
        quote = 0;
        while (*p != '\0') {
            if (isspace((unsigned char) *p)) {
                quote = 1;
                break;
            }
            ++p;
        }
        if (quote) {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&ds, " - \"", conn->authUser, "\" ", NULL);
        } else {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&ds, " - ", conn->authUser, " ", NULL);
        }
    }

    /*
     * Append a common log format time stamp including GMT offset.
     */

    if (!(logPtr->flags & LOG_FMTTIME)) {
        sprintf(buf, "[%ld]", (long) time(NULL));
    } else {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_LogTime">Ns_LogTime</a>(buf);
    }
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, buf);

    /*
     * Append the request line.
     */

    if (conn->request && conn->request->line) {
        
        if (logPtr->suppressquery) {
            /*
             * Don't display query data.
             * NB: Side-effect is that the real URI is returned, so places
             * where trailing slash returns "index.html" logs as "index.html".
             */
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&ds, " \"", conn->request->url, "\" ", NULL);
        } else {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&ds, " \"", conn->request->line, "\" ", NULL);
        }
    } else {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, " \"\" ");
    }

    /*
     * Construct and append the HTTP status code and bytes sent.
     */

    n = <a href="/cvs/aolserver/aolserver/nsd/conn.c#A_Ns_ConnResponseStatus">Ns_ConnResponseStatus</a>(conn);
    sprintf(buf, "%d %u ", n ? n : 200, <a href="/cvs/aolserver/aolserver/nsd/conn.c#A_Ns_ConnContentSent">Ns_ConnContentSent</a>(conn));
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, buf);

    if ((logPtr->flags & LOG_COMBINED)) {

        /*
         * Append the referer and user-agent headers (if any).
         */

        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, "\"");
        if ((p = <a href="/cvs/aolserver/aolserver/nsd/set.c#A_Ns_SetIGet">Ns_SetIGet</a>(conn->headers, "referer"))) {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, p);
        }
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, "\" \"");
        if ((p = <a href="/cvs/aolserver/aolserver/nsd/set.c#A_Ns_SetIGet">Ns_SetIGet</a>(conn->headers, "user-agent"))) {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, p);
        }
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, "\"");

    }

    /*
     * Append the request's elapsed time (if enabled).
     */

    if (logPtr->flags & LOG_REQTIME) {

        sprintf(buf, " %d.%06ld", (int)diff.sec, diff.usec);
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, buf);
    }


    /*
     * Append the extended headers (if any).
     */
    for (i=0; logPtr->extheaders[i] != NULL; i++) {
        if ((p = <a href="/cvs/aolserver/aolserver/nsd/set.c#A_Ns_SetIGet">Ns_SetIGet</a>(conn->headers, logPtr->extheaders[i]))) {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, " \"");
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, p);
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, "\"");
        } else {
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, " -");
        }
    }

    for (i=0; i<ds.length; i++) {
      /* don't allow terminal escape characters in the log file */
      if (ds.string[i] == 0x1b) {
        ds.string[i] = 7; /* bell */
      }
    }

    /*
     * Append the trailing newline and buffer and/or flush the line.
     */

    status = NS_OK;
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringAppend">Ns_DStringAppend</a>(&ds, "\n");
    Ns_MutexLock(&logPtr->lock);
    if (logPtr->maxlines <= 0) {
        status = <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogFlush">LogFlush</a>(logPtr, &ds);
    } else {
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringNAppend">Ns_DStringNAppend</a>(&logPtr->buffer, ds.string, ds.length);
        if (++logPtr->curlines > logPtr->maxlines) {
            status = <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogFlush">LogFlush</a>(logPtr, &logPtr->buffer);
            logPtr->curlines = 0;
        }
    }
    Ns_MutexUnlock(&logPtr->lock);
    <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
    if (status != NS_OK) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "nslog: failed to flush log: %s", strerror(errno));
    }
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCmd">LogCmd</a> --
 *
 *      Implement the ns_accesslog command.
 *
 * Results:
 *      Standard Tcl result.
 *
 * Side effects:
 *      Depends on command.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/nsopenssl/tclcmds.c#A_AddCmds">AddCmds</a>(Tcl_Interp *interp, void *arg)
{
    Tcl_CreateCommand(interp, "ns_accesslog", <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCmd">LogCmd</a>, arg, NULL);
    return TCL_OK;
}

static int
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCmd">LogCmd</a>(ClientData arg, Tcl_Interp *interp, int argc, CONST char **argv)
{
    char *rollfile;
    int status;
    <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr = arg;

    if (argc < 2) {
        Tcl_AppendResult(interp, "wrong # args: should be: \"",
            argv[0], " command ?arg?\"", NULL);
        return TCL_ERROR;
    }
    if (STREQ(argv[1], "file")) {
        Tcl_SetResult(interp, logPtr->file, TCL_STATIC);
    } else if (STREQ(argv[1], "roll")) {
        if (argc != 2 && argc != 3) {
            Tcl_AppendResult(interp, "wrong # args: should be: \"",
                argv[0], " ", argv[1], " ?file?\"", NULL);
            return TCL_ERROR;
        }
        Ns_MutexLock(&logPtr->lock);
        if (argc == 2) {
            status = <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRoll">LogRoll</a>(logPtr);
        } else {
            rollfile = (char*)argv[2];
            status = NS_OK;
            if (access(rollfile, F_OK) == 0) {
                status = <a href="/cvs/aolserver/aolserver/nsd/rollfile.c#A_Ns_RollFile">Ns_RollFile</a>(rollfile, logPtr->maxbackup);
            }
            if (status == NS_OK) {
                if (rename(logPtr->file, rollfile) != 0) {
                    status = NS_ERROR;
                } else {
                    <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogFlush">LogFlush</a>(logPtr, &logPtr->buffer);
                    status = <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogOpen">LogOpen</a>(logPtr);
                }
            }
        }
        Ns_MutexUnlock(&logPtr->lock);
        if (status != NS_OK) {
            Tcl_AppendResult(interp, "could not roll \"", logPtr->file,
                "\": ", Tcl_PosixError(interp), NULL);
            return TCL_ERROR;
        }
    } else {
        Tcl_AppendResult(interp, "unknown command \"", argv[1],
            "\": should be file or roll", NULL);
        return TCL_ERROR;
    }
    return TCL_OK;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogArg">LogArg</a> --
 *
 *      Copy log file as argument for callback query.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogArg">LogArg</a>(Tcl_DString *dsPtr, void *arg)
{
    <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr = arg;

    Tcl_DStringAppendElement(dsPtr, logPtr->file);
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogOpen">LogOpen</a> --
 *
 *      Open the access log, closing previous log if opeopen
 *
 * Results:
 *      NS_OK or NS_ERROR.
 *
 * Side effects:
 *      <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> re-opened.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogOpen">LogOpen</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr)
{
    int fd;

    fd = open(logPtr->file, O_APPEND|O_WRONLY|O_CREAT, 0644);
    if (fd < 0) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "nslog: error '%s' opening '%s'",
               strerror(errno),logPtr->file);
        return NS_ERROR;
    }
    if (logPtr->fd >= 0) {
        close(logPtr->fd);
    }
    logPtr->fd = fd;
    <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Notice, "nslog: opened '%s'", logPtr->file);
    return NS_OK;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogClose">LogClose</a> --
 *
 *      Flush and/or close the log.
 *
 * Results:
 *      NS_TRUE or NS_FALSE if log was closed.
 *
 * Side effects:
 *      Buffer entries, if any, are flushed.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogClose">LogClose</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr)
{
    int status;

    status = NS_OK;
    if (logPtr->fd >= 0) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Notice, "nslog: closing '%s'", logPtr->file);
        status = <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogFlush">LogFlush</a>(logPtr, &logPtr->buffer);
        close(logPtr->fd);
        logPtr->fd = -1;
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&logPtr->buffer);
    }
    return status;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogFlush">LogFlush</a> --
 *
 *      Flush a log buffer to the open log file.  Note:  The mutex
 *      is assumed held during call. 
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Will disable the log on error.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogFlush">LogFlush</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr, Ns_DString *dsPtr)
{
    if (dsPtr->length > 0) {
        if (logPtr->fd >= 0 &&
            write(logPtr->fd, dsPtr->string, (size_t)dsPtr->length) != dsPtr->length) {
            <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "nslog: "
                   "logging disabled: write() failed: '%s'", strerror(errno));
            close(logPtr->fd);
            logPtr->fd = -1;
        }
        <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringTrunc">Ns_DStringTrunc</a>(dsPtr, 0);
    }
    if (logPtr->fd < 0) {
        return NS_ERROR;
    }
    return NS_OK;
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRoll">LogRoll</a> --
 *
 *      Roll and re-open the access log.  This procedure is scheduled
 *      and/or registered at signal catching.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Files are rolled to new names.
 *
 *----------------------------------------------------------------------
 */

static int
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRoll">LogRoll</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr)
{
    int         status;

    status = NS_OK;
    (void) <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogClose">LogClose</a>(logPtr);
    if (access(logPtr->file, F_OK) == 0) {
        if (logPtr->rollfmt == NULL) {
            status = <a href="/cvs/aolserver/aolserver/nsd/rollfile.c#A_Ns_RollFile">Ns_RollFile</a>(logPtr->file, logPtr->maxbackup);
        } else {
            Ns_DString  ds;
            time_t      now;
            struct tm  *ptm;
            char        timeBuf[512];

            now = time(NULL);
            ptm = ns_localtime(&now);
            strftime(timeBuf, 512, logPtr->rollfmt, ptm);
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringInit">Ns_DStringInit</a>(&ds);
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringVarAppend">Ns_DStringVarAppend</a>(&ds, logPtr->file, ".", timeBuf, NULL);
            if (access(ds.string, F_OK) == 0) {
                status = <a href="/cvs/aolserver/aolserver/nsd/rollfile.c#A_Ns_RollFile">Ns_RollFile</a>(ds.string, logPtr->maxbackup);
            } else if (errno != ENOENT) {
                <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "nslog: access(%s, F_OK) failed: '%s'", 
                       ds.string, strerror(errno));
                status = NS_ERROR;
            }
            if (status == NS_OK && rename(logPtr->file, ds.string) != 0) {
                <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "nslog: rename(%s, %s) failed: '%s'",
                    logPtr->file, ds.string, strerror(errno));
                status = NS_ERROR;
            }
            <a href="/cvs/aolserver/aolserver/nsd/dstring.c#A_Ns_DStringFree">Ns_DStringFree</a>(&ds);
            if (status == NS_OK) {
                status = <a href="/cvs/aolserver/aolserver/nsd/rollfile.c#A_Ns_PurgeFiles">Ns_PurgeFiles</a>(logPtr->file, logPtr->maxbackup);
            }
        }
    }
    status = <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogOpen">LogOpen</a>(logPtr);
    return status;
}       


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCloseCallback">LogCloseCallback</a>, <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRollCallback">LogRollCallback</a> -
 *
 *      Close or roll the log.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      See <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogClose">LogClose</a> and <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRoll">LogRoll</a>.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCallback">LogCallback</a>(int (proc)(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *), void *arg, char *desc)
{
    int status;
    <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr = arg;

    Ns_MutexLock(&logPtr->lock);
    status = (*proc)(logPtr);
    Ns_MutexUnlock(&logPtr->lock);
    if (status != NS_OK) {
        <a href="/cvs/aolserver/aolserver/nsd/log.c#A_Ns_Log">Ns_Log</a>(Error, "nslog: failed: %s '%s': '%s'",
               desc, logPtr->file, strerror(errno));
    }
}

static void
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCloseCallback">LogCloseCallback</a>(void *arg)
{
    <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCallback">LogCallback</a>(<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogClose">LogClose</a>, arg, "close");
}

static void
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRollCallback">LogRollCallback</a>(void *arg)
{
    <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogCallback">LogCallback</a>(<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogRoll">LogRoll</a>, arg, "roll");
}


/*
 *----------------------------------------------------------------------
 *
 * <a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogConfigExtHeaders">LogConfigExtHeaders</a>
 *
 *      <a href="/cvs/aolserver/aolserver/nsd/adpparse.c#A_Parse">Parse</a> the ExtendedHeaders configuration.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Sets logPtr->extheaders.
 *
 *----------------------------------------------------------------------
 */

static void
<a href="/cvs/aolserver/aolserver/nslog/nslog.c#A_LogConfigExtHeaders">LogConfigExtHeaders</a>(<a href="/cvs/aolserver/aolserver/nsd/log.c#A_Log">Log</a> *logPtr, char *path)
{
    char *config = <a href="/cvs/aolserver/aolserver/nsd/config.c#A_Ns_ConfigGetValue">Ns_ConfigGetValue</a>(path, "extendedheaders");
    char *p;
    int   i;

    if (config == NULL) {
        logPtr->extheaders = ns_calloc(1, sizeof *logPtr->extheaders);
        logPtr->extheaders[0] = NULL;
        return;
    }

    config = ns_strdup(config);

    /* Figure out how many extended headers there are. */

    for (i = 1, p = config; *p; p++) {
        if (*p == ',') {
            i++;
        }
    }

    /* Initialize the extended header pointers. */

    logPtr->extheaders = ns_calloc((size_t)(i + 1), sizeof *logPtr->extheaders);

    logPtr->extheaders[0] = config;

    for (i = 1, p = config; *p; p++) {
        if (*p == ',') {
            *p = '\000';
            logPtr->extheaders[i++] = p + 1;
        }
    }

    logPtr->extheaders[i] = NULL;

}
