mux/src/netcommon.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include <time.h>
#include "ansi.h"
#include "attrs.h"
#include "command.h"
#include "comsys.h"
#include "file_c.h"
#include "functions.h"
#include "mguests.h"
#include "powers.h"
#include "svdreport.h"

Include dependency graph for netcommon.cpp:

Go to the source code of this file.

Defines
#define	MAX_TRIMMED_NAME_LENGTH   16
#define	INFO_VERSION   "1"
#define	S_SUSPECT   1
#define	S_ACCESS   2
#define	CIF_LOGOUTTIME   4
Functions
void	make_portlist (dbref player, dbref target, char *buff, char **bufc)
void	make_port_ulist (dbref player, char *buff, char **bufc)
void	update_quotas (CLinearTimeAbsolute &ltaLast, const CLinearTimeAbsolute &ltaCurrent)
void	raw_notify_html (dbref player, const char *msg)
void	raw_notify (dbref player, const char *msg)
void	raw_notify_newline (dbref player)
void DCL_CDECL	raw_broadcast (int inflags, char *fmt,...)
void	clearstrings (DESC *d)
static void	add_to_output_queue (DESC *d, const char *b, int n)
void	queue_write_LEN (DESC *d, const char *b, int n)
void	queue_write (DESC *d, const char *b)
static const char *	encode_iac (const char *szString)
void	queue_string (DESC *d, const char *s)
void	freeqs (DESC *d)
void	desc_addhash (DESC *d)
static void	desc_delhash (DESC *d)
void	welcome_user (DESC *d)
void	save_command (DESC *d, CBLK *command)
static void	set_userstring (char **userstring, const char *command)
static void	parse_connect (const char *msg, char *command, char *user, char *pass)
static void	announce_connect (dbref player, DESC *d)
void	announce_disconnect (dbref player, DESC *d, const char *reason)
int	boot_off (dbref player, const char *message)
int	boot_by_port (SOCKET port, bool bGod, const char *message)
void	desc_reload (dbref player)
int	fetch_session (dbref target)
static DESC *	find_least_idle (dbref target)
int	fetch_height (dbref target)
int	fetch_width (dbref target)
int	fetch_idle (dbref target)
void	find_oldest (dbref target, DESC *dOldest[2])
int	fetch_connect (dbref target)
void	check_idle (void)
void	check_events (void)
static const char *	trimmed_name (dbref player, int *pvw)
static char *	trimmed_site (char *szName)
static void	dump_users (DESC *e, char *match, int key)
static void	dump_info (DESC *arg_desc)
static char *	MakeCanonicalDoing (char *pDoing, int *pnValidDoing, bool *pbValidDoing)
void	do_doing (dbref executor, dbref caller, dbref enactor, int key, char *arg)
void	init_logout_cmdtab (void)
static void	failconn (const char *logcode, const char *logtype, const char *logreason, DESC *d, int disconnect_reason, dbref player, int filecache, char *motd_msg, char *command, char *user, char *password, char *cmdsave)
static bool	check_connect (DESC *d, char *msg)
static void	do_logged_out_internal (DESC *d, int key, char *arg)
void	do_command (DESC *d, char *command)
void	logged_out1 (dbref executor, dbref caller, dbref enactor, int key, char *arg)
void	logged_out0 (dbref executor, dbref caller, dbref enactor, int key)
void	Task_ProcessCommand (void *arg_voidptr, int arg_iInteger)
int	site_check (struct in_addr host, SITE *site_list)
static const char *	stat_string (int strtype, int flag)
static void	list_sites (dbref player, SITE *site_list, const char *header_txt, int stat_type)
void	list_siteinfo (dbref player)
void	make_ulist (dbref player, char *buff, char **bufc, bool bPorts)
dbref	find_connected_name (dbref player, char *name)
	FUNCTION (fun_doing)
	FUNCTION (fun_host)
	FUNCTION (fun_poll)
	FUNCTION (fun_motd)
int	fetch_cmds (dbref target)
static void	ParseConnectionInfoString (char *pConnInfo, char *pFields[5])
void	fetch_ConnectionInfoFields (dbref target, long anFields[4])
void	put_ConnectionInfoFields (dbref target, long anFields[4], CLinearTimeAbsolute &ltaLogout)
long	fetch_ConnectionInfoField (dbref target, int iField)
CLinearTimeAbsolute	fetch_logouttime (dbref target)
Variables
NAMETAB	logout_cmdtable []
static const char *	connect_fail = "Either that player does not exist, or has a different password.\r\n"

---

Define Documentation

#define CIF_LOGOUTTIME   4

Definition at line 2984 of file netcommon.cpp.

Referenced by fetch_logouttime().

#define INFO_VERSION   "1"

Definition at line 1719 of file netcommon.cpp.

Referenced by dump_info().

#define MAX_TRIMMED_NAME_LENGTH   16

Definition at line 1412 of file netcommon.cpp.

Referenced by trimmed_name().

#define S_ACCESS   2

Definition at line 2589 of file netcommon.cpp.

Referenced by list_siteinfo(), and stat_string().

#define S_SUSPECT   1

Definition at line 2588 of file netcommon.cpp.

Referenced by list_siteinfo(), and stat_string().

---

Function Documentation

static void add_to_output_queue	(	DESC *	d,
		const char *	b,
		int	n
	)			[static]

Definition at line 253 of file netcommon.cpp.

References text_block::data, text_block_hdr::end, text_block::hdr, ISOUTOFMEMORY, left, MEMALLOC, text_block_hdr::nchars, text_block_hdr::nxt, OUTPUT_BLOCK_SIZE, descriptor_data::output_head, descriptor_data::output_tail, and text_block_hdr::start.

Referenced by queue_write_LEN().

{
    TBLOCK *tp;
    int left;

    // Allocate an output buffer if needed.
    //
    if (d->output_head == NULL)
    {
        tp = (TBLOCK *)MEMALLOC(OUTPUT_BLOCK_SIZE);
        ISOUTOFMEMORY(tp);
        tp->hdr.nxt = NULL;
        tp->hdr.start = tp->data;
        tp->hdr.end = tp->data;
        tp->hdr.nchars = 0;
        d->output_head = tp;
        d->output_tail = tp;
    }
    else
    {
        tp = d->output_tail;
    }

    // Now tp points to the last buffer in the chain.
    //
    do
    {
        // See if there is enough space in the buffer to hold the
        // string.  If so, copy it and update the pointers..
        //
        left = OUTPUT_BLOCK_SIZE - (tp->hdr.end - (char *)tp + 1);
        if (n <= left)
        {
            memcpy(tp->hdr.end, b, n);
            tp->hdr.end += n;
            tp->hdr.nchars += n;
            n = 0;
        }
        else
        {
            // It didn't fit.  Copy what will fit and then allocate
            // another buffer and retry.
            //
            if (left > 0)
            {
                memcpy(tp->hdr.end, b, left);
                tp->hdr.end += left;
                tp->hdr.nchars += left;
                b += left;
                n -= left;
            }
            tp = (TBLOCK *)MEMALLOC(OUTPUT_BLOCK_SIZE);
            ISOUTOFMEMORY(tp);
            tp->hdr.nxt = NULL;
            tp->hdr.start = tp->data;
            tp->hdr.end = tp->data;
            tp->hdr.nchars = 0;
            d->output_tail->hdr.nxt = tp;
            d->output_tail = tp;
        }
    } while (n > 0);
}

static void announce_connect	(	dbref	player,
		DESC *	d
	)			[static]

Definition at line 706 of file netcommon.cpp.

References A_ACONNECT, A_LPAGE, A_TIMEOUT, descriptor_data::addr, descriptor_data::address, alloc_lbuf, ANSI_HILITE, ANSI_NORMAL, atr_get_str_LEN(), atr_pget_str_LEN(), Can_Hide, CF_LOGIN, check_mail(), Contents, confdata::control_flags, statedata::curr_enactor, DARK, db, desc_addhash(), DESC_ITER_CONN, DESC_ITER_PLAYER, do_comconnect(), DOLIST, DS_PUEBLOCLIENT, FLAG_WORD1, FLAG_WORD2, descriptor_data::flags, Flags2, free_lbuf, object::fs, CLinearTimeAbsolute::GetLocal(), Good_obj, Guest, H_SUSPECT, confdata::have_comsys, confdata::have_mailer, confdata::have_zones, Hidden, descriptor_data::host_info, confdata::idle_timeout, LK_OBEYTERSE, LK_SHOWEXIT, LK_SHOWVRML, Location, log_text(), look_in(), confdata::master_room, Moniker(), MONITOR, confdata::motd_msg, MSG_FWDLIST, MSG_INV, MSG_LOC, MSG_NBR, MSG_NBR_EXITS, mudconf, mudstate, mux_atol(), Name, NOTHING, notify_check(), notify_except_rlevel(), raw_broadcast(), raw_notify(), record_login(), statedata::record_players, CLinearTimeAbsolute::ReturnDateString(), s_Connected, s_Flags, s_Html, Suspect, descriptor_data::timeout, tprintf(), TYPE_ROOM, TYPE_THING, Typeof, descriptor_data::username, VACATION, wait_que(), WIZARD, Wizard, confdata::wizmotd_msg, flagset::word, and Zone.

Referenced by check_connect().

{
    desc_addhash(d);

    DESC *dtemp;
    int count = 0;
    DESC_ITER_CONN(dtemp)
    {
        count++;
    }

    if (mudstate.record_players < count)
    {
        mudstate.record_players = count;
    }

    char *buf = alloc_lbuf("announce_connect");
    dbref aowner;
    int aflags;
    size_t nLen;
    atr_pget_str_LEN(buf, player, A_TIMEOUT, &aowner, &aflags, &nLen);
    if (nLen)
    {
        d->timeout = mux_atol(buf);
        if (d->timeout <= 0)
        {
            d->timeout = mudconf.idle_timeout;
        }
    }

    dbref loc = Location(player);
    s_Connected(player);

    if (d->flags & DS_PUEBLOCLIENT)
    {
        s_Html(player);
    }

    raw_notify( player, tprintf("\n%sMOTD:%s %s\n", ANSI_HILITE,
                ANSI_NORMAL, mudconf.motd_msg));

    if (Wizard(player))
    {
        raw_notify(player, tprintf("%sWIZMOTD:%s %s\n", ANSI_HILITE,
            ANSI_NORMAL, mudconf.wizmotd_msg));

        if (!(mudconf.control_flags & CF_LOGIN))
        {
            raw_notify(player, "*** Logins are disabled.");
        }
    }
    atr_get_str_LEN(buf, player, A_LPAGE, &aowner, &aflags, &nLen);
    if (nLen)
    {
        raw_notify(player, "Your PAGE LOCK is set.  You may be unable to receive some pages.");
    }
    int num = 0;
    DESC_ITER_PLAYER(player, dtemp)
    {
        num++;
    }

    // Reset vacation flag.
    //
    s_Flags(player, FLAG_WORD2, Flags2(player) & ~VACATION);

    char *pRoomAnnounceFmt;
    char *pMonitorAnnounceFmt;
    if (num < 2)
    {
        pRoomAnnounceFmt = "%s has connected.";
        if (mudconf.have_comsys)
        {
            do_comconnect(player);
        }
        if (  Hidden(player)
           && Can_Hide(player))
        {
            pMonitorAnnounceFmt = "GAME: %s has DARK-connected.";
        }
        else
        {
            pMonitorAnnounceFmt = "GAME: %s has connected.";
        }
        if (  Suspect(player)
           || (d->host_info & H_SUSPECT))
        {
            raw_broadcast(WIZARD, "[Suspect] %s has connected.", Moniker(player));
        }
    }
    else
    {
        pRoomAnnounceFmt = "%s has reconnected.";
        pMonitorAnnounceFmt = "GAME: %s has reconnected.";
        if (  Suspect(player)
           || (d->host_info & H_SUSPECT))
        {
            raw_broadcast(WIZARD, "[Suspect] %s has reconnected.", Moniker(player));
        }
    }
    sprintf(buf, pRoomAnnounceFmt, Moniker(player));
    raw_broadcast(MONITOR, pMonitorAnnounceFmt, Moniker(player));

    int key = MSG_INV;
    if (  loc != NOTHING
       && !(  Hidden(player)
           && Can_Hide(player)))
    {
        key |= (MSG_NBR | MSG_NBR_EXITS | MSG_LOC | MSG_FWDLIST);
    }

    dbref temp = mudstate.curr_enactor;
    mudstate.curr_enactor = player;
#ifdef REALITY_LVLS
    if(loc == NOTHING)
        notify_check(player, player, buf, key);
    else
        notify_except_rlevel(loc, player, player, buf, 0);
#else
    notify_check(player, player, buf, key);
#endif /* REALITY_LVLS */
    atr_pget_str_LEN(buf, player, A_ACONNECT, &aowner, &aflags, &nLen);
    CLinearTimeAbsolute lta;
    dbref zone, obj;
    if (nLen)
    {
        wait_que(player, player, player, false, lta, NOTHING, 0, buf,
            (char **)NULL, 0, NULL);
    }
    if (mudconf.master_room != NOTHING)
    {
        atr_pget_str_LEN(buf, mudconf.master_room, A_ACONNECT, &aowner,
            &aflags, &nLen);
        if (nLen)
        {
            wait_que(mudconf.master_room, player, player, false, lta,
                NOTHING, 0, buf, (char **)NULL, 0, NULL);
        }
        DOLIST(obj, Contents(mudconf.master_room))
        {
            atr_pget_str_LEN(buf, obj, A_ACONNECT, &aowner, &aflags, &nLen);
            if (nLen)
            {
                wait_que(obj, player, player, false, lta, NOTHING, 0, buf,
                    (char **)NULL, 0, NULL);
            }
        }
    }

    // Do the zone of the player's location's possible aconnect.
    //
    if (  mudconf.have_zones
       && Good_obj(zone = Zone(loc)))
    {
        switch (Typeof(zone))
        {
        case TYPE_THING:

            atr_pget_str_LEN(buf, zone, A_ACONNECT, &aowner, &aflags, &nLen);
            if (nLen)
            {
                wait_que(zone, player, player, false, lta, NOTHING, 0, buf,
                    (char **)NULL, 0, NULL);
            }
            break;

        case TYPE_ROOM:

            // check every object in the room for a connect action.
            //
            DOLIST(obj, Contents(zone))
            {
                atr_pget_str_LEN(buf, obj, A_ACONNECT, &aowner, &aflags,
                    &nLen);
                if (nLen)
                {
                    wait_que(obj, player, player, false, lta, NOTHING, 0,
                        buf, (char **)NULL, 0, NULL);
                }
            }
            break;

        default:

            log_text(tprintf("Invalid zone #%d for %s(#%d) has bad type %d",
                zone, Name(player), player, Typeof(zone)));
        }
    }
    free_lbuf(buf);
    CLinearTimeAbsolute ltaNow;
    ltaNow.GetLocal();
    char *time_str = ltaNow.ReturnDateString(7);

    record_login(player, true, time_str, d->addr, d->username,
        inet_ntoa((d->address).sin_addr));
    if (mudconf.have_mailer)
    {
        check_mail(player, 0, false);
    }
    look_in(player, Location(player), (LK_SHOWEXIT|LK_OBEYTERSE|LK_SHOWVRML));
    mudstate.curr_enactor = temp;
    if (Guest(player))
    {
        db[player].fs.word[FLAG_WORD1] &= ~DARK;
    }
}

void announce_disconnect	(	dbref	player,
		DESC *	d,
		const char *	reason
	)

Definition at line 913 of file netcommon.cpp.

References A_ADISCONNECT, alloc_lbuf, alloc_mbuf, argv, atr_pget_str_LEN(), c_Connected, Can_Hide, Contents, statedata::curr_enactor, DARK, db, desc_delhash(), DESC_ITER_PLAYER, do_comdisconnect(), do_mail_purge(), DOLIST, DS_AUTODARK, FLAG_WORD1, descriptor_data::flags, free_lbuf, free_mbuf, object::fs, Good_obj, Guest, H_SUSPECT, halt_que(), confdata::have_comsys, confdata::have_mailer, confdata::have_zones, Hidden, descriptor_data::host_info, local_disconnect(), Location, log_text(), confdata::master_room, Moniker(), MONITOR, MSG_FWDLIST, MSG_INV, MSG_LOC, MSG_NBR, MSG_NBR_EXITS, mudconf, mudstate, Name, NOTHING, notify_check(), notify_except_rlevel(), raw_broadcast(), Suspect, tprintf(), TYPE_ROOM, TYPE_THING, Typeof, wait_que(), WIZARD, flagset::word, and Zone.

Referenced by shutdownsock().

{
    int num = 0, key;
    DESC *dtemp;
    DESC_ITER_PLAYER(player, dtemp)
    {
        num++;
    }

    dbref temp = mudstate.curr_enactor;
    mudstate.curr_enactor = player;
    dbref loc = Location(player);

    if (num < 2)
    {
        if (  Suspect(player)
           || (d->host_info & H_SUSPECT))
        {
            raw_broadcast(WIZARD, "[Suspect] %s has disconnected.", Moniker(player));
        }
        char *buf = alloc_lbuf("announce_disconnect.only");

        sprintf(buf, "%s has disconnected.", Moniker(player));
        key = MSG_INV;
        if (  loc != NOTHING
           && !(  Hidden(player)
               && Can_Hide(player)))
        {
            key |= (MSG_NBR | MSG_NBR_EXITS | MSG_LOC | MSG_FWDLIST);
        }
#ifdef REALITY_LVLS
        if(loc == NOTHING)
            notify_check(player, player, buf, key);
        else
            notify_except_rlevel(loc, player, player, buf, 0);
#else
        notify_check(player, player, buf, key);
#endif /* REALITY_LVLS */

        if (mudconf.have_mailer)
        {
            do_mail_purge(player);
        }

        raw_broadcast(MONITOR, "GAME: %s has disconnected. <%s>", Moniker(player), reason);

        c_Connected(player);

        if (mudconf.have_comsys)
        {
            do_comdisconnect(player);
        }

        dbref aowner, zone, obj;
        int aflags;
        size_t nLen;
        char *argv[1];
        argv[0] = (char *)reason;
        CLinearTimeAbsolute lta;
        atr_pget_str_LEN(buf, player, A_ADISCONNECT, &aowner, &aflags, &nLen);
        if (nLen)
        {
            wait_que(player, player, player, false, lta, NOTHING, 0, buf,
                argv, 1, NULL);
        }
        if (mudconf.master_room != NOTHING)
        {
            atr_pget_str_LEN(buf, mudconf.master_room, A_ADISCONNECT, &aowner,
                &aflags, &nLen);
            if (nLen)
            {
                wait_que(mudconf.master_room, player, player, false, lta,
                    NOTHING, 0, buf, (char **)NULL, 0, NULL);
            }
            DOLIST(obj, Contents(mudconf.master_room))
            {
                atr_pget_str_LEN(buf, obj, A_ADISCONNECT, &aowner, &aflags,
                    &nLen);
                if (nLen)
                {
                    wait_que(obj, player, player, false, lta, NOTHING, 0,
                        buf, (char **)NULL, 0, NULL);
                }
            }
        }

        // Do the zone of the player's location's possible adisconnect.
        //
        if (mudconf.have_zones && Good_obj(zone = Zone(loc)))
        {
            switch (Typeof(zone))
            {
            case TYPE_THING:

                atr_pget_str_LEN(buf, zone, A_ADISCONNECT, &aowner, &aflags,
                    &nLen);
                if (nLen)
                {
                    wait_que(zone, player, player, false, lta, NOTHING, 0,
                        buf, (char **)NULL, 0, NULL);
                }
                break;

            case TYPE_ROOM:

                // check every object in the room for a connect action.
                //
                DOLIST(obj, Contents(zone))
                {
                    atr_pget_str_LEN(buf, obj, A_ADISCONNECT, &aowner, &aflags,
                        &nLen);
                    if (nLen)
                    {
                        wait_que(obj, player, player, false, lta, NOTHING,
                            0, buf, (char **)NULL, 0, NULL);
                    }
                }
                break;

            default:
                log_text(tprintf("Invalid zone #%d for %s(#%d) has bad type %d",
                    zone, Name(player), player, Typeof(zone)));
            }
        }
        free_lbuf(buf);
        if (d->flags & DS_AUTODARK)
        {
            d->flags &= ~DS_AUTODARK;
            db[player].fs.word[FLAG_WORD1] &= ~DARK;
        }

        if (Guest(player))
        {
            db[player].fs.word[FLAG_WORD1] |= DARK;
            halt_que(NOTHING, player);
        }
    }
    else
    {
        if (  Suspect(player)
           || (d->host_info & H_SUSPECT))
        {
            raw_broadcast(WIZARD, "[Suspect] %s has partially disconnected.", Moniker(player));
        }
        char *mbuf = alloc_mbuf("announce_disconnect.partial");
        sprintf(mbuf, "%s has partially disconnected.", Moniker(player));
        key = MSG_INV;
        if (  loc != NOTHING
           && !(  Hidden(player)
               && Can_Hide(player)))
        {
            key |= (MSG_NBR | MSG_NBR_EXITS | MSG_LOC | MSG_FWDLIST);
        }
#ifdef REALITY_LVLS
        if(loc == NOTHING)
            notify_check(player, player, mbuf, key);
        else
            notify_except_rlevel(loc, player, player, mbuf, 0);
#else
        notify_check(player, player, mbuf, key);
#endif /* REALITY_LVLS */
        raw_broadcast(MONITOR, "GAME: %s has partially disconnected.",
            Moniker(player));
        free_mbuf(mbuf);
    }

    mudstate.curr_enactor = temp;
    desc_delhash(d);

    local_disconnect(player, num);
}

int boot_by_port	(	SOCKET	port,
		bool	bGod,
		const char *	message
	)

Definition at line 1102 of file netcommon.cpp.

References DESC_SAFEITER_ALL, descriptor_data::descriptor, DS_CONNECTED, descriptor_data::flags, God, descriptor_data::player, queue_string(), queue_write_LEN(), R_BOOT, and shutdownsock().

Referenced by do_boot().

{
    DESC *d, *dnext;
    int count = 0;
    DESC_SAFEITER_ALL(d, dnext)
    {
        if (  d->descriptor == port
           && (  bGod
              || !(d->flags & DS_CONNECTED)
              || !God(d->player)))
        {
            if (  message
               && *message)
            {
                queue_string(d, message);
                queue_write_LEN(d, "\r\n", 2);
            }
            shutdownsock(d, R_BOOT);
            count++;
        }
    }
    return count;
}

int boot_off	(	dbref	player,
		const char *	message
	)

Definition at line 1085 of file netcommon.cpp.

References DESC_SAFEITER_PLAYER, queue_string(), queue_write_LEN(), R_BOOT, and shutdownsock().

Referenced by destroy_player(), do_boot(), and do_toad().

{
    DESC *d, *dnext;
    int count = 0;
    DESC_SAFEITER_PLAYER(player, d, dnext)
    {
        if (message && *message)
        {
            queue_string(d, message);
            queue_write_LEN(d, "\r\n", 2);
        }
        shutdownsock(d, R_BOOT);
        count++;
    }
    return count;
}

static bool check_connect	(	DESC *	d,
		char *	msg
	)			[static]

Definition at line 1954 of file netcommon.cpp.

References A_LAST, descriptor_data::addr, descriptor_data::address, AddToPublicChannel(), alloc_lbuf, alloc_mbuf, confdata::allow_guest_from_registered_site, announce_connect(), atr_get, CF_GUEST, CF_LOGIN, connect_player(), descriptor_data::connected_at, confdata::control_flags, create_player(), DARK, db, statedata::debug_cmd, DESC_ITER_CONN, DESC_ITER_PLAYER, descriptor_data::descriptor, confdata::downmotd_msg, DS_CONNECTED, ENDLOG, failconn(), FC_CONN_DOWN, FC_CONN_FULL, FC_CONN_GUEST, FC_CONN_REG, FC_CONN_SITE, FC_CREA_NEW, FC_CREA_REG, FC_MOTD, FC_WIZMOTD, fcache_dump(), FLAG_WORD1, descriptor_data::flags, free_lbuf, free_mbuf, object::fs, confdata::fullmotd_msg, CLinearTimeAbsolute::GetUTC(), God, Guest, confdata::guest_char, GUEST_PASSWORD, confdata::guest_prefix, H_GUEST, H_REGISTRATION, descriptor_data::host_info, descriptor_data::input_tot, local_connect(), LOG_LOGIN, log_name(), log_name_and_loc(), LOG_PCREATES, LOG_SECURITY, log_text(), confdata::max_players, move_object(), mudconf, mudstate, NOTHING, parse_connect(), descriptor_data::player, descriptor_data::program_data, queue_write(), queue_write_LEN(), R_BADLOGIN, R_GAMEDOWN, R_GAMEFULL, shutdownsock(), confdata::start_room, STARTLOG, string_prefix(), descriptor_data::username, welcome_user(), Wizard, WizRoy, and flagset::word.

Referenced by do_command().

{
    char *buff;
    dbref player, aowner;
    int aflags, nplayers;
    DESC *d2;
    const char *p;
    bool isGuest = false;

    char *cmdsave = mudstate.debug_cmd;
    mudstate.debug_cmd = (char *)"< check_connect >";

    // Hide the password length from SESSION.
    //
    d->input_tot -= (strlen(msg) + 1);

    // Crack the command apart.
    //
    char *command = alloc_lbuf("check_conn.cmd");
    char *user = alloc_lbuf("check_conn.user");
    char *password = alloc_lbuf("check_conn.pass");
    parse_connect(msg, command, user, password);

    // At this point, command, user, and password are all less than
    // MBUF_SIZE.
    //
    if (  strncmp(command, "co", 2) == 0
       || strncmp(command, "cd", 2) == 0)
    {
        if (string_prefix(user, mudconf.guest_prefix))
        {
            if (  (d->host_info & H_GUEST)
               || (   !mudconf.allow_guest_from_registered_site
                  && (d->host_info & H_REGISTRATION)))
            {
                // Someone from an IP with guest restrictions is
                // trying to use a guest account. Give them the blurb
                // most likely to have instructions about requesting a
                // character by other means and then fail this
                // connection.
                //
                // The guest 'power' is handled separately further
                // down.
                //
                failconn("CONN", "Connect", "Guest Site Forbidden", d,
                    R_GAMEDOWN, NOTHING, FC_CONN_REG, mudconf.downmotd_msg,
                    command, user, password, cmdsave);
                return false;
            }
            if (  mudconf.guest_char != NOTHING
               && (mudconf.control_flags & CF_LOGIN))
            {
                if (!(mudconf.control_flags & CF_GUEST))
                {
                    queue_write(d, "Guest logins are disabled.\r\n");
                    free_lbuf(command);
                    free_lbuf(user);
                    free_lbuf(password);
                    return false;
                }

                if ((p = Guest.Create(d)) == NULL)
                {
                    queue_write(d, "All guests are tied up, please try again later.\r\n");
                    free_lbuf(command);
                    free_lbuf(user);
                    free_lbuf(password);
                    return false;
                }
                strcpy(user, p);
                strcpy(password, GUEST_PASSWORD);
                isGuest = true;
            }
        }

        // See if this connection would exceed the max #players.
        //
        if (mudconf.max_players < 0)
        {
            nplayers = mudconf.max_players - 1;
        }
        else
        {
            nplayers = 0;
            DESC_ITER_CONN(d2)
            {
                nplayers++;
            }
        }

        player = connect_player(user, password, d->addr, d->username, inet_ntoa((d->address).sin_addr));
        if (  player == NOTHING
           || (!isGuest && Guest.CheckGuest(player)))
        {
            // Not a player, or wrong password.
            //
            queue_write(d, connect_fail);
            STARTLOG(LOG_LOGIN | LOG_SECURITY, "CON", "BAD");
            buff = alloc_lbuf("check_conn.LOG.bad");
            sprintf(buff, "[%u/%s] Failed connect to '%s'", d->descriptor, d->addr, user);
            log_text(buff);
            free_lbuf(buff);
            ENDLOG;
            if (--(d->retries_left) <= 0)
            {
                free_lbuf(command);
                free_lbuf(user);
                free_lbuf(password);
                shutdownsock(d, R_BADLOGIN);
                mudstate.debug_cmd = cmdsave;
                return false;
            }
        }
        else if (  (  (mudconf.control_flags & CF_LOGIN)
                   && (nplayers < mudconf.