mux/src/file_c.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "command.h"
#include "file_c.h"

Include dependency graph for file_c.cpp:

Go to the source code of this file.

Data Structures
struct	filecache_block
struct	filecache_block::filecache_block_hdr
struct	filecache_hdr
Defines
#define	FBLOCK_SIZE   (MBUF_SIZE - sizeof(FBLKHDR))
Typedefs
typedef filecache_block_hdr	FBLKHDR
typedef filecache_block	FBLOCK
typedef filecache_hdr	FCACHE
Functions
void	do_list_file (dbref executor, dbref caller, dbref enactor, int extra, char *arg)
static FBLOCK *	fcache_fill (FBLOCK *fp, char ch)
static int	fcache_read (FBLOCK **cp, char *filename)
void	fcache_rawdump (SOCKET fd, int num)
void	fcache_dump (DESC *d, int num)
void	fcache_send (dbref player, int num)
void	fcache_load (dbref player)
void	fcache_init (void)
Variables
static FCACHE	fcache []
static NAMETAB	list_files []

---

Define Documentation

#define FBLOCK_SIZE   (MBUF_SIZE - sizeof(FBLKHDR))

Definition at line 36 of file file_c.cpp.

---

Typedef Documentation

typedef struct filecache_block_hdr FBLKHDR

Definition at line 14 of file file_c.cpp.

typedef struct filecache_block FBLOCK

Definition at line 15 of file file_c.cpp.

typedef struct filecache_hdr FCACHE

Definition at line 34 of file file_c.cpp.

---

Function Documentation

void do_list_file	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	extra,
		char *	arg
	)

Definition at line 70 of file file_c.cpp.

References display_nametab(), fcache_send(), list_files, search_nametab(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(extra);

    int flagvalue;
    if (!search_nametab(executor, list_files, arg, &flagvalue))
    {
        display_nametab(executor, list_files, "Unknown file.  Use one of:", true);
        return;
    }
    fcache_send(executor, flagvalue);
}

void fcache_dump	(	DESC *	d,
		int	num
	)

Definition at line 212 of file file_c.cpp.

References filecache_block::data, FC_LAST, fcache, filecache_hdr::fileblock, filecache_block::hdr, filecache_block::filecache_block_hdr::nchars, filecache_block::filecache_block_hdr::nxt, and queue_write_LEN().

Referenced by check_connect(), failconn(), fcache_send(), shutdownsock(), and welcome_user().

{
    if ((num < 0) || (num > FC_LAST))
    {
        return;
    }
    FBLOCK *fp = fcache[num].fileblock;

    while (fp != NULL)
    {
        queue_write_LEN(d, fp->data, fp->hdr.nchars);
        fp = fp->hdr.nxt;
    }
}

static FBLOCK* fcache_fill	(	FBLOCK *	fp,
		char	ch
	)			[static]

Definition at line 85 of file file_c.cpp.

References alloc_mbuf, filecache_block::data, filecache_block::hdr, filecache_block::filecache_block_hdr::nchars, and filecache_block::filecache_block_hdr::nxt.

Referenced by fcache_read().

{
    if (fp->hdr.nchars >= sizeof(fp->data))
    {
        // We filled the current buffer.  Go get a new one.
        //
        FBLOCK *tfp = fp;
        fp = (FBLOCK *) alloc_mbuf("fcache_fill");
        fp->hdr.nxt = NULL;
        fp->hdr.nchars = 0;
        tfp->hdr.nxt = fp;
    }
    fp->data[fp->hdr.nchars++] = ch;
    return fp;
}

void fcache_init

(

void

)

Definition at line 274 of file file_c.cpp.

References fcache, fcache_load(), filecache_hdr::fileblock, NOTHING, and filecache_hdr::ppFilename.

Referenced by main().

{
    FCACHE *fp = fcache;
    for (fp = fcache; fp->ppFilename; fp++)
    {
        fp->fileblock = NULL;
    }

    fcache_load(NOTHING);
}

void fcache_load

(

dbref

player

)

Definition at line 237 of file file_c.cpp.

References alloc_lbuf, alloc_sbuf, filecache_hdr::desc, fcache, fcache_read(), filecache_hdr::fileblock, free_lbuf, free_sbuf, mux_ltoa(), NOTHING, notify, filecache_hdr::ppFilename, Quiet, and safe_str.

Referenced by do_readcache(), and fcache_init().

{
    FCACHE *fp;
    char *buff, *bufc, *sbuf;

    buff = bufc = alloc_lbuf("fcache_load.lbuf");
    sbuf = alloc_sbuf("fcache_load.sbuf");
    for (fp = fcache; fp->ppFilename; fp++)
    {
        int i = fcache_read(&fp->fileblock, *fp->ppFilename);
        if (  player != NOTHING
           && !Quiet(player))
        {
            mux_ltoa(i, sbuf);
            if (fp == fcache)
            {
                safe_str("File sizes: ", buff, &bufc);
            }
            else
            {
                safe_str("  ", buff, &bufc);
            }
            safe_str(fp->desc, buff, &bufc);
            safe_str("...", buff, &bufc);
            safe_str(sbuf, buff, &bufc);
        }
    }
    *bufc = '\0';
    if (  player != NOTHING
       && !Quiet(player))
    {
        notify(player, buff);
    }
    free_lbuf(buff);
    free_sbuf(sbuf);
}

void fcache_rawdump	(	SOCKET	fd,
		int	num
	)

Definition at line 182 of file file_c.cpp.

References cnt, filecache_block::data, FC_LAST, fcache, filecache_hdr::fileblock, filecache_block::hdr, filecache_block::filecache_block_hdr::nchars, filecache_block::filecache_block_hdr::nxt, and SOCKET_WRITE.

Referenced by new_connection().

{
    if ((num < 0) || (num > FC_LAST))
    {
        return;
    }

    FBLOCK *fp = fcache[num].fileblock;
    int cnt, remaining;
    char *start;

    while (fp != NULL)
    {
        start = fp->data;
        remaining = fp->hdr.nchars;
        while (remaining > 0)
        {
            cnt = SOCKET_WRITE(fd, start, remaining, 0);
            if (cnt < 0)
            {
                return;
            }
            remaining -= cnt;
            start += cnt;
        }
        fp = fp->hdr.nxt;
    }
    return;
}

static int fcache_read	(	FBLOCK **	cp,
		char *	filename
	)			[static]

Definition at line 101 of file file_c.cpp.

References alloc_lbuf, alloc_mbuf, DebugTotalFiles, ENDLOG, fcache_fill(), free_lbuf, free_mbuf, filecache_block::hdr, LBUF_SIZE, LOG_PROBLEMS, log_text(), filecache_block::filecache_block_hdr::nchars, filecache_block::filecache_block_hdr::nxt, O_BINARY, and STARTLOG.

Referenced by fcache_load().

{
    int n, nmax, tchars, fd;
    char *buff;
    FBLOCK *fp, *tfp;

    // Free a prior buffer chain.
    //
    fp = *cp;
    while (fp != NULL)
    {
        tfp = fp->hdr.nxt;
        free_mbuf(fp);
        fp = tfp;
    }
    *cp = NULL;

    // Read the text file into a new chain.
    //
    if ((fd = open(filename, O_RDONLY|O_BINARY)) == -1)
    {
        // Failure: log the event
        //
        STARTLOG(LOG_PROBLEMS, "FIL", "OPEN");
        buff = alloc_mbuf("fcache_read.LOG");
        sprintf(buff, "Couldn't open file '%s'.", filename);
        log_text(buff);
        free_mbuf(buff);
        ENDLOG
        return -1;
    }
    DebugTotalFiles++;
    buff = alloc_lbuf("fcache_read.temp");

    // Set up the initial cache buffer to make things easier.
    //
    fp = (FBLOCK *) alloc_mbuf("fcache_read.first");
    fp->hdr.nxt = NULL;
    fp->hdr.nchars = 0;
    *cp = fp;
    tchars = 0;

    // Process the file, one lbuf at a time.
    //
    nmax = read(fd, buff, LBUF_SIZE);
    while (nmax > 0)
    {
        for (n = 0; n < nmax; n++)
        {
            switch (buff[n])
            {
            case '\n':
                fp = fcache_fill(fp, '\r');
                fp = fcache_fill(fp, '\n');
                tchars += 2;
            case '\0':
            case '\r':
                break;
            default:
                fp = fcache_fill(fp, buff[n]);
                tchars++;
            }
        }
        nmax = read(fd, buff, LBUF_SIZE);
    }
    free_lbuf(buff);
    if (close(fd) == 0)
    {
        DebugTotalFiles--;
    }

    // If we didn't read anything in, toss the initial buffer.
    //
    if (fp->hdr.nchars == 0)
    {
        *cp = NULL;
        free_mbuf(fp);
    }
    return tchars;
}

void fcache_send	(	dbref	player,
		int	num
	)

Definition at line 227 of file file_c.cpp.

References DESC_ITER_PLAYER, and fcache_dump().

Referenced by do_list_file(), and do_motd().

{
    DESC *d;

    DESC_ITER_PLAYER(player, d)
    {
        fcache_dump(d, num);
    }
}

---

Variable Documentation

FCACHE fcache[] [static]

Initial value:

{
    { &mudconf.conn_file,    NULL,   "Conn" },
    { &mudconf.site_file,    NULL,   "Conn/Badsite" },
    { &mudconf.down_file,    NULL,   "Conn/Down" },
    { &mudconf.full_file,    NULL,   "Conn/Full" },
    { &mudconf.guest_file,   NULL,   "Conn/Guest" },
    { &mudconf.creg_file,    NULL,   "Conn/Reg" },
    { &mudconf.crea_file,    NULL,   "Crea/Newuser" },
    { &mudconf.regf_file,    NULL,   "Crea/RegFaill" },
    { &mudconf.motd_file,    NULL,   "Motd" },
    { &mudconf.wizmotd_file, NULL,   "Wizmotd" },
    { &mudconf.quit_file,    NULL,   "Quit" },
    { NULL,                  NULL,   NULL }
}

Definition at line 38 of file file_c.cpp.

Referenced by fcache_dump(), fcache_init(), fcache_load(), and fcache_rawdump().

NAMETAB list_files[] [static]

Initial value:

{
    {"badsite_connect",  1,  CA_WIZARD,  FC_CONN_SITE},
    {"connect",          2,  CA_WIZARD,  FC_CONN},
    {"create_register",  2,  CA_WIZARD,  FC_CREA_REG},
    {"down",             1,  CA_WIZARD,  FC_CONN_DOWN},
    {"full",             1,  CA_WIZARD,  FC_CONN_FULL},
    {"guest_motd",       1,  CA_WIZARD,  FC_CONN_GUEST},
    {"motd",             1,  CA_WIZARD,  FC_MOTD},
    {"newuser",          1,  CA_WIZARD,  FC_CREA_NEW},
    {"quit",             1,  CA_WIZARD,  FC_QUIT},
    {"register_connect", 1,  CA_WIZARD,  FC_CONN_REG},
    {"wizard_motd",      1,  CA_WIZARD,  FC_WIZMOTD},
    { NULL,              0,  0,          0}
}

Definition at line 54 of file file_c.cpp.

Referenced by do_list_file().

---