yquake2remaster/src/common/netchan.c

/*
 * Copyright (C) 1997-2001 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.
 *
 * =======================================================================
 *
 * The low level network code
 *
 * =======================================================================
 */

#include "header/common.h"

/*
 * packet header
 * -------------
 * 31	sequence
 * 1	does this message contain a reliable payload
 * 31	acknowledge sequence
 * 1	acknowledge receipt of even/odd message
 * 16	qport
 *
 * The remote connection never knows if it missed a reliable message,
 * the local side detects that it has been dropped by seeing a sequence
 * acknowledge higher thatn the last reliable sequence, but without the
 * correct even/odd bit for the reliable set.
 *
 * If the sender notices that a reliable message has been dropped, it
 * will be retransmitted.  It will not be retransmitted again until a
 * message after the retransmit has been acknowledged and the reliable
 * still failed to get there.
 *
 * if the sequence number is -1, the packet should be handled without a
 * netcon
 *
 * The reliable message can be added to at any time by doing MSG_Write*
 * (&netchan->message, <data>).
 *
 * If the message buffer is overflowed, either by a single message, or
 * by multiple frames worth piling up while the last reliable transmit
 * goes unacknowledged, the netchan signals a fatal error.
 *
 * Reliable messages are always placed first in a packet, then the
 * unreliable message is included if there is sufficient room.
 *
 * To the receiver, there is no distinction between the reliable and
 * unreliable parts of the message, they are just processed out as a
 * single larger message.
 *
 * Illogical packet sequence numbers cause the packet to be dropped, but
 * do not kill the connection.  This, combined with the tight window of
 * valid reliable acknowledgement numbers provides protection against
 * malicious address spoofing.
 *
 * The qport field is a workaround for bad address translating routers
 * that sometimes remap the client's source port on a packet during
 * gameplay.
 *
 * If the base part of the net address matches and the qport matches,
 * then the channel matches even if the IP port differs.  The IP port
 * should be updated to the new value before sending out any replies.
 *
 * If there is no information that needs to be transfered on a given
 * frame, such as during the connection stage while waiting for the
 * client to load, then a packet only needs to be delivered if there is
 * something in the unacknowledged reliable
 */

cvar_t		*showpackets;
cvar_t		*showdrop;
cvar_t		*qport;

netadr_t	net_from;
sizebuf_t	net_message;
byte		net_message_buffer[MAX_MSGLEN];

void Netchan_Init (void)
{
	int		port;

	/* pick a port value that should be nice and random */
	port = Sys_Milliseconds() & 0xffff;

	showpackets = Cvar_Get ("showpackets", "0", 0);
	showdrop = Cvar_Get ("showdrop", "0", 0);
	qport = Cvar_Get ("qport", va("%i", port), CVAR_NOSET);
}

/*
 * Sends an out-of-band datagram
 */
void Netchan_OutOfBand (int net_socket, netadr_t adr, int length, byte *data)
{
	sizebuf_t	send;
	byte		send_buf[MAX_MSGLEN];

	/* write the packet header */
	SZ_Init (&send, send_buf, sizeof(send_buf));

	MSG_WriteLong (&send, -1); /* -1 sequence means out of band */
	SZ_Write (&send, data, length);

	/* send the datagram */
	NET_SendPacket (net_socket, send.cursize, send.data, adr);
}

/*
 * Sends a text message in an out-of-band datagram
 */
void Netchan_OutOfBandPrint (int net_socket, netadr_t adr, char *format, ...)
{
	va_list		argptr;
	static char	string[MAX_MSGLEN - 4];

	va_start (argptr, format);
	vsnprintf (string, MAX_MSGLEN - 4, format, argptr);
	va_end (argptr);

	Netchan_OutOfBand (net_socket, adr, strlen(string), (byte *)string);
}

/*
 * called to open a channel to a remote system
 */
void Netchan_Setup (netsrc_t sock, netchan_t *chan, netadr_t adr, int qport)
{
	memset (chan, 0, sizeof(*chan));

	chan->sock = sock;
	chan->remote_address = adr;
	chan->qport = qport;
	chan->last_received = curtime;
	chan->incoming_sequence = 0;
	chan->outgoing_sequence = 1;

	SZ_Init (&chan->message, chan->message_buf, sizeof(chan->message_buf));
	chan->message.allowoverflow = true;
}

/*
 * Returns true if the last reliable message has acked
 */
qboolean Netchan_CanReliable (netchan_t *chan)
{
	if (chan->reliable_length)
		return false; /* waiting for ack */

	return true;
}

qboolean Netchan_NeedReliable (netchan_t *chan)
{
	qboolean	send_reliable;

	/* if the remote side dropped the last reliable message, resend it */
	send_reliable = false;

	if (chan->incoming_acknowledged > chan->last_reliable_sequence
	        && chan->incoming_reliable_acknowledged != chan->reliable_sequence)
		send_reliable = true;

	/* if the reliable transmit buffer is empty, copy the current message out */
	if (!chan->reliable_length && chan->message.cursize)
	{
		send_reliable = true;
	}

	return send_reliable;
}

/*
 * tries to send an unreliable message to a connection, and handles the
 * transmition / retransmition of the reliable messages.
 *
 * A 0 length will still generate a packet and deal with the reliable messages.
 */
void Netchan_Transmit (netchan_t *chan, int length, byte *data)
{
	sizebuf_t	send;
	byte		send_buf[MAX_MSGLEN];
	qboolean	send_reliable;
	unsigned	w1, w2;

	/* check for message overflow */
	if (chan->message.overflowed)
	{
		chan->fatal_error = true;
		Com_Printf ("%s:Outgoing message overflow\n"
		            , NET_AdrToString (chan->remote_address));
		return;
	}

	send_reliable = Netchan_NeedReliable (chan);

	if (!chan->reliable_length && chan->message.cursize)
	{
		memcpy (chan->reliable_buf, chan->message_buf, chan->message.cursize);
		chan->reliable_length = chan->message.cursize;
		chan->message.cursize = 0;
		chan->reliable_sequence ^= 1;
	}

	/* write the packet header */
	SZ_Init (&send, send_buf, sizeof(send_buf));

	w1 = ( chan->outgoing_sequence & ~(1<<31) ) | (send_reliable<<31);
	w2 = ( chan->incoming_sequence & ~(1<<31) ) | (chan->incoming_reliable_sequence<<31);

	chan->outgoing_sequence++;
	chan->last_sent = curtime;

	MSG_WriteLong (&send, w1);
	MSG_WriteLong (&send, w2);

	/* send the qport if we are a client */
	if (chan->sock == NS_CLIENT)
		MSG_WriteShort (&send, qport->value);

	/* copy the reliable message to the packet first */
	if (send_reliable)
	{
		SZ_Write (&send, chan->reliable_buf, chan->reliable_length);
		chan->last_reliable_sequence = chan->outgoing_sequence;
	}

	/* add the unreliable part if space is available */
	if (send.maxsize - send.cursize >= length)
		SZ_Write (&send, data, length);
	else
		Com_Printf ("Netchan_Transmit: dumped unreliable\n");

	/* send the datagram */
	NET_SendPacket (chan->sock, send.cursize, send.data, chan->remote_address);

	if (showpackets->value)
	{
		if (send_reliable)
			Com_Printf ("send %4i : s=%i reliable=%i ack=%i rack=%i\n"
			            , send.cursize
			            , chan->outgoing_sequence - 1
			            , chan->reliable_sequence
			            , chan->incoming_sequence
			            , chan->incoming_reliable_sequence);
		else
			Com_Printf ("send %4i : s=%i ack=%i rack=%i\n"
			            , send.cursize
			            , chan->outgoing_sequence - 1
			            , chan->incoming_sequence
			            , chan->incoming_reliable_sequence);
	}
}

/*
 * called when the current net_message is from remote_address
 * modifies net_message so that it points to the packet payload
 */
qboolean Netchan_Process (netchan_t *chan, sizebuf_t *msg)
{
	unsigned	sequence, sequence_ack;
	unsigned	reliable_ack, reliable_message;

	/* get sequence numbers */
	MSG_BeginReading (msg);
	sequence = MSG_ReadLong (msg);
	sequence_ack = MSG_ReadLong (msg);

	/* read the qport if we are a server */
	if (chan->sock == NS_SERVER)
		(void)MSG_ReadShort(msg);

	reliable_message = sequence >> 31;
	reliable_ack = sequence_ack >> 31;

	sequence &= ~(1<<31);
	sequence_ack &= ~(1<<31);

	if (showpackets->value)
	{
		if (reliable_message)
			Com_Printf ("recv %4i : s=%i reliable=%i ack=%i rack=%i\n"
			            , msg->cursize
			            , sequence
			            , chan->incoming_reliable_sequence ^ 1
			            , sequence_ack
			            , reliable_ack);
		else
			Com_Printf ("recv %4i : s=%i ack=%i rack=%i\n"
			            , msg->cursize
			            , sequence
			            , sequence_ack
			            , reliable_ack);
	}

	/* discard stale or duplicated packets */
	if (sequence <= chan->incoming_sequence)
	{
		if (showdrop->value)
			Com_Printf ("%s:Out of order packet %i at %i\n"
			            , NET_AdrToString (chan->remote_address)
			            ,  sequence
			            , chan->incoming_sequence);

		return false;
	}

	/* dropped packets don't keep the message from being used */
	chan->dropped = sequence - (chan->incoming_sequence+1);

	if (chan->dropped > 0)
	{
		if (showdrop->value)
			Com_Printf ("%s:Dropped %i packets at %i\n"
			            , NET_AdrToString (chan->remote_address)
			            , chan->dropped
			            , sequence);
	}

	/* if the current outgoing reliable message has been acknowledged
	   clear the buffer to make way for the next */
	if (reliable_ack == chan->reliable_sequence)
		chan->reliable_length = 0; /* it has been received */

	/* if this message contains a reliable message, bump incoming_reliable_sequence */
	chan->incoming_sequence = sequence;
	chan->incoming_acknowledged = sequence_ack;
	chan->incoming_reliable_acknowledged = reliable_ack;

	if (reliable_message)
	{
		chan->incoming_reliable_sequence ^= 1;
	}

	/* the message can now be read from the current message pointer */
	chan->last_received = curtime;

	return true;
}