mux/src/bsd.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <signal.h>
#include "attrs.h"
#include "command.h"
#include "file_c.h"
#include "slave.h"

Include dependency graph for bsd.cpp:

Go to the source code of this file.

Data Structures
struct	SIGNALTYPE
struct	MUX_SIGNAMES
Defines
#define	CheckInput(x)   FD_ISSET(x, &input_set)
#define	CheckOutput(x)   FD_ISSET(x, &output_set)
#define	CAST_SIGNAL_FUNC
Typedefs
typedef struct SIGNALTYPE *	PSIGNALTYPE
Functions
static void	TelnetSetup (DESC *d)
	Begin initial telnet negotiations on a socket.
static void	SiteMonSend (int, const char *, DESC *, const char *)
static DESC *	initializesock (SOCKET, struct sockaddr_in *)
static DESC *	new_connection (PortInfo *Port, int *piError)
static bool	process_input (DESC *)
static int	make_nonblocking (SOCKET s)
void	CleanUpSlaveSocket (void)
void	CleanUpSlaveProcess (void)
void	boot_slave (dbref executor, dbref caller, dbref enactor, int)
	Lauch reverse-DNS slave process.
static int	get_slave_result (void)
static void	make_socket (PortInfo *Port)
void	SetupPorts (int *pnPorts, PortInfo aPorts[], IntArray *pia)
bool	ValidSocket (SOCKET s)
void	shovechars (int nPorts, PortInfo aPorts[])
void	shutdownsock (DESC *d, int reason)
static void	make_nolinger (SOCKET s)
static void	config_socket (SOCKET s)
void	process_output (void *dvoid, int bHandleShutdown)
int	HimState (DESC *d, unsigned char chOption)
	Return the other side's negotiation state.
int	UsState (DESC *d, unsigned char chOption)
	Return our side's negotiation state.
static void	SetHimState (DESC *d, unsigned char chOption, int iHimState)
	Change the other side's negotiation state.
static void	SetUsState (DESC *d, unsigned char chOption, int iUsState)
	Change our side's negotiation state.
static void	SendWill (DESC *d, unsigned char chOption)
	Transmit a Telnet WILL sequence for the given option.
static void	SendDont (DESC *d, unsigned char chOption)
	Transmit a Telnet DONT sequence for the given option.
static void	SendDo (DESC *d, unsigned char chOption)
	Transmit a Telnet DO sequence for the given option.
static void	SendWont (DESC *d, unsigned char chOption)
	Transmit a Telnet WONT sequence for the given option.
static bool	DesiredHimOption (DESC *d, unsigned char chOption)
	Determine whether we want a particular option on his side of the link to be enabled.
static bool	DesiredUsOption (DESC *d, unsigned char chOption)
	Determine whether we want a particular option on our side of the link to be enabled.
void	EnableHim (DESC *d, unsigned char chOption)
	Start the process of negotiating the enablement of an option on his side.
void	DisableHim (DESC *d, unsigned char chOption)
	Start the process of negotiating the disablement of an option on his side.
void	EnableUs (DESC *d, unsigned char chOption)
	Start the process of negotiating the enablement of an option on our side.
void	DisableUs (DESC *d, unsigned char chOption)
	Start the process of negotiating the disablement of an option on our side.
static void	process_input_helper (DESC *d, char *pBytes, int nBytes)
	Parse raw data from network connection into command lines and Telnet indications.
void	close_sockets (bool emergency, char *message)
void	emergency_shutdown (void)
static void	check_panicking (int sig)
static void	unset_signals (void)
void	BuildSignalNamesTable (void)
static char *	SignalDesc (int iSignal)
static void	log_signal (int iSignal)
static void	log_signal_ignore (int iSignal)
void	LogStatBuf (int stat_buf, const char *Name)
static RETSIGTYPE DCL_CDECL	sighandler (int sig)
void	set_signals (void)
void	list_system_resources (dbref player)
Variables
PortInfo	aMainGamePorts [MAX_LISTEN_PORTS]
int	nMainGamePorts = 0
unsigned int	ndescriptors = 0
DESC *	descriptor_list = NULL
int	maxd = 0
pid_t	slave_pid = 0
int	slave_socket = INVALID_SOCKET
pid_t	game_pid
static const char *	disc_reasons []
static const char *	disc_messages []
static const unsigned char	nvt_input_xlat_table [256]
	Table to quickly classify characters recieved from the wire with their Telnet meaning.
static const int	nvt_input_action_table [8][14]
	Table to map current telnet parsing state state and input to specific actions and state changes.
const SIGNALTYPE	aSigTypes []
static MUX_SIGNAMES	signames [NSIG]
NAMETAB	sigactions_nametab []

---

Detailed Description

File for most TCP socket-related code. Some socket-related code also exists in netcommon.cpp, but most of it is here.

Id

bsd.cpp,v 1.81 2006/11/26 05:05:21 sdennis Exp

Definition in file bsd.cpp.

---

Define Documentation

#define CAST_SIGNAL_FUNC

Definition at line 3413 of file bsd.cpp.

Referenced by alarm_signal(), child_signal(), main(), set_signals(), and sighandler().

#define CheckInput

(

x

)

FD_ISSET(x, &input_set)

Referenced by shovechars().

#define CheckOutput

(

x

)

FD_ISSET(x, &output_set)

Referenced by shovechars().

---

Typedef Documentation

typedef struct SIGNALTYPE * PSIGNALTYPE

---

Function Documentation

void boot_slave	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int
	)

Lauch reverse-DNS slave process.

This spawns the reverse-DNS slave process and creates a socket-oriented, bi-directional communiocation path between that process and this process. Any existing slave process is killed.

Parameters:

	executor	dbref of Executor.
	caller	dbref of Caller.
	enactor	dbref of Enactor.

Returns:

None.

Definition at line 649 of file bsd.cpp.

References CleanUpSlaveProcess(), CleanUpSlaveSocket(), CMuxAlarm::Clear(), DebugTotalSockets, ENDLOG, LOG_ALWAYS, log_number(), log_text(), make_nonblocking(), maxd, MuxAlarm, slave_pid, slave_socket, and STARTLOG.

Referenced by main(), and shovechars().

{
    char *pFailedFunc = 0;
    int sv[2];
    int i;
    int maxfds;

#ifdef HAVE_GETDTABLESIZE
    maxfds = getdtablesize();
#else // HAVE_GETDTABLESIZE
    maxfds = sysconf(_SC_OPEN_MAX);
#endif // HAVE_GETDTABLESIZE

    CleanUpSlaveSocket();
    CleanUpSlaveProcess();

    if (socketpair(AF_UNIX, SOCK_DGRAM, 0, sv) < 0)
    {
        pFailedFunc = "socketpair() error: ";
        goto failure;
    }

    // Set to nonblocking.
    //
    if (make_nonblocking(sv[0]) < 0)
    {
        pFailedFunc = "make_nonblocking() error: ";
        close(sv[0]);
        close(sv[1]);
        goto failure;
    }
    slave_pid = fork();
    switch (slave_pid)
    {
    case -1:

        pFailedFunc = "fork() error: ";
        close(sv[0]);
        close(sv[1]);
        goto failure;

    case 0:

        // If we don't clear this alarm, the child will eventually receive a
        // SIG_PROF.
        //
        MuxAlarm.Clear();

        // Child.  The following calls to dup2() assume only the minimal
        // dup2() functionality.  That is, the destination descriptor is
        // always available for it, and sv[1] is never that descriptor.
        // It is likely that the standard defined behavior of dup2()
        // would handle the job by itself more directly, but a little
        // extra code is low-cost insurance.
        //
        close(sv[0]);
        if (sv[1] != 0)
        {
            close(0);
            if (dup2(sv[1], 0) == -1)
            {
                _exit(1);
            }
        }
        if (sv[1] != 1)
        {
            close(1);
            if (dup2(sv[1], 1) == -1)
            {
                _exit(1);
            }
        }
        for (i = 3; i < maxfds; i++)
        {
            close(i);
        }
        execlp("bin/slave", "slave", NULL);
        _exit(1);
    }
    close(sv[1]);

    slave_socket = sv[0];
    DebugTotalSockets++;
    if (make_nonblocking(slave_socket) < 0)
    {
        pFailedFunc = "make_nonblocking() error: ";
        CleanUpSlaveSocket();
        goto failure;
    }
    if (maxd <= slave_socket)
    {
        maxd = slave_socket + 1;
    }

    STARTLOG(LOG_ALWAYS, "NET", "SLAVE");
    log_text("DNS lookup slave started on fd ");
    log_number(slave_socket);
    ENDLOG;
    return;

failure:

    CleanUpSlaveProcess();
    STARTLOG(LOG_ALWAYS, "NET", "SLAVE");
    log_text(pFailedFunc);
    log_number(errno);
    ENDLOG;
}

void BuildSignalNamesTable

(

void

)

Definition at line 3632 of file bsd.cpp.

References aSigTypes, SIGNALTYPE::iSignal, MUX_SIGNAMES::pLongName, MUX_SIGNAMES::pShortName, signames, and SIGNALTYPE::szSignal.

Referenced by main().

{
    int i;
    for (i = 0; i < NSIG; i++)
    {
        signames[i].pShortName = NULL;
        signames[i].pLongName  = NULL;
    }

    const SIGNALTYPE *pst = aSigTypes;
    while (pst->szSignal)
    {
        int sig = pst->iSignal;
        if (  0 <= sig
           && sig < NSIG)
        {
            MUX_SIGNAMES *tsn = &signames[sig];
            if (tsn->pShortName == NULL)
            {
                tsn->pShortName = pst->szSignal;
#ifndef WIN32
                if (sig == SIGUSR1)
                {
                    tsn->pLongName = "Restart server";
                }
                else if (sig == SIGUSR2)
                {
                    tsn->pLongName = "Drop flatfile";
                }
#endif // WIN32
#ifdef SysSigNames
                if (  tsn->pLongName == NULL
                   && SysSigNames[sig]
                   && strcmp(tsn->pShortName, SysSigNames[sig]) != 0)
                {
                    tsn->pLongName = SysSigNames[sig];
                }
#endif // SysSigNames
            }
        }
        pst++;
    }
    for (i = 0; i < NSIG; i++)
    {
        MUX_SIGNAMES *tsn = &signames[i];
        if (tsn->pShortName == NULL)
        {
#ifdef SysSigNames
            if (SysSigNames[i])
            {
                tsn->pLongName = SysSigNames[i];
            }
#endif // SysSigNames

            // This is the only non-const memory case.
            //
            tsn->pShortName = StringClone(tprintf("SIG%03d", i));
        }
    }
}

static void check_panicking

(

int

sig

)

[static]

Definition at line 3380 of file bsd.cpp.

References game_pid, mudstate, statedata::panicking, and UNUSED_PARAMETER.

Referenced by sighandler().

{
    // If we are panicking, turn off signal catching and resignal.
    //
    if (mudstate.panicking)
    {
        for (int i = 0; i < NSIG; i++)
        {
            signal(i, SIG_DFL);
        }
#ifdef WIN32
        UNUSED_PARAMETER(sig);
        abort();
#else // WIN32
        kill(game_pid, sig);
#endif // WIN32
    }
    mudstate.panicking = true;
}

void CleanUpSlaveProcess

(

void

)

Definition at line 478 of file bsd.cpp.

References slave_pid.

Referenced by boot_slave(), do_restart(), get_slave_result(), main(), new_connection(), and sighandler().

{
    if (slave_pid > 0)
    {
        kill(slave_pid, SIGKILL);
        waitpid(slave_pid, NULL, 0);
    }
    slave_pid = 0;
}

void CleanUpSlaveSocket

(

void

)

Definition at line 465 of file bsd.cpp.

References DebugTotalSockets, INVALID_SOCKET, IS_INVALID_SOCKET, SD_BOTH, and slave_socket.

Referenced by boot_slave(), do_restart(), get_slave_result(), main(), new_connection(), and sighandler().

{
    if (!IS_INVALID_SOCKET(slave_socket))
    {
        shutdown(slave_socket, SD_BOTH);
        if (close(slave_socket) == 0)
        {
            DebugTotalSockets--;
        }
        slave_socket = INVALID_SOCKET;
    }
}

void close_sockets	(	bool	emergency,
		char *	message
	)

Definition at line 3336 of file bsd.cpp.

References aMainGamePorts, DebugTotalSockets, DESC_SAFEITER_ALL, descriptor_data::descriptor, INVALID_SOCKET, IS_SOCKET_ERROR, log_perror(), nMainGamePorts, queue_string(), queue_write_LEN(), R_GOING_DOWN, SD_BOTH, shutdownsock(), PortInfo::socket, SOCKET_CLOSE, and SOCKET_WRITE.

Referenced by emergency_shutdown(), and main().

{
    DESC *d, *dnext;

    DESC_SAFEITER_ALL(d, dnext)
    {
        if (emergency)
        {
            SOCKET_WRITE(d->descriptor, message, strlen(message), 0);
            if (IS_SOCKET_ERROR(shutdown(d->descriptor, SD_BOTH)))
            {
                log_perror("NET", "FAIL", NULL, "shutdown");
            }
            if (SOCKET_CLOSE(d->descriptor) == 0)
            {
                DebugTotalSockets--;
            }
        }
        else
        {
            queue_string(d, message);
            queue_write_LEN(d, "\r\n", 2);
            shutdownsock(d, R_GOING_DOWN);
        }
    }
    for (int i = 0; i < nMainGamePorts; i++)
    {
        if (SOCKET_CLOSE(aMainGamePorts[i].socket) == 0)
        {
            DebugTotalSockets--;
        }
        aMainGamePorts[i].socket = INVALID_SOCKET;
    }
}

static void config_socket

(

SOCKET

s

)

[static]

Definition at line 2202 of file bsd.cpp.

References make_nolinger(), and make_nonblocking().

Referenced by initializesock().

{
    make_nonblocking(s);
    make_nolinger(s);
}

static bool DesiredHimOption	(	DESC *	d,
		unsigned char	chOption
	)			[static]

Determine whether we want a particular option on his side of the link to be enabled.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

Yes if we want it enabled.

Definition at line 2797 of file bsd.cpp.

References TELNET_EOR, TELNET_NAWS, TELNET_SGA, and UNUSED_PARAMETER.

Referenced by process_input_helper().

{
    UNUSED_PARAMETER(d);

    if (  TELNET_NAWS == chOption
       || TELNET_EOR  == chOption
       || TELNET_SGA  == chOption)
    {
        return true;
    }
    return false;
}

static bool DesiredUsOption	(	DESC *	d,
		unsigned char	chOption
	)			[static]

Determine whether we want a particular option on our side of the link to be enabled.

It doesn't make sense for NAWS to be enabled on the server side, and we only negotiate SGA on our side if we have already successfully negotiated the EOR option.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

Yes if we want it enabled.

Definition at line 2822 of file bsd.cpp.

References OPTION_YES, TELNET_EOR, TELNET_SGA, and UsState().

Referenced by process_input_helper().

{
    if (  TELNET_EOR  == chOption
       || (  TELNET_SGA == chOption
          && OPTION_YES == UsState(d, TELNET_EOR)))
    {
        return true;
    }
    return false;
}

void DisableHim	(	DESC *	d,
		unsigned char	chOption
	)

Start the process of negotiating the disablement of an option on his side.

Whether we actually send anything across the wire to disable this depends on the negotiation state. The option could potentially already be disabled.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2874 of file bsd.cpp.

References HimState(), OPTION_WANTNO_EMPTY, OPTION_WANTNO_OPPOSITE, OPTION_WANTYES_EMPTY, OPTION_WANTYES_OPPOSITE, OPTION_YES, SendDont(), and SetHimState().

{
    switch (HimState(d, chOption))
    {
    case OPTION_YES:
        SetHimState(d, chOption, OPTION_WANTNO_EMPTY);
        SendDont(d, chOption);
        break;

    case OPTION_WANTNO_OPPOSITE:
        SetHimState(d, chOption, OPTION_WANTNO_EMPTY);
        break;

    case OPTION_WANTYES_EMPTY:
        SetHimState(d, chOption, OPTION_WANTYES_OPPOSITE);
        break;
    }
}

void DisableUs	(	DESC *	d,
		unsigned char	chOption
	)

Start the process of negotiating the disablement of an option on our side.

Whether we actually send anything across the wire to disable this depends on the negotiation state. The option could potentially already be disabled.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2934 of file bsd.cpp.

References HimState(), OPTION_WANTNO_EMPTY, OPTION_WANTNO_OPPOSITE, OPTION_WANTYES_EMPTY, OPTION_WANTYES_OPPOSITE, OPTION_YES, SendWont(), and SetUsState().

Referenced by SetUsState().

{
    switch (HimState(d, chOption))
    {
    case OPTION_YES:
        SetUsState(d, chOption, OPTION_WANTNO_EMPTY);
        SendWont(d, chOption);
        break;

    case OPTION_WANTNO_OPPOSITE:
        SetUsState(d, chOption, OPTION_WANTNO_EMPTY);
        break;

    case OPTION_WANTYES_EMPTY:
        SetUsState(d, chOption, OPTION_WANTYES_OPPOSITE);
        break;
    }
}

void emergency_shutdown

(

void

)

Definition at line 3371 of file bsd.cpp.

References close_sockets().

Referenced by do_shutdown().

{
    close_sockets(true, "Going down - Bye");
}

void EnableHim	(	DESC *	d,
		unsigned char	chOption
	)

Start the process of negotiating the enablement of an option on his side.

Whether we actually send anything across the wire to enable this depends on the negotiation state. The option could potentially already be enabled.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2844 of file bsd.cpp.

References HimState(), OPTION_NO, OPTION_WANTNO_EMPTY, OPTION_WANTNO_OPPOSITE, OPTION_WANTYES_EMPTY, OPTION_WANTYES_OPPOSITE, SendDo(), and SetHimState().

Referenced by TelnetSetup().

{
    switch (HimState(d, chOption))
    {
    case OPTION_NO:
        SetHimState(d, chOption, OPTION_WANTYES_EMPTY);
        SendDo(d, chOption);
        break;

    case OPTION_WANTNO_EMPTY:
        SetHimState(d, chOption, OPTION_WANTNO_OPPOSITE);
        break;

    case OPTION_WANTYES_OPPOSITE:
        SetHimState(d, chOption, OPTION_WANTYES_EMPTY);
        break;
    }
}

void EnableUs	(	DESC *	d,
		unsigned char	chOption
	)

Start the process of negotiating the enablement of an option on our side.

Whether we actually send anything across the wire to enable this depends on the negotiation state. The option could potentially already be enabled.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2904 of file bsd.cpp.

References HimState(), OPTION_NO, OPTION_WANTNO_EMPTY, OPTION_WANTNO_OPPOSITE, OPTION_WANTYES_EMPTY, OPTION_WANTYES_OPPOSITE, SendWill(), and SetUsState().

Referenced by SetUsState(), and TelnetSetup().

{
    switch (HimState(d, chOption))
    {
    case OPTION_NO:
        SetUsState(d, chOption, OPTION_WANTYES_EMPTY);
        SendWill(d, chOption);
        break;

    case OPTION_WANTNO_EMPTY:
        SetUsState(d, chOption, OPTION_WANTNO_OPPOSITE);
        break;

    case OPTION_WANTYES_OPPOSITE:
        SetUsState(d, chOption, OPTION_WANTYES_EMPTY);
        break;
    }
}

static int get_slave_result

(

void

)

[static]

Definition at line 806 of file bsd.cpp.

References A_LASTIP, A_LASTSITE, descriptor_data::addr, descriptor_data::address, alloc_lbuf, atr_add_raw(), CleanUpSlaveProcess(), CleanUpSlaveSocket(), descriptor_list, ENDLOG, free_lbuf, LBUF_SIZE, LOG_ALWAYS, log_text(), mudconf, descriptor_data::next, descriptor_data::player, slave_socket, SOCKET_EWOULDBLOCK, SOCKET_LAST_ERROR, STARTLOG, tprintf(), confdata::use_hostname, and descriptor_data::username.

Referenced by shovechars().

{
    int local_port, remote_port;
    DESC *d;

    char *buf = alloc_lbuf("slave_buf");

    int len = read(slave_socket, buf, LBUF_SIZE-1);
    if (len < 0)
    {
        int iSocketError = SOCKET_LAST_ERROR;
        if (  iSocketError == SOCKET_EAGAIN
           || iSocketError == SOCKET_EWOULDBLOCK)
        {
            free_lbuf(buf);
            return -1;
        }
        CleanUpSlaveSocket();
        CleanUpSlaveProcess();
        free_lbuf(buf);

        STARTLOG(LOG_ALWAYS, "NET", "SLAVE");
        log_text("read() of slave result failed. Slave stopped.");
        ENDLOG;

        return -1;
    }
    else if (len == 0)
    {
        free_lbuf(buf);
        return -1;
    }
    buf[len] = '\0';

    char *token = alloc_lbuf("slave_token");
    char *os = alloc_lbuf("slave_os");
    char *userid = alloc_lbuf("slave_userid");
    char *host = alloc_lbuf("slave_host");
    char *p;
    if (sscanf(buf, "%s %s", host, token) != 2)
    {
        goto Done;
    }
    p = strchr(buf, '\n');
    *p = '\0';
    if (mudconf.use_hostname)
    {
        for (d = descriptor_list; d; d = d->next)
        {
            if (strcmp(d->addr, host) != 0)
            {
                continue;
            }

            strncpy(d->addr, token, 50);
            d->addr[50] = '\0';
            if (d->player != 0)
            {
                if (d->username[0])
                {
                    atr_add_raw(d->player, A_LASTSITE, tprintf("%s@%s",
                        d->username, d->addr));
                }
                else
                {
                    atr_add_raw(d->player, A_LASTSITE, d->addr);
                }
                atr_add_raw(d->player, A_LASTIP, inet_ntoa((d->address).sin_addr));
            }
        }
    }

    if (sscanf(p + 1, "%s %d , %d : %s : %s : %s",
           host,
           &remote_port, &local_port,
           token, os, userid) != 6)
    {
        goto Done;
    }
    for (d = descriptor_list; d; d = d->next)
    {
        if (ntohs((d->address).sin_port) != remote_port)
            continue;
        strncpy(d->username, userid, 10);
        d->username[10] = '\0';
        if (d->player != 0)
        {
            atr_add_raw(d->player, A_LASTSITE, tprintf("%s@%s",
                             d->username, d->addr));
        }
    }
Done:
    free_lbuf(buf);
    free_lbuf(token);
    free_lbuf(os);
    free_lbuf(userid);
    free_lbuf(host);
    return 0;
}

int HimState	(	DESC *	d,
		unsigned char	chOption
	)

Return the other side's negotiation state.

The negotiation of each optional feature of telnet can be in one of six states (defined in interface.h): OPTION_NO, OPTION_YES, OPTION_WANTNO_EMPTY, OPTION_WANTNO_OPPOSITE, OPTION_WANTYES_EMPTY, and OPTION_WANTYES_OPPOSITE.

An option is only enabled when it is in the OPTION_YES state.

Parameters:

	d	Player connection context.
	chOption	Telnet Option

Returns:

One of six states.

Definition at line 2629 of file bsd.cpp.

References descriptor_data::nvt_eor_him_state, descriptor_data::nvt_naws_him_state, descriptor_data::nvt_sga_him_state, OPTION_NO, TELNET_EOR, TELNET_NAWS, and TELNET_SGA.

Referenced by DisableHim(), DisableUs(), EnableHim(), EnableUs(), and process_input_helper().

{
    if (TELNET_NAWS == chOption)
    {
        return d->nvt_naws_him_state;
    }
    else if (TELNET_EOR == chOption)
    {
        return d->nvt_eor_him_state;
    }
    else if (TELNET_SGA == chOption)
    {
        return d->nvt_sga_him_state;
    }
    return OPTION_NO;
}

DESC * initializesock	(	SOCKET	,
		struct sockaddr_in *
	)			[static]

Definition at line 2210 of file bsd.cpp.

References statedata::access_list, descriptor_data::addr, descriptor_data::address, alloc_desc, confdata::cmd_quota_max, descriptor_data::command_count, config_socket(), descriptor_data::connected_at, descriptor_data::descriptor, descriptor_list, descriptor_data::doing, descriptor_data::flags, CLinearTimeAbsolute::GetUTC(), descriptor_data::hashnext, descriptor_data::height, descriptor_data::host_info, confdata::idle_timeout, descriptor_data::input_head, descriptor_data::input_lost, descriptor_data::input_size, descriptor_data::input_tail, descriptor_data::input_tot, descriptor_data::last_time, mudconf, mudstate, ndescriptors, descriptor_data::next, descriptor_data::nOption, descriptor_data::nvt_eor_him_state, descriptor_data::nvt_eor_us_state, NVT_IS_NORMAL, descriptor_data::nvt_naws_him_state, descriptor_data::nvt_naws_us_state, descriptor_data::nvt_sga_him_state, descriptor_data::nvt_sga_us_state, OPTION_NO, descriptor_data::output_head, descriptor_data::output_lost, descriptor_data::output_prefix, descriptor_data::output_size, descriptor_data::output_suffix, descriptor_data::output_tail, descriptor_data::output_tot, descriptor_data::player, descriptor_data::prev, descriptor_data::program_data, descriptor_data::quota, descriptor_data::raw_input, descriptor_data::raw_input_at, descriptor_data::raw_input_state, descriptor_data::retries_left, confdata::retry_limit, site_check(), statedata::suspect_list, descriptor_data::timeout, descriptor_data::username, and descriptor_data::width.

Referenced by new_connection().

{
    DESC *d;

#ifdef WIN32
    // protect adding the descriptor from the linked list from
    // any interference from socket shutdowns
    //
    if (platform == VER_PLATFORM_WIN32_NT)
    {
        EnterCriticalSection(&csDescriptorList);
    }
#endif // WIN32

    d = alloc_desc("init_sock");

#ifdef WIN32
    if (platform == VER_PLATFORM_WIN32_NT)
    {
        LeaveCriticalSection(&csDescriptorList);
    }
#endif // WIN32

    d->descriptor = s;
    d->flags = 0;
    d->connected_at.GetUTC();
    d->last_time = d->connected_at;
    d->retries_left = mudconf.retry_limit;
    d->command_count = 0;
    d->timeout = mudconf.idle_timeout;
    d->host_info = site_check((*a).sin_addr, mudstate.access_list)
                 | site_check((*a).sin_addr, mudstate.suspect_list);

    // Be sure #0 isn't wizard. Shouldn't be.
    //
    d->player = 0;

    d->addr[0] = '\0';
    d->doing[0] = '\0';
    d->username[0] = '\0';
    config_socket(s);
    d->output_prefix = NULL;
    d->output_suffix = NULL;
    d->output_size = 0;
    d->output_tot = 0;
    d->output_lost = 0;
    d->output_head = NULL;
    d->output_tail = NULL;
    d->input_head = NULL;
    d->input_tail = NULL;
    d->input_size = 0;
    d->input_tot = 0;
    d->input_lost = 0;
    d->raw_input = NULL;
    d->raw_input_at = NULL;
    d->nOption = 0;
    d->raw_input_state = NVT_IS_NORMAL;
    d->nvt_sga_him_state = OPTION_NO;
    d->nvt_sga_us_state = OPTION_NO;
    d->nvt_eor_him_state = OPTION_NO;
    d->nvt_eor_us_state = OPTION_NO;
    d->nvt_naws_him_state = OPTION_NO;
    d->nvt_naws_us_state = OPTION_NO;
    d->height = 24;
    d->width = 78;
    d->quota = mudconf.cmd_quota_max;
    d->program_data = NULL;
    d->address = *a;
    strncpy(d->addr, inet_ntoa(a->sin_addr), 50);
    d->addr[50] = '\0';

#ifdef WIN32
    // protect adding the descriptor from the linked list from
    // any interference from socket shutdowns
    //
    if (platform == VER_PLATFORM_WIN32_NT)
    {
        EnterCriticalSection (&csDescriptorList);
    }
#endif // WIN32

    ndescriptors++;

    if (descriptor_list)
    {
        descriptor_list->prev = &d->next;
    }
    d->hashnext = NULL;
    d->next = descriptor_list;
    d->prev = &descriptor_list;
    descriptor_list = d;

#ifdef WIN32
    // ok to continue now
    //
    if (platform == VER_PLATFORM_WIN32_NT)
    {
        LeaveCriticalSection (&csDescriptorList);

        d->OutboundOverlapped.hEvent = NULL;
        d->InboundOverlapped.hEvent = NULL;
        d->InboundOverlapped.Offset = 0;
        d->InboundOverlapped.OffsetHigh = 0;
        d->bWritePending = false;   // no write pending yet
        d->bConnectionShutdown = false; // not shutdown yet
        d->bConnectionDropped = false; // not dropped yet
        d->bCallProcessOutputLater = false;
    }
#endif // WIN32
    return d;
}

void list_system_resources

(

dbref

player

)

Definition at line 4070 of file bsd.cpp.

References DebugTotalFiles, DebugTotalSockets, and notify.

Referenced by do_list().

{
    char buffer[80];

    int nTotal = 0;
    notify(player, "System Resources");

    sprintf(buffer, "Total Open Files: %ld", DebugTotalFiles);
    notify(player, buffer);
    nTotal += DebugTotalFiles;

    sprintf(buffer, "Total Sockets: %ld", DebugTotalSockets);
    notify(player, buffer);
    nTotal += DebugTotalSockets;

#ifdef WIN32
    sprintf(buffer, "Total Threads: %ld", DebugTotalThreads);
    notify(player, buffer);
    nTotal += DebugTotalThreads;

    sprintf(buffer, "Total Semaphores: %ld", DebugTotalSemaphores);
    notify(player, buffer);
    nTotal += DebugTotalSemaphores;
#endif // WIN32

    sprintf(buffer, "Total Handles (sum of above): %d", nTotal);
    notify(player, buffer);

#ifdef WIN32
    for (int i = 0; i < NUM_SLAVE_THREADS; i++)
    {
        sprintf(buffer, "Thread %d at line %u", i+1, SlaveThreadInfo[i].iDoing);
        notify(player, buffer);
    }
#endif // WIN32
}

static void log_signal

(

int

iSignal

)

[static]

Definition at line 3708 of file bsd.cpp.

References ENDLOG, LOG_PROBLEMS, log_text(), SignalDesc(), and STARTLOG.

Referenced by sighandler().

{
    STARTLOG(LOG_PROBLEMS, "SIG", "CATCH");
    log_text("Caught signal ");
    log_text(SignalDesc(iSignal));
    ENDLOG;
}

static void log_signal_ignore

(

int

iSignal

)

[static]

Definition at line 3717 of file bsd.cpp.

References ENDLOG, LOG_PROBLEMS, log_text(), SignalDesc(), and STARTLOG.

Referenced by sighandler().

{
    STARTLOG(LOG_PROBLEMS, "SIG", "CATCH");
    log_text("Caught signal and ignored signal ");
    log_text(SignalDesc(iSignal));
    log_text(" because server just came up.");
    ENDLOG;
}

void LogStatBuf	(	int	stat_buf,
		const char *	Name
	)

Definition at line 3726 of file bsd.cpp.

References ENDLOG, Log, LOG_ALWAYS, log_text(), SignalDesc(), STARTLOG, and CLogFile::tinyprintf().

Referenced by sighandler().

{
    STARTLOG(LOG_ALWAYS, "NET", Name);
    if (WIFEXITED(stat_buf))
    {
        Log.tinyprintf("process exited unexpectedly with exit status %d.", WEXITSTATUS(stat_buf));
    }
    else if (WIFSIGNALED(stat_buf))
    {
        Log.tinyprintf("process was terminated with signal %s.", SignalDesc(WTERMSIG(stat_buf)));
    }
    else
    {
        log_text("process ended unexpectedly.");
    }
    ENDLOG;
}

static void make_nolinger

(

SOCKET

s

)

[static]

Definition at line 2189 of file bsd.cpp.

References IS_SOCKET_ERROR, and log_perror().

Referenced by config_socket().

{
#if defined(HAVE_LINGER)
    struct linger ling;
    ling.l_onoff = 0;
    ling.l_linger = 0;
    if (IS_SOCKET_ERROR(setsockopt(s, SOL_SOCKET, SO_LINGER, (char *)&ling, sizeof(ling))))
    {
        log_perror("NET", "FAIL", "linger", "setsockopt");
    }
#endif // HAVE_LINGER
}

int make_nonblocking

(

SOCKET

s

)

[static]

Definition at line 2149 of file bsd.cpp.

References IS_SOCKET_ERROR, and log_perror().

Referenced by boot_slave(), and config_socket().

{
#ifdef WIN32
    unsigned long on = 1;
    if (IS_SOCKET_ERROR(ioctlsocket(s, FIONBIO, &on)))
    {
        log_perror("NET", "FAIL", "make_nonblocking", "ioctlsocket");
        return -1;
    }
#else // WIN32
#if defined(O_NONBLOCK)
    if (fcntl(s, F_SETFL, O_NONBLOCK) < 0)
    {
        log_perror("NET", "FAIL", "make_nonblocking", "fcntl");
        return -1;
    }
#elif defined(FNDELAY)
    if (fcntl(s, F_SETFL, FNDELAY) < 0)
    {
        log_perror("NET", "FAIL", "make_nonblocking", "fcntl");
        return -1;
    }
#elif defined(O_NDELAY)
    if (fcntl(s, F_SETFL, O_NDELAY) < 0)
    {
        log_perror("NET", "FAIL", "make_nonblocking", "fcntl");
        return -1;
    }
#elif defined(FIONBIO)
    unsigned long on = 1;
    if (ioctl(s, FIONBIO, &on) < 0)
    {
        log_perror("NET", "FAIL", "make_nonblocking", "ioctl");
        return -1;
    }
#endif // O_NONBLOCK, FNDELAY, O_NDELAY, FIONBIO
#endif // WIN32
    return 0;
}

static void make_socket

(

PortInfo *

Port

)

[static]

Definition at line 907 of file bsd.cpp.

References DebugTotalSockets, ENDLINE, INVALID_HANDLE_VALUE, INVALID_SOCKET, IS_INVALID_SOCKET, IS_SOCKET_ERROR, Log, log_perror(), PortInfo::port, PortInfo::socket, SOCKET_CLOSE, SOCKET_LAST_ERROR, and CLogFile::tinyprintf().

{
    SOCKET s;
    struct sockaddr_in server;
    int opt = 1;

#ifdef WIN32

    // If we are running Windows NT we must create a completion port,
    // and start up a listening thread for new connections
    //
    if (platform == VER_PLATFORM_WIN32_NT)
    {
        int nRet;

        // create initial IO completion port, so threads have something to wait on
        //
        CompletionPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);

        if (!CompletionPort)
        {
            Log.tinyprintf("Error %ld on CreateIoCompletionPort" ENDLINE,  GetLastError());
            WSACleanup();     // clean up
            exit(1);
        }

        // Initialize the critical section
        //
        if (!bDescriptorListInit)
        {
            InitializeCriticalSection(&csDescriptorList);
            bDescriptorListInit = true;
        }

        // Create a TCP/IP stream socket
        //
        s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (s == INVALID_SOCKET)
        {
            log_perror("NET", "FAIL", NULL, "creating master socket");
            exit(3);
        }
        DebugTotalSockets++;
        if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0)
        {
            log_perror("NET", "FAIL", NULL, "setsockopt");
        }

        // Fill in the the address structure
        //
        server.sin_port = htons((unsigned short)(Port->port));
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = INADDR_ANY;

        // bind our name to the socket
        //
        nRet = bind(s, (LPSOCKADDR) &server, sizeof server);

        if (nRet == SOCKET_ERROR)
        {
            Log.tinyprintf("Error %ld on Win32: bind" ENDLINE, SOCKET_LAST_ERROR);
            if (closesocket(s) == 0)
            {
                DebugTotalSockets--;
            }
            s = INVALID_SOCKET;
            WSACleanup();     // clean up
            exit(1);
        }

        // Set the socket to listen
        //
        nRet = listen(s, SOMAXCONN);

        if (nRet)
        {
            Log.tinyprintf("Error %ld on Win32: listen" ENDLINE, SOCKET_LAST_ERROR);
            WSACleanup();
            exit(1);
        }

        // Create the MUD listening thread
        //
        if (_beginthread(MUDListenThread, 0, (void *) Port) == (unsigned)(-1))
        {
            log_perror("NET", "FAIL", "_beginthread", "setsockopt");
            WSACleanup();
            exit(1);
        }

        Port->socket = s;
        Log.tinyprintf("Listening (NT-style) on port %d" ENDLINE, Port->port);
        return;
    }
#endif // WIN32

    s = socket(AF_INET, SOCK_STREAM, 0);
    if (IS_INVALID_SOCKET(s))
    {
        log_perror("NET", "FAIL", NULL, "creating master socket");
#ifdef WIN32
        WSACleanup();
#endif // WIN32
        exit(3);
    }
    DebugTotalSockets++;
    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof(opt)) < 0)
    {
        log_perror("NET", "FAIL", NULL, "setsockopt");
    }
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = INADDR_ANY;
    server.sin_port = htons((unsigned short)(Port->port));
    int cc  = bind(s, (struct sockaddr *)&server, sizeof(server));
    if (IS_SOCKET_ERROR(cc))
    {
        log_perror("NET", "FAIL", NULL, "bind");
        if (SOCKET_CLOSE(s) == 0)
        {
            DebugTotalSockets--;
        }
        s = INVALID_SOCKET;
#ifdef WIN32
        WSACleanup();
#endif // WIN32
        exit(4);
    }
    listen(s, SOMAXCONN);
    Port->socket = s;
    Log.tinyprintf("Listening on port %d" ENDLINE, Port->port);
}

DESC * new_connection	(	PortInfo *	Port,
		int *	piError
	)			[static]

Definition at line 1677 of file bsd.cpp.

References statedata::access_list, alloc_lbuf, alloc_mbuf, CleanUpSlaveProcess(), CleanUpSlaveSocket(), statedata::debug_cmd, DebugTotalSockets, ENDLOG, FC_CONN_SITE, fcache_rawdump(), free_lbuf, free_mbuf, H_FORBIDDEN, initializesock(), INVALID_SOCKET, IS_INVALID_SOCKET, LOG_ALWAYS, LOG_NET, LOG_SECURITY, log_text(), mudconf, mudstate, PortInfo::port, SD_BOTH, site_check(), SiteMonSend(), slave_socket, PortInfo::socket, SOCKET_CLOSE, SOCKET_LAST_ERROR, STARTLOG, TelnetSetup(), confdata::use_hostname, and welcome_user().

Referenced by shovechars().

{
    DESC *d;
    struct sockaddr_in addr;
#ifdef SOCKLEN_T_DCL
    socklen_t addr_len;
#else // SOCKLEN_T_DCL
    int addr_len;
#endif // SOCKLEN_T_DCL
#ifndef WIN32
    int len;
#endif // !WIN32

    char *cmdsave = mudstate.debug_cmd;
    mudstate.debug_cmd = "< new_connection >";
    addr_len = sizeof(struct sockaddr);

    SOCKET newsock = accept(Port->socket, (struct sockaddr *)&addr, &addr_len);

    if (IS_INVALID_SOCKET(newsock))
    {
        *piSocketError = SOCKET_LAST_ERROR;
        return 0;
    }

    char *pBuffM2 = alloc_mbuf("new_connection.address");
    strcpy(pBuffM2, inet_ntoa(addr.sin_addr));
    unsigned short usPort = ntohs(addr.sin_port);

    DebugTotalSockets++;
    if (site_check(addr.sin_addr, mudstate.access_list) == H_FORBIDDEN)
    {
        STARTLOG(LOG_NET | LOG_SECURITY, "NET", "SITE");
        char *pBuffM1  = alloc_mbuf("new_connection.LOG.badsite");
        sprintf(pBuffM1, "[%u/%s] Connection refused.  (Remote port %d)",
            newsock, pBuffM2, usPort);
        log_text(pBuffM1);
        free_mbuf(pBuffM1);
        ENDLOG;

        // Report site monitor information.
        //
        SiteMonSend(newsock, pBuffM2, NULL, "Connection refused");

        fcache_rawdump(newsock, FC_CONN_SITE);
        shutdown(newsock, SD_BOTH);
        if (SOCKET_CLOSE(newsock) == 0)
        {
            DebugTotalSockets--;
        }
        newsock = INVALID_SOCKET;
        errno = 0;
        d = NULL;
    }
    else
    {
#ifdef WIN32
        // Make slave request
        //
        // Go take control of the stack, but don't bother if it takes
        // longer than 5 seconds to do it.
        //
        if (  bSlaveBooted
           && WAIT_OBJECT_0 == WaitForSingleObject(hSlaveRequestStackSemaphore, 5000))
        {
            // We have control of the stack. Skip the request if the stack is full.
            //
            if (iSlaveRequest < SLAVE_REQUEST_STACK_SIZE)
            {
                // There is room on the stack, so make the request.
                //
                SlaveRequests[iSlaveRequest].sa_in = addr;
                SlaveRequests[iSlaveRequest].port_in = Port->port;
                iSlaveRequest++;
                ReleaseSemaphore(hSlaveRequestStackSemaphore, 1, NULL);

                // Wake up a single slave thread. Event automatically resets itself.
                //
                ReleaseSemaphore(hSlaveThreadsSemaphore, 1, NULL);
            }
            else
            {
                // No room on the stack, so skip it.
                //
                ReleaseSemaphore(hSlaveRequestStackSemaphore, 1, NULL);
            }
        }
#else // WIN32
        // Make slave request
        //
        if (  !IS_INVALID_SOCKET(slave_socket)
           && mudconf.use_hostname)
        {
            char *pBuffL1 = alloc_lbuf("new_connection.write");
            sprintf(pBuffL1, "%s\n%s,%d,%d\n", pBuffM2, pBuffM2, usPort,
                Port->port);
            len = strlen(pBuffL1);
            if (write(slave_socket, pBuffL1, len) < 0)
            {
                CleanUpSlaveSocket();
                CleanUpSlaveProcess();

                STARTLOG(LOG_ALWAYS, "NET", "SLAVE");
                log_text("write() of slave request failed. Slave stopped.");
                ENDLOG;
            }
            free_lbuf(pBuffL1);
        }
#endif // WIN32

        STARTLOG(LOG_NET, "NET", "CONN");
        char *pBuffM3 = alloc_mbuf("new_connection.LOG.open");
        sprintf(pBuffM3, "[%u/%s] Connection opened (remote port %d)", newsock,
            pBuffM2, usPort);
        log_text(pBuffM3);
        free_mbuf(pBuffM3);
        ENDLOG;

        d = initializesock(newsock, &addr);
        TelnetSetup(d);

        // Initalize everything before sending the sitemon info, so that we
        // can pass the descriptor, d.
        //
        SiteMonSend(newsock, pBuffM2, d, "Connection");

        welcome_user(d);
        mudstate.debug_cmd = cmdsave;
    }
    free_mbuf(pBuffM2);
    mudstate.debug_cmd = cmdsave;
    *piSocketError = SOCKET_LAST_ERROR;
    return d;
}

bool process_input

(

DESC *

)

[static]

Definition at line 3309 of file bsd.cpp.

References statedata::debug_cmd, descriptor_data::descriptor, IS_SOCKET_ERROR, LBUF_SIZE, mudstate, process_input_helper(), SOCKET_EINTR, SOCKET_EWOULDBLOCK, SOCKET_LAST_ERROR, and SOCKET_READ.

Referenced by shovechars().

{
    char *cmdsave = mudstate.debug_cmd;
    mudstate.debug_cmd = "< process_input >";

    char buf[LBUF_SIZE];
    int got = SOCKET_READ(d->descriptor, buf, sizeof(buf), 0);
    if (IS_SOCKET_ERROR(got) || got == 0)
    {
        int iSocketError = SOCKET_LAST_ERROR;
        mudstate.debug_cmd = cmdsave;
        if (  IS_SOCKET_ERROR(got)
           && (  iSocketError == SOCKET_EWOULDBLOCK
#ifdef SOCKET_EAGAIN
              || iSocketError == SOCKET_EAGAIN
#endif // SOCKET_EAGAIN
              || iSocketError == SOCKET_EINTR))
        {
            return true;
        }
        return false;
    }
    process_input_helper(d, buf, got);
    mudstate.debug_cmd = cmdsave;
    return true;
}

static void process_input_helper	(	DESC *	d,
		char *	pBytes,
		int	nBytes
	)			[static]

Parse raw data from network connection into command lines and Telnet indications.

Once input has been received from a particular socket, it is given to this function for initial parsing. While most clients do line editing on their side, a raw telnet client is still capable of sending backspace (BS) and Delete (DEL) to the server, so we perform basic editing on our side.

TinyMUX only allows printable characters through, imposes a maximum line length, and breaks lines at CRLF.

Parameters:

	d	Player connection on which the input arrived.
	pBytes	Point to received bytes.
	nBytes	Number of received bytes in above buffer.

Returns:

None.

Definition at line 2993 of file bsd.cpp.

References alloc_lbuf, descriptor_data::aOption, cmd_block::cmd, DesiredHimOption(), DesiredUsOption(), free_lbuf, descriptor_data::height, HimState(), descriptor_data::input_lost, descriptor_data::input_size, descriptor_data::input_tot, LBUF_SIZE, mux_isprint, descriptor_data::nOption, NVT_DEL, NVT_IS_HAVE_IAC, NVT_IS_HAVE_IAC_DO, NVT_IS_HAVE_IAC_DONT, NVT_IS_HAVE_IAC_SB, NVT_IS_HAVE_IAC_SB_IAC, NVT_IS_HAVE_IAC_WILL, NVT_IS_HAVE_IAC_WONT, NVT_IS_NORMAL, OPTION_NO, OPTION_WANTNO_EMPTY, OPTION_WANTNO_OPPOSITE, OPTION_WANTYES_EMPTY, OPTION_WANTYES_OPPOSITE, OPTION_YES, queue_string(), descriptor_data::raw_input, descriptor_data::raw_input_at, descriptor_data::raw_input_state, save_command(), SBUF_SIZE, SendDo(), SendDont(), SendWill(), SendWont(), SetHimState(), SetUsState(), TELNET_NAWS, UsState(), and descriptor_data::width.

Referenced by process_input().

{
    if (!d->raw_input)
    {
        d->raw_input = (CBLK *) alloc_lbuf("process_input.raw");
        d->raw_input_at = d->raw_input->cmd;
    }

    int nInputBytes = 0;
    int nLostBytes  = 0;

    char *p    = d->raw_input_at;
    char *pend = d->raw_input->cmd + (LBUF_SIZE - sizeof(CBLKHDR) - 1);

    unsigned char *q    = d->aOption + d->nOption;
    unsigned char *qend = d->aOption + SBUF_SIZE - 1;

    int n = nBytes;
    while (n--)
    {
        unsigned char ch = (unsigned char)*pBytes;
        int iAction = nvt_input_action_table[d->raw_input_state][nvt_input_xlat_table[ch]];
        switch (iAction)
        {
        case 1:
            // Action 1 - Accept CHR(X).
            //
            if (mux_isprint(ch))
            {
                if (p < pend)
                {
                    *p++ = ch;
                    nInputBytes++;
                }
                else
                {
                    nLostBytes++;
                }
            }
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 0:
            // Action 0 - Nothing.
            //
            break;

        case 2:
            // Action 2 - Erase Character.
            //
            if (NVT_DEL == ch)
            {
                queue_string(d, "\b \b");
            }
            else
            {
                queue_string(d, " \b");
            }

            if (p > d->raw_input->cmd)
            {
                // The character we took back.
                //
                nInputBytes -= 1;
                p--;
            }
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 3:
            // Action  3 - Accept Line.
            //
            *p = '\0';
            if (d->raw_input->cmd < p)
            {
                save_command(d, d->raw_input);
                d->raw_input = (CBLK *) alloc_lbuf("process_input.raw");

                p = d->raw_input_at = d->raw_input->cmd;
                pend = d->raw_input->cmd + (LBUF_SIZE - sizeof(CBLKHDR) - 1);
            }
            break;

        case 4:
            // Action 4 - Transition to the Normal state.
            //
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 5:
            // Action  5 - Transition to Have_IAC state.
            //
            d->raw_input_state = NVT_IS_HAVE_IAC;
            break;

        case 6:
            // Action 6 - Transition to the Have_IAC_WILL state.
            //
            d->raw_input_state = NVT_IS_HAVE_IAC_WILL;
            break;

        case 7:
            // Action  7 - Transition to the Have_IAC_DONT state.
            //
            d->raw_input_state = NVT_IS_HAVE_IAC_DONT;
            break;

        case 8:
            // Action  8 - Transition to the Have_IAC_DO state.
            //
            d->raw_input_state = NVT_IS_HAVE_IAC_DO;
            break;

        case 9:
            // Action  9 - Transition to the Have_IAC_WONT state.
            //
            d->raw_input_state = NVT_IS_HAVE_IAC_WONT;
            break;

        case 10:
            // Action 10 - Transition to the Have_IAC_SB state.
            //
            q = d->aOption;
            d->raw_input_state = NVT_IS_HAVE_IAC_SB;
            break;

        case 11:
            // Action 11 - Transition to the Have_IAC_SB_IAC state.
            //
            d->raw_input_state = NVT_IS_HAVE_IAC_SB_IAC;
            break;

        case 12:
            // Action 12 - Respond to IAC AYT and return to the Normal state.
            //
            queue_string(d, "\r\n[Yes]\r\n");
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 13:
            // Action 13 - Respond to IAC WILL X
            //
            switch (HimState(d, ch))
            {
            case OPTION_NO:
                if (DesiredHimOption(d, ch))
                {
                    SetHimState(d, ch, OPTION_YES);
                    SendDo(d, ch);
                }
                else
                {
                    SendDont(d, ch);
                }
                break;

            case OPTION_WANTNO_EMPTY:
                SetHimState(d, ch, OPTION_NO);
                break;

            case OPTION_WANTYES_OPPOSITE:
                SetHimState(d, ch, OPTION_WANTNO_EMPTY);
                SendDont(d, ch);
                break;

            default:
                SetHimState(d, ch, OPTION_YES);
                break;
            }
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 14:
            // Action 14 - Respond to IAC DONT X
            //
            switch (UsState(d, ch))
            {
            case OPTION_YES:
                SetUsState(d, ch, OPTION_NO);
                SendWont(d, ch);
                break;

            case OPTION_WANTNO_OPPOSITE:
                SetUsState(d, ch, OPTION_WANTYES_EMPTY);
                SendWill(d, ch);
                break;

            default:
                SetUsState(d, ch, OPTION_NO);
                break;
            }
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 15:
            // Action 15 - Respond to IAC DO X
            //
            switch (UsState(d, ch))
            {
            case OPTION_NO:
                if (DesiredUsOption(d, ch))
                {
                    SetUsState(d, ch, OPTION_YES);
                    SendWill(d, ch);
                }
                else
                {
                    SendWont(d, ch);
                }
                break;

            case OPTION_WANTNO_EMPTY:
                SetUsState(d, ch, OPTION_NO);
                break;

            case OPTION_WANTYES_OPPOSITE:
                SetUsState(d, ch, OPTION_WANTNO_EMPTY);
                SendWont(d, ch);
                break;

            default:
                SetUsState(d, ch, OPTION_YES);
                break;
            }
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 16:
            // Action 16 - Respond to IAC WONT X
            //
            // Ignore.
            //
            switch (HimState(d, ch))
            {
            case OPTION_NO:
                break;

            case OPTION_YES:
                SetHimState(d, ch, OPTION_NO);
                SendDont(d, ch);
                break;

            case OPTION_WANTNO_OPPOSITE:
                SetHimState(d, ch, OPTION_WANTYES_EMPTY);
                SendDo(d, ch);
                break;

            default:
                SetHimState(d, ch, OPTION_NO);
                break;
            }
            d->raw_input_state = NVT_IS_NORMAL;
            break;

        case 17:
            // Action 17 - Accept CHR(X) for Sub-Option (and transition to Have_IAC_SB state).
            //
            d->raw_input_state = NVT_IS_HAVE_IAC_SB;
            if (  d->aOption <= q
               && q < qend)
            {
                *q++ = ch;
            }
            break;

        case 18:
            // Action 18 - Accept Completed Sub-option and transition to Normal state.
            //
            if (  d->aOption < q
               && q < qend)
            {
                size_t m = q - d->aOption;
                switch (d->aOption[0])
                {
                case TELNET_NAWS:
                    if (m == 5)
                    {
                        d->width  = (d->aOption[1] << 8 ) | d->aOption[2];
                        d->height = (d->aOption[3] << 8 ) | d->aOption[4];
                    }
                    break;
                }
            }
            q = d->aOption;
            d->raw_input_state = NVT_IS_NORMAL;
            break;
        }
        pBytes++;
    }

    if (  d->raw_input->cmd < p
       && p <= pend)
    {
        d->raw_input_at = p;
    }
    else
    {
        free_lbuf(d->raw_input);
        d->raw_input = NULL;
        d->raw_input_at = NULL;
    }

    if ( d->aOption <= q
       && q < qend)
    {
        d->nOption = q - d->aOption;
    }
    else
    {
        d->nOption = 0;
    }
    d->input_tot  += nBytes;
    d->input_size += nInputBytes;
    d->input_lost += nLostBytes;
}

void process_output	(	void *	dvoid,
		int	bHandleShutdown
	)

Definition at line 2493 of file bsd.cpp.

References statedata::debug_cmd, descriptor_data::descriptor, text_block::hdr, IS_SOCKET_ERROR, MEMFREE, mudstate, text_block_hdr::nchars, text_block_hdr::nxt, descriptor_data::output_head, descriptor_data::output_size, descriptor_data::output_tail, R_SOCKDIED, shutdownsock(), SOCKET_EWOULDBLOCK, SOCKET_LAST_ERROR, SOCKET_WRITE, and text_block_hdr::start.

Referenced by main(), queue_write_LEN(), raw_broadcast(), shovechars(), shutdownsock(), and SiteMonSend().

{
    DESC *d = (DESC *)dvoid;

    char *cmdsave = mudstate.debug_cmd;
    mudstate.debug_cmd = "< process_output >";

    TBLOCK *tb = d->output_head;
    while (tb != NULL)
    {
        while (tb->hdr.nchars > 0)
        {
            int cnt = SOCKET_WRITE(d->descriptor, tb->hdr.start, tb->hdr.nchars, 0);
            if (IS_SOCKET_ERROR(cnt))
            {
                int iSocketError = SOCKET_LAST_ERROR;
                mudstate.debug_cmd = cmdsave;
                if (  iSocketError != SOCKET_EWOULDBLOCK
#ifdef SOCKET_EAGAIN
                   && iSocketError != SOCKET_EAGAIN
#endif // SOCKET_EAGAIN
                   && bHandleShutdown)
                {
                    shutdownsock(d, R_SOCKDIED);
                }
                return;
            }
            d->output_size -= cnt;
            tb->hdr.nchars -= cnt;
            tb->hdr.start += cnt;
        }
        TBLOCK *save = tb;
        tb = tb->hdr.nxt;
        MEMFREE(save);
        save = NULL;
        d->output_head = tb;
        if (tb == NULL)
        {
            d->output_tail = NULL;
        }
    }

    mudstate.debug_cmd = cmdsave;
}

static void SendDo	(	DESC *	d,
		unsigned char	chOption
	)			[static]

Transmit a Telnet DO sequence for the given option.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2768 of file bsd.cpp.

References NVT_DO, NVT_IAC, and queue_write_LEN().

Referenced by EnableHim(), and process_input_helper().

{
    char aDo[3]   = { NVT_IAC, NVT_DO,   0 };
    aDo[2] = chOption;
    queue_write_LEN(d, aDo, sizeof(aDo));
}

static void SendDont	(	DESC *	d,
		unsigned char	chOption
	)			[static]

Transmit a Telnet DONT sequence for the given option.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2754 of file bsd.cpp.

References NVT_DONT, NVT_IAC, and queue_write_LEN().

Referenced by DisableHim(), and process_input_helper().

{
    char aDont[3] = { NVT_IAC, NVT_DONT, 0 };
    aDont[2] = chOption;
    queue_write_LEN(d, aDont, sizeof(aDont));
}

static void SendWill	(	DESC *	d,
		unsigned char	chOption
	)			[static]

Transmit a Telnet WILL sequence for the given option.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2740 of file bsd.cpp.

References NVT_IAC, NVT_WILL, and queue_write_LEN().

Referenced by EnableUs(), and process_input_helper().

{
    char aWill[3] = { NVT_IAC, NVT_WILL, 0 };
    aWill[2] = chOption;
    queue_write_LEN(d, aWill, sizeof(aWill));
}

static void SendWont	(	DESC *	d,
		unsigned char	chOption
	)			[static]

Transmit a Telnet WONT sequence for the given option.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.

Returns:

None.

Definition at line 2782 of file bsd.cpp.

References NVT_IAC, NVT_WONT, and queue_write_LEN().

Referenced by DisableUs(), and process_input_helper().

{
    char aWont[3] = { NVT_IAC, NVT_WONT, 0 };
    aWont[2] = chOption;
    queue_write_LEN(d, aWont, sizeof(aWont));
}

void set_signals

(

void

)

Definition at line 4015 of file bsd.cpp.

References CAST_SIGNAL_FUNC, and sighandler().

Referenced by main().

{
#ifndef WIN32
    sigset_t sigs;

    // We have to reset our signal mask, because of the possibility
    // that we triggered a restart on a SIGUSR1. If we did so, then
    // the signal became blocked, and stays blocked, since control
    // never returns to the caller; i.e., further attempts to send
    // a SIGUSR1 would fail.
    //
#undef sigfillset
#undef sigprocmask
    sigfillset(&sigs);
    sigprocmask(SIG_UNBLOCK, &sigs, NULL);
#endif // !WIN32

    signal(SIGINT,  CAST_SIGNAL_FUNC sighandler);
    signal(SIGTERM, CAST_SIGNAL_FUNC sighandler);
    signal(SIGILL,  CAST_SIGNAL_FUNC sighandler);
    signal(SIGSEGV, CAST_SIGNAL_FUNC sighandler);
    signal(SIGABRT, CAST_SIGNAL_FUNC sighandler);
    signal(SIGFPE,  SIG_IGN);

#ifndef WIN32
    signal(SIGCHLD, CAST_SIGNAL_FUNC sighandler);
    signal(SIGHUP,  CAST_SIGNAL_FUNC sighandler);
    signal(SIGQUIT, CAST_SIGNAL_FUNC sighandler);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGUSR1, CAST_SIGNAL_FUNC sighandler);
    signal(SIGUSR2, CAST_SIGNAL_FUNC sighandler);
    signal(SIGTRAP, CAST_SIGNAL_FUNC sighandler);
    signal(SIGILL,  CAST_SIGNAL_FUNC sighandler);
#ifdef HAVE_SETITIMER
    signal(SIGPROF,  CAST_SIGNAL_FUNC sighandler);
#endif

#ifdef SIGXCPU
    signal(SIGXCPU, CAST_SIGNAL_FUNC sighandler);
#endif // SIGXCPU
#ifdef SIGFSZ
    signal(SIGXFSZ, CAST_SIGNAL_FUNC sighandler);
#endif // SIGFSZ
#ifdef SIGEMT
    signal(SIGEMT, CAST_SIGNAL_FUNC sighandler);
#endif // SIGEMT
#ifdef SIGBUS
    signal(SIGBUS, CAST_SIGNAL_FUNC sighandler);
#endif // SIGBUS
#ifdef SIGSYS
    signal(SIGSYS, CAST_SIGNAL_FUNC sighandler);
#endif // SIGSYS
#endif // !WIN32
}

static void SetHimState	(	DESC *	d,
		unsigned char	chOption,
		int	iHimState
	)			[static]

Change the other side's negotiation state.

Parameters:

	d	Player connection context.
	chOption	Telnet Option
	iHimState	One of the six option negotiation states.

Returns:

None.

Definition at line 2685 of file bsd.cpp.

References descriptor_data::nvt_eor_him_state, descriptor_data::nvt_naws_him_state, descriptor_data::nvt_sga_him_state, TELNET_EOR, TELNET_NAWS, and TELNET_SGA.

Referenced by DisableHim(), EnableHim(), and process_input_helper().

{
    if (TELNET_NAWS == chOption)
    {
        d->nvt_naws_him_state = iHimState;
    }
    else if (TELNET_EOR == chOption)
    {
        d->nvt_eor_him_state = iHimState;
    }
    else if (TELNET_SGA == chOption)
    {
        d->nvt_sga_him_state = iHimState;
    }
}

void SetupPorts	(	int *	pnPorts,
		PortInfo	aPorts[],
		IntArray *	pia
	)

Definition at line 1039 of file bsd.cpp.

References DebugTotalSockets, INVALID_SOCKET, tag_int_array::n, tag_int_array::pi, PortInfo::port, PortInfo::socket, and SOCKET_CLOSE.

Referenced by main().

{
    // Any existing open port which does not appear in the requested set
    // should be closed.
    //
    int i, j, k;
    bool bFound;
    for (i = 0; i < *pnPorts; i++)
    {
        bFound = false;
        for (j = 0; j < pia->n; j++)
        {
            if (aPorts[i].port == pia->pi[j])
            {
                bFound = true;
                break;
            }
        }
        if (!bFound)
        {
            if (SOCKET_CLOSE(aPorts[i].socket) == 0)
            {
                DebugTotalSockets--;
                (*pnPorts)--;
                k = *pnPorts;
                if (i != k)
                {
                    aPorts[i] = aPorts[k];
                }
                aPorts[k].port = 0;
                aPorts[k].socket = INVALID_SOCKET;
            }
        }
    }

    // Any requested port which does not appear in the existing open set
    // of ports should be opened.
    //
    for (j = 0; j < pia->n; j++)
    {
        bFound = false;
        for (i = 0; i < *pnPorts; i++)
        {
            if (aPorts[i].port == pia->pi[j])
            {
                bFound = true;
                break;
            }
        }
        if (!bFound)
        {
            k = *pnPorts;
            (*pnPorts)++;
            aPorts[k].port = pia->pi[j];
            make_socket(aPorts+k);
        }
    }

#ifndef WIN32
    for (i = 0; i < *pnPorts; i++)
    {
        if (maxd <= aPorts[i].socket)
        {
            maxd = aPorts[i].socket + 1;
        }
    }
#endif
}

static void SetUsState	(	DESC *	d,
		unsigned char	chOption,
		int	iUsState
	)			[static]

Change our side's negotiation state.

Parameters:

	d	Player connection context.
	chOption	Telnet Option.
	iHimState	One of the six option negotiation states.

Returns:

None.

Definition at line 2709 of file bsd.cpp.

References DisableUs(), EnableUs(), descriptor_data::nvt_eor_us_state, descriptor_data::nvt_naws_us_state, descriptor_data::nvt_sga_us_state, OPTION_NO, OPTION_YES, TELNET_EOR, TELNET_NAWS, and TELNET_SGA.

Referenced by DisableUs(), EnableUs(), and process_input_helper().

{
    if (TELNET_NAWS == chOption)
    {
        d->nvt_naws_us_state = iUsState;
    }
    else if (TELNET_EOR == chOption)
    {
        d->nvt_eor_us_state = iUsState;
        if (OPTION_YES == iUsState)
        {
            EnableUs(d, TELNET_SGA);
        }
        else if (OPTION_NO == iUsState)
        {
            DisableUs(d, TELNET_SGA);
        }
    }
    else if (TELNET_SGA == chOption)
    {
        d->nvt_sga_us_state = iUsState;
    }
}

void shovechars	(	int	nPorts,
		PortInfo	aPorts[]
	)

Definition at line 1417 of file bsd.cpp.

References boot_slave(), CheckInput, CheckOutput, d1, DARK, db, statedata::debug_cmd, DESC_ITER_ALL, DESC_ITER_PLAYER, DESC_SAFEITER_ALL, descriptor_data::descriptor, DS_AUTODARK, ENDLOG, FLAG_WORD1, descriptor_data::flags, object::fs, get_slave_result(), CLinearTimeAbsolute::GetUTC(), GOD, IS_INVALID_SOCKET, IS_SOCKET_ERROR, log_number(), log_perror(), LOG_PROBLEMS, log_text(), maxd, mudstate, ndescriptors, new_connection(), process_input(), process_output(), R_SOCKDIED, CScheduler::RunTasks(), scheduler, statedata::shutdown_flag, shutdownsock(), slave_socket, SOCKET_EBADF, SOCKET_EINTR, SOCKET_LAST_ERROR, STARTLOG, time_30m, update_quotas(), ValidSocket(), CScheduler::WhenNext(), and flagset::word.

Referenced by main().

{
    fd_set input_set, output_set;
    int found;
    DESC *d, *dnext, *newd;
    unsigned int avail_descriptors;
    int maxfds;
    int i;

#define CheckInput(x)     FD_ISSET(x, &input_set)
#define CheckOutput(x)    FD_ISSET(x, &output_set)

    mudstate.debug_cmd = "< shovechars >";

    CLinearTimeAbsolute ltaLastSlice;
    ltaLastSlice.GetUTC();

#ifdef HAVE_GETDTABLESIZE
    maxfds = getdtablesize();
#else // HAVE_GETDTABLESIZE
    maxfds = sysconf(_SC_OPEN_MAX);
#endif // HAVE_GETDTABLESIZE

    avail_descriptors = maxfds - 7;

    while (mudstate.shutdown_flag == 0)
    {
        CLinearTimeAbsolute ltaCurrent;
        ltaCurrent.GetUTC();
        update_quotas(ltaLastSlice, ltaCurrent);

        // Check the scheduler.
        //
        scheduler.RunTasks(ltaCurrent);
        CLinearTimeAbsolute ltaWakeUp;
        if (scheduler.WhenNext(&ltaWakeUp))
        {
            if (ltaWakeUp < ltaCurrent)
            {
                ltaWakeUp = ltaCurrent;
            }
        }
        else
        {
            CLinearTimeDelta ltd = time_30m;
            ltaWakeUp = ltaCurrent + ltd;
        }

        if (mudstate.shutdown_flag)
        {
            break;
        }

        FD_ZERO(&input_set);
        FD_ZERO(&output_set);

        // Listen for new connections if there are free descriptors.
        //
        if (ndescriptors < avail_descriptors)
        {
            for (i = 0; i < nPorts; i++)
            {
                FD_SET(aPorts[i].socket, &input_set);
            }
        }

        // Listen for replies from the slave socket.
        //
        if (!IS_INVALID_SOCKET(slave_socket))
        {
            FD_SET(slave_socket, &input_set);
        }

#ifdef QUERY_SLAVE
        // Listen for replies from the sqlslave socket.
        //
        if (!IS_INVALID_SOCKET(sqlslave_socket))
        {
            FD_SET(sqlslave_socket, &input_set);
        }
#endif // QUERY_SLAVE

        // Mark sockets that we want to test for change in status.
        //
        DESC_ITER_ALL(d)
        {
            if (!d->input_head)
            {
                FD_SET(d->descriptor, &input_set);
            }
            if (d->output_head)
            {
                FD_SET(d->descriptor, &output_set);
            }
        }

        // Wait for something to happen.
        //
        struct timeval timeout;
        CLinearTimeDelta ltdTimeout = ltaWakeUp - ltaCurrent;
        ltdTimeout.ReturnTimeValueStruct(&timeout);
        found = select(maxd, &input_set, &output_set, (fd_set *) NULL,
                   &timeout);

        if (IS_SOCKET_ERROR(found))
        {
            int iSocketError = SOCKET_LAST_ERROR;
            if (iSocketError == SOCKET_EBADF)
            {
                // This one is bad, as it results in a spiral of
                // doom, unless we can figure out what the bad file
                // descriptor is and get rid of it.
                //
                log_perror("NET", "FAIL", "checking for activity", "select");

                // Search for a bad socket amoungst the players.
                //
                DESC_ITER_ALL(d)
                {
                    if (!ValidSocket(d->descriptor))
                    {
                        STARTLOG(LOG_PROBLEMS, "ERR", "EBADF");
                        log_text("Bad descriptor ");
                        log_number(d->descriptor);
                        ENDLOG;
                        shutdownsock(d, R_SOCKDIED);
                    }
                }
                if (  !IS_INVALID_SOCKET(slave_socket)
                   && !ValidSocket(slave_socket))
                {
                    // Try to restart the slave, since it presumably
                    // died.
                    //
                    STARTLOG(LOG_PROBLEMS, "ERR", "EBADF");
                    log_text("Bad slave descriptor ");
                    log_number(slave_socket);
                    ENDLOG;
                    boot_slave(GOD, GOD, GOD, 0);
                }

#ifdef QUERY_SLAVE
                if (  !IS_INVALID_SOCKET(sqlslave_socket)
                   && !ValidSocket(sqlslave_socket))
                {
                    CleanUpSQLSlaveSocket();
                }
#endif // QUERY_SLAVE

                for (i = 0; i < nPorts; i++)
                {
                    if (!ValidSocket(aPorts[i].socket))
                    {
                        // That's it. Game over.
                        //
                        STARTLOG(LOG_PROBLEMS, "ERR", "EBADF");
                        log_text("Bad game port descriptor ");
                        log_number(aPorts[i].socket);
                        ENDLOG;
                        return;
                    }
                }
            }
            else if (iSocketError != SOCKET_EINTR)
            {
                log_perror("NET", "FAIL", "checking for activity", "select");
            }
            continue;
        }

        // Get usernames and hostnames.
        //
        if (  !IS_INVALID_SOCKET(slave_socket)
           && CheckInput(slave_socket))
        {
            while (get_slave_result() == 0)
            {
                ; // Nothing.
            }
        }

#ifdef QUERY_SLAVE
        // Get result sets from sqlslave.
        //
        if (  !IS_INVALID_SOCKET(sqlslave_socket)
           && CheckInput(sqlslave_socket))
        {
            while (get_sqlslave_result() == 0)
            {
                ; // Nothing.
            }
        }
#endif // QUERY_SLAVE

        // Check for new connection requests.
        //
        for (i = 0; i < nPorts; i++)
        {
            if (CheckInput(aPorts[i].socket))
            {
                int iSocketError;
                newd = new_connection(aPorts+i, &iSocketError);
                if (!newd)
                {
                    if (  iSocketError
                       && iSocketError != SOCKET_EINTR)
                    {
                        log_perror("NET", "FAIL", NULL, "new_connection");
                    }
                }
                else if (maxd <= newd->descriptor)
                {
                    maxd = newd->descriptor + 1;
                }
            }
        }

        // Check for activity on user sockets.
        //
        DESC_SAFEITER_ALL(d, dnext)
        {
            // Process input from sockets with pending input.
            //
            if (CheckInput(d->descriptor))
            {
                // Undo autodark
                //
                if (d->flags & DS_AUTODARK)
                {
                    // Clear the DS_AUTODARK on every related session.
                    //
                    DESC *d1;
                    DESC_ITER_PLAYER(d->player, d1)
                    {
                        d1->flags &= ~DS_AUTODARK;
                    }
                    db[d->player].fs.word[FLAG_WORD1] &= ~DARK;
                }

                // Process received data.
                //
                if (!process_input(d))
                {
                    shutdownsock(d, R_SOCKDIED);
                    continue;
                }
            }

            // Process output for sockets with pending output.
            //
            if (CheckOutput(d->descriptor))
            {
                process_output(d, true);
            }
        }
    }
}

void shutdownsock	(	DESC *	d,
		int	reason
	)

Definition at line 1843 of file bsd.cpp.

References A_PROGCMD, A_REASON, statedata::access_list, descriptor_data::addr, descriptor_data::address, alloc_lbuf, alloc_mbuf, announce_disconnect(), atr_add_raw(), atr_clr(), CIF_LASTCONNECT, CIF_LONGESTCONNECT, CIF_NUMCONNECTS, CIF_TOTALTIME, clearstrings(), descriptor_data::command_count, descriptor_data::connected_at, db, decode_flags(), DESC_ITER_PLAYER, descriptor_data::descriptor, DS_CONNECTED, ENDLOG, FC_QUIT, fcache_dump(), fetch_ConnectionInfoFields(), find_oldest(), descriptor_data::flags, free_lbuf, free_mbuf, free_sbuf, CLinearTimeAbsolute::GetUTC(), GOD, H_FORBIDDEN, Location, LOG_ACCOUNTING, LOG_LOGIN, log_name(), LOG_NET, LOG_SECURITY, log_text(), MAX_GLOBAL_REGS, MEMFREE, mudstate, Name, Pennies(), descriptor_data::player, process_output(), descriptor_data::program_data, put_ConnectionInfoFields(), R_LOGOUT, R_QUIT, CLinearTimeDelta::ReturnSeconds(), site_check(), SiteMonSend(), STARTLOG, and prog_data::wait_regs.

Referenced by boot_by_port(), boot_off(), check_connect(), check_idle(), close_sockets(), do_logged_out_internal(), failconn(), load_restart_db(), process_output(), and shovechars().

{
    char *buff, *buff2;
    int i, num;
    DESC *dtemp;

    if (  (reason == R_LOGOUT)
       && (site_check((d->address).sin_addr, mudstate.access_list) == H_FORBIDDEN))
    {
        reason = R_QUIT;
    }

    CLinearTimeAbsolute ltaNow;
    ltaNow.GetUTC();

    if (d->flags & DS_CONNECTED)
    {
        // Added by D.Piper (del@doofer.org) 1997 & 2000-APR
        //

        // Reason: attribute (disconnect reason)
        //
        atr_add_raw(d->player, A_REASON, (char *)disc_messages[reason]);

        // Update the A_CONNINFO attribute.
        //
        long anFields[4];
        fetch_ConnectionInfoFields(d->player, anFields);

        // One of the active sessions is going away. It doesn't matter which
        // one.
        //
        anFields[CIF_NUMCONNECTS]++;

        // What are the two longest sessions?
        //
        DESC *dOldest[2];
        find_oldest(d->player, dOldest);

        CLinearTimeDelta ltdFull;
        ltdFull = ltaNow - dOldest[0]->connected_at;
        long tFull = ltdFull.ReturnSeconds();
        if (dOldest[0] == d)
        {
            // We are dropping the oldest connection.
            //
            CLinearTimeDelta ltdPart;
            if (dOldest[1])
            {
                // There is another (more recently made) connection.
                //
                ltdPart = dOldest[1]->connected_at - dOldest[0]->connected_at;
            }
            else
            {
                // There is only one connection.
                //
                ltdPart = ltdFull;
            }
            long tPart = ltdPart.ReturnSeconds();

            anFields[CIF_TOTALTIME] += tPart;
            if (anFields[CIF_LONGESTCONNECT] < tFull)
            {
                anFields[CIF_LONGESTCONNECT] = tFull;
            }
        }
        anFields[CIF_LASTCONNECT] = tFull;

        put_ConnectionInfoFields(d->player, anFields, ltaNow);

        // If we are doing a LOGOUT, keep the connection open so that the
        // player can connect to a different character. Otherwise, we
        // do the normal disconnect stuff.
        //
        if (reason == R_LOGOUT)
        {
            STARTLOG(LOG_NET | LOG_LOGIN, "NET", "LOGO")
            buff = alloc_mbuf("shutdownsock.LOG.logout");
            sprintf(buff, "[%u/%s] Logout by ", d->descriptor, d->addr);
            log_text(buff);
            log_name(d->player);
            sprintf(buff, " <Reason: %s>", disc_reasons[reason]);
            log_text(buff);
            free_mbuf(buff);
            ENDLOG;
        }
        else
        {
            fcache_dump(d, FC_QUIT);
            STARTLOG(LOG_NET | LOG_LOGIN, "NET", "DISC")
            buff = alloc_mbuf("shutdownsock.LOG.disconn");
            sprintf(buff, "[%u/%s] Logout by ", d->descriptor, d->addr);
            log_text(buff);
            log_name(d->player);
            sprintf(buff, " <Reason: %s>", disc_reasons[reason]);
            log_text(buff);
            free_mbuf(buff);
            ENDLOG;
            SiteMonSend(d->descriptor, d->addr, d, "Disconnection");
        }

        // If requested, write an accounting record of the form:
        // Plyr# Flags Cmds ConnTime Loc Money [Site] <DiscRsn> Name
        //
        STARTLOG(LOG_ACCOUNTING, "DIS", "ACCT");
        CLinearTimeDelta ltd = ltaNow - d->connected_at;
        int Seconds = ltd.ReturnSeconds();
        buff = alloc_lbuf("shutdownsock.LOG.accnt");
        buff2 = decode_flags(GOD, &(db[d->player].fs));
        sprintf(buff, "%d %s %d %d %d %d [%s] <%s> %s", d->player, buff2, d->command_count,
                Seconds, Location(d->player), Pennies(d->player), d->addr, disc_reasons[reason],
                Name(d->player));
        log_text(buff);
        free_lbuf(buff);
        free_sbuf(buff2);
        ENDLOG;
        announce_disconnect(d->player, d, disc_messages[reason]);
    }
    else
    {
        if (reason == R_LOGOUT)
        {
            reason = R_QUIT;
        }
        STARTLOG(LOG_SECURITY | LOG_NET, "NET", "DISC");
        buff = alloc_mbuf("shutdownsock.LOG.neverconn");
        sprintf(buff, "[%u/%s] Connection closed, never connected. <Reason: %s>", d->descriptor, d->addr, disc_reasons[reason]);
        log_text(buff);
        free_mbuf(buff);
        ENDLOG;
        SiteMonSend(d->descriptor, d->addr, d, "N/C Connection Closed");
    }

    process_output(d, false);
    clearstrings(d);

    d->flags &= ~DS_CONNECTED;

    // Is this desc still in interactive mode?
    //
    if (d->program_data != NULL)
    {
        num = 0;
        DESC_ITER_PLAYER(d->player, dtemp) num++;

        if (num == 0)
        {
            for (i = 0; i < MAX_GLOBAL_REGS; i++)
            {
                if (d->program_data->wait_regs[i])
                {
                    free_lbuf(d->program_data->wait_regs[i]);
                    d->program_data->wait_regs[i] = NULL;
                }
            }
            MEMFREE(d->program_data);
            atr_clr(d->player, A_PROGCMD);
        }
        d->program_data = NULL;
    }
    if (reason == R_LOGOUT)
    {
        d->connected_at.GetUTC();
        d->retries_left = mudconf.retry_limit;
        d->command_count = 0;
        d->timeout = mudconf.idle_timeout;
        d->player = 0;
        d->doing[0] = '\0';
        d->quota = mudconf.cmd_quota_max;
        d->last_time = d->connected_at;
        d->host_info = site_check((d->address).sin_addr, mudstate.access_list)
                     | site_check((d->address).sin_addr, mudstate.suspect_list);
        d->input_tot = d->input_size;
        d->output_tot = 0;
        welcome_user(d);
    }
    else
    {
        // Cancel any scheduled processing on this descriptor.
        //
        scheduler.CancelTask(Task_ProcessCommand, d, 0);

#ifdef WIN32
        if (platform == VER_PLATFORM_WIN32_NT)
        {
            // Don't close down the socket twice.
            //
            if (!d->bConnectionShutdown)
            {
                // Make sure we don't try to initiate or process any
                // outstanding IOs
                //
                d->bConnectionShutdown = true;

                // Protect removing the descriptor from our linked list from
                // any interference from the listening thread.
                //
                EnterCriticalSection(&csDescriptorList);
                *d->prev = d->next;
                if (d->next)
                {
                    d->next->prev = d->prev;
                }
                LeaveCriticalSection(&csDescriptorList);

                // This descriptor may hang around awhile, clear out the links.
                //
                d->next = 0;
                d->prev = 0;

                // Close the connection in 5 seconds.
                //
                scheduler.DeferTask(ltaNow + FACTOR_100NS_PER_SECOND*5,
                    PRIORITY_SYSTEM, Task_DeferredClose, d, 0);
            }
            return;
        }
#endif

        shutdown(d->descriptor, SD_BOTH);
        if (SOCKET_CLOSE(d->descriptor) == 0)
        {
            DebugTotalSockets--;
        }
        d->descriptor = INVALID_SOCKET;

        *d->prev = d->next;
        if (d->next)
        {
            d->next->prev = d->prev;
        }

        // This descriptor may hang around awhile, clear out the links.
        //
        d->next = 0;
        d->prev = 0;

        // If we don't have queued IOs, then we can free these, now.
        //
        freeqs(d);
        free_desc(d);
        ndescriptors--;
    }
}

static RETSIGTYPE DCL_CDECL sighandler

(

int

sig

)

[static]

Definition at line 3745 of file bsd.cpp.

References al_store(), statedata::bCanRestart, CScheduler::CancelTask(), CAST_SIGNAL_FUNC, check_panicking(), CleanUpSlaveProcess(), CleanUpSlaveSocket(), CLOSE, confdata::config_file, CScheduler::DeferTask(), dispatch_DatabaseDump(), do_restart(), statedata::dump_counter, dump_database_internal(), DUMP_I_RESTART, DUMP_I_SIGNAL, dump_restart_db(), statedata::dumped, statedata::dumper, statedata::dumping, ENDLOG, CLogFile::Flush(), confdata::fork_dump, CLinearTimeAbsolute::GetUTC(), GOD, local_dump_complete_signal(), local_presync_database_sigsegv(), Log, LOG_PROBLEMS, log_signal(), log_signal_ignore(), LogStatBuf(), confdata::mud_name, mudconf, mudstate, MuxAlarm, statedata::panicking, pcache_sync(), confdata::pid_file, PRIORITY_SYSTEM, raw_broadcast(), report(), SA_EXIT, scheduler, statedata::shutdown_flag, confdata::sig_action, CMuxAlarm::Signal(), SignalDesc(), slave_pid, STARTLOG, SYNC, CLogFile::tinyprintf(), and unset_signals().

Referenced by set_signals().

{
#ifndef WIN32
    int stat_buf;
    pid_t child;
#endif // !WIN32

    switch (sig)
    {
#ifndef WIN32
    case SIGUSR1:
        if (mudstate.bCanRestart)
        {
            log_signal(sig);
            do_restart(GOD, GOD, GOD, 0);
        }
        else
        {
            log_signal_ignore(sig);
        }
        break;

    case SIGUSR2:

        // Drop a flatfile.
        //
        log_signal(sig);
        raw_broadcast(0, "Caught signal %s requesting a flatfile @dump. Please wait.", SignalDesc(sig));
        dump_database_internal(DUMP_I_SIGNAL);
        break;

    case SIGCHLD:

        // Change in child status.
        //
#ifndef SIGNAL_SIGCHLD_BRAINDAMAGE
        signal(SIGCHLD, CAST_SIGNAL_FUNC sighandler);
#endif // !SIGNAL_SIGCHLD_BRAINDAMAGE

        while ((child = waitpid(0, &stat_buf, WNOHANG)) > 0)
        {
            if (  WIFEXITED(stat_buf)
               || WIFSIGNALED(stat_buf))
            {
                if (child == slave_pid)
                {
                    // The reverse-DNS slave process ended unexpectedly.
                    //
                    CleanUpSlaveSocket();
                    slave_pid = 0;

                    LogStatBuf(stat_buf, "SLAVE");

                    continue;
                }
#ifdef QUERY_SLAVE
                else if (child == sqlslave_pid)
                {
                    // The SQL slave process ended unexpectedly.
                    //
                    CleanUpSQLSlaveSocket();
                    sqlslave_pid = 0;

                    LogStatBuf(stat_buf, "QUERY");

                    continue;
                }
#endif // QUERY_SLAVE
                else if (  mudconf.fork_dump
                        && mudstate.dumping)
                {
                    mudstate.dumped = child;
                    if (mudstate.dumper == mudstate.dumped)
                    {
                        // The dumping process finished.
                        //
                        mudstate.dumper  = 0;
                        mudstate.dumped  = 0;
                    }
                    else
                    {
                        // The dumping process finished before we could
                        // obtain its process id from fork().
                        //
                    }
                    mudstate.dumping = false;
                    local_dump_complete_signal();

                    continue;
                }
            }

            log_signal(sig);
            LogStatBuf(stat_buf, "UKNWN");

            STARTLOG(LOG_PROBLEMS, "SIG", "DEBUG");
#ifdef QUERY_SLAVE
            Log.tinyprintf("mudstate.dumper=%d, child=%d, slave_pid=%d, sqlslave_pid=%d" ENDLINE,
                mudstate.dumper, child, slave_pid, sqlslave_pid);
#else
            Log.tinyprintf("mudstate.dumper=%d, child=%d, slave_pid=%d" ENDLINE,
                mudstate.dumper, child, slave_pid);
#endif // QUERY_SLAVE
            ENDLOG;
        }
        break;

    case SIGHUP:

        // Perform a database dump.
        //
        log_signal(sig);
        extern void dispatch_DatabaseDump(void *pUnused, int iUnused);
        scheduler.CancelTask(dispatch_DatabaseDump, 0, 0);
        mudstate.dump_counter.GetUTC();
        scheduler.DeferTask(mudstate.dump_counter, PRIORITY_SYSTEM, dispatch_DatabaseDump, 0, 0);
        break;

#ifdef HAVE_SETITIMER
    case SIGPROF:

        // Softcode is running longer than is reasonable.  Apply the brakes.
        //
        log_signal(sig);
        MuxAlarm.Signal();
        break;
#endif

#endif // !WIN32

    case SIGINT:

        // Log + ignore
        //
        log_signal(sig);
        break;

#ifndef WIN32
    case SIGQUIT:
#endif // !WIN32
    case SIGTERM:
#ifdef SIGXCPU
    case SIGXCPU:
#endif // SIGXCPU
        // Time for a normal and short-winded shutdown.
        //
        check_panicking(sig);
        log_signal(sig);
        raw_broadcast(0, "GAME: Caught signal %s, exiting.", SignalDesc(sig));
        mudstate.shutdown_flag = true;
        break;

    case SIGILL:
    case SIGFPE:
    case SIGSEGV:
#ifndef WIN32
    case SIGTRAP:
#ifdef SIGXFSZ
    case SIGXFSZ:
#endif // SIGXFSZ
#ifdef SIGEMT
    case SIGEMT:
#endif // SIGEMT
#ifdef SIGBUS
    case SIGBUS:
#endif // SIGBUS
#ifdef SIGSYS
    case SIGSYS:
#endif // SIGSYS
#endif // !WIN32

        // Panic save + restart.
        //
        Log.Flush();
        check_panicking(sig);
        log_signal(sig);
        report();

        local_presync_database_sigsegv();
#ifndef MEMORY_BASED
        al_store();
#endif
        pcache_sync();
        SYNC;

        if (  mudconf.sig_action != SA_EXIT
           && mudstate.bCanRestart)
        {
            raw_broadcast
            (  0,
               "GAME: Fatal signal %s caught, restarting.",
               SignalDesc(sig)
            );

            // There is no older DB. It's a fiction. Our only choice is
            // between unamed attributes and named ones. We go with what we
            // got.
            //
            dump_database_internal(DUMP_I_RESTART);
            SYNC;
            CLOSE;
#ifdef WIN32
            unset_signals();
            signal(sig, SIG_DFL);
            WSACleanup();
            exit(12345678);
#else // WIN32
            CleanUpSlaveSocket();
            CleanUpSlaveProcess();

            // Try our best to dump a core first
            //
            if (!fork())
            {
                // We are the broken parent. Die.
                //
                unset_signals();
                exit(1);
            }

            // We are the reproduced child with a slightly better chance.
            //
            dump_restart_db();
#ifdef GAME_DOOFERMUX
            execl("bin/netmux", mudconf.mud_name, "-c", mudconf.config_file, "-p", mudconf.pid_file, NULL);
#else // GAME_DOOFERMUX
            execl("bin/netmux", "netmux", "-c", mudconf.config_file, "-p", mudconf.pid_file, NULL);
#endif // GAME_DOOFERMUX
            break;
#endif // WIN32
        }
        else
        {
#ifdef WIN32
            WSACleanup();
#endif // WIN32

            unset_signals();
            signal(sig, SIG_DFL);
            exit(1);
        }
        break;

    case SIGABRT:

        // Coredump.
        //
        check_panicking(sig);
        log_signal(sig);
        report();

#ifdef WIN32
        WSACleanup();
#endif // WIN32

        unset_signals();
        signal(sig, SIG_DFL);
        exit(1);
    }
    signal(sig, CAST_SIGNAL_FUNC sighandler);
    mudstate.panicking = 0;
}

static char* SignalDesc

(

int

iSignal

)

[static]

Definition at line 3693 of file bsd.cpp.

References LBUF_SIZE, safe_chr, safe_str, and signames.

Referenced by log_signal(), log_signal_ignore(), LogStatBuf(), and sighandler().

{
    static char buff[LBUF_SIZE];
    char *bufc = buff;
    safe_str(signames[iSignal].pShortName, buff, &bufc);
    if (signames[iSignal].pLongName)
    {
        safe_str(" (", buff, &bufc);
        safe_str(signames[iSignal].pLongName, buff, &bufc);
        safe_chr(')', buff, &bufc);
    }
    *bufc = '\0';
    return buff;
}

void SiteMonSend	(	int	,
		const char *	,
		DESC *	,
		const char *
	)			[static]

Definition at line 4599 of file bsd.cpp.

References DESC_ITER_CONN, H_NOSITEMON, H_SUSPECT, descriptor_data::host_info, IS_INVALID_SOCKET, descriptor_data::player, process_output(), queue_string(), queue_write_LEN(), SiteMon, and tprintf().

Referenced by new_connection(), and shutdownsock().

{
    // Don't do sitemon for blocked sites.
    //
    if (  d != NULL
       && (d->host_info & H_NOSITEMON))
    {
        return;
    }

    // Build the msg.
    //
    char *sendMsg;
    bool bSuspect = (d != NULL) && (d->host_info & H_SUSPECT);
    if (IS_INVALID_SOCKET(port))
    {
        sendMsg = tprintf("SITEMON: [UNKNOWN] %s from %s.%s", msg, address,
            bSuspect ? " (SUSPECT)": "");
    }
    else
    {
        sendMsg = tprintf("SITEMON: [%d] %s from %s.%s", port, msg,
            address, bSuspect ? " (SUSPECT)": "");
    }

    DESC *nd;
    DESC_ITER_CONN(nd)
    {
        if (SiteMon(nd->player))
        {
            queue_string(nd, sendMsg);
            queue_write_LEN(nd, "\r\n", 2);
            process_output(nd, false);
        }
    }
}

void TelnetSetup

(

DESC *

d

)

[static]

Begin initial telnet negotiations on a socket.

The two sides of the connection may not agree on the following set of options, and keep in mind that the successful negotiation of a particular option may cause the negotiation of another option.

Without this function, we are only react to client requests.

Parameters:

d

Player connection on which the input arrived.

Returns:

None.

Definition at line 2965 of file bsd.cpp.

References EnableHim(), EnableUs(), TELNET_EOR, TELNET_NAWS, and TELNET_SGA.

Referenced by new_connection().

{
    // Attempt negotation of EOR so we can use that, and if that succeeds,
    // code elsewhere will attempt the negotation of SGA for our side as well.
    //
    EnableUs(d, TELNET_EOR);
    EnableHim(d, TELNET_EOR);
    EnableHim(d, TELNET_SGA);
    EnableHim(d, TELNET_NAWS);
}

static void unset_signals

(

void

)

[static]

Definition at line 3400 of file bsd.cpp.

Referenced by sighandler().

{
    int i;

    for (i = 0; i < NSIG; i++)
    {
        signal(i, SIG_DFL);
    }
}

int UsState	(	DESC *	d,
		unsigned char	chOption
	)

Return our side's negotiation state.

The negotiation of each optional feature of telnet can be in one of six states (defined in interface.h): OPTION_NO, OPTION_YES, OPTION_WANTNO_EMPTY, OPTION_WANTNO_OPPOSITE, OPTION_WANTYES_EMPTY, and OPTION_WANTYES_OPPOSITE.

An option is only enabled when it is in the OPTION_YES state.

Parameters:

	d	Player connection context.
	chOption	Telnet Option

Returns:

One of six states.

Definition at line 2660 of file bsd.cpp.

References descriptor_data::nvt_eor_us_state, descriptor_data::nvt_naws_us_state, descriptor_data::nvt_sga_us_state, OPTION_NO, TELNET_EOR, TELNET_NAWS, and TELNET_SGA.

Referenced by DesiredUsOption(), do_prog(), handle_prog(), and process_input_helper().

{
    if (TELNET_NAWS == chOption)
    {
        return d->nvt_naws_us_state;
    }
    else if (TELNET_EOR == chOption)
    {
        return d->nvt_eor_us_state;
    }
    else if (TELNET_SGA == chOption)
    {
        return d->nvt_sga_us_state;
    }
    return OPTION_NO;
}

bool ValidSocket

(

SOCKET

s

)

Definition at line 1407 of file bsd.cpp.

Referenced by shovechars().

{
    struct stat fstatbuf;
    if (fstat(s, &fstatbuf) < 0)
    {
        return false;
    }
    return true;
}

---

Variable Documentation

PortInfo aMainGamePorts[MAX_LISTEN_PORTS]

Definition at line 32 of file bsd.cpp.

Referenced by close_sockets(), dump_restart_db(), load_restart_db(), and main().

const SIGNALTYPE aSigTypes[]

Definition at line 3426 of file bsd.cpp.

Referenced by BuildSignalNamesTable().

DESC* descriptor_list = NULL

Definition at line 36 of file bsd.cpp.

Referenced by get_slave_result(), initializesock(), and load_restart_db().

const char* disc_messages[] [static]

Initial value:

{
    "Unknown",
    "Quit",
    "Timeout",
    "Boot",
    "Netfailure",
    "Shutdown",
    "BadLogin",
    "NoLogins",
    "Logout"
}

Definition at line 1830 of file bsd.cpp.

const char* disc_reasons[] [static]

Initial value:

{
    "Unspecified",
    "Quit",
    "Inactivity Timeout",
    "Booted",
    "Remote Close or Net Failure",
    "Game Shutdown",
    "Login Retry Limit",
    "Logins Disabled",
    "Logout (Connection Not Dropped)",
    "Too Many Connected Players"
}

Definition at line 1814 of file bsd.cpp.

pid_t game_pid

Definition at line 52 of file bsd.cpp.

Referenced by check_panicking(), list_process(), main(), and write_pidfile().

int maxd = 0

Definition at line 49 of file bsd.cpp.

Referenced by boot_slave(), load_restart_db(), and shovechars().

unsigned int ndescriptors = 0

Definition at line 35 of file bsd.cpp.

Referenced by initializesock(), load_restart_db(), and shovechars().

int nMainGamePorts = 0

Definition at line 33 of file bsd.cpp.

Referenced by close_sockets(), dump_restart_db(), load_restart_db(), and main().

const int nvt_input_action_table[8][14] [static]

Initial value:

{

    {   1,   2,   3,   0,   1,   1,   1,   1,   1,   1,   1,   1,   1,   5  }, 
    {   4,   4,   4,   4,   4,   4,  12,   2,  10,   6,   7,   8,   9,   1  }, 
    {  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,  13,   4  }, 
    {  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,  14,   4  }, 
    {  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,  15,   4  }, 
    {  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,  16,   4  }, 
    {  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  17,  11  }, 
    {   0,   0,   0,   0,  18,   0,   0,   0,   0,   0,   0,   0,   0,  17  }, 
}

Table to map current telnet parsing state state and input to specific actions and state changes.

Action 0 - Nothing. Action 1 - Accept CHR(X) (and transition to Normal state). Action 2 - Erase Character. Action 3 - Accept Line. Action 4 - Transition to the Normal state. Action 5 - Transition to Have_IAC state. Action 6 - Transition to the Have_IAC_WILL state. Action 7 - Transition to the Have_IAC_DONT state. Action 8 - Transition to the Have_IAC_DO state. Action 9 - Transition to the Have_IAC_WONT state. Action 10 - Transition to the Have_IAC_SB state. Action 11 - Transition to the Have_IAC_SB_IAC state. Action 12 - Respond to IAC AYT and return to the Normal state. Action 13 - Respond to IAC WILL X Action 14 - Respond to IAC DONT X Action 15 - Respond to IAC DO X Action 16 - Respond to IAC WONT X Action 17 - Accept CHR(X) for Sub-Option (and transition to Have_IAC_SB state). Action 18 - Accept Completed Sub-option and transition to Normal state.

Definition at line 2602 of file bsd.cpp.

const unsigned char nvt_input_xlat_table[256] [static]

Initial value:

{


    0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  2,  0,  0,  3,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  

    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  
    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  5,  
    4,  5,  5,  5,  5,  5,  6,  7,  5,  5,  8,  9, 10, 11, 12, 13   
}

Table to quickly classify characters recieved from the wire with their Telnet meaning.

The use of this table reduces the size of the state table.

Class 0 - Any byte. Class 5 - BRK (0xF3) Class 10 - WONT (0xFC) Class 1 - BS (0x08) Class 5 - IP (0xF4) Class 11 - DO (0xFD) Class 2 - LF (0x0A) Class 5 - AO (0xF5) Class 12 - DONT (0xFE) Class 3 - CR (0x0D) Class 6 - AYT (0xF6) Class 13 - IAC (0xFF) Class 1 - DEL (0x7F) Class 7 - EC (0xF7) Class 5 - EOR (0xEF) Class 5 - EL (0xF8) Class 4 - SE (0xF0) Class 5 - GA (0xF9) Class 5 - NOP (0xF1) Class 8 - SB (0xFA) Class 5 - DM (0xF2) Class 9 - WILL (0xFB)

Definition at line 2555 of file bsd.cpp.

NAMETAB sigactions_nametab[]

Initial value:

{
    {"exit",        3,  0,  SA_EXIT},
    {"default",     1,  0,  SA_DFLT},
    { NULL,         0,  0,  0}
}

Definition at line 4008 of file bsd.cpp.

MUX_SIGNAMES signames[NSIG] [static]

Definition at line 3624 of file bsd.cpp.

Referenced by BuildSignalNamesTable(), and SignalDesc().

pid_t slave_pid = 0

Definition at line 50 of file bsd.cpp.

Referenced by boot_slave(), CleanUpSlaveProcess(), and sighandler().

int slave_socket = INVALID_SOCKET

Definition at line 51 of file bsd.cpp.

Referenced by boot_slave(), CleanUpSlaveSocket(), get_slave_result(), new_connection(), and shovechars().

---