src/p.comsys.h File Reference

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

Go to the source code of this file.

Functions
void	init_chantab (void)
void	send_channel (char *chan, const char *format,...)
char *	get_channel_from_alias (dbref player, char *alias)
void	load_comsystem (FILE *fp)
void	save_comsystem (FILE *fp)
void	do_processcom (dbref player, char *arg1, char *arg2)
channel *	select_channel (char *channel)
comuser *	select_user (struct channel *ch, dbref player)
void	do_addcom (dbref player, dbref cause, int key, char *arg1, char *arg2)
void	do_delcom (dbref player, dbref cause, int key, char *arg1)
void	do_delcomchannel (dbref player, char *channel)
void	do_createchannel (dbref player, dbref cause, int key, char *channel)
void	do_destroychannel (dbref player, dbref cause, int key, char *channel)
void	do_listchannels (dbref player)
void	do_comtitle (dbref player, dbref cause, int key, char *arg1, char *arg2)
void	do_comlist (dbref player, dbref cause, int key)
void	do_channelnuke (dbref player)
void	do_clearcom (dbref player, dbref cause, int key)
void	do_allcom (dbref player, dbref cause, int key, char *arg1)
void	do_channelwho (dbref player, dbref cause, int key, char *arg1)
void	do_comdisconnectraw_notify (dbref player, char *chan)
void	do_comconnectraw_notify (dbref player, char *chan)
void	do_comconnectchannel (dbref player, char *channel, char *alias, int i)
void	do_comdisconnect (dbref player)
void	do_comconnect (dbref player, DESC *d)
void	do_comdisconnectchannel (dbref player, char *channel)
void	do_editchannel (dbref player, dbref cause, int flag, char *arg1, char *arg2)
int	do_comsystem (dbref who, char *cmd)
void	do_chclose (dbref player, char *chan)
void	do_cemit (dbref player, dbref cause, int key, char *chan, char *text)
void	do_chopen (dbref player, dbref cause, int key, char *chan, char *object)
void	do_chloud (dbref player, char *chan)
void	do_chsquelch (dbref player, char *chan)
void	do_chtransparent (dbref player, char *chan)
void	do_chopaque (dbref player, char *chan)
void	do_chboot (dbref player, dbref cause, int key, char *channel, char *victim)
void	do_chanobj (dbref player, char *channel, char *object)
void	do_chanstatus (dbref player, dbref cause, int key, char *chan)
void	do_chanlist (dbref player, dbref cause, int key)

---

Function Documentation

void do_addcom	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1,
		char *	arg2
	)

Definition at line 235 of file comstar.c.

References c, CHANNEL_JOIN, comstar_add_user_to_channel(), comstar_find_channel_by_name(), do_joinchannel(), do_setnewtitle(), do_test_access(), get_commac(), confdata::have_comsys, mudconf, channel::name, notify_printf(), commac::numchannels, raw_notify(), select_channel(), select_user(), and comuser::title.

                                                                           {
    struct channel *channel = NULL;
    if(!mudconf.have_comsys) {
        raw_notify(player, "Comsys disabled.");
        return;
    }

    if(!arg1 || !*arg1) {
        raw_notify(player, "You need to specify an alias.");
        return;
    }

    if(!arg2 || !*arg2) {
        raw_notify(player, "You need to specify a channel.");
        return;
    }
    
    channel = comstar_find_channel_by_name(arg2);
    if(!channel) {
        raw_notify(player, "Sorry, Channel does not exist.");
        return;
    }

    if(!comstar_add_user_to_channel(arg2, arg1, player)) {
        raw_notify(player, "Operation failed due to invalid argument.");
        return;
    }
    raw_notify(player, "Operation succeeded.");
    return;
}

void do_allcom	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1
	)

Definition at line 959 of file comsys.c.

References c, do_processcom(), get_commac(), confdata::have_comsys, mudconf, and raw_notify().

{
        int i;
        struct commac *c;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        c = get_commac(player);

        if((strcasecmp(arg1, "who") != 0) && (strcasecmp(arg1, "on") != 0) &&
           (strcasecmp(arg1, "off") != 0)) {
                raw_notify(player, "Only options available are: on, off and who.");
                return;
        }
        for(i = 0; i < c->numchannels; i++) {
                do_processcom(player, c->channels[i], arg1);
                if(strcasecmp(arg1, "who") == 0)
                        raw_notify(player, "");
        }

}

void do_cemit	(	dbref	player,
		dbref	cause,
		int	key,
		char *	chan,
		char *	text
	)

Definition at line 1380 of file comsys.c.

References CEMIT_NOHEADER, channel::charge_who, Comm_All, do_comprintf(), do_comsend(), confdata::have_comsys, mudconf, notify_printf(), raw_notify(), and select_channel().

{
        struct channel *ch;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        if(!(ch = select_channel(chan))) {
                notify_printf(player, "Channel %s does not exist.", chan);
                return;
        }
        if((player != ch->charge_who) && (!Comm_All(player))) {
                raw_notify(player, "Permission denied.");
                return;
        }
        if(key == CEMIT_NOHEADER)
                do_comsend(ch, text);
        else
                do_comprintf(ch, "[%s] %s", chan, text);
}

void do_chanlist	(	dbref	player,
		dbref	cause,
		int	key
	)

Definition at line 1605 of file comsys.c.

References A_DESC, alloc_mbuf, atr_pget(), channel::chan_obj, statedata::channel_htab, CHANNEL_JOIN, CHANNEL_LOUD, CHANNEL_PUBLIC, channel::charge_who, CLIST_FULL, Comm_All, do_listchannels(), do_test_access(), free_lbuf, free_mbuf, hash_firstentry(), hash_nextentry(), confdata::have_comsys, mudconf, mudstate, Name(), channel::name, NOTHING, channel::owner, raw_notify(), and channel::type.

Referenced by do_chopen().

{
        dbref owner;
        struct channel *ch;
        int flags;
        char *temp;
        char *buf;
        char *atrstr;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        flags = (int) NULL;

        if(key & CLIST_FULL) {
                do_listchannels(player);
                return;
        }
        temp = alloc_mbuf("do_chanlist_temp");
        buf = alloc_mbuf("do_chanlist_buf");

        raw_notify(player, "** Channel       Owner           Description");

        for(ch = (struct channel *) hash_firstentry(&mudstate.channel_htab);
                ch; ch = (struct channel *) hash_nextentry(&mudstate.channel_htab)) {
                if(Comm_All(player) || (ch->type & CHANNEL_PUBLIC) ||
                   ch->charge_who == player || (do_test_access(player, CHANNEL_JOIN, ch))) {

                        atrstr = atr_pget(ch->chan_obj, A_DESC, &owner, &flags);
                        if((ch->chan_obj == NOTHING) || !*atrstr)
                                sprintf(buf, "%s", "No description.");
                        else
                                sprintf(buf, "%-54.54s", atrstr);

                        free_lbuf(atrstr);
                        sprintf(temp, "%c%c %-13.13s %-15.15s %-45.45s",
                                        (ch->type & (CHANNEL_PUBLIC)) ? 'P' : '-',
                                        (ch->type & (CHANNEL_LOUD)) ? 'L' : '-', ch->name,
                                        Name(ch->charge_who), buf);

                        raw_notify(player, temp);
                }
        }
        free_mbuf(temp);
        free_mbuf(buf);
        raw_notify(player, "-- End of list of Channels --");
}

void do_channelnuke

(

dbref

player

)

Definition at line 924 of file comsys.c.

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

Referenced by toast_player().

{
        struct channel *ch;
        int j;

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

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

void do_channelwho	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1
	)

Definition at line 1005 of file comsys.c.

References CHANNEL_TRANSPARENT, channel::charge_who, Comm_All, Dark, flag, free_lbuf, confdata::have_comsys, Hidden, LBUF_SIZE, mudconf, channel::name, notify_printf(), channel::num_users, comuser::on, raw_notify(), select_channel(), strip_ansi_r(), channel::type, TYPE_PLAYER, Typeof, UNDEAD, unparse_object(), channel::users, comuser::who, and Wizard_Who.

{
        struct channel *ch;
        struct comuser *user;
        char channel[100];
        int flag = 0;
        char *cp;
        int i;
        char ansibuffer[LBUF_SIZE];
        char outputbuffer[LBUF_SIZE];

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        cp = strchr(arg1, '/');
        if(!cp) {
                strncpy(channel, arg1, 100);
                channel[99] = '\0';
        } else {
                /* channelname/all */
                if(cp - arg1 >= 100) {
                        raw_notify(player, "Channel name too long.");
                        return;
                }
                strncpy(channel, arg1, cp - arg1);
                channel[cp - arg1] = '\0';
                if(*++cp == 'a')
                        flag = 1;
        }

        if(!(ch = select_channel(channel))) {
                notify_printf(player, "Unknown channel \"%s\".", channel);
                return;
        }
        if(!((Comm_All(player)) || (player == ch->charge_who))) {
                raw_notify(player, "You do not have permission to do that.");
                return;
        }
        notify_printf(player, "-- %s --", ch->name);
        notify_printf(player, "%-29.29s %-6.6s %-6.6s", "Name", "Status",
                                  "Player");
        for(i = 0; i < ch->num_users; i++) {
                user = ch->users[i];
                if((flag || UNDEAD(user->who)) && (!Hidden(user->who) ||
                                                                                   ((ch->type & CHANNEL_TRANSPARENT)
                                                                                        && !Dark(user->who))
                                                                                   || Wizard_Who(player))) {
                        cp = unparse_object(player, user->who, 0);
                        strip_ansi_r(ansibuffer, cp, LBUF_SIZE);
                        notify_printf(player, "%-29.29s %-6.6s %-6.6s", ansibuffer,
                                                  ((user->on) ? "on " : "off"),
                                                  (Typeof(user->who) == TYPE_PLAYER) ? "yes" : "no ");
                        free_lbuf(cp);
                }
        }
        notify_printf(player, "-- %s --", ch->name);
}

void do_chanobj	(	dbref	player,
		char *	channel,
		char *	object
	)

Definition at line 1574 of file comsys.c.

References channel::chan_obj, channel::charge_who, Comm_All, free_lbuf, init_match(), match_everything(), match_result(), channel::name, NOTHING, notify_printf(), NOTYPE, raw_notify(), select_channel(), and unparse_object().

Referenced by do_chopen().

{
        struct channel *ch;
        dbref thing;
        char *buff;

        init_match(player, object, NOTYPE);
        match_everything(0);
        thing = match_result();

        if(!(ch = select_channel(channel))) {
                raw_notify(player, "That channel does not exist.");
                return;
        }
        if(thing == NOTHING) {
                ch->chan_obj = NOTHING;
                raw_notify(player, "Set.");
                return;
        }
        if(!(ch->charge_who == player) && !Comm_All(player)) {
                raw_notify(player, "Permission denied.");
                return;
        }
        ch->chan_obj = thing;
        buff = unparse_object(player, thing, 0);
        notify_printf(player,
                                  "Channel %s is now using %s as channel object.", ch->name,
                                  buff);
        free_lbuf(buff);
}

void do_chanstatus	(	dbref	player,
		dbref	cause,
		int	key,
		char *	chan
	)

Definition at line 1654 of file comsys.c.

References A_DESC, alloc_mbuf, channel::amount_col, atr_pget(), channel::chan_obj, CHANNEL_JOIN, CHANNEL_LOUD, CHANNEL_OBJ_MULT, CHANNEL_PL_MULT, CHANNEL_PUBLIC, CHANNEL_RECIEVE, CHANNEL_TRANSMIT, channel::charge, channel::charge_who, Comm_All, CSTATUS_FULL, free_lbuf, free_mbuf, confdata::have_comsys, MBUF_SIZE, mudconf, Name(), channel::name, NOTHING, notify_printf(), channel::num_messages, channel::num_users, channel::owner, raw_notify(), select_channel(), and channel::type.

Referenced by do_chopen().

{
        dbref owner;
        struct channel *ch;
        int flags;
        char *temp;
        char *buf;
        char *atrstr;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }

        if(key & CSTATUS_FULL) {
                struct channel *ch;
                int perm;

                if(!(perm = Comm_All(player))) {
                        raw_notify(player,
                                           "Warning: Only public channels and your channels will be shown.");
                }
                raw_notify(player,
                                   "** Channel             --Flags--  Obj   Own   Charge  Balance  Users   Messages");

                if(!(ch = select_channel(chan))) {
                        notify_printf(player,
                                                  "@cstatus: Channel %s does not exist.", chan);
                        return;
                }
                if(perm || (ch->type & CHANNEL_PUBLIC) || ch->charge_who == player) {

                        notify_printf(player,
                                                  "%c%c %-20.20s %c%c%c/%c%c%c %5d %5d %8d %8d %6d %10d",
                                                  (ch->type & (CHANNEL_PUBLIC)) ? 'P' : '-',
                                                  (ch->type & (CHANNEL_LOUD)) ? 'L' : '-', ch->name,
                                                  (ch->
                                                   type & (CHANNEL_PL_MULT *
                                                                   CHANNEL_JOIN)) ? 'J' : '-',
                                                  (ch->
                                                   type & (CHANNEL_PL_MULT *
                                                                   CHANNEL_TRANSMIT)) ? 'X' : '-',
                                                  (ch->
                                                   type & (CHANNEL_PL_MULT *
                                                                   CHANNEL_RECIEVE)) ? 'R' : '-',
                                                  (ch->
                                                   type & (CHANNEL_OBJ_MULT *
                                                                   CHANNEL_JOIN)) ? 'j' : '-',
                                                  (ch->
                                                   type & (CHANNEL_OBJ_MULT *
                                                                   CHANNEL_TRANSMIT)) ? 'x' : '-',
                                                  (ch->
                                                   type & (CHANNEL_OBJ_MULT *
                                                                   CHANNEL_RECIEVE)) ? 'r' : '-',
                                                  (ch->chan_obj != NOTHING) ? ch->chan_obj : -1,
                                                  ch->charge_who, ch->charge, ch->amount_col,
                                                  ch->num_users, ch->num_messages);
                }
                raw_notify(player, "-- End of list of Channels --");
                return;
        }
        temp = alloc_mbuf("do_chanstatus_temp");
        buf = alloc_mbuf("do_chanstatus_buf");

        raw_notify(player, "** Channel       Owner           Description");
        if(!(ch = select_channel(chan))) {
                notify_printf(player, "@cstatus: Channel %s does not exist.", chan);
                return;
        }
        if(Comm_All(player) || (ch->type & CHANNEL_PUBLIC) ||
           ch->charge_who == player) {

                atrstr = atr_pget(ch->chan_obj, A_DESC, &owner, &flags);
                if((ch->chan_obj == NOTHING) || !*atrstr)
                        sprintf(buf, "%s", "No description.");
                else
                        sprintf(buf, "%-54.54s", atrstr);

                free_lbuf(atrstr);
                snprintf(temp, MBUF_SIZE, "%c%c %-13.13s %-15.15s %-45.45s",
                                 (ch->type & (CHANNEL_PUBLIC)) ? 'P' : '-',
                                 (ch->type & (CHANNEL_LOUD)) ? 'L' : '-', ch->name,
                                 Name(ch->charge_who), buf);

                raw_notify(player, temp);
        }
        free_mbuf(temp);
        free_mbuf(buf);
        raw_notify(player, "-- End of list of Channels --");
}

void do_chboot	(	dbref	player,
		dbref	cause,
		int	key,
		char *	channel,
		char *	victim
	)

Definition at line 1526 of file comsys.c.

References channel::charge_who, Comm_All, do_comprintf(), do_delcomchannel(), confdata::have_comsys, match_thing(), mudconf, channel::name, Name(), NOTHING, notify_printf(), raw_notify(), select_channel(), select_user(), and unparse_object_numonly().

{
        struct comuser *user;
        struct channel *ch;
        struct comuser *vu;
        dbref thing;

        /*
         * * I sure hope it's not going to be that *
         * *  * *  * *  * * long.  
         */

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        if(!(ch = select_channel(channel))) {
                raw_notify(player, "@cboot: Unknown channel.");
                return;
        }
        if(!(user = select_user(ch, player))) {
                raw_notify(player, "@cboot: You are not on that channel.");
                return;
        }
        if(!((ch->charge_who == player) || Comm_All(player))) {
                raw_notify(player, "Permission denied.");
                return;
        }
        thing = match_thing(player, victim);

        if(thing == NOTHING) {
                return;
        }
        if(!(vu = select_user(ch, thing))) {
                notify_printf(player, "@cboot: %s in not on the channel.",
                                          Name(thing));
                return;
        }
        /*
         * We should be in the clear now. :) 
         */
        do_comprintf(ch, "[%s] %s boots %s off the channel.", ch->name,
               unparse_object_numonly(player), unparse_object_numonly(thing));
        do_delcomchannel(thing, channel);

}

void do_chclose	(	dbref	player,
		char *	chan
	)

Definition at line 1362 of file comsys.c.

References CHANNEL_PUBLIC, channel::charge_who, Comm_All, notify_printf(), raw_notify(), select_channel(), and channel::type.

Referenced by do_chopen().

{
        struct channel *ch;

        if(!(ch = select_channel(chan))) {
                notify_printf(player, "@cset: Channel %s does not exist.", chan);
                return;
        }
        if((player != ch->charge_who) && (!Comm_All(player))) {
                raw_notify(player, "@cset: Permission denied.");
                return;
        }
        ch->type &= (~(CHANNEL_PUBLIC));
        notify_printf(player,
                                  "@cset: Channel %s taken off the public listings.", chan);
        return;
}

void do_chloud	(	dbref	player,
		char *	chan
	)

Definition at line 1451 of file comsys.c.

References CHANNEL_LOUD, channel::charge_who, Comm_All, notify_printf(), raw_notify(), select_channel(), and channel::type.

Referenced by do_chopen().

{
        struct channel *ch;

        if(!(ch = select_channel(chan))) {
                notify_printf(player, "@cset: Channel %s does not exist.", chan);
                return;
        }
        if((player != ch->charge_who) && (!Comm_All(player))) {
                raw_notify(player, "@cset: Permission denied.");
                return;
        }
        ch->type |= (CHANNEL_LOUD);
        notify_printf(player,
                                  "@cset: Channel %s now sends connect/disconnect msgs.",
                                  chan);
        return;
}

void do_chopaque	(	dbref	player,
		char *	chan
	)

Definition at line 1507 of file comsys.c.

References CHANNEL_TRANSPARENT, channel::charge_who, Comm_All, notify_printf(), raw_notify(), select_channel(), and channel::type.

Referenced by do_chopen().

{
        struct channel *ch;

        if(!(ch = select_channel(chan))) {
                notify_printf(player, "@cset: Channel %s does not exist.", chan);
                return;
        }
        if((player != ch->charge_who) && (!Comm_All(player))) {
                raw_notify(player, "@cset: Permission denied.");
                return;
        }
        ch->type &= ~CHANNEL_TRANSPARENT;
        notify_printf(player,
                                  "@cset: Channel %s now does not show all listeners to everyone.",
                                  chan);
        return;
}

void do_chopen	(	dbref	player,
		dbref	cause,
		int	key,
		char *	chan,
		char *	object
	)

Definition at line 1402 of file comsys.c.

References CHANNEL_PUBLIC, channel::charge_who, Comm_All, CSET_LIST, CSET_LOUD, CSET_OBJECT, CSET_OPAQUE, CSET_PRIVATE, CSET_QUIET, CSET_STATUS, CSET_TRANSPARENT, do_chanlist(), do_chanobj(), do_chanstatus(), do_chclose(), do_chloud(), do_chopaque(), do_chsquelch(), do_chtransparent(), confdata::have_comsys, mudconf, NOTHING, notify_printf(), raw_notify(), select_channel(), and channel::type.

{
        struct channel *ch;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        switch (key) {
        case CSET_PRIVATE:
                do_chclose(player, chan);
                return;
        case CSET_LOUD:
                do_chloud(player, chan);
                return;
        case CSET_QUIET:
                do_chsquelch(player, chan);
                return;
        case CSET_LIST:
                do_chanlist(player, NOTHING, 1);
                return;
        case CSET_OBJECT:
                do_chanobj(player, chan, object);
                return;
        case CSET_STATUS:
                do_chanstatus(player, NOTHING, 1, chan);
                return;
        case CSET_TRANSPARENT:
                do_chtransparent(player, chan);
                return;
        case CSET_OPAQUE:
                do_chopaque(player, chan);
                return;
        }

        if(!(ch = select_channel(chan))) {
                notify_printf(player, "@cset: Channel %s does not exist.", chan);
                return;
        }
        if((player != ch->charge_who) && (!Comm_All(player))) {
                raw_notify(player, "@cset: Permission denied.");
                return;
        }
        ch->type |= (CHANNEL_PUBLIC);
        notify_printf(player, "@cset: Channel %s placed on the public listings.",
                                  chan);
        return;
}

void do_chsquelch	(	dbref	player,
		char *	chan
	)

Definition at line 1470 of file comsys.c.

References CHANNEL_LOUD, channel::charge_who, Comm_All, notify_printf(), raw_notify(), select_channel(), and channel::type.

Referenced by do_chopen().

{
        struct channel *ch;

        if(!(ch = select_channel(chan))) {
                notify_printf(player, "@cset: Channel %s does not exist.", chan);
                return;
        }
        if((player != ch->charge_who) && (!Comm_All(player))) {
                raw_notify(player, "@cset: Permission denied.");
                return;
        }
        ch->type &= ~(CHANNEL_LOUD);
        notify_printf(player,
                                  "@cset: Channel %s connect/disconnect msgs muted.", chan);
        return;
}

void do_chtransparent	(	dbref	player,
		char *	chan
	)

Definition at line 1488 of file comsys.c.

References CHANNEL_TRANSPARENT, channel::charge_who, Comm_All, notify_printf(), raw_notify(), select_channel(), and channel::type.

Referenced by do_chopen().

{
        struct channel *ch;

        if(!(ch = select_channel(chan))) {
                notify_printf(player, "@cset: Channel %s does not exist.", chan);
                return;
        }
        if((player != ch->charge_who) && (!Comm_All(player))) {
                raw_notify(player, "@cset: Permission denied.");
                return;
        }
        ch->type |= CHANNEL_TRANSPARENT;
        notify_printf(player,
                                  "@cset: Channel %s now shows all listeners to everyone.",
                                  chan);
        return;
}

void do_clearcom	(	dbref	player,
		dbref	cause,
		int	key
	)

Definition at line 943 of file comsys.c.

References c, do_delcom(), get_commac(), confdata::have_comsys, mudconf, and raw_notify().

Referenced by toast_player().

{
        int i;
        struct commac *c;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        c = get_commac(player);

        for(i = (c->numchannels) - 1; i > -1; --i) {
                do_delcom(player, player, 0, c->alias + i * 6);
        }
}

void do_comconnect	(	dbref	player,
		DESC *	d
	)

Definition at line 1130 of file comsys.c.

References descriptor_data::addr, c, do_comconnectchannel(), do_comconnectraw_notify(), get_commac(), Name(), and send_channel().

Referenced by announce_connect().

{
        struct commac *c;
        int i;
        char *lsite;

        c = get_commac(player);

        for(i = 0; i < c->numchannels; i++) {
                do_comconnectchannel(player, c->channels[i], c->alias, i);
                do_comconnectraw_notify(player, c->channels[i]);
        }
        lsite = d->addr;
        if(lsite && *lsite)
                send_channel("MUXConnections","* %s has connected from %s *", Name(player), lsite);
        else
                send_channel("MUXConnections","* %s has connected from somewhere *", Name(player));
}

void do_comconnectchannel	(	dbref	player,
		char *	channel,
		char *	alias,
		int	i
	)

Definition at line 1094 of file comsys.c.

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

Referenced by do_comconnect().

{
        struct channel *ch;
        struct comuser *user;

        if((ch = select_channel(channel))) {
                for(user = ch->on_users; user && user->who != player;
                        user = user->on_next);

                if(!user) {
                        if((user = select_user(ch, player))) {
                                user->on_next = ch->on_users;
                                ch->on_users = user;
                        } else
                                notify_printf(player, "Bad Comsys Alias: %s for Channel: %s",
                                                          alias + i * 6, channel);
                }
        } else
                notify_printf(player, "Bad Comsys Alias: %s for Channel: %s",
                                          alias + i * 6, channel);
}

void do_comconnectraw_notify	(	dbref	player,
		char *	chan
	)

Definition at line 1079 of file comsys.c.

References CHANNEL_LOUD, Dark, do_comprintf(), Name(), channel::name, comuser::on, select_channel(), select_user(), and channel::type.

Referenced by do_comconnect().

{
        struct channel *ch;
        struct comuser *cu;

        if(!(ch = select_channel(chan)))
                return;
        if(!(cu = select_user(ch, player)))
                return;

        if((ch->type & CHANNEL_LOUD) && (cu->on) && (!Dark(player))) {
                do_comprintf(ch, "[%s] %s has connected.", ch->name, Name(player));
        }
}

void do_comdisconnect

(

dbref

player

)

Definition at line 1116 of file comsys.c.

References c, do_comdisconnectchannel(), do_comdisconnectraw_notify(), get_commac(), Name(), and send_channel().

Referenced by announce_disconnect().

{
        int i;
        struct commac *c;

        c = get_commac(player);

        for(i = 0; i < c->numchannels; i++) {
                do_comdisconnectchannel(player, c->channels[i]);
                do_comdisconnectraw_notify(player, c->channels[i]);
        }
        send_channel("MUXConnections", "* %s has disconnected *", Name(player));
}

void do_comdisconnectchannel	(	dbref	player,
		char *	channel
	)

Definition at line 1149 of file comsys.c.

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

Referenced by do_comdisconnect(), and do_delcomchannel().

{
        struct comuser *user, *prevuser = NULL;
        struct channel *ch;

        if(!(ch = select_channel(channel)))
                return;
        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_comdisconnectraw_notify	(	dbref	player,
		char *	chan
	)

Definition at line 1064 of file comsys.c.

References CHANNEL_LOUD, Dark, do_comprintf(), Name(), channel::name, comuser::on, select_channel(), select_user(), and channel::type.

Referenced by do_comdisconnect().

{
        struct channel *ch;
        struct comuser *cu;

        if(!(ch = select_channel(chan)))
                return;
        if(!(cu = select_user(ch, player)))
                return;

        if((ch->type & CHANNEL_LOUD) && (cu->on) && (!Dark(player))) {
                do_comprintf(ch, "[%s] %s has disconnected.", ch->name, Name(player));
        }
}

void do_comlist	(	dbref	player,
		dbref	cause,
		int	key
	)

Definition at line 896 of file comsys.c.

References c, get_commac(), confdata::have_comsys, mudconf, notify_printf(), comuser::on, raw_notify(), select_channel(), select_user(), and comuser::title.

{
        struct comuser *user;
        struct commac *c;
        int i;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        c = get_commac(player);

        raw_notify(player,
                           "Alias     Channel             Title                                   Status");

        for(i = 0; i < c->numchannels; i++) {
                if((user = select_user(select_channel(c->channels[i]), player))) {
                        notify_printf(player, "%-9.9s %-19.19s %-39.39s %s",
                                                  c->alias + i * 6, c->channels[i],
                                                  user->title, (user->on ? "on" : "off"));
                } else {
                        notify_printf(player, "Bad Comsys Alias: %s for Channel: %s",
                                                  c->alias + i * 6, c->channels[i]);
                }
        }
        raw_notify(player, "-- End of comlist --");
}

int do_comsystem	(	dbref	who,
		char *	cmd
	)

Definition at line 1334 of file comsys.c.

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

Referenced by process_command().

{
        char *t;
        char *ch;
        char *alias;
        char *s;

        alias = alloc_lbuf("do_comsystem");
        s = alias;
        for(t = cmd; *t && *t != ' '; *s++ = *t++)
                /* nothing */ ;

        *s = '\0';

        if(*t)
                t++;

        ch = get_channel_from_alias(who, alias);
        if(ch && *ch) {
                do_processcom(who, ch, t);
                free_lbuf(alias);
                return 0;
        }
        free_lbuf(alias);
        return 1;

}

void do_comtitle	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1,
		char *	arg2
	)

Definition at line 865 of file comsys.c.

References do_setnewtitle(), get_channel_from_alias(), confdata::have_comsys, mudconf, notify_printf(), raw_notify(), select_channel(), and select_user().

{
        struct channel *ch;
        char channel[100];

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        if(!*arg1) {
                raw_notify(player, "Need an alias to do comtitle.");
                return;
        }
        strncpy(channel, get_channel_from_alias(player, arg1), 100);
        channel[99] = '\0';

        if(!*channel) {
                raw_notify(player, "Unknown alias");
                return;
        }
        if((ch = select_channel(channel)) && select_user(ch, player)) {
                notify_printf(player, "Title set to '%s' on channel %s.",
                                          arg2, channel);
                do_setnewtitle(player, ch, arg2);
        }
        if(!ch) {
                raw_notify(player, "Invalid comsys alias, please delete.");
                return;
        }
}

void do_createchannel	(	dbref	player,
		dbref	cause,
		int	key,
		char *	channel
	)

Definition at line 168 of file comstar.c.

References channel::amount_col, CHAN_NAME_LEN, channel::chan_obj, statedata::channel_htab, channel::channel_object, channel::charge, channel::charge_who, Comm_All, comstar_compare_channel_user(), comstar_find_channel_by_name(), hashadd(), confdata::have_comsys, channel::max_users, mudconf, mudstate, channel::name, NOTHING, notify_printf(), num_channels, channel::num_messages, channel::num_users, channel::on_users, channel::owner, raw_notify(), rb_init(), select_channel(), channel::temp1, channel::temp2, channel::type, and channel::users.

                                                                          {
    struct channel *newchannel = NULL;

    if(!mudconf.have_comsys) {
        raw_notify(player, "Comsys disabled.");
        return;
    }
    if(comstar_find_channel_by_name(channame)) {
        notify_printf(player, "Channel %s already exists.", channame);
        return;
    }
    if(!channame || !*channame) {
        raw_notify(player, "You must specify a channel to create.");
        return;
    }
    if(!(Comm_All(player))) {
        raw_notify(player, "You do not have permission to do that.");
        return;
    }
    if(strlen(channame) > (CHAN_NAME_LEN-1)) {
        raw_notify(player, "Name too long.");
        return;
    }
    newchannel = (struct channel *) malloc(sizeof(struct channel));
    memset(newchannel, 0, sizeof(struct channel));

    strncpy(newchannel->name, channame, CHAN_NAME_LEN - 1);

    newchannel->type = 127;
    newchannel->owner = player;
    newchannel->channel_object = NOTHING;
    newchannel->users = rb_init(comstar_compare_channel_user, NULL);
    notify_printf(player, "Channel %s created.", channame);
}

void do_delcom	(	dbref	player,
		dbref	cause,
		int	key,
		char *	arg1
	)

Definition at line 266 of file comstar.c.

References c, comstar_find_channel_by_user_alias(), comstar_remove_user_from_channel(), do_delcomchannel(), get_commac(), confdata::have_comsys, mudconf, channel::name, notify_printf(), commac::numchannels, and raw_notify().

                                                               {
    struct channel *channel = NULL;

    if(!mudconf.have_comsys) {
        raw_notify(player, "Comsys disabled.");
        return;
    }
    if(!arg1 || !*arg1) {
        raw_notify(player, "Need an alias to delete.");
        return;
    }

    channel = comstar_find_channel_by_user_alias(player, arg1);
    if(!channel) {
        raw_notify(player, "Channel alias does not exist.");
        return;
    }

    if(!comstar_remove_user_from_channel(channel->name, player)) {
        raw_notify(player, "Operation failed due to invalid argument.");
        return;
    }

    raw_notify(player, "Operation succeeded.");
    return;
}

void do_delcomchannel	(	dbref	player,
		char *	channel
	)

Definition at line 710 of file comsys.c.

References A_ALEAVE, c, Dark, did_it(), do_comdisconnectchannel(), do_comprintf(), Name(), notify_printf(), channel::num_users, comuser::on, select_channel(), comuser::title, TYPE_THING, Typeof, channel::users, and comuser::who.

Referenced by do_chboot(), and do_delcom().

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

        if(!(ch = select_channel(channel))) {
                notify_printf(player, "Unknown channel %s.", channel);
        } else {

                /* Trigger ALEAVE of any channel objects on the channel */
                for(i = ch->num_users - 1; i > 0; i--) {
                        if(Typeof(ch->users[i]->who) == TYPE_THING)
                                did_it(player, ch->users[i]->who, 0, NULL, 0, NULL, A_ALEAVE,
                                           (char **) NULL, 0);
                }

                for(i = 0; i < ch->num_users; i++) {
                        user = ch->users[i];
                        if(user->who == player) {
                                do_comdisconnectchannel(player, channel);
                                if(user->on && !Dark(player)) {
                                        char *c = Name(player);

                                        if(c && *c)
                                                do_comprintf(ch, "[%s] %s has left this channel.", channel, c);
                                }
                                notify_printf(player, "You have left channel %s.", channel);

                                if(user->title)
                                        free(user->title);
                                free(user);
                                ch->num_users--;
                                if(i < ch->num_users)
                                        memmove(ch->users + i, ch->users + i + 1,
                                                        sizeof(ch->users) * (ch->num_users - i));
                        }
                }
        }
}

void do_destroychannel	(	dbref	player,
		dbref	cause,
		int	key,
		char *	channel
	)

Definition at line 203 of file comstar.c.

References channel_user::channel, statedata::channel_htab, channels, channel::charge_who, Comm_All, comstar_find_channel_by_name(), comstar_remove_user_from_channel(), hashdelete(), hashfind(), confdata::have_comsys, mudconf, mudstate, channel::name, notify_printf(), num_channels, channel::num_users, channel::owner, channel_user::player, raw_notify(), rb_delete(), rb_search(), rb_size(), SEARCH_FIRST, and channel::users.

                                                                           {
    struct channel *channel = NULL;

    if(!mudconf.have_comsys) {
        raw_notify(player, "Comsys disabled.");
        return;
    }
    if(!channame || !*channame) {
        raw_notify(player, "No argument supplied.");
        return;
    }
    channel = comstar_find_channel_by_name(channame);

    if(!channel) {
        notify_printf(player, "Could not find channel %s.", channel);
        return;
    } else if(!(Comm_All(player)) && (player != channel->owner)) {
        raw_notify(player, "You do not have permission to do that. ");
        return;
    }
    while(rb_size(channel->users) > 1) {
        struct channel_user *channel_user = NULL;
        channel_user = rb_search(channel->users, SEARCH_FIRST, NULL);
        if(!channel_user) break;
        if(!comstar_remove_user_from_channel(channel->name, channel_user->player))
            break;
    }
    rb_delete(channels, channame);
    memset(channel, 0, sizeof(struct channel));
    free(channel);
}

void do_editchannel	(	dbref	player,
		dbref	cause,
		int	flag,
		char *	arg1,
		char *	arg2
	)

Definition at line 1170 of file comsys.c.

References CHANNEL_JOIN, CHANNEL_OBJ_MULT, CHANNEL_PL_MULT, CHANNEL_RECIEVE, CHANNEL_TRANSMIT, channel::charge, channel::charge_who, Comm_All, confdata::have_comsys, lookup_player(), mudconf, NOTHING, notify_printf(), raw_notify(), select_channel(), and channel::type.

{
        char *s;
        struct channel *ch;
        int add_remove = 1;

        if(!mudconf.have_comsys) {
                raw_notify(player, "Comsys disabled.");
                return;
        }
        if(!(ch = select_channel(arg1))) {
                notify_printf(player, "Unknown channel %s.", arg1);
                return;
        }
        if(!((Comm_All(player)) || (player == ch->charge_who))) {
                raw_notify(player, "Permission denied.");
                return;
        }
        s = arg2;
        if(*s == '!') {
                add_remove = 0;
                s++;
        }
        switch (flag) {
        case 0:
                if(lookup_player(player, arg2, 1) != NOTHING) {
                        ch->charge_who = lookup_player(player, arg2, 1);
                        raw_notify(player, "Set.");
                        return;
                } else {
                        raw_notify(player, "Invalid player.");
                        return;
                }
        case 1:
                ch->charge = atoi(arg2);
                raw_notify(player, "Set.");
                return;
        case 3:
                if(strcasecmp(s, "join") == 0) {
                        add_remove ? (ch->type |=
                                                  (CHANNEL_PL_MULT * CHANNEL_JOIN)) : (ch->type &=
                                                                                                                           ~
                                                                                                                           (CHANNEL_PL_MULT
                                                                                                                                *
                                                                                                                                CHANNEL_JOIN));
                        raw_notify(player,
                                           (add_remove) ? "@cpflags: Set." :
                                           "@cpflags: Cleared.");
                        return;
                }
                if(strcasecmp(s, "receive") == 0) {
                        add_remove ? (ch->type |=
                                                  (CHANNEL_PL_MULT * CHANNEL_RECIEVE)) : (ch->type &=
                                                                                                                                  ~
                                                                                                                                  (CHANNEL_PL_MULT
                                                                                                                                   *
                                                                                                                                   CHANNEL_RECIEVE));
                        raw_notify(player,
                                           (add_remove) ? "@cpflags: Set." :
                                           "@cpflags: Cleared.");
                        return;
                }
                if(strcasecmp(s, "transmit") == 0) {
                        add_remove ? (ch->type |=
                                                  (CHANNEL_PL_MULT * CHANNEL_TRANSMIT)) : (ch->type &=
                                                                                                                                   ~
                                                                                                                                   (CHANNEL_PL_MULT
                                                                                                                                        *
                                                                                                                                        CHANNEL_TRANSMIT));
                        raw_notify(player,
                                           (add_remove) ? "@cpflags: Set." :
                                           "@cpflags: Cleared.");
                        return;
                }
                raw_notify(player, "@cpflags: Unknown Flag.");
                break;
        case 4:
                if(strcasecmp(s, "join") == 0) {
                        add_remove ? (ch->type |=
                                                  (CHANNEL_OBJ_MULT * CHANNEL_JOIN)) : (ch->type &=
                                                                                                                                ~
                                                                                                                                (CHANNEL_OBJ_MULT
                                                                                                                                 *
                                                                                                                                 CHANNEL_JOIN));
                        raw_notify(player,
                                           (add_remove) ? "@coflags: Set." :
                                           "@coflags: Cleared.");
                        return;
                }
                if(strcasecmp(s, "receive") == 0) {
                        add_remove ? (ch->type |=
                                                  (CHANNEL_OBJ_MULT * CHANNEL_RECIEVE)) : (ch->type &=
                                                                                                                                   ~
                                                                                                                                   (CHANNEL_OBJ_MULT
                                                                                                                                        *
                                                                                                                                        CHANNEL_RECIEVE));
                        raw_notify(player,
                                           (add_remove) ? "@coflags: Set." :
                                           "@coflags: Cleared.");
                        return;
                }
                if(strcasecmp(s, "transmit") == 0) {
                        add_remove ? (ch->type |=
                                                  (CHANNEL_OBJ_MULT *
                                                   CHANNEL_TRANSMIT)) : (ch->type &=
                                                                                                 ~(CHANNEL_OBJ_MULT *
                                                                                                   CHANNEL_TRANSMIT));
                        raw_notify(player,
                                           (add_remove) ? "@coflags: Set." :
                                           "@coflags: Cleared.");
                        return;
                }
                raw_notify(player, "@coflags: Unknown Flag.");
                break;
        }
        return;
}

void do_listchannels

(

dbref

player

)

Definition at line 825 of file comsys.c.

References channel::amount_col, channel::chan_obj, statedata::channel_htab, CHANNEL_JOIN, CHANNEL_LOUD, CHANNEL_OBJ_MULT, CHANNEL_PL_MULT, CHANNEL_PUBLIC, CHANNEL_RECIEVE, CHANNEL_TRANSMIT, channel::charge, channel::charge_who, Comm_All, hash_firstentry(), hash_nextentry(), mudstate, channel::name, NOTHING, notify_printf(), channel::num_messages, channel::num_users, raw_notify(), and channel::type.

Referenced by do_chanlist().

{
        struct channel *ch;
        int perm;

        if(!(perm = Comm_All(player))) {
                raw_notify(player,
                                   "Warning: Only public channels and your channels will be shown.");
        }
        raw_notify(player,
                           "** Channel             --Flags--  Obj   Own   Charge  Balance  Users   Messages");

        for(ch = (struct channel *) hash_firstentry(&mudstate.channel_htab);
                ch; ch = (struct channel *) hash_nextentry(&mudstate.channel_htab))
                if(perm || (ch->type & CHANNEL_PUBLIC)
                   || ch->charge_who == player) {

                        notify_printf(player,
                                                  "%c%c %-20.20s %c%c%c/%c%c%c %5d %5d %8d %8d %6d %10d",
                                                  (ch->type & (CHANNEL_PUBLIC)) ? 'P' : '-',
                                                  (ch->type & (CHANNEL_LOUD)) ? 'L' : '-', ch->name,
                                                  (ch->type & (CHANNEL_PL_MULT *
                                                                           CHANNEL_JOIN)) ? 'J' : '-',
                                                  (ch->type & (CHANNEL_PL_MULT *
                                                                           CHANNEL_TRANSMIT)) ? 'X' : '-',
                                                  (ch->type & (CHANNEL_PL_MULT *
                                                                           CHANNEL_RECIEVE)) ? 'R' : '-',
                                                  (ch->type & (CHANNEL_OBJ_MULT *
                                                                           CHANNEL_JOIN)) ? 'j' : '-',
                                                  (ch->type & (CHANNEL_OBJ_MULT *
                                                                           CHANNEL_TRANSMIT)) ? 'x' : '-',
                                                  (ch->type & (CHANNEL_OBJ_MULT *
                                                                           CHANNEL_RECIEVE)) ? 'r' : '-',
                                                  (ch->chan_obj != NOTHING) ? ch->chan_obj : -1,
                                                  ch->charge_who, ch->charge, ch->amount_col,
                                                  ch->num_users, ch->num_messages);
                }
        raw_notify(player, "-- End of list of Channels --");
}

void do_processcom	(	dbref	player,
		char *	arg1,
		char *	arg2
	)

Definition at line 274 of file comsys.c.

References confdata::allow_chanlurking, channel::amount_col, CHANNEL_TRANSMIT, channel::charge, channel::charge_who, do_comlast(), do_comprintf(), do_comwho(), do_joinchannel(), do_leavechannel(), do_test_access(), giveto(), Guest, In_IC_Loc(), LBUF_SIZE, confdata::many_coins, mudconf, Name(), notify_printf(), comuser::on, payfor(), raw_notify(), select_channel(), select_user(), comuser::title, and Wizard.

Referenced by do_allcom(), and do_comsystem().

{
        struct channel *ch;
        struct comuser *user;

        if((strlen(arg1) + strlen(arg2)) > LBUF_SIZE / 2) {
                arg2[LBUF_SIZE / 2 - strlen(arg1)] = '\0';
        }
        if(!*arg2) {
                raw_notify(player, "No message.");
                return;
        }

        if(!Wizard(player) && In_IC_Loc(player)) {
                raw_notify(player, "Permission denied.");
                return;
        }

        if(!(ch = select_channel(arg1))) {
                notify_printf(player, "Unknown channel %s.", arg1);
                return;
        }
        if(!(user = select_user(ch, player))) {
                raw_notify(player,
                                   "You are not listed as on that channel.  Delete this alias and re-add.");
                return;
        }
        if(!strcasecmp(arg2, "on")) {
                do_joinchannel(player, ch);
        } else if(!strcasecmp(arg2, "off")) {
                do_leavechannel(player, ch);
        } else if(!user->on && !Wizard(player) && !mudconf.allow_chanlurking) {
                notify_printf(player, "You must be on %s to do that.", arg1);
                return;
        } else if(!strcasecmp(arg2, "who")) {
                do_comwho(player, ch);
        } else if(!strcasecmp(arg2, "last")) {
                do_comlast(player, ch);
        } else if(!user->on) {
                notify_printf(player, "You must be on %s to do that.", arg1);
                return;
        } else if(!do_test_access(player, CHANNEL_TRANSMIT, ch)) {
                raw_notify(player, "That channel type cannot be transmitted on.");
                return;
        } else {
                if(!payfor(player, Guest(player) ? 0 : ch->charge)) {
                        notify_printf(player, "You don't have enough %s.",
                                                  mudconf.many_coins);
                        return;
                } else {
                        ch->amount_col += ch->charge;
                        giveto(ch->charge_who, ch->charge);
                }

                if((*arg2) == ':')
                        do_comprintf(ch, "[%s] %s %s", arg1, Name(player), arg2 + 1);
                else if((*arg2) == ';')
                        do_comprintf(ch, "[%s] %s%s", arg1, Name(player), arg2 + 1);
                else if(strlen(user->title))
                        do_comprintf(ch, "[%s] %s: <%s> %s", arg1, Name(player), user->title, arg2);
                else
                        do_comprintf(ch, "[%s] %s: %s", arg1, Name(player), arg2);
        }
}

char* get_channel_from_alias	(	dbref	player,
		char *	alias
	)

Definition at line 66 of file comsys.c.

References c, dir, and get_commac().

Referenced by do_comsystem(), and do_comtitle().

{
        struct commac *c;
        int first, last, current = 0;
        int dir;

        c = get_commac(player);

        first = 0;
        last = c->numchannels - 1;
        dir = 1;

        while (dir && (first <= last)) {
                current = (first + last) / 2;
                dir = strcasecmp(alias, c->alias + 6 * current);
                if(dir < 0)
                        last = current - 1;
                else
                        first = current + 1;
        }

        if(!dir)
                return c->channels[current];
        else
                return "";
}

void init_chantab

(

void

)

Definition at line 41 of file comsys.c.

References statedata::channel_htab, HASH_FACTOR, hashinit(), and mudstate.

Referenced by main().

{
        hashinit(&mudstate.channel_htab, 30 * HASH_FACTOR);
}

void load_comsystem

(

FILE *

fp

)

Definition at line 93 of file comsys.c.

References c, CHAN_NAME_LEN, statedata::channel_htab, Create, do_joinchannel(), God, Going, hashadd(), isPlayer, LBUF_SIZE, mudstate, myfifo_push(), channel::name, num_channels, comuser::on, comuser::on_next, channel::on_users, Owner, sort_users(), comuser::title, and comuser::who.

{
        int i, j, k, dummy;
        int nc, new = 0;
        struct channel *ch;
        struct comuser *user;
        char temp[LBUF_SIZE];
        char buf[8];

        num_channels = 0;

        fgets(buf, sizeof(buf), fp);
        if(!strncmp(buf, "+V2", 3)) {
                new = 2;
                fscanf(fp, "%d\n", &nc);
        } else if(!strncmp(buf, "+V1", 3)) {
                new = 1;
                fscanf(fp, "%d\n", &nc);
        } else
                nc = atoi(buf);

        num_channels = nc;

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

                fscanf(fp, "%[^\n]\n", temp);

                strncpy(ch->name, temp, CHAN_NAME_LEN);
                ch->name[CHAN_NAME_LEN - 1] = '\0';
                ch->on_users = NULL;

                hashadd(ch->name, (int *) ch, &mudstate.channel_htab);

                ch->last_messages = NULL;

                if(new) {                               /* V1 or higher */

                        if(fscanf(fp,
                                          new ==
                                          1 ? "%d %d %d %d %d %d %d %d\n" :
                                          "%d %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), &dummy) >= 9 &&
                           new > 1) {
                                /* Do things with 'dummy' */
                                if(dummy > 0) {
                                        for(j = 0; j < dummy; j++) {
                                                chmsg *c;

                                                fscanf(fp, "%d %[^\n]\n", &k, temp);
                                                Create(c, chmsg, 1);
                                                c->msg = strdup(temp);
                                                c->time = k;
                                                myfifo_push(&ch->last_messages, c);
                                        }
                                }
                        }
                } else {
                        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));
                }

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

                        for(j = 0; j < ch->num_users; j++) {
                                user = (struct comuser *) malloc(sizeof(struct comuser));

                                ch->users[j] = user;

                                if(new) {
                                        fscanf(fp, "%d %d\n", &(user->who), &(user->on));
                                } else {
                                        fscanf(fp, "%d %d %d", &(user->who), &(dummy), &(dummy));
                                        fscanf(fp, "%d\n", &(user->on));
                                }

                                fscanf(fp, "%[^\n]\n", temp);

                                user->title = strdup(temp + 2);

                                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;
                                } else {
                                        user->on_next = ch->on_users;
                                        ch->on_users = user;
                                }
                        }
                        sort_users(ch);
                } else
                        ch->users = NULL;
        }
}

void save_comsystem

(

FILE *

fp

)

Definition at line 204 of file comsys.c.

References channel::amount_col, channel::chan_obj, statedata::channel_htab, channel::charge, channel::charge_who, do_save_com(), hash_firstentry(), hash_nextentry(), isPlayer, isRobot, mudstate, myfifo_length(), myfifo_trav_r(), channel::name, num_channels, channel::num_messages, channel::num_users, comuser::on, channel::temp1, channel::temp2, temp_file, comuser::title, channel::type, channel::users, and comuser::who.

{
        struct channel *ch;
        struct comuser *user;
        int j, k, player_users;

        fprintf(fp, "+V2\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);
                k = myfifo_length(&ch->last_messages);
                /*            1  2  3  4  5  6  7  8  9 */
                fprintf(fp, "%d %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, k);

                if(k) {
                        temp_file = fp;
                        myfifo_trav_r(&ch->last_messages, do_save_com);
                }
                player_users = 0;
                for(j = 0; j < ch->num_users; j++)
                        if(isPlayer(ch->users[j]->who) || isRobot(ch->users[j]->who))
                                player_users++;

                fprintf(fp, "%d\n", player_users);
                for(j = 0; j < ch->num_users; j++) {
                        user = ch->users[j];
                        if(!isPlayer(user->who) && !isRobot(user->who))
                                continue;
                        fprintf(fp, "%d %d\n", user->who, user->on);
                        if(strlen(user->title))
                                fprintf(fp, "t:%s\n", user->title);
                        else
                                fprintf(fp, "t:\n");
                }
        }
}

struct channel* select_channel

(

char *

channel

)

Definition at line 519 of file comsys.c.

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

Referenced by do_addcom(), do_cemit(), do_channelwho(), do_chanobj(), do_chanstatus(), do_chboot(), do_chclose(), do_chloud(), do_chopaque(), do_chopen(), do_chsquelch(), do_chtransparent(), do_comconnectchannel(), do_comconnectraw_notify(), do_comdisconnectchannel(), do_comdisconnectraw_notify(), do_comlist(), do_comtitle(), do_createchannel(), do_delcomchannel(), do_editchannel(), do_processcom(), fun_cemit(), fun_clist(), fun_cobj(), fun_cwho(), and send_channel().

{
        return (struct channel *) hashfind(channel, &mudstate.channel_htab);
}

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

Definition at line 524 of file comsys.c.

References dir, channel::num_users, and channel::users.

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

{
        int last, current;
        int dir = 1, first = 0;

        if(!ch)
                return NULL;

        last = ch->num_users - 1;
        current = (first + last) / 2;

        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 send_channel	(	char *	chan,
		const char *	format,
			...
	)

Definition at line 46 of file comsys.c.

References do_comsend(), LBUF_SIZE, and select_channel().

Referenced by announce_connect(), announce_disconnect(), do_comconnect(), do_comdisconnect(), do_fixdb(), do_kill(), do_name(), mech_sendchannel(), and process_command().

{
        struct channel *ch;
        char buf[LBUF_SIZE];
        char data[LBUF_SIZE];
        char *newline;
        va_list ap;

        if(!(ch = select_channel(chan)))
                return;
        va_start(ap, format);
        vsnprintf(data, LBUF_SIZE, format, ap);
        va_end(ap);

        snprintf(buf, LBUF_SIZE-1, "[%s] %s", chan, data);
        while ((newline = strchr(buf, '\n')))
                *newline = ' ';
        do_comsend(ch, buf);
}

---