mux/src/comsys.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include <sys/types.h>
#include "ansi.h"
#include "attrs.h"
#include "command.h"
#include "comsys.h"
#include "functions.h"
#include "interface.h"
#include "powers.h"

Include dependency graph for comsys.cpp:

Go to the source code of this file.

Data Structures
struct	chanlist_node
Defines
#define	DFLT_MAX_LOG   0
#define	MIN_RECALL_REQUEST   1
#define	DFLT_RECALL_REQUEST   10
#define	MAX_RECALL_REQUEST   200
#define	MAX_ALIASES_PER_PLAYER   50
#define	MAX_SUPPORTED_NUM_ENTRIES   10000
Functions
static char *	RestrictTitleValue (char *pTitleRequest)
static void	do_setcomtitlestatus (dbref player, struct channel *ch, bool status)
static void	do_setnewtitle (dbref player, struct channel *ch, char *pValidatedTitle)
void	load_comsys (char *filename)
void	save_comsys (char *filename)
static char *	MakeCanonicalComAlias (const char *pAlias, int *nValidAlias, bool *bValidAlias)
static bool	ParseChannelLine (char *pBuffer, char *pAlias5, char **ppChannelName)
void	load_channels (FILE *fp)
void	purge_comsystem (void)
void	save_channels (FILE *fp)
comsys_t *	create_new_comsys (void)
static comsys_t *	get_comsys (dbref which)
void	add_comsys (comsys_t *c)
void	del_comsys (dbref who)
void	destroy_comsys (comsys_t *c)
void	sort_com_aliases (comsys_t *c)
static char *	get_channel_from_alias (dbref player, char *alias)
void	load_comsystem (FILE *fp)
void	save_comsystem (FILE *fp)
static void	BuildChannelMessage (bool bSpoof, const char *pHeader, struct comuser *user, char *pPose, char **messNormal, char **messNoComtitle)
static void	do_processcom (dbref player, char *arg1, char *arg2)
void	SendChannelMessage (dbref executor, struct channel *ch, char *msgNormal, char *msgNoComtitle)
void	do_joinchannel (dbref player, struct channel *ch)
void	do_leavechannel (dbref player, struct channel *ch)
static void	do_comwho_line (dbref player, struct channel *ch, struct comuser *user)
void	do_comwho (dbref player, struct channel *ch)
void	do_comlast (dbref player, struct channel *ch, int arg)
static bool	do_chanlog (dbref player, char *channel, char *arg)
channel *	select_channel (char *channel)
comuser *	select_user (struct channel *ch, dbref player)
void	do_addcom (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *arg1, char *arg2)
void	do_delcom (dbref executor, dbref caller, dbref enactor, int key, char *arg1)
void	do_delcomchannel (dbref player, char *channel, bool bQuiet)
void	do_createchannel (dbref executor, dbref caller, dbref enactor, int key, char *channel)
void	do_destroychannel (dbref executor, dbref caller, dbref enactor, int key, char *channel)
static void	do_listchannels (dbref player)
void	do_comtitle (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *arg1, char *arg2)
void	do_comlist (dbref executor, dbref caller, dbref enactor, int key, char *pattern)
void	do_channelnuke (dbref player)
void	do_clearcom (dbref executor, dbref caller, dbref enactor, int unused2)
void	do_allcom (dbref executor, dbref caller, dbref enactor, int key, char *arg1)
void	sort_users (struct channel *ch)
void	do_channelwho (dbref executor, dbref caller, dbref enactor, int key, char *arg1)
static void	do_comdisconnectraw_notify (dbref player, char *chan)
static void	do_comconnectraw_notify (dbref player, char *chan)
static void	do_comconnectchannel (dbref player, char *channel, char *alias, int i)
void	do_comdisconnect (dbref player)
void	do_comconnect (dbref player)
void	do_comdisconnectchannel (dbref player, char *channel)
void	do_editchannel (dbref executor, dbref caller, dbref enactor, int flag, int nargs, char *arg1, char *arg2)
bool	test_join_access (dbref player, struct channel *chan)
bool	test_transmit_access (dbref player, struct channel *chan)
bool	test_receive_access (dbref player, struct channel *chan)
bool	do_comsystem (dbref who, char *cmd)
void	do_cemit (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *chan, char *text)
void	do_chopen (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *chan, char *value)
void	do_chboot (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *channel, char *victim)
void	do_cheader (dbref player, char *channel, char *header)
static int DCL_CDECL	chanlist_comp (const void *a, const void *b)
void	do_chanlist (dbref executor, dbref caller, dbref enactor, int key, char *pattern)
	FUNCTION (fun_comtitle)
	FUNCTION (fun_comalias)
	FUNCTION (fun_channels)
Variables
static int	num_channels
static comsys_t *	comsys_table [NUM_COMSYS]

---

Define Documentation

#define DFLT_MAX_LOG   0

Definition at line 23 of file comsys.cpp.

Referenced by SendChannelMessage().

#define DFLT_RECALL_REQUEST   10

Definition at line 25 of file comsys.cpp.

Referenced by do_processcom().

#define MAX_ALIASES_PER_PLAYER   50

Definition at line 1460 of file comsys.cpp.

Referenced by do_addcom().

#define MAX_RECALL_REQUEST   200

Definition at line 26 of file comsys.cpp.

Referenced by do_chanlog(), do_chopen(), do_comlast(), and SendChannelMessage().

#define MAX_SUPPORTED_NUM_ENTRIES   10000

Referenced by do_chanlist().

#define MIN_RECALL_REQUEST   1

Definition at line 24 of file comsys.cpp.

Referenced by do_comlast().

---

Function Documentation

void add_comsys

(

comsys_t *

c

)

Definition at line 398 of file comsys.cpp.

References comsys_table, statedata::db_top, ENDLINE, Log, mudstate, tagComsys::next, NUM_COMSYS, CLogFile::tinyprintf(), and tagComsys::who.

Referenced by get_comsys(), and load_channels().

{
    if (c->who < 0 || c->who >= mudstate.db_top)
    {
        Log.tinyprintf("add_comsys: dbref %d out of range [0, %d)" ENDLINE, c->who, mudstate.db_top);
        return;
    }

    c->next = comsys_table[c->who % NUM_COMSYS];
    comsys_table[c->who % NUM_COMSYS] = c;
}

static void BuildChannelMessage	(	bool	bSpoof,
		const char *	pHeader,
		struct comuser *	user,
		char *	pPose,
		char **	messNormal,
		char **	messNoComtitle
	)			[static]

Definition at line 807 of file comsys.cpp.

References alloc_lbuf, comuser::ComTitleStatus, EV_EVAL, EV_FCHECK, EV_TOP, confdata::eval_comtitle, free_lbuf, LBUF_SIZE, modSpeech(), Moniker(), mudconf, mux_exec(), safe_chr, safe_str, comuser::title, and comuser::who.

Referenced by do_chboot(), do_comconnectraw_notify(), do_comdisconnectraw_notify(), do_delcomchannel(), do_joinchannel(), do_leavechannel(), and do_processcom().

{
    // Allocate necessary buffers.
    //
    *messNormal = alloc_lbuf("BCM.messNormal");
    *messNoComtitle = NULL;
    if (!bSpoof)
    {
        *messNoComtitle = alloc_lbuf("BCM.messNoComtitle");
    }

    // Comtitle Check
    //
    bool hasComTitle = (user->title[0] != '\0');

    char *mnptr  = *messNormal;     // Message without comtitle removal
    char *mncptr = *messNoComtitle; // Message with comtitle removal

    safe_str(pHeader, *messNormal, &mnptr);
    safe_chr(' ', *messNormal, &mnptr);
    if (!bSpoof)
    {
        safe_str(pHeader, *messNoComtitle, &mncptr);
        safe_chr(' ', *messNoComtitle, &mncptr);
    }

    // Don't evaluate a title if there isn't one to parse or evaluation of
    // comtitles is disabled.
    // If they're set spoof, ComTitleStatus doesn't matter.
    if (hasComTitle && (user->ComTitleStatus || bSpoof))
    {
        if (mudconf.eval_comtitle)
        {
            // Evaluate the comtitle as code.
            //
            char TempToEval[LBUF_SIZE];
            strcpy(TempToEval, user->title);
            char *q = TempToEval;
            mux_exec(*messNormal, &mnptr, user->who, user->who, user->who,
                EV_FCHECK | EV_EVAL | EV_TOP, &q, (char **)NULL, 0);
        }
        else
        {
            safe_str(user->title, *messNormal, &mnptr);
        }
        if (!bSpoof)
        {
            safe_chr(' ', *messNormal, &mnptr);
            safe_str(Moniker(user->who), *messNormal, &mnptr);
            safe_str(Moniker(user->who), *messNoComtitle, &mncptr);
        }
    }
    else
    {
        safe_str(Moniker(user->who), *messNormal, &mnptr);
        if (!bSpoof)
        {
            safe_str(Moniker(user->who), *messNoComtitle, &mncptr);
        }
    }

    char *saystring = NULL;
    char *newPose = NULL;

    switch(pPose[0])
    {
    case ':':
        pPose++;
        newPose = modSpeech(user->who, pPose, true, "channel/pose");
        if (newPose)
        {
            pPose = newPose;
        }
        safe_chr(' ', *messNormal, &mnptr);
        safe_str(pPose, *messNormal, &mnptr);
        if (!bSpoof)
        {
            safe_chr(' ', *messNoComtitle, &mncptr);
            safe_str(pPose, *messNoComtitle, &mncptr);
        }
        break;

    case ';':
        pPose++;
        newPose = modSpeech(user->who, pPose, true, "channel/pose");
        if (newPose)
        {
            pPose = newPose;
        }
        safe_str(pPose, *messNormal, &mnptr);
        if (!bSpoof)
        {
            safe_str(pPose, *messNoComtitle, &mncptr);
        }
        break;

    default:
        newPose = modSpeech(user->who, pPose, true, "channel");
        if (newPose)
        {
            pPose = newPose;
        }
        saystring = modSpeech(user->who, pPose, false, "channel");
        if (saystring)
        {
            safe_chr(' ', *messNormal, &mnptr);
            safe_str(saystring, *messNormal, &mnptr);
            safe_str(" \"", *messNormal, &mnptr);
        }
        else
        {
            safe_str(" says, \"", *messNormal, &mnptr);
        }
        safe_str(pPose, *messNormal, &mnptr);
        safe_chr('"', *messNormal, &mnptr);
        if (!bSpoof)
        {
            if (saystring)
            {
                safe_chr(' ', *messNoComtitle, &mncptr);
                safe_str(saystring, *messNoComtitle, &mncptr);
                safe_str(" \"", *messNoComtitle, &mncptr);
            }
            else
            {
                safe_str(" says, \"", *messNoComtitle, &mncptr);
            }
            safe_str(pPose, *messNoComtitle, &mncptr);
            safe_chr('"', *messNoComtitle, &mncptr);
        }
        break;
    }
    *mnptr = '\0';
    if (!bSpoof)
    {
        *mncptr = '\0';
    }
    if (newPose)
    {
        free_lbuf(newPose);
    }
    if (saystring)
    {
        free_lbuf(saystring);
    }
}

static int DCL_CDECL chanlist_comp	(	const void *	a,
		const void *	b
	)			[static]

Definition at line 2935 of file comsys.cpp.

References mux_stricmp(), and chanlist_node::name.

Referenced by do_chanlist().

{
    chanlist_node* ca = (chanlist_node*)a;
    chanlist_node* cb = (chanlist_node*)b;
    return mux_stricmp(ca->name, cb->name);
}

comsys_t* create_new_comsys

(

void

)

Definition at line 363 of file comsys.cpp.

References tagComsys::alias, tagComsys::channels, ISOUTOFMEMORY, tagComsys::maxchannels, MEMALLOC, tagComsys::next, NOTHING, tagComsys::numchannels, and tagComsys::who.

Referenced by get_comsys(), and load_channels().

{
    comsys_t *c = (comsys_t *)MEMALLOC(sizeof(comsys_t));
    ISOUTOFMEMORY(c);

    c->who         = NOTHING;
    c->numchannels = 0;
    c->maxchannels = 0;
    c->alias       = NULL;
    c->channels    = NULL;
    c->next        = NULL;
    return c;
}

void del_comsys

(

dbref

who

)

Definition at line 410 of file comsys.cpp.

References comsys_table, statedata::db_top, destroy_comsys(), ENDLINE, Log, mudstate, tagComsys::next, NUM_COMSYS, CLogFile::tinyprintf(), and tagComsys::who.

Referenced by purge_comsystem(), and ReleaseAllResources().

{
    if (who < 0 || who >= mudstate.db_top)
    {
        Log.tinyprintf("del_comsys: dbref %d out of range [0, %d)" ENDLINE, who, mudstate.db_top);
        return;
    }

    comsys_t *c = comsys_table[who % NUM_COMSYS];

    if (c == NULL)
    {
        return;
    }

    if (c->who == who)
    {
        comsys_table[who % NUM_COMSYS] = c->next;
        destroy_comsys(c);
        return;
    }
    comsys_t *last = c;
    c = c->next;
    while (c)
    {
        if (c->who == who)
        {
            last->next = c->next;
            destroy_comsys(c);
            return;
        }
        last = c;
        c = c->next;
    }
}

void destroy_comsys

(

comsys_t *

c

)

Definition at line 446 of file comsys.cpp.

References tagComsys::alias, tagComsys::channels, MEMFREE, and tagComsys::numchannels.

Referenced by del_comsys().

{
    int i;

    if (c->alias)
    {
        MEMFREE(c->alias);
        c->alias = NULL;
    }
    for (i = 0; i < c->numchannels; i++)
    {
        MEMFREE(c->channels[i]);
        c->channels[i] = NULL;
    }
    if (c->channels)
    {
        MEMFREE(c->channels);
        c->channels = NULL;
    }
    MEMFREE(c);
    c = NULL;
}

void do_addcom	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	arg1,
		char *	arg2
	)

Definition at line 1463 of file comsys.cpp.

References tagComsys::alias, ALIAS_SIZE, ANSI_ENDGOAL_NORMAL, ANSI_TruncateToField(), tagComsys::channels, get_comsys(), confdata::have_comsys, ISOUTOFMEMORY, MakeCanonicalComAlias(), MAX_ALIASES_PER_PLAYER, MAX_CHANNEL_LEN, tagComsys::maxchannels, MEMALLOC, MEMFREE, mudconf, tagComsys::numchannels, raw_notify(), select_channel(), test_join_access(), tprintf(), and UNUSED_PARAMETER.

Referenced by CGuests::AddToGuestChannel(), and AddToPublicChannel().

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

    if (!mudconf.have_comsys)
    {
        raw_notify(executor, "Comsys disabled.");
        return;
    }
    bool bValidAlias;
    int  nValidAlias;
    char *pValidAlias = MakeCanonicalComAlias(arg1, &nValidAlias, &bValidAlias);
    if (!bValidAlias)
    {
        raw_notify(executor, "You need to specify a valid alias.");
        return;
    }
    char *s = arg2;
    if (!*s)
    {
        raw_notify(executor, "You need to specify a channel.");
        return;
    }
    char channel[MAX_CHANNEL_LEN+1];
    char *t = channel;
    while (*s && ((t - channel) < MAX_CHANNEL_LEN))
    {
        if (*s != ' ')
            *t++ = *s++;
        else
            s++;
    }
    *t = '\0';

    int i, j, where;
    char *na;
    char **nc;
    struct channel *ch = select_channel(channel);
    char Buffer[MAX_CHANNEL_LEN+1];
    if (!ch)
    {
        int nVisualWidth;
        ANSI_TruncateToField(channel, sizeof(Buffer), Buffer, sizeof(Buffer), &nVisualWidth, ANSI_ENDGOAL_NORMAL);
        raw_notify(executor, tprintf("Channel %s does not exist yet.", Buffer));
        return;
    }
    if (!test_join_access(executor, ch))
    {
        raw_notify(executor, "Sorry, this channel type does not allow you to join.");
        return;
    }
    comsys_t *c = get_comsys(executor);
    if (c->numchannels >= MAX_ALIASES_PER_PLAYER)
    {
        raw_notify(executor, tprintf("Sorry, but you have reached the maximum number of aliases allowed."));
        return;
    }
    for (j = 0; j < c->numchannels && (strcmp(pValidAlias, c->alias + j * ALIAS_SIZE) > 0); j++)
    {
        ; // Nothing.
    }
    if (j < c->numchannels && !strcmp(pValidAlias, c->alias + j * ALIAS_SIZE))
    {
        char *p = tprintf("That alias is already in use for channel %s.", c->channels[j]);
        raw_notify(executor, p);
        return;
    }
    if (c->numchannels >= c->maxchannels)
    {
        c->maxchannels += 10;

        na = (char *)MEMALLOC(ALIAS_SIZE * c->maxchannels);
        ISOUTOFMEMORY(na);
        nc = (char **)MEMALLOC(sizeof(char *) * c->maxchannels);
        ISOUTOFMEMORY(nc);

        for (i = 0; i < c->numchannels; i++)
        {
            strcpy(na + i * ALIAS_SIZE, c->alias + i * ALIAS_SIZE);
            nc[i] = c->channels[i];
        }
        if (c->alias)
        {
            MEMFREE(c->alias);
            c->alias = NULL;
        }
        if (c->channels)
        {
            MEMFREE(c->channels);
            c->channels = NULL;
        }
        c->alias = na;
        c->channels = nc;
    }
    where = c->numchannels++;
    for (i = where; i > j; i--)
    {
        strcpy(c->alias + i * ALIAS_SIZE, c->alias + (i - 1) * ALIAS_SIZE);
        c->channels[i] = c->channels[i - 1];
    }

    where = j;
    memcpy(c->alias + where * ALIAS_SIZE, pValidAlias, nValidAlias);
    *(c->alias + where * ALIAS_SIZE + nValidAlias) = '\0';
    c->channels[where] = StringClone(channel);

    if (!select_user(ch, executor))
    {
        do_joinchannel(executor, ch);
    }

    raw_notify(executor, tprintf("Channel %s added with alias %s.", channel, pValidAlias));
}

void do_allcom	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	arg1
	)

Definition at line 2134 of file comsys.cpp.

References tagComsys::channels, do_processcom(), get_comsys(), confdata::have_comsys, mudconf, tagComsys::numchannels, raw_notify(), and UNUSED_PARAMETER.

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

    if (!mudconf.have_comsys)
    {
        raw_notify(executor, "Comsys disabled.");
        return;
    }
    if (  strcmp(arg1, "who") != 0
       && strcmp(arg1, "on")  != 0
       && strcmp(arg1, "off") != 0)
    {
        raw_notify(executor, "Only options available are: on, off and who.");
        return;
    }

    comsys_t *c = get_comsys(executor);
    int i;
    for (i = 0; i < c->numchannels; i++)
    {
        do_processcom(executor, c->channels[i], arg1);
        if (strcmp(arg1, "who") == 0)
        {
            raw_notify(executor, "");
        }
    }
}

void do_cemit	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		int	nargs,
		char *	chan,
		char *	text
	)

Definition at line 2643 of file comsys.cpp.

References alloc_lbuf, CEMIT_NOHEADER, channel::charge_who, Comm_All, Controls, confdata::have_comsys, channel::header, mudconf, NOPERM_MESSAGE, raw_notify(), select_channel(), SendChannelMessage(), tprintf(), and UNUSED_PARAMETER.

Referenced by FUNCTION().

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

    if (!mudconf.have_comsys)
    {
        raw_notify(executor, "Comsys disabled.");
        return;
    }
    struct channel *ch = select_channel(chan);
    if (!ch)
    {
        raw_notify(executor, tprintf("Channel %s does not exist.", chan));
        return;
    }
    if (  !Controls(executor, ch->charge_who)
       && !Comm_All(executor))
    {
        raw_notify(executor, NOPERM_MESSAGE);
        return;
    }
    char *text2 = alloc_lbuf("do_cemit");
    if (key == CEMIT_NOHEADER)
    {
        strcpy(text2, text);
    }
    else
    {
        strcpy(text2, tprintf("%s %s", ch->header, text));
    }
    SendChannelMessage(executor, ch, text2, text2);
}

void do_chanlist	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	key,
		char *	pattern
	)

Definition at line 2943 of file comsys.cpp.

References A_DESC, alloc_mbuf, ANSI_TruncateAndPad_sbuf(), atr_pget, channel::chan_obj, chanlist_comp(), statedata::channel_htab, CHANNEL_LOUD, CHANNEL_PUBLIC, CHANNEL_SPOOF, channel::charge_who, CLIST_FULL, CLIST_HEADERS, Comm_All, Controls, do_listchannels(), free_lbuf, free_sbuf, CHashTable::GetEntryCount(), hash_firstentry(), hash_nextentry(), confdata::have_comsys, channel::header, ISOUTOFMEMORY, MAX_SUPPORTED_NUM_ENTRIES, MEMALLOC, Moniker(), mudconf, mudstate, channel::name, chanlist_node::name, NOTHING, chanlist_node::ptr, quick_wild(), raw_notify(), channel::type, and UNUSED_PARAMETER.

Referenced by do_chopen().

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);

    if (!mudconf.have_comsys)
    {
        raw_notify(executor, "Comsys disabled.");
        return;
    }
    if (key & CLIST_FULL)
    {
        do_listchannels(executor);
        return;
    }

    dbref owner;
    struct channel *ch;
    int flags = 0;
    char *atrstr;
    char *temp = alloc_mbuf("do_chanlist_temp");
    char *buf = alloc_mbuf("do_chanlist_buf");

    if (key & CLIST_HEADERS)
    {
        raw_notify(executor, "*** Channel       Owner           Header");
    }
    else
    {
        raw_notify(executor, "*** Channel       Owner           Description");
    }

    bool bWild;
    if (  NULL != pattern
       && '\0' != *pattern)
    {
        bWild = true;
    }
    else
    {
        bWild = false;
    }

#define MAX_SUPPORTED_NUM_ENTRIES 10000

    INT64 iEntryCount64 = mudstate.channel_htab.GetEntryCount();
    if (MAX_SUPPORTED_NUM_ENTRIES < iEntryCount64)
    {
        // Nobody should have so many channels.
        //
        iEntryCount64 = MAX_SUPPORTED_NUM_ENTRIES;
    }
    size_t entries = (size_t)iEntryCount64;

    struct chanlist_node* charray = (chanlist_node*)MEMALLOC(sizeof(chanlist_node)*entries);
    ISOUTOFMEMORY(charray);

    // Arrayify all the channels
    //
    size_t  actualEntries;
    for (  actualEntries = 0, ch = (struct channel *)hash_firstentry(&mudstate.channel_htab);
           ch
        && actualEntries < entries;
           ch = (struct channel *)hash_nextentry(&mudstate.channel_htab))
    {
            if (  !bWild
               || quick_wild(pattern, ch->name))
            {
                charray[actualEntries].name = ch->name;
                charray[actualEntries].ptr = ch;
                actualEntries++;
            }
    }

    qsort(charray, actualEntries, sizeof(struct chanlist_node), chanlist_comp);

    for (size_t i = 0; i < actualEntries; i++)
    {
        ch = charray[i].ptr;
        if (  Comm_All(executor)
           || (ch->type & CHANNEL_PUBLIC)
           || Controls(executor, ch->charge_who))
        {
            char *pBuffer;
            if (key & CLIST_HEADERS)
            {
                pBuffer = ch->header;
            }
            else
            {
                atrstr = atr_pget(ch->chan_obj, A_DESC, &owner, &flags);
                if (  NOTHING == ch->chan_obj
                   || !*atrstr)
                {
                    strcpy(buf, "No description.");
                }
                else
                {
                    sprintf(buf, "%-54.54s", atrstr);
                }
                free_lbuf(atrstr);

                pBuffer = buf;
            }

            char *ownername_ansi = ANSI_TruncateAndPad_sbuf(Moniker(ch->charge_who), 15);
            sprintf(temp, "%c%c%c %-13.13s %s %-45.45s",
                (ch->type & (CHANNEL_PUBLIC)) ? 'P' : '-',
                (ch->type & (CHANNEL_LOUD)) ? 'L' : '-',
                (ch->type & (CHANNEL_SPOOF)) ? 'S' : '-',
                ch->name, ownername_ansi, pBuffer);
            free_sbuf(ownername_ansi);

            raw_notify(executor, temp);
        }
    }
    MEMFREE(charray);
    free_mbuf(temp);
    free_mbuf(buf);
    raw_notify(executor, "-- End of list of Channels --");
}

static bool do_chanlog	(	dbref	player,
		char *	channel,
		char *	arg
	)			[static]

Definition at line 1355 of file comsys.cpp.

References AF_CONST, AF_NOPARSE, AF_NOPROG, atr_add(), atr_clr(), atr_get, atr_str(), channel::chan_obj, free_lbuf, GOD, Good_obj, is_integer(), MAX_RECALL_REQUEST, mkattr(), mux_atol(), mux_ltoa_t(), select_channel(), tprintf(), and UNUSED_PARAMETER.

Referenced by do_chopen().

{
    UNUSED_PARAMETER(player);

    int value;
    if (  !*arg
       || !is_integer(arg, NULL)
       || (value = mux_atol(arg)) > MAX_RECALL_REQUEST)
    {
        return false;
    }
    if (value < 0)
    {
        value = 0;
    }
    struct channel *ch = select_channel(channel);
    if (!Good_obj(ch->chan_obj))
    {
        // No channel object has been set.
        //
        return false;
    }
    int atr = mkattr(GOD, "MAX_LOG");
    if (atr <= 0)
    {
        return false;
    }
    dbref aowner;
    int aflags;
    char *oldvalue = atr_get(ch->chan_obj, atr, &aowner, &aflags);
    if (oldvalue)
    {
        int oldnum = mux_atol(oldvalue);
        if (oldnum > value)
        {
            ATTR *hist;
            for (int count = 0; count <= oldnum; count++)
            {
                hist = atr_str(tprintf("HISTORY_%d", count));
                if (hist)
                {
                    atr_clr(ch->chan_obj, hist->number);
                }
            }
        }
        free_lbuf(oldvalue);
    }
    atr_add(ch->chan_obj, atr, mux_ltoa_t(value), GOD,
        AF_CONST|AF_NOPROG|AF_NOPARSE);
    return true;
}

void do_channelnuke

(

dbref

player

)

Definition at line 2090 of file comsys.cpp.

References statedata::channel_htab, channel::charge_who, hash_firstentry(), hash_nextentry(), hashdeleteLEN(), MEMFREE, mudstate, channel::name, num_channels, channel::num_users, and channel::users.

Referenced by ReleaseAllResources().

{
    struct channel *ch;
    int j;

    for (ch = (struct channel *)hash_firstentry(&mudstate.channel_htab);
         ch; ch = (struct channel *)hash_nextentry(&mudstate.channel_htab))
    {
        if (player == ch->charge_who)
        {
            num_channels--;
            hashdeleteLEN(ch->name, strlen(ch->name), &mudstate.channel_htab);

            for (j = 0; j < ch->num_users; j++)
            {
                MEMFREE(ch->users[j]);
                ch->users[j] = NULL;
            }
            MEMFREE(ch->users);
            ch->users = NULL;
            MEMFREE(ch);
            ch = NULL;
        }
    }
}