mux/src/comsys.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	chanentry
struct	comuser
struct	channel
struct	tagComsys
Defines
#define	NUM_COMSYS   500
#define	MAX_CHANNEL_LEN   50
#define	MAX_HEADER_LEN   100
#define	MAX_TITLE_LEN   200
#define	MAX_ALIAS_LEN   5
#define	ALIAS_SIZE   (MAX_ALIAS_LEN+1)
#define	CHANNEL_PLAYER_JOIN   (0x00000001UL)
#define	CHANNEL_PLAYER_TRANSMIT   (0x00000002UL)
#define	CHANNEL_PLAYER_RECEIVE   (0x00000004UL)
#define	CHANNEL_OBJECT_JOIN   (0x00000010UL)
#define	CHANNEL_OBJECT_TRANSMIT   (0x00000020UL)
#define	CHANNEL_OBJECT_RECEIVE   (0x00000040UL)
#define	CHANNEL_LOUD   (0x00000100UL)
#define	CHANNEL_PUBLIC   (0x00000200UL)
#define	CHANNEL_SPOOF   (0x00000400UL)
#define	UNDEAD(x)   (Good_obj(x) && ((Typeof(x) != TYPE_PLAYER) || Connected(x)))
Typedefs
typedef chanentry	CHANENT
typedef tagComsys	comsys_t
Functions
void	save_comsys (char *filename)
void	load_comsys (char *filename)
void	del_comsys (dbref who)
void	add_comsys (comsys_t *c)
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)
void	do_joinchannel (dbref player, struct channel *ch)
void	do_comdisconnectchannel (dbref player, char *channel)
void	load_channels (FILE *fp)
void	purge_comsystem (void)
void	save_channels (FILE *fp)
void	destroy_comsys (comsys_t *c)
void	sort_com_aliases (comsys_t *c)
void	load_comsystem (FILE *fp)
void	save_comsystem (FILE *fp)
void	SendChannelMessage (dbref player, struct channel *ch, char *msgNormal, char *msgNoComtitle)
void	do_comwho (dbref player, struct channel *ch)
void	do_comlast (dbref player, struct channel *ch, int arg)
void	do_leavechannel (dbref player, struct channel *ch)
void	do_delcomchannel (dbref player, char *channel, bool bQuiet)
void	do_channelnuke (dbref player)
void	sort_users (struct channel *ch)
void	do_comdisconnect (dbref player)
void	do_comconnect (dbref player)
void	do_clearcom (dbref executor, dbref caller, dbref enactor, int unused2)
void	do_cheader (dbref player, char *channel, char *header)
void	do_addcom (dbref executor, dbref caller, dbref enactor, int key, int nargs, char *arg1, char *arg2)
comsys_t *	create_new_comsys ()
channel *	select_channel (char *channel)
comuser *	select_user (struct channel *ch, dbref player)
char *	get_channel_from_alias ()
bool	do_comsystem (dbref who, char *cmd)
void	do_chanlist (dbref executor, dbref caller, dbref enactor, int key, char *pattern)

---

Define Documentation

#define ALIAS_SIZE   (MAX_ALIAS_LEN+1)

Definition at line 22 of file comsys.h.

Referenced by do_addcom(), do_clearcom(), do_comconnectchannel(), do_comlist(), do_delcom(), FUNCTION(), get_channel_from_alias(), load_channels(), MakeCanonicalComAlias(), save_channels(), and sort_com_aliases().

#define CHANNEL_LOUD   (0x00000100UL)

Definition at line 126 of file comsys.h.

Referenced by do_chanlist(), do_chopen(), do_comconnectraw_notify(), do_comdisconnectraw_notify(), and do_listchannels().

#define CHANNEL_OBJECT_JOIN   (0x00000010UL)

Definition at line 123 of file comsys.h.

Referenced by do_editchannel(), do_listchannels(), and test_join_access().

#define CHANNEL_OBJECT_RECEIVE   (0x00000040UL)

Definition at line 125 of file comsys.h.

Referenced by do_editchannel(), do_listchannels(), and test_receive_access().

#define CHANNEL_OBJECT_TRANSMIT   (0x00000020UL)

Definition at line 124 of file comsys.h.

Referenced by do_editchannel(), do_listchannels(), and test_transmit_access().

#define CHANNEL_PLAYER_JOIN   (0x00000001UL)

Definition at line 120 of file comsys.h.

Referenced by do_editchannel(), do_listchannels(), and test_join_access().

#define CHANNEL_PLAYER_RECEIVE   (0x00000004UL)

Definition at line 122 of file comsys.h.

Referenced by do_editchannel(), do_listchannels(), and test_receive_access().

#define CHANNEL_PLAYER_TRANSMIT   (0x00000002UL)

Definition at line 121 of file comsys.h.

Referenced by do_editchannel(), do_listchannels(), and test_transmit_access().

#define CHANNEL_PUBLIC   (0x00000200UL)

Definition at line 127 of file comsys.h.

Referenced by do_chanlist(), do_chopen(), do_listchannels(), FUNCTION(), and load_comsystem().

#define CHANNEL_SPOOF   (0x00000400UL)

Definition at line 128 of file comsys.h.

Referenced by do_chanlist(), do_chboot(), do_chopen(), do_comconnectraw_notify(), do_comdisconnectraw_notify(), do_comtitle(), do_comwho_line(), do_delcomchannel(), do_joinchannel(), do_leavechannel(), do_listchannels(), do_processcom(), and SendChannelMessage().

#define MAX_ALIAS_LEN   5

Definition at line 21 of file comsys.h.

Referenced by MakeCanonicalComAlias().

#define MAX_CHANNEL_LEN   50

Definition at line 18 of file comsys.h.

Referenced by do_addcom(), do_channelwho(), do_comtitle(), do_createchannel(), and load_comsystem().

#define MAX_HEADER_LEN   100

Definition at line 19 of file comsys.h.

Referenced by do_cheader(), do_createchannel(), and load_comsystem().

#define MAX_TITLE_LEN   200

Definition at line 20 of file comsys.h.

Referenced by load_comsystem(), and RestrictTitleValue().

#define NUM_COMSYS   500

Definition at line 16 of file comsys.h.

Referenced by add_comsys(), del_comsys(), get_comsys(), load_comsys(), purge_comsystem(), and save_channels().

#define UNDEAD

(

x

)

(Good_obj(x) && ((Typeof(x) != TYPE_PLAYER) || Connected(x)))

Definition at line 132 of file comsys.h.

Referenced by do_channelwho(), and do_joinchannel().

---

Typedef Documentation

typedef struct chanentry CHANENT

Definition at line 9 of file comsys.h.

typedef struct tagComsys comsys_t

---

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;
}

comsys_t* create_new_comsys

(

)

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_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, chanlist_node::name, channel::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 --");
}

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;
        }
    }
}

void do_cheader	(	dbref	player,
		char *	channel,
		char *	header
	)

Definition at line 2903 of file comsys.cpp.

References ANSI_ENDGOAL_NORMAL, ANSI_TruncateToField(), channel::charge_who, Comm_All, Controls, channel::header, MAX_HEADER_LEN, NOPERM_MESSAGE, raw_notify(), RemoveSetOfCharacters(), and select_channel().

Referenced by do_chopen().

{
    struct channel *ch = select_channel(channel);
    if (!ch)
    {
        raw_notify(player, "That channel does not exist.");
        return;
    }
    if (  !Controls(player, ch->charge_who)
       && !Comm_All(player))
    {
        raw_notify(player, NOPERM_MESSAGE);
        return;
    }
    char *p = RemoveSetOfCharacters(header, "\r\n\t");

    // Optimize/terminate any ANSI in the string.
    //
    char NewHeader_ANSI[MAX_HEADER_LEN+1];
    int nVisualWidth;
    int nLen = ANSI_TruncateToField(p, sizeof(NewHeader_ANSI),
        NewHeader_ANSI, sizeof(NewHeader_ANSI), &nVisualWidth,
        ANSI_ENDGOAL_NORMAL);
    memcpy(ch->header, NewHeader_ANSI, nLen+1);
}

void do_clearcom	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	unused2
	)

Definition at line 2116 of file comsys.cpp.

References tagComsys::alias, ALIAS_SIZE, do_delcom(), get_comsys(), confdata::have_comsys, mudconf, tagComsys::numchannels, raw_notify(), and UNUSED_PARAMETER.

Referenced by ReleaseAllResources().

{
    UNUSED_PARAMETER(unused2);

    if (!mudconf.have_comsys)
    {
        raw_notify(executor, "Comsys disabled.");
        return;
    }
    comsys_t *c = get_comsys(executor);

    int i;
    for (i = (c->numchannels) - 1; i > -1; --i)
    {
        do_delcom(executor, caller, enactor, 0, c->alias + i * ALIAS_SIZE);
    }
}

void do_comconnect

(

dbref

player

)

Definition at line 2349 of file comsys.cpp.

References tagComsys::alias, tagComsys::channels, do_comconnectchannel(), do_comconnectraw_notify(), get_comsys(), and tagComsys::numchannels.

Referenced by announce_connect().

{
    comsys_t *c = get_comsys(player);
    int i;

    for (i = 0; i < c->numchannels; i++)
    {
        char *CurrentChannel = c->channels[i];
        bool bFound = false;
        int j;

        for (j = 0; j < i; j++)
        {
            if (strcmp(c->channels[j], CurrentChannel) == 0)
            {
                bFound = true;
                break;
            }
        }

        if (!bFound)
        {
            do_comconnectchannel(player, CurrentChannel, c->alias, i);
            do_comconnectraw_notify(player, CurrentChannel);
        }
    }
}

void do_comdisconnect

(

dbref

player

)

Definition at line 2321 of file comsys.cpp.

References tagComsys::channels, do_comdisconnectchannel(), do_comdisconnectraw_notify(), get_comsys(), and tagComsys::numchannels.

Referenced by announce_disconnect(), and ReleaseAllResources().

{
    comsys_t *c = get_comsys(player);
    int i;

    for (i = 0; i < c->numchannels; i++)
    {
        char *CurrentChannel = c->channels[i];
        bool bFound = false;
        int j;

        for (j = 0; j < i; j++)
        {
            if (strcmp(c->channels[j], CurrentChannel) == 0)
            {
                bFound = true;
                break;
            }
        }

        if (!bFound)
        {
            do_comdisconnectchannel(player, CurrentChannel);
            do_comdisconnectraw_notify(player, CurrentChannel);
        }
    }
}

void do_comdisconnectchannel	(	dbref	player,
		char *	channel
	)

Definition at line 2378 of file comsys.cpp.

References comuser::on_next, channel::on_users, select_channel(), and comuser::who.

Referenced by do_comdisconnect(), do_comwho(), and do_delcomchannel().

{
    struct channel *ch = select_channel(channel);
    if (!ch)
    {
        return;
    }

    struct comuser *prevuser = NULL;
    struct comuser *user;
    for (user = ch->on_users; user;)
    {
        if (user->who == player)
        {
            if (prevuser)
            {
                prevuser->on_next = user->on_next;
            }
            else
            {
                ch->on_users = user->on_next;
            }
            return;
        }
        else
        {
            prevuser = user;
            user = user->on_next;
        }
    }
}

void do_comlast	(	dbref	player,
		struct channel *	ch,
		int	arg
	)

Definition at line 1304 of file comsys.cpp.

References atr_get, atr_get_info(), atr_str(), channel::chan_obj, free_lbuf, Good_obj, iMod(), MAX_RECALL_REQUEST, MIN_RECALL_REQUEST, mux_atol(), channel::num_messages, attr::number, raw_notify(), and tprintf().

Referenced by do_processcom().

{
    if (!Good_obj(ch->chan_obj))
    {
        raw_notify(player, "Channel does not have an object.");
        return;
    }
    dbref aowner;
    int aflags;
    dbref obj = ch->chan_obj;
    int logmax = MAX_RECALL_REQUEST;
    ATTR *pattr = atr_str("MAX_LOG");
    if (  pattr
       && (atr_get_info(obj, pattr->number, &aowner, &aflags)))
    {
        char *maxbuf = atr_get(obj, pattr->number, &aowner, &aflags);
        logmax = mux_atol(maxbuf);
        free_lbuf(maxbuf);
    }
    if (logmax < 1)
    {
        raw_notify(player, "Channel does not log.");
        return;
    }
    if (arg < MIN_RECALL_REQUEST)
    {
        arg = MIN_RECALL_REQUEST;
    }
    if (arg > logmax)
    {
        arg = logmax;
    }

    char *message;
    int histnum = ch->num_messages - arg;

    raw_notify(player, "-- Begin Comsys Recall --");
    for (int count = 0; count < arg; count++)
    {
        histnum++;
        pattr = atr_str(tprintf("HISTORY_%d", iMod(histnum, logmax)));
        if (pattr)
        {
            message = atr_get(obj, pattr->number, &aowner, &aflags);
            raw_notify(player, message);
            free_lbuf(message);
        }
    }
    raw_notify(player, "-- End Comsys Recall --");
}

bool do_comsystem	(	dbref	who,
		char *	cmd
	)

Definition at line 2610 of file comsys.cpp.

References alloc_lbuf, do_processcom(), free_lbuf, get_channel_from_alias(), and LBUF_SIZE.

Referenced by process_command().

{
    char *t;
    char *alias = alloc_lbuf("do_comsystem");
    char *s = alias;
    for (t = cmd; *t && *t != ' ' && s < alias + LBUF_SIZE; *s++ = *t++)
    {
        ; // Nothing.
    }

    *s = '\0';

    if (*t)
    {
        t++;
    }

    char *ch = get_channel_from_alias(who, alias);
    if (  ch[0] != '\0'
       && t[0] != '\0')
    {
        do_processcom(who, ch, t);
        free_lbuf(alias);
        return false;
    }
    else
    {
        free_lbuf(alias);
    }
    return true;
}

void do_comwho	(	dbref	player,
		struct channel *	ch
	)

Definition at line 1260 of file comsys.cpp.

References comuser::bUserIsOn, Connected, do_comdisconnectchannel(), do_comwho_line(), God, Going, Hidden, isPlayer, channel::name, comuser::on_next, channel::on_users, Owner, raw_notify(), See_Hidden, tprintf(), comuser::who, and Wizard_Who.

Referenced by do_processcom().

{
    struct comuser *user;

    raw_notify(player, "-- Players --");
    for (user = ch->on_users; user; user = user->on_next)
    {
        if (isPlayer(user->who))
        {
            if (  Connected(user->who)
               && (  !Hidden(user->who)
                  || Wizard_Who(player)
                  || See_Hidden(player)))
            {
                if (user->bUserIsOn)
                {
                    do_comwho_line(player, ch, user);
                }
            }
            else if (!Hidden(user->who))
            {
                do_comdisconnectchannel(user->who, ch->name);
            }
        }
    }
    raw_notify(player, "-- Objects --");
    for (user = ch->on_users; user; user = user->on_next)
    {
        if (!isPlayer(user->who))
        {
            if (  Going(user->who)
               && God(Owner(user->who)))
            {
                do_comdisconnectchannel(user->who, ch->name);
            }
            else if (user->bUserIsOn)
            {
                do_comwho_line(player, ch, user);
            }
        }
    }
    raw_notify(player, tprintf("-- %s --", ch->name));
}

void do_delcomchannel	(	dbref	player,
		char *	channel,
		bool	bQuiet
	)

Definition at line 1649 of file comsys.cpp.

References BuildChannelMessage(), comuser::bUserIsOn, CHANNEL_SPOOF, do_comdisconnectchannel(), channel::header, Hidden, MEMFREE, channel::num_users, raw_notify(), select_channel(), SendChannelMessage(), comuser::title, tprintf(), channel::type, channel::users, and comuser::who.

Referenced by do_chboot(), and do_delcom().

{
    struct comuser *user;

    struct channel *ch = select_channel(channel);
    if (!ch)
    {
        raw_notify(player, tprintf("Unknown channel %s.", channel));
    }
    else
    {
        int i;
        int j = 0;
        for (i = 0; i < ch->num_users && !j; i++)
        {
            user = ch->users[i];
            if (user->who == player)
            {
                do_comdisconnectchannel(player, channel);
                if (!bQuiet)
                {
                    if (  user->bUserIsOn
                       && !Hidden(player))
                    {
                        char *messNormal, *messNoComtitle;
                        BuildChannelMessage((ch->type & CHANNEL_SPOOF) != 0,
                                            ch->header, user, ":has left this channel.",
                                            &messNormal, &messNoComtitle);
                        SendChannelMessage(player, ch, messNormal, messNoComtitle);
                    }
                    raw_notify(player, tprintf("You have left channel %s.", channel));
                }

                if (user->title)
                {
                    MEMFREE(user->title);
                    user->title = NULL;
                }
                MEMFREE(user);
                user = NULL;
                j = 1;
            }
        }

        if (j)
        {
            ch->num_users--;
            for (i--; i < ch->num_users; i++)
            {
                ch->users[i] = ch->users[i + 1];
            }
        }
    }
}

void do_joinchannel	(	dbref	player,
		struct channel *	ch
	)

Definition at line 1129 of file comsys.cpp.

References BuildChannelMessage(), comuser::bUserIsOn, CHANNEL_SPOOF, comuser::ComTitleStatus, channel::header, Hidden, ISOUTOFMEMORY, channel::max_users, MEMALLOC, MEMFREE, channel::name, channel::num_users, comuser::on_next, channel::on_users, raw_notify(), select_user(), SendChannelMessage(), StringClone(), comuser::title, tprintf(), channel::type, UNDEAD, channel::users, and comuser::who.

Referenced by do_processcom(), and load_comsystem().

{
    struct comuser **cu;
    int i;

    struct comuser *user = select_user(ch, player);

    if (!user)
    {
        ch->num_users++;
        if (ch->num_users >= ch->max_users)
        {
            ch->max_users += 10;
            cu = (struct comuser **)MEMALLOC(sizeof(struct comuser *) * ch->max_users);
            ISOUTOFMEMORY(cu);

            for (i = 0; i < (ch->num_users - 1); i++)
            {
                cu[i] = ch->users[i];
            }
            MEMFREE(ch->users);
            ch->users = cu;
        }
        user = (struct comuser *)MEMALLOC(sizeof(struct comuser));
        ISOUTOFMEMORY(user);

        for (i = ch->num_users - 1; i > 0 && ch->users[i - 1]->who > player; i--)
        {
            ch->users[i] = ch->users[i - 1];
        }
        ch->users[i] = user;

        user->who            = player;
        user->bUserIsOn      = true;
        user->ComTitleStatus = true;
        user->title          = StringClone("");

        // if (Connected(player))&&(isPlayer(player))
        //
        if (UNDEAD(player))
        {
            user->on_next = ch->on_users;
            ch->on_users  = user;
        }
    }
    else if (!user->bUserIsOn)
    {
        user->bUserIsOn = true;
    }
    else
    {
        raw_notify(player, tprintf("You are already on channel %s.", ch->name));
        return;
    }

    if (!Hidden(player))
    {
        char *messNormal, *messNoComtitle;
        BuildChannelMessage((ch->type & CHANNEL_SPOOF) != 0, ch->header, user,
            ":has joined this channel.", &messNormal, &messNoComtitle);
        SendChannelMessage(player, ch, messNormal, messNoComtitle);
    }
}

void do_leavechannel	(	dbref	player,
		struct channel *	ch
	)

Definition at line 1193 of file comsys.cpp.

References BuildChannelMessage(), comuser::bUserIsOn, CHANNEL_SPOOF, channel::header, Hidden, channel::name, raw_notify(), select_user(), SendChannelMessage(), tprintf(), and channel::type.

Referenced by do_processcom().

{
    struct comuser *user = select_user(ch, player);
    raw_notify(player, tprintf("You have left channel %s.", ch->name));
    if (  user->bUserIsOn
       && !Hidden(player))
    {
        char *messNormal, *messNoComtitle;
        BuildChannelMessage((ch->type & CHANNEL_SPOOF) != 0, ch->header, user,
            ":has left this channel.", &messNormal, &messNoComtitle);
        SendChannelMessage(player, ch, messNormal, messNoComtitle);
    }
    user->bUserIsOn = false;
}

char* get_channel_from_alias

(

)

void load_channels

(

FILE *

fp

)

Definition at line 236 of file comsys.cpp.

References add_comsys(), tagComsys::alias, ALIAS_SIZE, tagComsys::channels, create_new_comsys(), ENDLINE, GetLineTrunc(), Good_obj, ISOUTOFMEMORY, LBUF_SIZE, Log, tagComsys::maxchannels, MEMALLOC, mux_assert, tagComsys::numchannels, ParseChannelLine(), purge_comsystem(), sort_com_aliases(), CLogFile::tinyprintf(), and tagComsys::who.

Referenced by load_comsys().

{
    int i, j;
    char buffer[LBUF_SIZE];
    comsys_t *c;

    int np = 0;
    int cc = fscanf(fp, "%d\n", &np);
    mux_assert(1 == cc);
    for (i = 0; i < np; i++)
    {
        c = create_new_comsys();
        c->who = 0;
        c->numchannels = 0;
        cc = fscanf(fp, "%d %d\n", &(c->who), &(c->numchannels));
        mux_assert(2 == cc);
        c->maxchannels = c->numchannels;
        if (c->maxchannels > 0)
        {
            c->alias = (char *)MEMALLOC(c->maxchannels * ALIAS_SIZE);
            ISOUTOFMEMORY(c->alias);
            c->channels = (char **)MEMALLOC(sizeof(char *) * c->maxchannels);
            ISOUTOFMEMORY(c->channels);

            for (j = 0; j < c->numchannels; j++)
            {
                int n = GetLineTrunc(buffer, sizeof(buffer), fp);
                if (buffer[n-1] == '\n')
                {
                    // Get rid of trailing '\n'.
                    //
                    n--;
                    buffer[n] = '\0';
                }
                if (!ParseChannelLine(buffer, c->alias + j * ALIAS_SIZE, c->channels+j))
                {
                    c->numchannels--;
                    j--;
                }
            }
            sort_com_aliases(c);
        }
        else
        {
            c->alias = NULL;
            c->channels = NULL;
        }
        if (Good_obj(c->who))
        {
            add_comsys(c);
        }
        else
        {
            Log.tinyprintf("Invalid dbref %d." ENDLINE, c->who);
        }
        purge_comsystem();
    }
}

void load_comsys

(

char *

filename

)

Definition at line 71 of file comsys.cpp.

References comsys_table, DebugTotalFiles, ENDLINE, load_channels(), load_comsystem(), Log, NUM_COMSYS, and CLogFile::tinyprintf().

Referenced by load_game().

{
    int i;
    char buffer[200];

    for (i = 0; i < NUM_COMSYS; i++)
    {
        comsys_table[i] = NULL;
    }

    FILE *fp = fopen(filename, "rb");
    if (!fp)
    {
        Log.tinyprintf("Error: Couldn't find %s." ENDLINE, filename);
    }
    else
    {
        DebugTotalFiles++;
        Log.tinyprintf("LOADING: %s" ENDLINE, filename);
        if (fscanf(fp, "*** Begin %s ***\n", buffer) == 1 && !strcmp(buffer, "CHANNELS"))
        {
            load_channels(fp);
        }
        else
        {
            Log.tinyprintf("Error: Couldn't find Begin CHANNELS in %s.", filename);
            if (fclose(fp) == 0)
            {
                DebugTotalFiles--;
            }
            return;
        }

        if (fscanf(fp, "*** Begin %s ***\n", buffer) == 1 && !strcmp(buffer, "COMSYS"))
        {
            load_comsystem(fp);
        }
        else
        {
            Log.tinyprintf("Error: Couldn't find Begin COMSYS in %s.", filename);
            if (fclose(fp) == 0)
            {
                DebugTotalFiles--;
            }
            return;
        }

        if (fclose(fp) == 0)
        {
            DebugTotalFiles--;
        }
        Log.tinyprintf("LOADING: %s (done)" ENDLINE, filename);
    }
}

void load_comsystem

(

FILE *

fp

)

Definition at line 525 of file comsys.cpp.

References ANSI_BLUE, ANSI_CYAN, ANSI_ENDGOAL_NORMAL, ANSI_HILITE, ANSI_MAGENTA, ANSI_NORMAL, ANSI_RED, ANSI_TruncateToField(), statedata::channel_htab, CHANNEL_PUBLIC, statedata::db_top, do_joinchannel(), ENDLINE, GetLineTrunc(), God, Going, Good_dbref, hashaddLEN(), isGarbage, ISOUTOFMEMORY, isPlayer, LBUF_SIZE, Log, MAX_CHANNEL_LEN, MAX_HEADER_LEN, MAX_TITLE_LEN, MEMALLOC, mudstate, mux_assert, mux_atol(), NOTHING, num_channels, comuser::on_next, Owner, sort_users(), StringCloneLen(), CLogFile::tinyprintf(), comuser::title, and comuser::who.

Referenced by load_comsys().

{
    int i, j, dummy;
    int ver = 0;
    struct channel *ch;
    char temp[LBUF_SIZE];

    num_channels = 0;

    int nc = 0;
    fgets(temp, sizeof(temp), fp);
    if (!strncmp(temp, "+V", 2))
    {
        // +V2 has colored headers
        //
        ver = mux_atol(temp + 2);
        if (ver < 1 || 3 < ver)
        {
            return;
        }
        int cc;
        cc = fscanf(fp, "%d\n", &nc);
        mux_assert(1 == cc);
    }
    else
    {
        nc = mux_atol(temp);
    }

    num_channels = nc;

    for (i = 0; i < nc; i++)
    {
        ch = (struct channel *)MEMALLOC(sizeof(struct channel));
        ISOUTOFMEMORY(ch);

        int nChannel = GetLineTrunc(temp, sizeof(temp), fp);
        if (nChannel > MAX_CHANNEL_LEN)
        {
            nChannel = MAX_CHANNEL_LEN;
        }
        if (temp[nChannel-1] == '\n')
        {
            // Get rid of trailing '\n'.
            //
            nChannel--;
        }
        memcpy(ch->name, temp, nChannel);
        ch->name[nChannel] = '\0';

        if (ver >= 2)
        {
            int nHeader = GetLineTrunc(temp, sizeof(temp), fp);
            if (nHeader > MAX_HEADER_LEN)
            {
                nHeader = MAX_HEADER_LEN;
            }
            if (temp[nHeader-1] == '\n')
            {
                nHeader--;
            }
            memcpy(ch->header, temp, nHeader);
            ch->header[nHeader] = '\0';
        }

        ch->on_users = NULL;

        hashaddLEN(ch->name, nChannel, ch, &mudstate.channel_htab);

        ch->type         = 127;
        ch->temp1        = 0;
        ch->temp2        = 0;
        ch->charge       = 0;
        ch->charge_who   = NOTHING;
        ch->amount_col   = 0;
        ch->num_messages = 0;
        ch->chan_obj     = NOTHING;

        int cc;
        if (ver >= 1)
        {
            cc = fscanf(fp, "%d %d %d %d %d %d %d %d\n",
                &(ch->type), &(ch->temp1), &(ch->temp2),
                &(ch->charge), &(ch->charge_who),
                &(ch->amount_col), &(ch->num_messages), &(ch->chan_obj));
            mux_assert(8 == cc);
        }
        else
        {
            cc = fscanf(fp, "%d %d %d %d %d %d %d %d %d %d\n",
                &(ch->type), &(dummy), &(ch->temp1), &(ch->temp2),
                &(dummy), &(ch->charge), &(ch->charge_who),
                &(ch->amount_col), &(ch->num_messages), &(ch->chan_obj));
            mux_assert(10 == cc);
        }

        if (ver <= 1)
        {
            // Build colored header if not +V2 or later db.
            //
            if (ch->type & CHANNEL_PUBLIC)
            {
                sprintf(temp, "%s[%s%s%s%s%s]%s", ANSI_CYAN, ANSI_HILITE,
                    ANSI_BLUE, ch->name, ANSI_NORMAL, ANSI_CYAN, ANSI_NORMAL);
            }
            else
            {
                sprintf(temp, "%s[%s%s%s%s%s]%s", ANSI_MAGENTA, ANSI_HILITE,
                    ANSI_RED, ch->name, ANSI_NORMAL, ANSI_MAGENTA,
                    ANSI_NORMAL);
            }
            int vwVisual;
            ANSI_TruncateToField(temp, MAX_HEADER_LEN+1, ch->header,
                MAX_HEADER_LEN+1, &vwVisual, ANSI_ENDGOAL_NORMAL);
        }

        ch->num_users = 0;
        cc =fscanf(fp, "%d\n", &(ch->num_users));
        mux_assert(1 == cc);
        ch->max_users = ch->num_users;
        if (ch->num_users > 0)
        {
            ch->users = (struct comuser **)calloc(ch->max_users, sizeof(struct comuser *));
            ISOUTOFMEMORY(ch->users);

            int jAdded = 0;
            for (j = 0; j < ch->num_users; j++)
            {
                struct comuser t_user;
                memset(&t_user, 0, sizeof(t_user));

                t_user.who = NOTHING;
                t_user.bUserIsOn = false;
                t_user.ComTitleStatus = false;

                int iUserIsOn;
                if (ver == 3)
                {
                    int iComTitleStatus;
                    cc = fscanf(fp, "%d %d %d\n", &(t_user.who), &iUserIsOn,
                        &iComTitleStatus);
                    mux_assert(3 == cc);
                    t_user.bUserIsOn = (iUserIsOn ? true : false);
                    t_user.ComTitleStatus = (iComTitleStatus ? true : false);
                }
                else
                {
                    t_user.ComTitleStatus = true;
                    if (ver)
                    {
                        cc = fscanf(fp, "%d %d\n", &(t_user.who), &iUserIsOn);
                        mux_assert(2 == cc);
                        t_user.bUserIsOn = (iUserIsOn ? true : false);
                    }
                    else
                    {
                        cc = fscanf(fp, "%d %d %d", &(t_user.who), &(dummy), &(dummy));
                        mux_assert(3 == cc);
                        cc = fscanf(fp, "%d\n", &iUserIsOn);
                        mux_assert(1 == cc);
                        t_user.bUserIsOn = (iUserIsOn ? true : false);
                    }
                }

                // Read Comtitle.
                //
                int nTitle = GetLineTrunc(temp, sizeof(temp), fp);
                char *pTitle = temp;

                if (!Good_dbref(t_user.who))
                {
                    Log.tinyprintf("load_comsystem: dbref %d out of range [0, %d)." ENDLINE, t_user.who, mudstate.db_top);
                }
                else if (isGarbage(t_user.who))
                {
                    Log.tinyprintf("load_comsystem: dbref is GARBAGE." ENDLINE, t_user.who);
                }
                else
                {
                    // Validate comtitle
                    //
                    if (3 < nTitle && temp[0] == 't' && temp[1] == ':')
                    {
                        pTitle = temp+2;
                        nTitle -= 2;
                        if (pTitle[nTitle-1] == '\n')
                        {
                            // Get rid of trailing '\n'.
                            //
                            nTitle--;
                        }
                        if (nTitle <= 0 || MAX_TITLE_LEN < nTitle)
                        {
                            nTitle = 0;
                            pTitle = temp;
                        }
                    }
                    else
                    {
                        nTitle = 0;
                    }

                    struct comuser *user = (struct comuser *)MEMALLOC(sizeof(struct comuser));
                    ISOUTOFMEMORY(user);
                    memcpy(user, &t_user, sizeof(struct comuser));

                    user->title = StringCloneLen(pTitle, nTitle);
                    ch->users[jAdded++] = user;

                    if (  !(isPlayer(user->who))
                       && !(Going(user->who)
                       && (God(Owner(user->who)))))
                    {
                        do_joinchannel(user->who, ch);
                    }
                    user->on_next = ch->on_users;
                    ch->on_users = user;
                }
            }
            ch->num_users = jAdded;
            sort_users(ch);
        }
        else
        {
            ch->users = NULL;
        }
    }
}

void purge_comsystem

(

void

)

Definition at line 295 of file comsys.cpp.

References comsys_table, del_comsys(), God, Going, isPlayer, tagComsys::next, NUM_COMSYS, tagComsys::numchannels, Owner, and tagComsys::who.

Referenced by load_channels(), and save_channels().

{
#ifdef ABORT_PURGE_COMSYS
    return;
#endif // ABORT_PURGE_COMSYS

    comsys_t *c;
    comsys_t *d;
    int i;
    for (i = 0; i < NUM_COMSYS; i++)
    {
        c = comsys_table[i];
        while (c)
        {
            d = c;
            c = c->next;
            if (d->numchannels == 0)
            {
                del_comsys(d->who);
                continue;
            }
            if (isPlayer(d->who))
            {
                continue;
            }
            if (  God(Owner(d->who))
               && Going(d->who))
            {
                del_comsys(d->who);
                continue;
            }
        }
    }
}

void save_channels

(

FILE *

fp

)

Definition at line 330 of file comsys.cpp.

References ALIAS_SIZE, comsys_table, tagComsys::next, NUM_COMSYS, and purge_comsystem().

Referenced by save_comsys().

{
    purge_comsystem();

    comsys_t *c;
    int i, j;
    int np = 0;
    for (i = 0; i < NUM_COMSYS; i++)
    {
        c = comsys_table[i];
        while (c)
        {
            np++;
            c = c->next;
        }
    }

    fprintf(fp, "%d\n", np);
    for (i = 0; i < NUM_COMSYS; i++)
    {
        c = comsys_table[i];
        while (c)
        {
            fprintf(fp, "%d %d\n", c->who, c->numchannels);
            for (j = 0; j < c->numchannels; j++)
            {
                fprintf(fp, "%s %s\n", c->alias + j * ALIAS_SIZE, c->channels[j]);
            }
            c = c->next;
        }
    }
}

void save_comsys

(

char *

filename

)

Definition at line 126 of file comsys.cpp.

References DebugTotalFiles, ENDLINE, Log, ReplaceFile(), save_channels(), save_comsystem(), and CLogFile::tinyprintf().

Referenced by dump_database_internal().

{
    char buffer[500];

    sprintf(buffer, "%s.#", filename);
    FILE *fp = fopen(buffer, "wb");
    if (!fp)
    {
        Log.tinyprintf("Unable to open %s for writing." ENDLINE, buffer);
        return;
    }
    DebugTotalFiles++;
    fprintf(fp, "*** Begin CHANNELS ***\n");
    save_channels(fp);

    fprintf(fp, "*** Begin COMSYS ***\n");
    save_comsystem(fp);

    if (fclose(fp) == 0)
    {
        DebugTotalFiles--;
    }
    ReplaceFile(buffer, filename);
}

void save_comsystem

(

FILE *

fp

)

Definition at line 754 of file comsys.cpp.

References channel::amount_col, comuser::bUserIsOn, channel::chan_obj, statedata::channel_htab, channel::charge, channel::charge_who, comuser::ComTitleStatus, statedata::db_top, hash_firstentry(), hash_nextentry(), channel::header, mudstate, channel::name, num_channels, channel::num_messages, channel::num_users, channel::temp1, channel::temp2, comuser::title, channel::type, channel::users, and comuser::who.

Referenced by save_comsys().

{
    struct channel *ch;
    struct comuser *user;
    int j;

    fprintf(fp, "+V3\n");
    fprintf(fp, "%d\n", num_channels);
    for (ch = (struct channel *)hash_firstentry(&mudstate.channel_htab);
         ch;
         ch = (struct channel *)hash_nextentry(&mudstate.channel_htab))
    {
        fprintf(fp, "%s\n", ch->name);
        fprintf(fp, "%s\n", ch->header);

        fprintf(fp, "%d %d %d %d %d %d %d %d\n", ch->type, ch->temp1,
            ch->temp2, ch->charge, ch->charge_who, ch->amount_col,
            ch->num_messages, ch->chan_obj);

        // Count the number of 'valid' users to dump.
        //
        int nUsers = 0;
        for (j = 0; j < ch->num_users; j++)
        {
            user = ch->users[j];
            if (user->who >= 0 && user->who < mudstate.db_top)
            {
                nUsers++;
            }
        }

        fprintf(fp, "%d\n", nUsers);
        for (j = 0; j < ch->num_users; j++)
        {
            user = ch->users[j];
            if (user->who >= 0 && user->who < mudstate.db_top)
            {
                user = ch->users[j];
                fprintf(fp, "%d %d %d\n", user->who, user->bUserIsOn, user->ComTitleStatus);
                if (user->title[0] != '\0')
                {
                    fprintf(fp, "t:%s\n", user->title);
                }
                else
                {
                    fprintf(fp, "t:\n");
                }
            }
        }
    }
}

struct channel* select_channel

(

char *

channel

)

Definition at line 1407 of file comsys.cpp.

References statedata::channel_htab, hashfindLEN(), and mudstate.

Referenced by do_addcom(), do_cemit(), do_chanlog(), do_channelwho(), do_chboot(), do_cheader(), do_chopen(), do_comconnectchannel(), do_comconnectraw_notify(), do_comdisconnectchannel(), do_comdisconnectraw_notify(), do_comlist(), do_comtitle(), do_createchannel(), do_delcomchannel(), do_editchannel(), do_processcom(), and FUNCTION().

{
    struct channel *cp = (struct channel *)hashfindLEN(channel,
        strlen(channel), &mudstate.channel_htab);
    return cp;
}

struct comuser* select_user	(	struct channel *	ch,
		dbref	player
	)

Definition at line 1414 of file comsys.cpp.

References channel::num_users, channel::users, and comuser::who.

Referenced by do_chboot(), do_comconnectchannel(), do_comconnectraw_notify(), do_comdisconnectraw_notify(), do_comlist(), do_comtitle(), do_joinchannel(), do_leavechannel(), do_processcom(), do_setcomtitlestatus(), do_setnewtitle(), and FUNCTION().

{
    if (!ch)
    {
        return NULL;
    }

    int first = 0;
    int last = ch->num_users - 1;
    int dir = 1;
    int current = 0;

    while (dir && (first <= last))
    {
        current = (first + last) / 2;
        if (ch->users[current] == NULL)
        {
            last--;
            continue;
        }
        if (ch->users[current]->who == player)
        {
            dir = 0;
        }
        else if (ch->users[current]->who < player)
        {
            dir = 1;
            first = current + 1;
        }
        else
        {
            dir = -1;
            last = current - 1;
        }
    }

    if (!dir)
    {
        return ch->users[current];
    }
    else
    {
        return NULL;
    }
}

void SendChannelMessage	(	dbref	player,
		struct channel *	ch,
		char *	msgNormal,
		char *	msgNoComtitle
	)

Definition at line 1051 of file comsys.cpp.

References AF_CONST, AF_NOPARSE, AF_NOPROG, atr_add(), atr_get, atr_str(), comuser::bUserIsOn, channel::chan_obj, CHANNEL_SPOOF, comuser::ComTitleStatus, DFLT_MAX_LOG, free_lbuf, GOD, Good_obj, iMod(), MAX_RECALL_REQUEST, mkattr(), mux_atol(), mux_ltoa_t(), NOTHING, notify_with_cause_ooc, channel::num_messages, attr::number, comuser::on_next, channel::on_users, test_receive_access(), tprintf(), channel::type, and comuser::who.

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

{
    bool bSpoof = ((ch->type & CHANNEL_SPOOF) != 0);
    ch->num_messages++;

    struct comuser *user;
    for (user = ch->on_users; user; user = user->on_next)
    {
        if (  user->bUserIsOn
           && test_receive_access(user->who, ch))
        {
            if (  user->ComTitleStatus
               || bSpoof
               || msgNoComtitle == NULL)
            {
                notify_with_cause_ooc(user->who, executor, msgNormal);
            }
            else
            {
                notify_with_cause_ooc(user->who, executor, msgNoComtitle);
            }
        }
    }

    dbref obj = ch->chan_obj;
    if (Good_obj(obj))
    {
        dbref aowner;
        int aflags;
        int logmax = DFLT_MAX_LOG;
        char *maxbuf;
        ATTR *pattr = atr_str("MAX_LOG");
        if (  pattr
           && pattr->number)
        {
            maxbuf = atr_get(obj, pattr->number, &aowner, &aflags);
            logmax = mux_atol(maxbuf);
            free_lbuf(maxbuf);
        }
        if (logmax > 0)
        {
            if (logmax > MAX_RECALL_REQUEST)
            {
                logmax = MAX_RECALL_REQUEST;
                atr_add(ch->chan_obj, pattr->number, mux_ltoa_t(logmax), GOD,
                    AF_CONST|AF_NOPROG|AF_NOPARSE);
            }
            char *p = tprintf("HISTORY_%d", iMod(ch->num_messages, logmax));
            int atr = mkattr(GOD, p);
            if (0 < atr)
            {
                atr_add(ch->chan_obj, atr, msgNormal, GOD, AF_CONST|AF_NOPROG|AF_NOPARSE);
            }
        }
    }
    else if (ch->chan_obj != NOTHING)
    {
        ch->chan_obj = NOTHING;
    }

    // Since msgNormal and msgNoComTitle are no longer needed, free them here.
    //
    if (msgNormal)
    {
        free_lbuf(msgNormal);
    }
    if (  msgNoComtitle
       && msgNoComtitle != msgNormal)
    {
        free_lbuf(msgNoComtitle);
    }
}

void sort_com_aliases

(

comsys_t *

c

)

Definition at line 469 of file comsys.cpp.

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

Referenced by load_channels().

{
    int i;
    char buffer[10];
    char *s;
    bool cont = true;

    while (cont)
    {
        cont = false;
        for (i = 0; i < c->numchannels - 1; i++)
        {
            if (strcmp(c->alias + i * ALIAS_SIZE, c->alias + (i + 1) * ALIAS_SIZE) > 0)
            {
                strcpy(buffer, c->alias + i * ALIAS_SIZE);
                strcpy(c->alias + i * ALIAS_SIZE, c->alias + (i + 1) * ALIAS_SIZE);
                strcpy(c->alias + (i + 1) * ALIAS_SIZE, buffer);
                s = c->channels[i];
                c->channels[i] = c->channels[i + 1];
                c->channels[i + 1] = s;
                cont = true;
            }
        }
    }
}

void sort_users

(

struct channel *

ch

)

Definition at line 2165 of file comsys.cpp.

References channel::num_users, channel::users, and comuser::who.

Referenced by load_comsystem().

{
    int i;
    bool done = false;
    struct comuser *user;
    int nu = ch->num_users;

    while (!done)
    {
        done = true;
        for (i = 0; i < (nu - 1); i++)
        {
            if (ch->users[i]->who > ch->users[i + 1]->who)
            {
                user = ch->users[i];
                ch->users[i] = ch->users[i + 1];
                ch->users[i + 1] = user;
                done = false;
            }
        }
    }
}

bool test_join_access	(	dbref	player,
		struct channel *	chan
	)

Definition at line 2546 of file comsys.cpp.

References A_LOCK, channel::chan_obj, CHANNEL_OBJECT_JOIN, CHANNEL_PLAYER_JOIN, Comm_All, could_doit(), isPlayer, and channel::type.

Referenced by do_addcom().

{
    if (Comm_All(player))
    {
        return true;
    }

    int access;
    if (isPlayer(player))
    {
        access = CHANNEL_PLAYER_JOIN;
    }
    else
    {
        access = CHANNEL_OBJECT_JOIN;
    }
    return (  (chan->type & access) != 0
           || could_doit(player, chan->chan_obj, A_LOCK));
}

bool test_receive_access	(	dbref	player,
		struct channel *	chan
	)

Definition at line 2587 of file comsys.cpp.

References A_LENTER, channel::chan_obj, CHANNEL_OBJECT_RECEIVE, CHANNEL_PLAYER_RECEIVE, Comm_All, could_doit(), isPlayer, and channel::type.

Referenced by SendChannelMessage().

{
    if (Comm_All(player))
    {
        return true;
    }

    int access;
    if (isPlayer(player))
    {
        access = CHANNEL_PLAYER_RECEIVE;
    }
    else
    {
        access = CHANNEL_OBJECT_RECEIVE;
    }
    return (  (chan->type & access) != 0
           || could_doit(player, chan->chan_obj, A_LENTER));

}

bool test_transmit_access	(	dbref	player,
		struct channel *	chan
	)

Definition at line 2566 of file comsys.cpp.

References A_LUSE, channel::chan_obj, CHANNEL_OBJECT_TRANSMIT, CHANNEL_PLAYER_TRANSMIT, Comm_All, could_doit(), isPlayer, and channel::type.

Referenced by do_processcom().

{
    if (Comm_All(player))
    {
        return true;
    }

    int access;
    if (isPlayer(player))
    {
        access = CHANNEL_PLAYER_TRANSMIT;
    }
    else
    {
        access = CHANNEL_OBJECT_TRANSMIT;
    }
    return (  (chan->type & access) != 0
           || could_doit(player, chan->chan_obj, A_LUSE));

}

---