mux/src/log.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include <sys/types.h>
#include "command.h"

Include dependency graph for log.cpp:

Go to the source code of this file.

Functions
bool	start_log (const char *primary, const char *secondary)
void	end_log (void)
void	log_perror (const char *primary, const char *secondary, const char *extra, const char *failing_object)
void	log_text (const char *text)
void	log_number (int num)
void DCL_CDECL	log_printf (const char *fmt,...)
void	log_name (dbref target)
void	log_name_and_loc (dbref player)
static const char *	OBJTYP (dbref thing)
void	log_type_and_name (dbref thing)
void	do_log (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *whichlog, char *logtext)
Variables
NAMETAB	logdata_nametab []
NAMETAB	logoptions_nametab []

---

Function Documentation

void do_log	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	whichlog,
		char *	logtext
	)

Definition at line 261 of file log.cpp.

References alloc_lbuf, ENDLINE, free_lbuf, mux_isalnum, notify, pFilename, strip_ansi(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(key);
    UNUSED_PARAMETER(nargs);

    bool bValid = true;

    // Strip the filename of all ANSI.
    //
    char *pFilename = strip_ansi(whichlog);

    // Restrict filename to a subdirectory to reduce the possibility
    // of a security hole.
    //
    char *temp_ptr = strrchr(pFilename, '/');
    if (temp_ptr)
    {
        pFilename = ++temp_ptr;
    }
    temp_ptr = strrchr(pFilename, '\\');
    if (temp_ptr)
    {
        pFilename = ++temp_ptr;
    }

    // Check for and disallow leading periods, empty strings
    // and filenames over 30 characters.
    //
    size_t n = strlen(pFilename);
    if (  n == 0
       || n > 30)
    {
        bValid = false;
    }
    else
    {
        unsigned int i;
        for (i = 0; i < n; i++)
        {
            if (!mux_isalnum(pFilename[i]))
            {
                bValid = false;
                break;
            }
        }
    }

    char *pFullName = NULL;
    char *pMessage = "";
    if (bValid)
    {
        pFullName = alloc_lbuf("do_log_filename");
        sprintf(pFullName, "logs/M-%s.log", pFilename);

        // Strip the message of all ANSI.
        //
        pMessage = strip_ansi(logtext);

        // Check for and disallow empty messages.
        //
        if (pMessage[0] == '\0')
        {
            bValid = false;
        }
    }
    if (!bValid)
    {
        if (pFullName) free_lbuf(pFullName);
        notify(executor, "Syntax: @log file=message");
        return;
    }

    FILE *hFile = fopen(pFullName, "r");
    if (hFile)
    {
        fclose(hFile);
        hFile = fopen(pFullName, "a");
    }
    if (hFile == NULL)
    {
        notify(executor, "Not a valid log file.");
        if (pFullName) free_lbuf(pFullName);
        return;
    }

    // Okay, at this point, the file exists.
    //
    fprintf(hFile, "%s" ENDLINE, pMessage);
    fclose(hFile);
    free_lbuf(pFullName);
}

void end_log

(

void

)

Definition at line 106 of file log.cpp.

References ENDLINE, CLogFile::Flush(), Log, statedata::logging, mudstate, and CLogFile::WriteString().

Referenced by pool_alloc(), pool_alloc_lbuf(), pool_free(), pool_free_lbuf(), and report_timecheck().

{
    Log.WriteString(ENDLINE);
    Log.Flush();
    mudstate.logging--;
}

void log_name

(

dbref

target

)

Definition at line 169 of file log.cpp.

References statedata::bStandAlone, free_lbuf, GOD, Log, confdata::log_info, LOGOPT_FLAGS, LOGOPT_OWNER, mudconf, mudstate, Name, Owner, strip_ansi(), CLogFile::tinyprintf(), unparse_object(), unparse_object_numonly(), and CLogFile::WriteString().

Referenced by CF_HAND(), check_connect(), do_backup(), do_boot(), do_fixdb(), do_global(), do_name(), do_newpassword(), do_pcreate(), do_quota(), do_restart(), do_shout(), do_shutdown(), do_toad(), failconn(), log_name_and_loc(), queue_write_LEN(), report_timecheck(), and shutdownsock().

{
    if (mudstate.bStandAlone)
    {
        Log.tinyprintf("%s(#%d)", Name(target), target);
    }
    else
    {
        char *tp;

        if (mudconf.log_info & LOGOPT_FLAGS)
        {
            tp = unparse_object(GOD, target, false);
        }
        else
        {
            tp = unparse_object_numonly(target);
        }
        Log.WriteString(strip_ansi(tp));
        free_lbuf(tp);
        if (  (mudconf.log_info & LOGOPT_OWNER)
           && target != Owner(target))
        {
            if (mudconf.log_info & LOGOPT_FLAGS)
            {
                tp = unparse_object(GOD, Owner(target), false);
            }
            else
            {
                tp = unparse_object_numonly(Owner(target));
            }
            Log.tinyprintf("[%s]", strip_ansi(tp));
            free_lbuf(tp);
        }
    }
}

void log_name_and_loc

(

dbref

player

)

Definition at line 210 of file log.cpp.

References Has_location, Location, confdata::log_info, log_name(), log_text(), LOGOPT_LOC, and mudconf.

Referenced by check_connect(), do_boot(), do_command(), do_toad(), eval_boolexp(), process_command(), report(), and Task_RunQueueEntry().

{
    log_name(player);
    if (  (mudconf.log_info & LOGOPT_LOC)
       && Has_location(player))
    {
        log_text(" in ");
        log_name(Location(player));
    }
    return;
}

void log_number

(

int

num

)

Definition at line 148 of file log.cpp.

References Log, and CLogFile::WriteInteger().

Referenced by boot_slave(), Log_header_err(), report_timecheck(), and shovechars().

{
    Log.WriteInteger(num);
}

void log_perror	(	const char *	primary,
		const char *	secondary,
		const char *	extra,
		const char *	failing_object
	)

Definition at line 117 of file log.cpp.

References ENDLINE, CLogFile::Flush(), Log, log_text(), statedata::logging, mudstate, start_log(), and CLogFile::WriteString().

Referenced by close_sockets(), dump_database_internal(), fork_and_dump(), make_nolinger(), make_nonblocking(), make_socket(), and shovechars().

{
    start_log(primary, secondary);
    if (extra && *extra)
    {
        log_text("(");
        log_text(extra);
        log_text(") ");
    }

    // <Failing_object text>: <strerror() text>
    //
    Log.WriteString(failing_object);
    Log.WriteString(": ");
    Log.WriteString(strerror(errno));
#ifndef WIN32
    Log.WriteString(ENDLINE);
#endif // !WIN32
    Log.Flush();
    mudstate.logging--;
}

void DCL_CDECL log_printf	(	const char *	fmt,
			...
	)

Definition at line 153 of file log.cpp.

References Log, mux_vsnprintf(), SIZEOF_LOG_BUFFER, and CLogFile::WriteBuffer().

{
    va_list ap;
    va_start(ap, fmt);
    char aTempBuffer[SIZEOF_LOG_BUFFER];
    int nString = mux_vsnprintf(aTempBuffer, SIZEOF_LOG_BUFFER, fmt, ap);
    va_end(ap);
    Log.WriteBuffer(nString, aTempBuffer);
}

void log_text

(

const char *

text

)

Definition at line 143 of file log.cpp.

References Log, strip_ansi(), and CLogFile::WriteString().

Referenced by announce_connect(), announce_disconnect(), boot_slave(), CF_HAND(), cf_log_syntax(), cf_status_from_succfail(), check_connect(), do_backup(), do_boot(), do_command(), do_fixdb(), do_global(), do_link(), do_logged_out_internal(), do_mail_nuke(), do_mail_read(), do_name(), do_newpassword(), do_pcreate(), do_quota(), do_restart(), do_shout(), do_shutdown(), do_toad(), dump_database(), eval_boolexp(), failconn(), fcache_read(), fork_and_dump(), get_slave_result(), helpindex_read(), init_version(), CHashFile::Insert(), load_game(), Log_header_err(), log_name_and_loc(), log_perror(), Log_pointer_err(), log_signal(), log_signal_ignore(), Log_simple_err(), log_type_and_name(), LogStatBuf(), main(), CGuests::MakeGuestChar(), new_connection(), new_mail_message(), pool_free(), pool_free_lbuf(), process_command(), purge_going(), queue_write_LEN(), report(), report_timecheck(), ReportTopic(), shovechars(), shutdownsock(), Task_RunQueueEntry(), and ValidateHelpFileIndex().

{
    Log.WriteString(strip_ansi(text));
}

void log_type_and_name

(

dbref

thing

)

Definition at line 245 of file log.cpp.

References Good_obj, log_text(), Name, and OBJTYP().

Referenced by Log_header_err(), Log_pointer_err(), Log_simple_err(), and purge_going().

{
    char nbuf[16];

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

static const char* OBJTYP

(

dbref

thing

)

[static]

Definition at line 222 of file log.cpp.

References Good_dbref, TYPE_EXIT, TYPE_GARBAGE, TYPE_PLAYER, TYPE_ROOM, TYPE_THING, and Typeof.

Referenced by log_type_and_name().

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

bool start_log	(	const char *	primary,
		const char *	secondary
	)

Definition at line 52 of file log.cpp.

References statedata::bStandAlone, ENDLINE, CLinearTimeAbsolute::GetLocal(), FIELDEDTIME::iDayOfMonth, FIELDEDTIME::iHour, FIELDEDTIME::iMinute, FIELDEDTIME::iMonth, FIELDEDTIME::iSecond, FIELDEDTIME::iYear, Log, confdata::log_info, statedata::logging, LOGOPT_TIMESTAMP, confdata::mud_name, mudconf, mudstate, CLinearTimeAbsolute::ReturnFields(), CLogFile::tinyprintf(), and CLogFile::WriteString().

Referenced by log_perror(), pool_alloc(), pool_alloc_lbuf(), pool_free(), pool_free_lbuf(), and report_timecheck().

{
    mudstate.logging++;
    if (  1 <= mudstate.logging
       && mudstate.logging <= 2)
    {
        if (!mudstate.bStandAlone)
        {
            // Format the timestamp.
            //
            char buffer[256];
            buffer[0] = '\0';
            if (mudconf.log_info & LOGOPT_TIMESTAMP)
            {
                CLinearTimeAbsolute ltaNow;
                ltaNow.GetLocal();
                FIELDEDTIME ft;
                ltaNow.ReturnFields(&ft);
                sprintf(buffer, "%d.%02d%02d:%02d%02d%02d ",ft.iYear,
                    ft.iMonth, ft.iDayOfMonth, ft.iHour, ft.iMinute,
                    ft.iSecond);
            }

            // Write the header to the log.
            //
            if (  secondary
               && *secondary)
            {
                Log.tinyprintf("%s%s %3s/%-5s: ", buffer, mudconf.mud_name,
                    primary, secondary);
            }
            else
            {
                Log.tinyprintf("%s%s %-9s: ", buffer, mudconf.mud_name,
                    primary);
            }
        }

        // If a recursive call, log it and return indicating no log.
        //
        if (mudstate.logging == 1)
        {
            return true;
        }
        Log.WriteString("Recursive logging request." ENDLINE);
    }
    mudstate.logging--;
    return false;
}

---

Variable Documentation

NAMETAB logdata_nametab[]

Initial value:

{
    {"flags",           1,  0,  LOGOPT_FLAGS},
    {"location",        1,  0,  LOGOPT_LOC},
    {"owner",           1,  0,  LOGOPT_OWNER},
    {"timestamp",       1,  0,  LOGOPT_TIMESTAMP},
    { NULL,             0,  0,  0}
}

Definition at line 15 of file log.cpp.

Referenced by do_list().

NAMETAB logoptions_nametab[]

Initial value:

{
    {"accounting",      2,  0,  LOG_ACCOUNTING},
    {"all_commands",    2,  0,  LOG_ALLCOMMANDS},
    {"bad_commands",    2,  0,  LOG_BADCOMMANDS},
    {"buffer_alloc",    3,  0,  LOG_ALLOCATE},
    {"bugs",            3,  0,  LOG_BUGS},
    {"checkpoints",     2,  0,  LOG_DBSAVES},
    {"config_changes",  2,  0,  LOG_CONFIGMODS},
    {"create",          2,  0,  LOG_PCREATES},
    {"killing",         1,  0,  LOG_KILLS},
    {"logins",          1,  0,  LOG_LOGIN},
    {"network",         1,  0,  LOG_NET},
    {"problems",        1,  0,  LOG_PROBLEMS},
    {"security",        2,  0,  LOG_SECURITY},
    {"shouts",          2,  0,  LOG_SHOUTS},
    {"startup",         2,  0,  LOG_STARTUP},
    {"suspect",         2,  0,  LOG_SUSPECTCMDS},
    {"time_usage",      1,  0,  LOG_TIMEUSE},
    {"wizard",          1,  0,  LOG_WIZARD},
    { NULL,                     0,  0,  0}
}

Definition at line 24 of file log.cpp.

Referenced by do_list().

---