chan.c File Reference

#include "shared/shared.h"
#include "common/common.h"
#include "common/cvar.h"
#include "common/msg.h"
#include "common/net/chan.h"
#include "common/net/net.h"
#include "common/protocol.h"
#include "common/sizebuf.h"
#include "common/zone.h"
#include "system/system.h"

Go to the source code of this file.

Macros
#define	SHOWPACKET(...)
#define	SHOWDROP(...)

Functions
static void	net_maxmsglen_changed (cvar_t *self)
void	Netchan_Init (void)
void	Netchan_OutOfBand (netsrc_t sock, const netadr_t *address, const char *format,...)
static size_t	NetchanOld_TransmitNextFragment (netchan_t *netchan)
static size_t	NetchanOld_Transmit (netchan_t *netchan, size_t length, const void *data, int numpackets)
static qboolean	NetchanOld_Process (netchan_t *netchan)
static qboolean	NetchanOld_ShouldUpdate (netchan_t *netchan)
static netchan_t *	NetchanOld_Setup (netsrc_t sock, const netadr_t *adr, int qport, size_t maxpacketlen)
static size_t	NetchanNew_TransmitNextFragment (netchan_t *netchan)
static size_t	NetchanNew_Transmit (netchan_t *netchan, size_t length, const void *data, int numpackets)
static qboolean	NetchanNew_Process (netchan_t *netchan)
static qboolean	NetchanNew_ShouldUpdate (netchan_t *netchan)
static netchan_t *	NetchanNew_Setup (netsrc_t sock, const netadr_t *adr, int qport, size_t maxpacketlen)
netchan_t *	Netchan_Setup (netsrc_t sock, netchan_type_t type, const netadr_t *adr, int qport, size_t maxpacketlen, int protocol)
void	Netchan_Close (netchan_t *netchan)

Variables
cvar_t *	net_qport
cvar_t *	net_maxmsglen
cvar_t *	net_chantype

Macro Definition Documentation

SHOWDROP

#define SHOWDROP

(

...

)

Definition at line 95 of file chan.c.

SHOWPACKET

#define SHOWPACKET

(

...

)

Definition at line 94 of file chan.c.

Function Documentation

net_maxmsglen_changed()

static void net_maxmsglen_changed ( cvar_t *  self )

static

Definition at line 103 of file chan.c.

{
    if (self->integer) {
        Cvar_ClampInteger(self, MIN_PACKETLEN, MAX_PACKETLEN_WRITABLE);
    }
}

Referenced by Netchan_Init().

Netchan_Close()

void Netchan_Close

(

netchan_t *

netchan

)

Definition at line 866 of file chan.c.

{
    Z_Free(netchan);
}

Referenced by CL_ConnectionlessPacket(), CL_Disconnect(), CL_ParseReconnect(), and SV_RemoveClient().

Netchan_Init()

void Netchan_Init

(

void

)

Definition at line 116 of file chan.c.

{
    int     port;
 
#ifdef _DEBUG
    showpackets = Cvar_Get("showpackets", "0", 0);
    showdrop = Cvar_Get("showdrop", "0", 0);
#endif
 
    // pick a port value that should be nice and random
    port = Sys_Milliseconds() & 0xffff;
    net_qport = Cvar_Get("qport", va("%d", port), 0);
    net_maxmsglen = Cvar_Get("net_maxmsglen", va("%d", MAX_PACKETLEN_WRITABLE_DEFAULT), 0);
    net_maxmsglen->changed = net_maxmsglen_changed;
    net_chantype = Cvar_Get("net_chantype", "1", 0);
}

Referenced by Qcommon_Init().

Netchan_OutOfBand()

void Netchan_OutOfBand	(	netsrc_t	sock,
		const netadr_t *	address,
		const char *	format,
			...
	)

Definition at line 140 of file chan.c.

{
    va_list     argptr;
    struct {
        uint32_t    header;
        char        data[MAX_PACKETLEN_DEFAULT - 4];
    } packet;
    size_t      len;
 
    // write the packet header
    packet.header = 0xffffffff;
 
    va_start(argptr, format);
    len = Q_vsnprintf(packet.data, sizeof(packet.data), format, argptr);
    va_end(argptr);
 
    if (len >= sizeof(packet.data)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    // send the datagram
    NET_SendPacket(sock, &packet, len + 4, address);
}

Referenced by CL_CheckForResend(), CL_SendRcon(), redirect(), send_connect_packet(), SVC_GetChallenge(), and SVC_RemoteCommand().

Netchan_Setup()

netchan_t* Netchan_Setup	(	netsrc_t	sock,
		netchan_type_t	type,
		const netadr_t *	adr,
		int	qport,
		size_t	maxpacketlen,
		int	protocol
	)

Definition at line 835 of file chan.c.

{
    netchan_t *netchan;
 
    clamp(maxpacketlen, MIN_PACKETLEN, MAX_PACKETLEN_WRITABLE);
 
    switch (type) {
    case NETCHAN_OLD:
        netchan = NetchanOld_Setup(sock, adr, qport, maxpacketlen);
        break;
    case NETCHAN_NEW:
        netchan = NetchanNew_Setup(sock, adr, qport, maxpacketlen);
        break;
    default:
        Com_Error(ERR_FATAL, "Netchan_Setup: bad type");
        netchan = NULL;
    }
 
    netchan->protocol = protocol;
    netchan->type = type;
 
    return netchan;
 
}

Referenced by CL_ConnectionlessPacket(), and SVC_DirectConnect().

NetchanNew_Process()

static qboolean NetchanNew_Process ( netchan_t *  netchan )

static

Definition at line 632 of file chan.c.

{
    netchan_new_t *chan = (netchan_new_t *)netchan;
    uint32_t    sequence, sequence_ack, reliable_ack;
    qboolean    reliable_message, fragmented_message, more_fragments;
    uint16_t    fragment_offset;
    size_t      length;
 
// get sequence numbers
    MSG_BeginReading();
    sequence = MSG_ReadLong();
    sequence_ack = MSG_ReadLong();
 
    // read the qport if we are a server
#if USE_CLIENT
    if (netchan->sock == NS_SERVER)
#endif
        if (netchan->qport) {
            MSG_ReadByte();
        }
 
    reliable_message = sequence >> 31;
    reliable_ack = sequence_ack >> 31;
    fragmented_message = (sequence >> 30) & 1;
 
    sequence &= 0x3FFFFFFF;
    sequence_ack &= 0x3FFFFFFF;
 
    fragment_offset = 0;
    more_fragments = qfalse;
    if (fragmented_message) {
        fragment_offset = MSG_ReadShort();
        more_fragments = fragment_offset >> 15;
        fragment_offset &= 0x7FFF;
    }
 
    SHOWPACKET("recv %4"PRIz" : s=%d ack=%d rack=%d",
               msg_read.cursize, sequence, sequence_ack, reliable_ack);
    if (fragmented_message) {
        SHOWPACKET(" fragment_offset=%d more_fragments=%d",
                   fragment_offset, more_fragments);
    }
    if (reliable_message) {
        SHOWPACKET(" reliable=%d", chan->incoming_reliable_sequence ^ 1);
    }
    SHOWPACKET("\n");
 
//
// discard stale or duplicated packets
//
    if (sequence <= netchan->incoming_sequence) {
        SHOWDROP("%s: out of order packet %i at %i\n",
                 NET_AdrToString(&netchan->remote_address),
                 sequence, netchan->incoming_sequence);
        return qfalse;
    }
 
//
// dropped packets don't keep the message from being used
//
    netchan->dropped = sequence - (netchan->incoming_sequence + 1);
    if (netchan->dropped > 0) {
        SHOWDROP("%s: dropped %i packets at %i\n",
                 NET_AdrToString(&netchan->remote_address),
                 netchan->dropped, sequence);
    }
 
//
// if the current outgoing reliable message has been acknowledged
// clear the buffer to make way for the next
//
    chan->incoming_reliable_acknowledged = reliable_ack;
    if (reliable_ack == chan->reliable_sequence) {
        netchan->reliable_length = 0;   // it has been received
    }
 
 
//
// parse fragment header, if any
//
    if (fragmented_message) {
        if (chan->fragment_sequence != sequence) {
            // start new receive sequence
            chan->fragment_sequence = sequence;
            SZ_Clear(&chan->fragment_in);
        }
 
        if (fragment_offset < chan->fragment_in.cursize) {
            SHOWDROP("%s: out of order fragment at %i\n",
                     NET_AdrToString(&netchan->remote_address), sequence);
            return qfalse;
        }
 
        if (fragment_offset > chan->fragment_in.cursize) {
            SHOWDROP("%s: dropped fragment(s) at %i\n",
                     NET_AdrToString(&netchan->remote_address), sequence);
            return qfalse;
        }
 
        length = msg_read.cursize - msg_read.readcount;
        if (chan->fragment_in.cursize + length > chan->fragment_in.maxsize) {
            SHOWDROP("%s: oversize fragment at %i\n",
                     NET_AdrToString(&netchan->remote_address), sequence);
            return qfalse;
        }
 
        SZ_Write(&chan->fragment_in, msg_read.data +
                 msg_read.readcount, length);
        if (more_fragments) {
            return qfalse;
        }
 
        // message has been sucessfully assembled
        SZ_Clear(&msg_read);
        SZ_Write(&msg_read, chan->fragment_in.data,
                 chan->fragment_in.cursize);
        SZ_Clear(&chan->fragment_in);
    }
 
    netchan->incoming_sequence = sequence;
    netchan->incoming_acknowledged = sequence_ack;
 
//
// if this message contains a reliable message, bump incoming_reliable_sequence
//
    if (reliable_message) {
        netchan->reliable_ack_pending = qtrue;
        chan->incoming_reliable_sequence ^= 1;
    }
 
//
// the message can now be read from the current message pointer
//
    netchan->last_received = com_localTime;
 
    netchan->total_dropped += netchan->dropped;
    netchan->total_received += netchan->dropped + 1;
 
    return qtrue;
}

Referenced by NetchanNew_Setup().

NetchanNew_Setup()

static netchan_t* NetchanNew_Setup ( netsrc_t  sock, const netadr_t *  adr, int  qport, size_t  maxpacketlen  )

static

Definition at line 797 of file chan.c.

{
    netchan_new_t *chan;
    netchan_t *netchan;
 
    chan = Z_TagMallocz(sizeof(*chan),
                        sock == NS_SERVER ? TAG_SERVER : TAG_GENERAL);
    netchan = (netchan_t *)chan;
    netchan->sock = sock;
    netchan->remote_address = *adr;
    netchan->qport = qport;
    netchan->maxpacketlen = maxpacketlen;
    netchan->last_received = com_localTime;
    netchan->last_sent = com_localTime;
    netchan->incoming_sequence = 0;
    netchan->outgoing_sequence = 1;
 
    netchan->Process = NetchanNew_Process;
    netchan->Transmit = NetchanNew_Transmit;
    netchan->TransmitNextFragment = NetchanNew_TransmitNextFragment;
    netchan->ShouldUpdate = NetchanNew_ShouldUpdate;
 
    SZ_Init(&netchan->message, chan->message_buf,
            sizeof(chan->message_buf));
    SZ_TagInit(&chan->fragment_in, chan->fragment_in_buf,
               sizeof(chan->fragment_in_buf), SZ_NC_FRG_IN);
    SZ_TagInit(&chan->fragment_out, chan->fragment_out_buf,
               sizeof(chan->fragment_out_buf), SZ_NC_FRG_OUT);
 
    return netchan;
}

Referenced by Netchan_Setup().

NetchanNew_ShouldUpdate()

static qboolean NetchanNew_ShouldUpdate ( netchan_t *  netchan )

static

Definition at line 778 of file chan.c.

{
    netchan_new_t *chan = (netchan_new_t *)netchan;
 
    if (netchan->message.cursize ||
        netchan->reliable_ack_pending ||
        chan->fragment_out.cursize ||
        com_localTime - netchan->last_sent > 1000) {
        return qtrue;
    }
 
    return qfalse;
}

Referenced by NetchanNew_Setup().

NetchanNew_Transmit()

static size_t NetchanNew_Transmit ( netchan_t *  netchan, size_t  length, const void *  data, int  numpackets  )

static

Definition at line 523 of file chan.c.

{
    netchan_new_t *chan = (netchan_new_t *)netchan;
    sizebuf_t   send;
    byte        send_buf[MAX_PACKETLEN];
    qboolean    send_reliable;
    uint32_t    w1, w2;
    int         i;
 
// check for message overflow
    if (netchan->message.overflowed) {
        netchan->fatal_error = qtrue;
        Com_WPrintf("%s: outgoing message overflow\n",
                    NET_AdrToString(&netchan->remote_address));
        return 0;
    }
 
    if (netchan->fragment_pending) {
        return NetchanNew_TransmitNextFragment(netchan);
    }
 
    send_reliable = qfalse;
 
// if the remote side dropped the last reliable message, resend it
    if (netchan->incoming_acknowledged > chan->last_reliable_sequence &&
        chan->incoming_reliable_acknowledged != chan->reliable_sequence) {
        send_reliable = qtrue;
    }
 
// if the reliable transmit buffer is empty, copy the current message out
    if (!netchan->reliable_length && netchan->message.cursize) {
        send_reliable = qtrue;
        memcpy(chan->reliable_buf, chan->message_buf,
               netchan->message.cursize);
        netchan->reliable_length = netchan->message.cursize;
        netchan->message.cursize = 0;
        chan->reliable_sequence ^= 1;
    }
 
    if (length > netchan->maxpacketlen || (send_reliable &&
                                           (netchan->reliable_length + length > netchan->maxpacketlen))) {
        if (send_reliable) {
            chan->last_reliable_sequence = netchan->outgoing_sequence;
            SZ_Write(&chan->fragment_out, chan->reliable_buf,
                     netchan->reliable_length);
        }
        // add the unreliable part if space is available
        if (chan->fragment_out.maxsize - chan->fragment_out.cursize >= length)
            SZ_Write(&chan->fragment_out, data, length);
        else
            Com_WPrintf("%s: dumped unreliable\n",
                        NET_AdrToString(&netchan->remote_address));
        return NetchanNew_TransmitNextFragment(netchan);
    }
 
// write the packet header
    w1 = (netchan->outgoing_sequence & 0x3FFFFFFF) | (send_reliable << 31);
    w2 = (netchan->incoming_sequence & 0x3FFFFFFF) |
         (chan->incoming_reliable_sequence << 31);
 
    SZ_TagInit(&send, send_buf, sizeof(send_buf), SZ_NC_SEND_NEW);
 
    SZ_WriteLong(&send, w1);
    SZ_WriteLong(&send, w2);
 
#if USE_CLIENT
    // send the qport if we are a client
    if (netchan->sock == NS_CLIENT && netchan->qport) {
        SZ_WriteByte(&send, netchan->qport);
    }
#endif
 
    // copy the reliable message to the packet first
    if (send_reliable) {
        chan->last_reliable_sequence = netchan->outgoing_sequence;
        SZ_Write(&send, chan->reliable_buf, netchan->reliable_length);
    }
 
    // add the unreliable part
    SZ_Write(&send, data, length);
 
    SHOWPACKET("send %4"PRIz" : s=%d ack=%d rack=%d",
               send.cursize,
               netchan->outgoing_sequence,
               netchan->incoming_sequence,
               chan->incoming_reliable_sequence);
    if (send_reliable) {
        SHOWPACKET(" reliable=%d", chan->reliable_sequence);
    }
    SHOWPACKET("\n");
 
    // send the datagram
    for (i = 0; i < numpackets; i++) {
        NET_SendPacket(netchan->sock, send.data, send.cursize,
                       &netchan->remote_address);
    }
 
    netchan->outgoing_sequence++;
    netchan->reliable_ack_pending = qfalse;
    netchan->last_sent = com_localTime;
 
    return send.cursize * numpackets;
}

Referenced by NetchanNew_Setup().

NetchanNew_TransmitNextFragment()

static size_t NetchanNew_TransmitNextFragment ( netchan_t *  netchan )

static

Definition at line 437 of file chan.c.

{
    netchan_new_t *chan = (netchan_new_t *)netchan;
    sizebuf_t   send;
    byte        send_buf[MAX_PACKETLEN];
    qboolean    send_reliable;
    uint32_t    w1, w2;
    uint16_t    offset;
    size_t      fragment_length;
    qboolean    more_fragments;
 
    send_reliable = netchan->reliable_length ? qtrue : qfalse;
 
    // write the packet header
    w1 = (netchan->outgoing_sequence & 0x3FFFFFFF) | (1 << 30) |
         (send_reliable << 31);
    w2 = (netchan->incoming_sequence & 0x3FFFFFFF) | (0 << 30) |
         (chan->incoming_reliable_sequence << 31);
 
    SZ_TagInit(&send, send_buf, sizeof(send_buf), SZ_NC_SEND_FRG);
 
    SZ_WriteLong(&send, w1);
    SZ_WriteLong(&send, w2);
 
#if USE_CLIENT
    // send the qport if we are a client
    if (netchan->sock == NS_CLIENT && netchan->qport) {
        SZ_WriteByte(&send, netchan->qport);
    }
#endif
 
    fragment_length = chan->fragment_out.cursize - chan->fragment_out.readcount;
    if (fragment_length > netchan->maxpacketlen) {
        fragment_length = netchan->maxpacketlen;
    }
 
    more_fragments = qtrue;
    if (chan->fragment_out.readcount + fragment_length ==
        chan->fragment_out.cursize) {
        more_fragments = qfalse;
    }
 
    // write fragment offset
    offset = (chan->fragment_out.readcount & 0x7FFF) |
             (more_fragments << 15);
    SZ_WriteShort(&send, offset);
 
    // write fragment contents
    SZ_Write(&send, chan->fragment_out.data + chan->fragment_out.readcount,
             fragment_length);
 
    SHOWPACKET("send %4"PRIz" : s=%d ack=%d rack=%d "
               "fragment_offset=%"PRIz" more_fragments=%d",
               send.cursize,
               netchan->outgoing_sequence,
               netchan->incoming_sequence,
               chan->incoming_reliable_sequence,
               chan->fragment_out.readcount,
               more_fragments);
    if (send_reliable) {
        SHOWPACKET(" reliable=%i ", chan->reliable_sequence);
    }
    SHOWPACKET("\n");
 
    chan->fragment_out.readcount += fragment_length;
    netchan->fragment_pending = more_fragments;
 
    // if the message has been sent completely, clear the fragment buffer
    if (!netchan->fragment_pending) {
        netchan->outgoing_sequence++;
        netchan->last_sent = com_localTime;
        SZ_Clear(&chan->fragment_out);
    }
 
    // send the datagram
    NET_SendPacket(netchan->sock, send.data, send.cursize,
                   &netchan->remote_address);
 
    return send.cursize;
}

Referenced by NetchanNew_Setup(), and NetchanNew_Transmit().

NetchanOld_Process()

static qboolean NetchanOld_Process ( netchan_t *  netchan )

static

Definition at line 285 of file chan.c.

{
    netchan_old_t *chan = (netchan_old_t *)netchan;
    uint32_t    sequence, sequence_ack;
    uint32_t    reliable_ack, reliable_message;
 
// get sequence numbers
    MSG_BeginReading();
    sequence = MSG_ReadLong();
    sequence_ack = MSG_ReadLong();
 
    // read the qport if we are a server
#if USE_CLIENT
    if (netchan->sock == NS_SERVER)
#endif
    {
        if (netchan->protocol < PROTOCOL_VERSION_R1Q2) {
            MSG_ReadShort();
        } else if (netchan->qport) {
            MSG_ReadByte();
        }
    }
 
    reliable_message = sequence >> 31;
    reliable_ack = sequence_ack >> 31;
 
    sequence &= ~(1 << 31);
    sequence_ack &= ~(1 << 31);
 
    SHOWPACKET("recv %4"PRIz" : s=%d ack=%d rack=%d",
               msg_read.cursize,
               sequence,
               sequence_ack,
               reliable_ack);
    if (reliable_message) {
        SHOWPACKET(" reliable=%d", chan->incoming_reliable_sequence ^ 1);
    }
    SHOWPACKET("\n");
 
//
// discard stale or duplicated packets
//
    if (sequence <= netchan->incoming_sequence) {
        SHOWDROP("%s: out of order packet %i at %i\n",
                 NET_AdrToString(&netchan->remote_address),
                 sequence, netchan->incoming_sequence);
        return qfalse;
    }
 
//
// dropped packets don't keep the message from being used
//
    netchan->dropped = sequence - (netchan->incoming_sequence + 1);
    if (netchan->dropped > 0) {
        SHOWDROP("%s: dropped %i packets at %i\n",
                 NET_AdrToString(&netchan->remote_address),
                 netchan->dropped, sequence);
    }
 
//
// if the current outgoing reliable message has been acknowledged
// clear the buffer to make way for the next
//
    chan->incoming_reliable_acknowledged = reliable_ack;
    if (reliable_ack == chan->reliable_sequence)
        netchan->reliable_length = 0;   // it has been received
 
//
// if this message contains a reliable message, bump incoming_reliable_sequence
//
    netchan->incoming_sequence = sequence;
    netchan->incoming_acknowledged = sequence_ack;
    if (reliable_message) {
        netchan->reliable_ack_pending = qtrue;
        chan->incoming_reliable_sequence ^= 1;
    }
 
//
// the message can now be read from the current message pointer
//
    netchan->last_received = com_localTime;
 
    netchan->total_dropped += netchan->dropped;
    netchan->total_received += netchan->dropped + 1;
 
    return qtrue;
}

Referenced by NetchanOld_Setup().

NetchanOld_Setup()

static netchan_t* NetchanOld_Setup ( netsrc_t  sock, const netadr_t *  adr, int  qport, size_t  maxpacketlen  )

static

Definition at line 395 of file chan.c.

{
    netchan_old_t *chan;
    netchan_t *netchan;
 
    Z_TagReserve(sizeof(*chan) + maxpacketlen * 2,
                 sock == NS_SERVER ? TAG_SERVER : TAG_GENERAL);
 
    chan = Z_ReservedAlloc(sizeof(*chan));
    memset(chan, 0, sizeof(*chan));
    netchan = (netchan_t *)chan;
    netchan->sock = sock;
    netchan->remote_address = *adr;
    netchan->qport = qport;
    netchan->maxpacketlen = maxpacketlen;
    netchan->last_received = com_localTime;
    netchan->last_sent = com_localTime;
    netchan->incoming_sequence = 0;
    netchan->outgoing_sequence = 1;
 
    netchan->Process = NetchanOld_Process;
    netchan->Transmit = NetchanOld_Transmit;
    netchan->TransmitNextFragment = NetchanOld_TransmitNextFragment;
    netchan->ShouldUpdate = NetchanOld_ShouldUpdate;
 
    chan->message_buf = Z_ReservedAlloc(maxpacketlen);
    SZ_Init(&netchan->message, chan->message_buf, maxpacketlen);
 
    chan->reliable_buf = Z_ReservedAlloc(maxpacketlen);
 
    return netchan;
}

Referenced by Netchan_Setup().

NetchanOld_ShouldUpdate()

static qboolean NetchanOld_ShouldUpdate ( netchan_t *  netchan )

static

Definition at line 378 of file chan.c.

{
    if (netchan->message.cursize || netchan->reliable_ack_pending ||
        com_localTime - netchan->last_sent > 1000) {
        return qtrue;
    }
 
    return qfalse;
}

Referenced by NetchanOld_Setup().

NetchanOld_Transmit()

static size_t NetchanOld_Transmit ( netchan_t *  netchan, size_t  length, const void *  data, int  numpackets  )

static

Definition at line 184 of file chan.c.

{
    netchan_old_t *chan = (netchan_old_t *)netchan;
    sizebuf_t   send;
    byte        send_buf[MAX_PACKETLEN];
    qboolean    send_reliable;
    uint32_t    w1, w2;
    int         i;
 
// check for message overflow
    if (netchan->message.overflowed) {
        netchan->fatal_error = qtrue;
        Com_WPrintf("%s: outgoing message overflow\n",
                    NET_AdrToString(&netchan->remote_address));
        return 0;
    }
 
    send_reliable = qfalse;
 
    // if the remote side dropped the last reliable message, resend it
    if (netchan->incoming_acknowledged > chan->last_reliable_sequence &&
        chan->incoming_reliable_acknowledged != chan->reliable_sequence) {
        send_reliable = qtrue;
    }
 
// if the reliable transmit buffer is empty, copy the current message out
    if (!netchan->reliable_length && netchan->message.cursize) {
        send_reliable = qtrue;
        memcpy(chan->reliable_buf, chan->message_buf,
               netchan->message.cursize);
        netchan->reliable_length = netchan->message.cursize;
        netchan->message.cursize = 0;
        chan->reliable_sequence ^= 1;
    }
 
// write the packet header
    w1 = (netchan->outgoing_sequence & ~(1 << 31)) |
         (send_reliable << 31);
    w2 = (netchan->incoming_sequence & ~(1 << 31)) |
         (chan->incoming_reliable_sequence << 31);
 
    SZ_TagInit(&send, send_buf, sizeof(send_buf), SZ_NC_SEND_OLD);
 
    SZ_WriteLong(&send, w1);
    SZ_WriteLong(&send, w2);
 
#if USE_CLIENT
    // send the qport if we are a client
    if (netchan->sock == NS_CLIENT) {
        if (netchan->protocol < PROTOCOL_VERSION_R1Q2) {
            SZ_WriteShort(&send, netchan->qport);
        } else if (netchan->qport) {
            SZ_WriteByte(&send, netchan->qport);
        }
    }
#endif
 
// copy the reliable message to the packet first
    if (send_reliable) {
        SZ_Write(&send, chan->reliable_buf, netchan->reliable_length);
        chan->last_reliable_sequence = netchan->outgoing_sequence;
    }
 
// add the unreliable part if space is available
    if (send.maxsize - send.cursize >= length)
        SZ_Write(&send, data, length);
    else
        Com_WPrintf("%s: dumped unreliable\n",
                    NET_AdrToString(&netchan->remote_address));
 
    SHOWPACKET("send %4"PRIz" : s=%d ack=%d rack=%d",
               send.cursize,
               netchan->outgoing_sequence,
               netchan->incoming_sequence,
               chan->incoming_reliable_sequence);
    if (send_reliable) {
        SHOWPACKET(" reliable=%i", chan->reliable_sequence);
    }
    SHOWPACKET("\n");
 
    // send the datagram
    for (i = 0; i < numpackets; i++) {
        NET_SendPacket(netchan->sock, send.data, send.cursize,
                       &netchan->remote_address);
    }
 
    netchan->outgoing_sequence++;
    netchan->reliable_ack_pending = qfalse;
    netchan->last_sent = com_localTime;
 
    return send.cursize * numpackets;
}

Referenced by NetchanOld_Setup().

NetchanOld_TransmitNextFragment()

static size_t NetchanOld_TransmitNextFragment ( netchan_t *  netchan )

static

Definition at line 168 of file chan.c.

{
    Com_Error(ERR_FATAL, "%s: not implemented", __func__);
    return 0;
}

Referenced by NetchanOld_Setup().

Variable Documentation

net_chantype

cvar_t* net_chantype

Definition at line 100 of file chan.c.

Referenced by CL_CheckForResend(), and Netchan_Init().

net_maxmsglen

cvar_t* net_maxmsglen

Definition at line 99 of file chan.c.

Referenced by CL_CheckForResend(), Netchan_Init(), and parse_packet_length().

net_qport

cvar_t* net_qport

Definition at line 98 of file chan.c.

Referenced by CL_CheckForResend(), and Netchan_Init().