The Quake sources as originally release under the GPL license on December 21, 1999

2026-03-20 00:49:48 +01:00 · 2012-01-31 14:32:09 -06:00
commit 0023db327b
605 changed files with 282548 additions and 0 deletions
--- a/WinQuake/net_ser.c
+++ b/WinQuake/net_ser.c
@@ -0,0 +1,951 @@
+/*
+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 the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+*/
+// net_ser.c
+
+#include "quakedef.h"
+#include "net_ser.h"
+#include "dosisms.h"
+#include "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;
+
+	sprintf(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;
+	sprintf(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;
+}