/*
 * log.c - logging routines 
 */

/*
 * $Id: log.c,v 1.3 2005/08/08 09:43:07 murrayma Exp $ 
 */

#include "copyright.h"
#include "config.h"

#include <sys/types.h>

#include "db.h"
#include "mudconf.h"
#include "externs.h"
#include "flags.h"
#include "powers.h"
#include "alloc.h"
#include "htab.h"
#include "ansi.h"
#ifdef ARBITRARY_LOGFILES
#include "logcache.h"
#endif

#ifndef STANDALONE
/* *INDENT-OFF* */

NAMETAB logdata_nametab[] = {
    {(char *)"flags",		1,	0,	LOGOPT_FLAGS},
    {(char *)"location",		1,	0,	LOGOPT_LOC},
    {(char *)"owner",		1,	0,	LOGOPT_OWNER},
    {(char *)"timestamp",		1,	0,	LOGOPT_TIMESTAMP},
    { NULL,				0,	0,	0}};

NAMETAB logoptions_nametab[] = {
    {(char *)"accounting",		2,	0,	LOG_ACCOUNTING},
    {(char *)"all_commands",	2,	0,	LOG_ALLCOMMANDS},
    {(char *)"suspect_commands",	2,	0,	LOG_SUSPECTCMDS},
    {(char *)"bad_commands",	2,	0,	LOG_BADCOMMANDS},
    {(char *)"buffer_alloc",	3,	0,	LOG_ALLOCATE},
    {(char *)"bugs",		3,	0,	LOG_BUGS},
    {(char *)"checkpoints",		2,	0,	LOG_DBSAVES},
    {(char *)"config_changes",	2,	0,	LOG_CONFIGMODS},
    {(char *)"create",		2,	0,	LOG_PCREATES},
    {(char *)"killing",		1,	0,	LOG_KILLS},
    {(char *)"logins",		1,	0,	LOG_LOGIN},
    {(char *)"network",		1,	0,	LOG_NET},
    {(char *)"problems",		1,	0,	LOG_PROBLEMS},
    {(char *)"security",		2,	0,	LOG_SECURITY},
    {(char *)"shouts",		2,	0,	LOG_SHOUTS},
    {(char *)"startup",		2,	0,	LOG_STARTUP}, 
    {(char *)"wizard",		1,	0,	LOG_WIZARD},
    { NULL,				0,	0,	0}};

/* *INDENT-ON* */





#endif

char *strip_ansi_r(char *dest, char *raw, size_t n) {
    char *p = (char *) raw;
    char *q = dest;

    while (p && *p && ((q-dest) < n)) {
        if (*p == ESC_CHAR) {
            /*
             * Start of ANSI code. Skip to end. 
             */
            while (*p && !isalpha(*p))
                p++;
            if (*p)
                p++;
        } else
            *q++ = *p++;
    }
    *q = '\0';
    return dest;
}


char *strip_ansi(const char *raw) {
    static char buf[LBUF_SIZE];
    char *p = (char *) raw;
    char *q = buf;

    while (p && *p) {
        if (*p == ESC_CHAR) {
            /*
             * Start of ANSI code. Skip to end. 
             */
            while (*p && !isalpha(*p))
                p++;
            if (*p)
                p++;
        } else
            *q++ = *p++;
    }
    *q = '\0';
    return buf;
}

char *normal_to_white(raw)
    const char *raw;
{
    static char buf[LBUF_SIZE];
    char *p = (char *) raw;
    char *q = buf;


    while (p && *p) {
        if (*p == ESC_CHAR) {
            /*
             * Start of ANSI code. 
             */
            *q++ = *p++;	/*
            * ESC CHAR 
            */
            *q++ = *p++;	/*
            * [ character. 
            */
            if (*p == '0') {	/*
                                 * ANSI_NORMAL 
                                 */
                safe_str("0m", buf, &q);
                safe_chr(ESC_CHAR, buf, &q);
                safe_str("[37m", buf, &q);
                p += 2;
            }
        } else
            *q++ = *p++;
    }
    *q = '\0';
    return buf;
}

/*
 * ---------------------------------------------------------------------------
 * * start_log: see if it is OK to log something, and if so, start writing the
 * * log entry.
 */

int start_log(primary, secondary)
    const char *primary, *secondary;
{
    struct tm *tp;
    time_t now;

    mudstate.logging++;
    switch (mudstate.logging) {
        case 1:
        case 2:

            /*
             * Format the timestamp 
             */

            if ((mudconf.log_info & LOGOPT_TIMESTAMP) != 0) {
                time((time_t *) (&now));
                tp = localtime((time_t *) (&now));
                sprintf(mudstate.buffer, "%d%02d%02d.%02d%02d%02d ",
                        tp->tm_year + 1900, tp->tm_mon + 1, tp->tm_mday,
                        tp->tm_hour, tp->tm_min, tp->tm_sec);
            } else {
                mudstate.buffer[0] = '\0';
            }
#ifndef STANDALONE
            /*
             * Write the header to the log 
             */

            if (secondary && *secondary)
                fprintf(stderr, "%s%s %3s/%-5s: ", mudstate.buffer,
                        mudconf.mud_name, primary, secondary);
            else
                fprintf(stderr, "%s%s %-9s: ", mudstate.buffer,
                        mudconf.mud_name, primary);
#endif
            /*
             * If a recursive call, log it and return indicating no log 
             */

            if (mudstate.logging == 1)
                return 1;
            fprintf(stderr, "Recursive logging request.\r\n");
        default:
            mudstate.logging--;
    }
    return 0;
}

/*
 * ---------------------------------------------------------------------------
 * * end_log: Finish up writing a log entry
 */

void end_log(void)
{
    fprintf(stderr, "\n");
    fflush(stderr);
    mudstate.logging--;
}

/*
 * ---------------------------------------------------------------------------
 * * log_perror: Write perror message to the log
 */

void log_perror(primary, secondary, extra, failing_object)
    const char *primary, *secondary, *extra, *failing_object;
{
    start_log(primary, secondary);
    if (extra && *extra) {
        log_text((char *) "(");
        log_text((char *) extra);
        log_text((char *) ") ");
    }
    perror((char *) failing_object);
    fflush(stderr);
    mudstate.logging--;
}

/*
 * ---------------------------------------------------------------------------
 * * log_text, log_number: Write text or number to the log file.
 */

void log_text(text)
    char *text;
{
    fprintf(stderr, "%s", strip_ansi(text));
}

void log_number(num)
    int num;
{
    fprintf(stderr, "%d", num);
}

/*
 * ---------------------------------------------------------------------------
 * * log_name: write the name, db number, and flags of an object to the log.
 * * If the object does not own itself, append the name, db number, and flags
 * * of the owner.
 */

void log_name(target)
    dbref target;
{
#ifndef STANDALONE
    char *tp;

    if ((mudconf.log_info & LOGOPT_FLAGS) != 0)
        tp = unparse_object((dbref) GOD, target, 0);
    else
        tp = unparse_object_numonly(target);
    fprintf(stderr, "%s", strip_ansi(tp));
    free_lbuf(tp);
    if (((mudconf.log_info & LOGOPT_OWNER) != 0) &&
            (target != Owner(target))) {
        if ((mudconf.log_info & LOGOPT_FLAGS) != 0)
            tp = unparse_object((dbref) GOD, Owner(target), 0);
        else
            tp = unparse_object_numonly(Owner(target));
        fprintf(stderr, "[%s]", strip_ansi(tp));
        free_lbuf(tp);
    }
#else
    fprintf(stderr, "%s(#%d)", Name(target), target);
#endif
    return;
}

/*
 * ---------------------------------------------------------------------------
 * * log_name_and_loc: Log both the name and location of an object
 */

void log_name_and_loc(player)
    dbref player;
{
    log_name(player);
    if ((mudconf.log_info & LOGOPT_LOC) && Has_location(player)) {
        log_text((char *) " in ");
        log_name(Location(player));
    }
    return;
}

char *OBJTYP(thing)
    dbref thing;
{
    if (!Good_obj(thing)) {
        return (char *) "??OUT-OF-RANGE??";
    }
    switch (Typeof(thing)) {
        case TYPE_PLAYER:
            return (char *) "PLAYER";
        case TYPE_THING:
            return (char *) "THING";
        case TYPE_ROOM:
            return (char *) "ROOM";
        case TYPE_EXIT:
            return (char *) "EXIT";
        case TYPE_GARBAGE:
            return (char *) "GARBAGE";
        default:
            return (char *) "??ILLEGAL??";
    }
}

void log_type_and_name(thing)
    dbref thing;
{
    char nbuf[16];

    log_text(OBJTYP(thing));
    sprintf(nbuf, " #%d(", thing);
    log_text(nbuf);
    if (Good_obj(thing))
        log_text(Name(thing));
    log_text((char *) ")");
    return;
}

void log_type_and_num(thing)
    dbref thing;
{
    char nbuf[16];

    log_text(OBJTYP(thing));
    sprintf(nbuf, " #%d", thing);
    log_text(nbuf);
    return;
}

#ifdef ARBITRARY_LOGFILES
int log_to_file(dbref thing, const char *logfile, const char *message) {
    char pathname[210];		/* Arbitrary limit in logfile length */
    char message_buffer[4096];

    if (!message || !*message)
        return 1;		/* Nothing to do */

    if (!logfile || !*logfile || strlen(logfile) > 200)
        return 0;		/* invalid logfile name */

    if(strstr(pathname, "..") != NULL) return 0;
    if(strstr(pathname, "/") != NULL) return 0;
    snprintf(pathname, 210, "logs/%s", logfile);

    /* Hacking checks. */
    
    if (access(pathname, R_OK|W_OK) != 0)
        return 0;
    
    snprintf(message_buffer, 4096, "%s\n", message);
    
    if(!logcache_writelog(pathname, message_buffer)) {
        notify(thing, "Serious failure while trying to write to log.");
        return 0;
    }
    return 1;
}

void do_log(dbref player, dbref cause, int key, char *logfile, char *message) {
    if (!message || !*message) {
        notify(player, "Nothing to log!");
        return;
    }

    if (!logfile || !*logfile) {
        notify(player, "Invalid logfile.");
        return;
    }

    if(!log_to_file(player, logfile, message)) {
        notify(player, "Request failed.");
        return;
    }

    notify(player, "Message logged.");
}
#endif