/*
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;
}