quakeforge/nq/source/net_ser.c

/*
	net_ser.c

	@description@

	Copyright (C) 1996-1997  Id Software, Inc.

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License
	as published by the Free Software Foundation; either version 2
	of the License, or (at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

	See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to:

		Free Software Foundation, Inc.
		59 Temple Place - Suite 330
		Boston, MA  02111-1307, USA

	$Id$
*/

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include "net_ser.h"
#include "dosisms.h"
#include "QF/crc.h"

#include "net_comx.c"

// serial protocol

#define SERIAL_PROTOCOL_VERSION 3

// The serial protocol is message oriented.  The high level message format is
// a one byte message type (MTYPE_xxx), data, and a 16-bit checksum.  All
// multi-byte fields are sent in network byte order.  There are currently 4
// MTYPEs defined.  Their formats are as follows:
//
// MTYPE_RELIABLE     sequence      data_length   data       checksum   eom
// MTYPE_UNRELIABLE   sequence      data_length   data       checksum   eom
// MTYPE_ACK          sequence      checksum      eom
// MTYPE_CONTROL      data_length   data          checksum   eom
//
// sequence is an 8-bit unsigned value starting from 0
// data_length is a 16-bit unsigned value; it is the length of the data only
// the checksum is a 16-bit value.  the CRC formula used is defined in crc.h.
//              the checksum covers the entire messages, excluding itself
// eom is a special 2 byte sequence used to mark the End Of Message.  This is
//              needed for error recovery.
//
// A lot of behavior is based on knowledge of the upper level Quake network
// layer.  For example, only one reliable message can be outstanding (pending
// reception of an MTYPE_ACK) at a time.
//
// The low level routines used to communicate with the modem are not part of
// this protocol.
//
// The CONTROL messages are only used for session establishment.  They are
// not reliable or sequenced.

#define MTYPE_RELIABLE			0x01
#define MTYPE_UNRELIABLE		0x02
#define MTYPE_CONTROL			0x03
#define MTYPE_ACK				0x04
#define MTYPE_CLIENT			0x80

#define ESCAPE_COMMAND			0xe0
#define ESCAPE_EOM				0x19

static qboolean listening = false;


typedef struct SerialLine_s {
	struct SerialLine_s *next;
	qsocket_t  *sock;
	int         lengthStated;
	int         lengthFound;
	int         tty;
	qboolean    connected;
	qboolean    connecting;
	qboolean    client;
	double      connect_time;
	unsigned short crcStated;
	unsigned short crcValue;
	byte        currState;
	byte        prevState;
	byte        mtype;
	byte        sequence;
} SerialLine;

#define STATE_READY		0
#define STATE_SEQUENCE	1
#define STATE_LENGTH1	2
#define STATE_LENGTH2	3
#define STATE_DATA		4
#define STATE_CRC1		5
#define STATE_CRC2		6
#define STATE_EOM		7
#define STATE_ESCAPE	8
#define STATE_ABORT		9

SerialLine  serialLine[NUM_COM_PORTS];

int         myDriverLevel;

static void Serial_SendACK (SerialLine * p, byte sequence);


static void
ResetSerialLineProtocol (SerialLine * p)
{
	p->connected = false;
	p->connecting = false;
	p->currState = STATE_READY;
	p->prevState = STATE_READY;
	p->lengthFound = 0;
}


static int
ProcessInQueue (SerialLine * p)
{
	int         b;

	while (1) {
		b = TTY_ReadByte (p->tty);
		if (b == ERR_TTY_NODATA)
			break;

		if (b == ERR_TTY_LINE_STATUS) {
			p->currState = STATE_ABORT;
			continue;
		}
		if (b == ERR_TTY_MODEM_STATUS) {
			p->currState = STATE_ABORT;
			return -1;
		}

		if (b == ESCAPE_COMMAND)
			if (p->currState != STATE_ESCAPE) {
				p->prevState = p->currState;
				p->currState = STATE_ESCAPE;
				continue;
			}

		if (p->currState == STATE_ESCAPE) {
			if (b == ESCAPE_EOM) {
				if (p->prevState == STATE_ABORT) {
					p->currState = STATE_READY;
					p->lengthFound = 0;
					continue;
				}

				if (p->prevState != STATE_EOM) {
					p->currState = STATE_READY;
					p->lengthFound = 0;
					Con_DPrintf ("Serial: premature EOM\n");
					continue;
				}

				switch (p->mtype) {
					case MTYPE_RELIABLE:
					Con_DPrintf ("Serial: sending ack %u\n", p->sequence);
					Serial_SendACK (p, p->sequence);
					if (p->sequence == p->sock->receiveSequence) {
						p->sock->receiveSequence = (p->sequence + 1) & 0xff;
						p->sock->receiveMessageLength += p->lengthFound;
					} else
						Con_DPrintf
							("Serial: reliable out of order; got %u wanted %u\n",
							 p->sequence, p->sock->receiveSequence);
					break;

					case MTYPE_UNRELIABLE:
					p->sock->unreliableReceiveSequence =
						(p->sequence + 1) & 0xff;
					p->sock->receiveMessageLength += p->lengthFound;
					break;

					case MTYPE_ACK:
					Con_DPrintf ("Serial: got ack %u\n", p->sequence);
					if (p->sequence == p->sock->sendSequence) {
						p->sock->sendSequence =
							(p->sock->sendSequence + 1) & 0xff;
						p->sock->canSend = true;
					} else
						Con_DPrintf
							("Serial: ack out of order; got %u wanted %u\n",
							 p->sequence, p->sock->sendSequence);
					break;

					case MTYPE_CONTROL:
					p->sock->receiveMessageLength += p->lengthFound;
					break;
				}

				p->currState = STATE_READY;
				p->lengthFound = 0;
				continue;
			}


			if (b != ESCAPE_COMMAND) {
				p->currState = STATE_ABORT;
				Con_DPrintf ("Serial: Bad escape sequence\n");
				continue;
			}
			// b == ESCAPE_COMMAND
			p->currState = p->prevState;
		}

		p->prevState = p->currState;

//DEBUG
		if (p->sock->receiveMessageLength + p->lengthFound > NET_MAXMESSAGE) {
			Con_DPrintf ("Serial blew out receive buffer: %u\n",
						 p->sock->receiveMessageLength + p->lengthFound);
			p->currState = STATE_ABORT;
		}
		if (p->sock->receiveMessageLength + p->lengthFound == NET_MAXMESSAGE) {
			Con_DPrintf ("Serial hit receive buffer limit: %u\n",
						 p->sock->receiveMessageLength + p->lengthFound);
			p->currState = STATE_ABORT;
		}
//end DEBUG

		switch (p->currState) {
			case STATE_READY:
			CRC_Init (&p->crcValue);
			CRC_ProcessByte (&p->crcValue, b);
			if (p->client) {
				if ((b & MTYPE_CLIENT) != 0) {
					p->currState = STATE_ABORT;
					Con_DPrintf ("Serial: client got own message\n");
					break;
				}
			} else {
				if ((b & MTYPE_CLIENT) == 0) {
					p->currState = STATE_ABORT;
					Con_DPrintf ("Serial: server got own message\n");
					break;
				}
				b &= 0x7f;
			}
			p->mtype = b;
			if (b != MTYPE_CONTROL)
				p->currState = STATE_SEQUENCE;
			else
				p->currState = STATE_LENGTH1;
			if (p->mtype < MTYPE_ACK) {
				p->sock->receiveMessage[p->sock->receiveMessageLength] = b;
				p->lengthFound++;
			}
			break;

			case STATE_SEQUENCE:
			p->sequence = b;
			CRC_ProcessByte (&p->crcValue, b);
			if (p->mtype != MTYPE_ACK)
				p->currState = STATE_LENGTH1;
			else
				p->currState = STATE_CRC1;
			break;

			case STATE_LENGTH1:
			p->lengthStated = b * 256;
			CRC_ProcessByte (&p->crcValue, b);
			p->currState = STATE_LENGTH2;
			break;

			case STATE_LENGTH2:
			p->lengthStated += b;
			CRC_ProcessByte (&p->crcValue, b);
			if (p->mtype == MTYPE_RELIABLE && p->lengthStated > MAX_MSGLEN) {
				p->currState = STATE_ABORT;
				Con_DPrintf ("Serial: bad reliable message length %u\n",
							 p->lengthStated);
			} else if (p->mtype == MTYPE_UNRELIABLE
					   && p->lengthStated > MAX_DATAGRAM) {
				p->currState = STATE_ABORT;
				Con_DPrintf ("Serial: bad unreliable message length %u\n",
							 p->lengthStated);
			} else {
				p->currState = STATE_DATA;
				if (p->mtype < MTYPE_ACK) {
					*(short *) &p->sock->receiveMessage[p->sock->
														receiveMessageLength +
														1] = p->lengthStated;
					p->lengthFound += 2;
				}
			}
			break;

			case STATE_DATA:
			p->sock->receiveMessage[p->sock->receiveMessageLength +
									p->lengthFound] = b;
			p->lengthFound++;
			CRC_ProcessByte (&p->crcValue, b);
			if (p->lengthFound == p->lengthStated + 3)
				p->currState = STATE_CRC1;
			break;

			case STATE_CRC1:
			p->crcStated = b * 256;
			p->currState = STATE_CRC2;
			break;

			case STATE_CRC2:
			p->crcStated += b;
			if (p->crcStated == CRC_Value (p->crcValue)) {
				p->currState = STATE_EOM;
			} else {
				p->currState = STATE_ABORT;
				Con_DPrintf ("Serial: Bad crc\n");
			}
			break;

			case STATE_EOM:
			p->currState = STATE_ABORT;
			Con_DPrintf ("Serial: Bad message format\n");
			break;

			case STATE_ABORT:
			break;
		}
	}
	return 0;
}


int
Serial_Init (void)
{
	int         n;

// LATER do Win32 serial support
#ifdef	_WIN32
	return -1;
#endif

	if (COM_CheckParm ("-nolan"))
		return -1;
	if (COM_CheckParm ("-noserial"))
		return -1;

	myDriverLevel = net_driverlevel;

	if (TTY_Init ())
		return -1;

	for (n = 0; n < NUM_COM_PORTS; n++) {
		serialLine[n].tty = TTY_Open (n);
		ResetSerialLineProtocol (&serialLine[n]);
	}

	Con_Printf ("Serial driver initialized\n");
	serialAvailable = true;

	return 0;
}


void
Serial_Shutdown (void)
{
	int         n;

	for (n = 0; n < NUM_COM_PORTS; n++) {
		if (serialLine[n].connected)
			Serial_Close (serialLine[n].sock);
	}

	TTY_Shutdown ();
}


void
Serial_Listen (qboolean state)
{
	listening = state;
}


qboolean
Serial_CanSendMessage (qsocket_t * sock)
{
	return sock->canSend;
}


qboolean
Serial_CanSendUnreliableMessage (qsocket_t * sock)
{
	return TTY_OutputQueueIsEmpty (((SerialLine *) sock->driverdata)->tty);
}


int
Serial_SendMessage (qsocket_t * sock, sizebuf_t *message)
{
	SerialLine *p;
	int         n;
	unsigned short crc;
	byte        b;

	p = (SerialLine *) sock->driverdata;
	CRC_Init (&crc);

	// message type
	b = MTYPE_RELIABLE;
	if (p->client)
		b |= MTYPE_CLIENT;
	TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// sequence
	b = p->sock->sendSequence;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// data length
	b = message->cursize >> 8;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);
	b = message->cursize & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// data
	for (n = 0; n < message->cursize; n++) {
		b = message->data[n];
		TTY_WriteByte (p->tty, b);
		if (b == ESCAPE_COMMAND)
			TTY_WriteByte (p->tty, b);
		CRC_ProcessByte (&crc, b);
	}

	// checksum
	b = CRC_Value (crc) >> 8;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	b = CRC_Value (crc) & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);

	// end of message
	TTY_WriteByte (p->tty, ESCAPE_COMMAND);
	TTY_WriteByte (p->tty, ESCAPE_EOM);

	TTY_Flush (p->tty);

	// mark sock as busy and save the message for possible retransmit
	sock->canSend = false;
	Q_memcpy (sock->sendMessage, message->data, message->cursize);
	sock->sendMessageLength = message->cursize;
	sock->lastSendTime = net_time;

	return 1;
}


static void
ReSendMessage (qsocket_t * sock)
{
	sizebuf_t   temp;

	Con_DPrintf ("Serial: re-sending reliable\n");
	temp.data = sock->sendMessage;
	temp.maxsize = sock->sendMessageLength;
	temp.cursize = sock->sendMessageLength;
	Serial_SendMessage (sock, &temp);
}


int
Serial_SendUnreliableMessage (qsocket_t * sock, sizebuf_t *message)
{
	SerialLine *p;
	int         n;
	unsigned short crc;
	byte        b;

	p = (SerialLine *) sock->driverdata;

	if (!TTY_OutputQueueIsEmpty (p->tty)) {
		TTY_Flush (p->tty);
		return 1;
	}

	CRC_Init (&crc);

	// message type
	b = MTYPE_UNRELIABLE;
	if (p->client)
		b |= MTYPE_CLIENT;
	TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// sequence
	b = p->sock->unreliableSendSequence;
	p->sock->unreliableSendSequence = (b + 1) & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// data length
	b = message->cursize >> 8;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);
	b = message->cursize & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// data
	for (n = 0; n < message->cursize; n++) {
		b = message->data[n];
		TTY_WriteByte (p->tty, b);
		if (b == ESCAPE_COMMAND)
			TTY_WriteByte (p->tty, b);
		CRC_ProcessByte (&crc, b);
	}

	// checksum
	b = CRC_Value (crc) >> 8;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	b = CRC_Value (crc) & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);

	// end of message
	TTY_WriteByte (p->tty, ESCAPE_COMMAND);
	TTY_WriteByte (p->tty, ESCAPE_EOM);

	TTY_Flush (p->tty);

	return 1;
}


static void
Serial_SendACK (SerialLine * p, byte sequence)
{
	unsigned short crc;
	byte        b;

	CRC_Init (&crc);

	// message type
	b = MTYPE_ACK;
	if (p->client)
		b |= MTYPE_CLIENT;
	TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// sequence
	b = sequence;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// checksum
	b = CRC_Value (crc) >> 8;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	b = CRC_Value (crc) & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);

	// end of message
	TTY_WriteByte (p->tty, ESCAPE_COMMAND);
	TTY_WriteByte (p->tty, ESCAPE_EOM);

	TTY_Flush (p->tty);
}


static void
Serial_SendControlMessage (SerialLine * p, sizebuf_t *message)
{
	unsigned short crc;
	int         n;
	byte        b;

	CRC_Init (&crc);

	// message type
	b = MTYPE_CONTROL;
	if (p->client)
		b |= MTYPE_CLIENT;
	TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// data length
	b = message->cursize >> 8;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);
	b = message->cursize & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	CRC_ProcessByte (&crc, b);

	// data
	for (n = 0; n < message->cursize; n++) {
		b = message->data[n];
		TTY_WriteByte (p->tty, b);
		if (b == ESCAPE_COMMAND)
			TTY_WriteByte (p->tty, b);
		CRC_ProcessByte (&crc, b);
	}

	// checksum
	b = CRC_Value (crc) >> 8;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);
	b = CRC_Value (crc) & 0xff;
	TTY_WriteByte (p->tty, b);
	if (b == ESCAPE_COMMAND)
		TTY_WriteByte (p->tty, b);

	// end of message
	TTY_WriteByte (p->tty, ESCAPE_COMMAND);
	TTY_WriteByte (p->tty, ESCAPE_EOM);

	TTY_Flush (p->tty);
}


static int
_Serial_GetMessage (SerialLine * p)
{
	byte        ret;
	short       length;

	if (ProcessInQueue (p))
		return -1;

	if (p->sock->receiveMessageLength == 0)
		return 0;

	ret = p->sock->receiveMessage[0];
	length = *(short *) &p->sock->receiveMessage[1];
	if (ret == MTYPE_CONTROL)
		ret = 1;

	SZ_Clear (&net_message);
	SZ_Write (&net_message, &p->sock->receiveMessage[3], length);

	length += 3;
	p->sock->receiveMessageLength -= length;

	if (p->sock->receiveMessageLength + p->lengthFound)
		Q_memcpy (p->sock->receiveMessage, &p->sock->receiveMessage[length],
				  p->sock->receiveMessageLength + p->lengthFound);

	return ret;
}

int
Serial_GetMessage (qsocket_t * sock)
{
	SerialLine *p;
	int         ret;

	p = (SerialLine *) sock->driverdata;

	ret = _Serial_GetMessage (p);

	if (ret == 1)
		messagesReceived++;

	if (!sock->canSend)
		if ((net_time - sock->lastSendTime) > 1.0) {
			ReSendMessage (sock);
			sock->lastSendTime = net_time;
		}

	return ret;
}


void
Serial_Close (qsocket_t * sock)
{
	SerialLine *p = (SerialLine *) sock->driverdata;

	TTY_Close (p->tty);
	ResetSerialLineProtocol (p);
}


char       *com_types[] = { "direct", "modem" };
unsigned    com_bauds[] = { 9600, 14400, 19200, 28800, 57600 };

void
Serial_SearchForHosts (qboolean xmit)
{
	int         n;
	SerialLine *p;

	if (sv.active)
		return;

	if (hostCacheCount == HOSTCACHESIZE)
		return;

	// see if we've already answered
	for (n = 0; n < hostCacheCount; n++)
		if (Q_strcmp (hostcache[n].cname, "#") == 0)
			return;

	for (n = 0; n < NUM_COM_PORTS; n++)
		if (TTY_IsEnabled (n))
			break;
	if (n == NUM_COM_PORTS)
		return;
	p = &serialLine[n];

	if (TTY_IsModem (p->tty))
		return;

	snprintf (hostcache[hostCacheCount].name,
			  sizeof (hostcache[hostCacheCount].name), "COM%u", n + 1);
	Q_strcpy (hostcache[hostCacheCount].map, "");
	hostcache[hostCacheCount].users = 0;
	hostcache[hostCacheCount].maxusers = 0;
	hostcache[hostCacheCount].driver = net_driverlevel;
	Q_strcpy (hostcache[hostCacheCount].cname, "#");
	hostCacheCount++;

	return;
}


static qsocket_t *
_Serial_Connect (char *host, SerialLine * p)
{
	int         ret;
	double      start_time;
	double      last_time;

	p->client = true;
	if (TTY_Connect (p->tty, host))
		return NULL;

	p->sock = NET_NewQSocket ();
	p->sock->driver = myDriverLevel;
	if (p->sock == NULL) {
		Con_Printf ("No sockets available\n");
		return NULL;
	}
	p->sock->driverdata = p;

	// send the connection request
	start_time = SetNetTime ();
	last_time = 0.0;

	SZ_Clear (&net_message);
	MSG_WriteByte (&net_message, CCREQ_CONNECT);
	MSG_WriteString (&net_message, "QUAKE");
	do {
		SetNetTime ();
		if ((net_time - last_time) >= 1.0) {
			Serial_SendControlMessage (p, &net_message);
			last_time = net_time;
			Con_Printf ("trying...\n");
			SCR_UpdateScreen ();
		}
		ret = _Serial_GetMessage (p);
	}
	while (ret == 0 && (net_time - start_time) < 5.0);

	if (ret == 0) {
		Con_Printf ("Unable to connect, no response\n");
		goto ErrorReturn;
	}

	if (ret == -1) {
		Con_Printf ("Connection request error\n");
		goto ErrorReturn;
	}

	MSG_BeginReading ();
	ret = MSG_ReadByte ();
	if (ret == CCREP_REJECT) {
		Con_Printf (MSG_ReadString ());
		goto ErrorReturn;
	}
	if (ret != CCREP_ACCEPT) {
		Con_Printf ("Unknown connection response\n");
		goto ErrorReturn;
	}

	p->connected = true;
	p->sock->lastMessageTime = net_time;

	Con_Printf ("Connection accepted\n");

	return p->sock;

  ErrorReturn:
	TTY_Disconnect (p->tty);
	return NULL;
}

qsocket_t  *
Serial_Connect (char *host)
{
	int         n;
	qsocket_t  *ret = NULL;

	// see if this looks like a phone number
	if (*host == '#')
		host++;
	for (n = 0; n < Q_strlen (host); n++)
		if (host[n] == '.' || host[n] == ':')
			return NULL;

	for (n = 0; n < NUM_COM_PORTS; n++)
		if (TTY_IsEnabled (n) && !serialLine[n].connected)
			if ((ret = _Serial_Connect (host, &serialLine[n])))
				break;
	return ret;
}


static qsocket_t *
_Serial_CheckNewConnections (SerialLine * p)
{
	int         command;

	p->client = false;
	if (!TTY_CheckForConnection (p->tty))
		return NULL;

	if (TTY_IsModem (p->tty)) {
		if (!p->connecting) {
			p->connecting = true;
			p->connect_time = net_time;
		} else if ((net_time - p->connect_time) > 15.0) {
			p->connecting = false;
			TTY_Disconnect (p->tty);
			return NULL;
		}
	}

	p->sock = NET_NewQSocket ();
	p->sock->driver = myDriverLevel;
	if (p->sock == NULL) {
		Con_Printf ("No sockets available\n");
		return NULL;
	}
	p->sock->driverdata = p;

	SZ_Clear (&net_message);
	if (_Serial_GetMessage (p) != 1) {
		NET_FreeQSocket (p->sock);
		return NULL;
	}

	MSG_BeginReading ();
	command = MSG_ReadByte ();

	if (command == CCREQ_SERVER_INFO) {
		if (Q_strcmp (MSG_ReadString (), "QUAKE") != 0)
			return NULL;

		if (MSG_ReadByte () != SERIAL_PROTOCOL_VERSION)
			return NULL;

		SZ_Clear (&net_message);
		MSG_WriteByte (&net_message, CCREP_SERVER_INFO);
		MSG_WriteString (&net_message, hostname->string);
		MSG_WriteString (&net_message, sv.name);
		MSG_WriteByte (&net_message, net_activeconnections);
		MSG_WriteByte (&net_message, svs.maxclients);
		Serial_SendControlMessage (p, &net_message);
		SZ_Clear (&net_message);
		return NULL;
	}

	if (command != CCREQ_CONNECT)
		return NULL;

	if (Q_strcmp (MSG_ReadString (), "QUAKE") != 0)
		return NULL;

	// send him back the info about the server connection he has been
	// allocated
	SZ_Clear (&net_message);
	MSG_WriteByte (&net_message, CCREP_ACCEPT);
	Serial_SendControlMessage (p, &net_message);
	SZ_Clear (&net_message);

	p->connected = true;
	p->connecting = false;
	p->sock->lastMessageTime = net_time;
	snprintf (p->sock->address, sizeof (p->sock->address), "COM%u",
			  (int) ((p - serialLine) + 1));

	return p->sock;
}

qsocket_t  *
Serial_CheckNewConnections (void)
{
	int         n;
	qsocket_t  *ret = NULL;

	for (n = 0; n < NUM_COM_PORTS; n++)
		if (TTY_IsEnabled (n) && !serialLine[n].connected)
			if ((ret = _Serial_CheckNewConnections (&serialLine[n])))
				break;
	return ret;
}