net_chan.c File Reference

#include "qcommon.h"

Go to the source code of this file.

Functions
void	Netchan_Init (void)
void	Netchan_OutOfBand (int net_socket, netadr_t adr, int length, byte *data)
void	Netchan_OutOfBandPrint (int net_socket, netadr_t adr, char *format,...)
void	Netchan_Setup (netsrc_t sock, netchan_t *chan, netadr_t adr, int qport)
qboolean	Netchan_CanReliable (netchan_t *chan)
qboolean	Netchan_NeedReliable (netchan_t *chan)
void	Netchan_Transmit (netchan_t *chan, int length, byte *data)
qboolean	Netchan_Process (netchan_t *chan, sizebuf_t *msg)

Variables
cvar_t *	showpackets
cvar_t *	showdrop
cvar_t *	qport
netadr_t	net_from
sizebuf_t	net_message
byte	net_message_buffer [MAX_MSGLEN]

Function Documentation

Netchan_CanReliable()

qboolean Netchan_CanReliable

(

netchan_t *

chan

)

Definition at line 175 of file net_chan.c.

{
    if (chan->reliable_length)
        return false;           // waiting for ack
    return true;
}

Netchan_Init()

void Netchan_Init

(

void

)

Definition at line 91 of file net_chan.c.

{
    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);
}

Referenced by Qcommon_Init().

Netchan_NeedReliable()

qboolean Netchan_NeedReliable

(

netchan_t *

chan

)

Definition at line 183 of file net_chan.c.

{
    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;
}

Referenced by Netchan_Transmit().

Netchan_OutOfBand()

void Netchan_OutOfBand	(	int	net_socket,
		netadr_t	adr,
		int	length,
		byte *	data
	)

Definition at line 110 of file net_chan.c.

{
    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);
}

Referenced by Netchan_OutOfBandPrint().

Netchan_OutOfBandPrint()

void Netchan_OutOfBandPrint	(	int	net_socket,
		netadr_t	adr,
		char *	format,
			...
	)

Definition at line 132 of file net_chan.c.

{
    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, (int)strlen(string), (byte *)string);
}

Referenced by CL_CheckForResend(), CL_ConnectionlessPacket(), CL_PingServers_f(), CL_SendConnectPacket(), Master_Heartbeat(), Master_Shutdown(), SV_FlushRedirect(), SV_SetMaster_f(), SVC_DirectConnect(), SVC_GetChallenge(), SVC_Info(), SVC_Ping(), and SVC_Status().

Netchan_Process()

qboolean Netchan_Process	(	netchan_t *	chan,
		sizebuf_t *	msg
	)

Definition at line 298 of file net_chan.c.

{
    unsigned    sequence, sequence_ack;
    unsigned    reliable_ack, reliable_message;
    int         qport;
 
// 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)
        qport = 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;
}

Referenced by CL_ReadPackets(), and SV_ReadPackets().

Netchan_Setup()

void Netchan_Setup	(	netsrc_t	sock,
		netchan_t *	chan,
		netadr_t	adr,
		int	qport
	)

Definition at line 152 of file net_chan.c.

{
    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;
}

Referenced by CL_ConnectionlessPacket(), and SVC_DirectConnect().

Netchan_Transmit()

void Netchan_Transmit	(	netchan_t *	chan,
		int	length,
		byte *	data
	)

Definition at line 213 of file net_chan.c.

{
    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);
    }
}

Referenced by CL_Disconnect(), CL_SendCmd(), SV_FinalMessage(), SV_SendClientDatagram(), and SV_SendClientMessages().

Variable Documentation

net_from

netadr_t net_from

Definition at line 81 of file net_chan.c.

Referenced by CL_ConnectionlessPacket(), CL_DumpPackets(), CL_ParseStatusMessage(), CL_ReadPackets(), NET_GetLoopPacket(), NET_GetPacket(), SV_ConnectionlessPacket(), SV_FlushRedirect(), SV_ReadPackets(), SVC_Ack(), SVC_DirectConnect(), SVC_GetChallenge(), SVC_Info(), SVC_Ping(), SVC_RemoteCommand(), and SVC_Status().

net_message

sizebuf_t net_message

Definition at line 82 of file net_chan.c.

Referenced by CL_ConnectionlessPacket(), CL_DumpPackets(), CL_Init(), CL_ParseBeam(), CL_ParseBeam2(), CL_ParseConfigString(), CL_ParseDelta(), CL_ParseDownload(), CL_ParseEntityBits(), CL_ParseFrame(), CL_ParseInventory(), CL_ParseLaser(), CL_ParseLightning(), CL_ParseMuzzleFlash(), CL_ParseMuzzleFlash2(), CL_ParseNuke(), CL_ParsePacketEntities(), CL_ParseParticles(), CL_ParsePlayerBeam(), CL_ParsePlayerstate(), CL_ParseServerData(), CL_ParseServerMessage(), CL_ParseStartSoundPacket(), CL_ParseStatusMessage(), CL_ParseSteam(), CL_ParseTEnt(), CL_ParseWidow(), CL_ReadPackets(), CL_WriteDemoMessage(), NET_GetLoopPacket(), NET_GetPacket(), SHOWNET(), SV_ConnectionlessPacket(), SV_ExecuteClientMessage(), SV_FinalMessage(), SV_Init(), SV_ReadPackets(), and SVC_RemoteCommand().

net_message_buffer

byte net_message_buffer[MAX_MSGLEN]

Definition at line 83 of file net_chan.c.

Referenced by CL_Init(), and SV_Init().

qport

cvar_t* qport

Definition at line 79 of file net_chan.c.

Referenced by Netchan_Init(), Netchan_Process(), Netchan_Setup(), Netchan_Transmit(), SV_ReadPackets(), and SVC_DirectConnect().

showdrop

cvar_t* showdrop

Definition at line 78 of file net_chan.c.

Referenced by Netchan_Init(), and Netchan_Process().

showpackets

cvar_t* showpackets

Definition at line 77 of file net_chan.c.

Referenced by Netchan_Init(), Netchan_Process(), and Netchan_Transmit().