send.c File Reference

#include "server.h"

Go to the source code of this file.

Macros
#define	FOR_EACH_MSG_SAFE(list)   LIST_FOR_EACH_SAFE(message_packet_t, msg, next, list, entry)
#define	MSG_FIRST(list)   LIST_FIRST(message_packet_t, list, entry)

Functions
void	SV_FlushRedirect (int redirected, char *outputbuf, size_t len)
static qboolean	SV_RateDrop (client_t *client)
static void	SV_CalcSendTime (client_t *client, size_t size)
void	SV_ClientPrintf (client_t *client, int level, const char *fmt,...)
void	SV_BroadcastPrintf (int level, const char *fmt,...)
void	SV_ClientCommand (client_t *client, const char *fmt,...)
void	SV_BroadcastCommand (const char *fmt,...)
void	SV_Multicast (vec3_t origin, multicast_t to)
static qboolean	compress_message (client_t *client, int flags)
void	SV_ClientAddMessage (client_t *client, int flags)
static void	free_msg_packet (client_t *client, message_packet_t *msg)
static void	free_all_messages (client_t *client)
static void	add_msg_packet (client_t *client, byte *data, size_t len, qboolean reliable)
static qboolean	check_entity (client_t *client, int entnum)
static void	emit_snd (client_t *client, message_packet_t *msg)
static void	write_snd (client_t *client, message_packet_t *msg, size_t maxsize)
static void	write_msg (client_t *client, message_packet_t *msg, size_t maxsize)
static void	write_unreliables (client_t *client, size_t maxsize)
static void	add_message_old (client_t *client, byte *data, size_t len, qboolean reliable)
static void	write_reliables_old (client_t *client, size_t maxsize)
static void	repack_unreliables (client_t *client, size_t maxsize)
static void	write_datagram_old (client_t *client)
static void	add_message_new (client_t *client, byte *data, size_t len, qboolean reliable)
static void	write_datagram_new (client_t *client)
static void	finish_frame (client_t *client)
void	SV_SendClientMessages (void)
static void	write_pending_download (client_t *client)
void	SV_SendAsyncPackets (void)
void	SV_InitClientSend (client_t *newcl)
void	SV_ShutdownClientSend (client_t *client)

Variables
char	sv_outputbuf [SV_OUTPUTBUF_LENGTH]

Macro Definition Documentation

FOR_EACH_MSG_SAFE

#define FOR_EACH_MSG_SAFE

(

list

)

LIST_FOR_EACH_SAFE(message_packet_t, msg, next, list, entry)

Definition at line 444 of file send.c.

MSG_FIRST

#define MSG_FIRST

(

list

)

LIST_FIRST(message_packet_t, list, entry)

Definition at line 446 of file send.c.

Function Documentation

add_message_new()

static void add_message_new ( client_t *  client, byte *  data, size_t  len, qboolean  reliable  )

static

Definition at line 776 of file send.c.

{
    if (reliable) {
        // don't packetize, netchan level will do fragmentation as needed
        SZ_Write(&client->netchan->message, data, len);
    } else {
        // still have to packetize, relative sounds need special processing
        add_msg_packet(client, data, len, qfalse);
    }
}

Referenced by SV_InitClientSend().

add_message_old()

static void add_message_old ( client_t *  client, byte *  data, size_t  len, qboolean  reliable  )

static

Definition at line 608 of file send.c.

{
    if (len > client->netchan->maxpacketlen) {
        if (reliable) {
            SV_DropClient(client, "oversize reliable message");
        } else {
            Com_DPrintf("Dumped oversize unreliable for %s\n", client->name);
        }
        return;
    }
 
    add_msg_packet(client, data, len, reliable);
}

Referenced by SV_InitClientSend().

add_msg_packet()

static void add_msg_packet ( client_t *  client, byte *  data, size_t  len, qboolean  reliable  )

static

Definition at line 463 of file send.c.

{
    message_packet_t    *msg;
 
    if (!client->msg_pool) {
        return; // already dropped
    }
 
    if (len > MSG_TRESHOLD) {
        if (len > MAX_MSGLEN) {
            Com_Error(ERR_FATAL, "%s: oversize packet", __func__);
        }
        if (client->msg_dynamic_bytes + len > MAX_MSGLEN) {
            Com_WPrintf("%s: %s: out of dynamic memory\n",
                        __func__, client->name);
            goto overflowed;
        }
        msg = SV_Malloc(sizeof(*msg) + len - MSG_TRESHOLD);
        client->msg_dynamic_bytes += len;
    } else {
        if (LIST_EMPTY(&client->msg_free_list)) {
            Com_WPrintf("%s: %s: out of message slots\n",
                        __func__, client->name);
            goto overflowed;
        }
        msg = MSG_FIRST(&client->msg_free_list);
        List_Remove(&msg->entry);
    }
 
    memcpy(msg->data, data, len);
    msg->cursize = (uint16_t)len;
 
    if (reliable) {
        List_Append(&client->msg_reliable_list, &msg->entry);
    } else {
        List_Append(&client->msg_unreliable_list, &msg->entry);
        client->msg_unreliable_bytes += len;
    }
 
    return;
 
overflowed:
    if (reliable) {
        free_all_messages(client);
        SV_DropClient(client, "reliable queue overflowed");
    }
}

Referenced by add_message_new(), and add_message_old().

check_entity()

static qboolean check_entity ( client_t *  client, int  entnum  )

static

Definition at line 515 of file send.c.

{
    client_frame_t *frame;
    unsigned i, j;
 
    frame = &client->frames[client->framenum & UPDATE_MASK];
 
    for (i = 0; i < frame->num_entities; i++) {
        j = (frame->first_entity + i) % svs.num_entities;
        if (svs.entities[j].number == entnum) {
            return qtrue;
        }
    }
 
    return qfalse;
}

Referenced by emit_snd().

compress_message()

static qboolean compress_message ( client_t *  client, int  flags  )

static

Definition at line 338 of file send.c.

{
#if USE_ZLIB
    byte    buffer[MAX_MSGLEN];
 
    if (!(flags & MSG_COMPRESS))
        return qfalse;
 
    if (!client->has_zlib)
        return qfalse;
 
    // older clients have problems seamlessly writing svc_zpackets
    if (client->settings[CLS_RECORDING]) {
        if (client->protocol != PROTOCOL_VERSION_Q2PRO)
            return qfalse;
        if (client->version < PROTOCOL_VERSION_Q2PRO_EXTENDED_LAYOUT)
            return qfalse;
    }
 
    // compress only sufficiently large layouts
    if (msg_write.cursize < client->netchan->maxpacketlen / 2)
        return qfalse;
 
    deflateReset(&svs.z);
    svs.z.next_in = msg_write.data;
    svs.z.avail_in = (uInt)msg_write.cursize;
    svs.z.next_out = buffer + 5;
    svs.z.avail_out = (uInt)(MAX_MSGLEN - 5);
 
    if (deflate(&svs.z, Z_FINISH) != Z_STREAM_END)
        return qfalse;
 
    buffer[0] = svc_zpacket;
    buffer[1] = svs.z.total_out & 255;
    buffer[2] = (svs.z.total_out >> 8) & 255;
    buffer[3] = msg_write.cursize & 255;
    buffer[4] = (msg_write.cursize >> 8) & 255;
 
    SV_DPrintf(0, "%s: comp: %lu into %lu\n",
               client->name, svs.z.total_in, svs.z.total_out + 5);
 
    if (svs.z.total_out + 5 > msg_write.cursize)
        return qfalse;
 
    client->AddMessage(client, buffer, svs.z.total_out + 5,
                       (flags & MSG_RELIABLE) ? qtrue : qfalse);
    return qtrue;
#else
    return qfalse;
#endif
}

Referenced by SV_ClientAddMessage().

emit_snd()

static void emit_snd ( client_t *  client, message_packet_t *  msg  )

static

Definition at line 533 of file send.c.

{
    int flags, entnum;
    int i;
 
    entnum = msg->sendchan >> 3;
    flags = msg->flags;
 
    // check if position needs to be explicitly sent
    if (!(flags & SND_POS) && !check_entity(client, entnum)) {
        SV_DPrintf(0, "Forcing position on entity %d for %s\n",
                   entnum, client->name);
        flags |= SND_POS;   // entity is not present in frame
    }
 
    MSG_WriteByte(svc_sound);
    MSG_WriteByte(flags);
    MSG_WriteByte(msg->index);
 
    if (flags & SND_VOLUME)
        MSG_WriteByte(msg->volume);
    if (flags & SND_ATTENUATION)
        MSG_WriteByte(msg->attenuation);
    if (flags & SND_OFFSET)
        MSG_WriteByte(msg->timeofs);
 
    MSG_WriteShort(msg->sendchan);
 
    if (flags & SND_POS) {
        for (i = 0; i < 3; i++) {
            MSG_WriteShort(msg->pos[i]);
        }
    }
}

Referenced by write_snd().

finish_frame()

static void finish_frame ( client_t *  client )

static

Definition at line 847 of file send.c.

{
    message_packet_t *msg, *next;
 
    FOR_EACH_MSG_SAFE(&client->msg_unreliable_list) {
        free_msg_packet(client, msg);
    }
    client->msg_unreliable_bytes = 0;
}

Referenced by SV_SendClientMessages().

free_all_messages()

static void free_all_messages ( client_t *  client )

static

Definition at line 449 of file send.c.

{
    message_packet_t *msg, *next;
 
    FOR_EACH_MSG_SAFE(&client->msg_unreliable_list) {
        free_msg_packet(client, msg);
    }
    FOR_EACH_MSG_SAFE(&client->msg_reliable_list) {
        free_msg_packet(client, msg);
    }
    client->msg_unreliable_bytes = 0;
    client->msg_dynamic_bytes = 0;
}

Referenced by add_msg_packet(), and SV_ShutdownClientSend().

free_msg_packet()

static void free_msg_packet ( client_t *  client, message_packet_t *  msg  )

inlinestatic

Definition at line 429 of file send.c.

{
    List_Remove(&msg->entry);
 
    if (msg->cursize > MSG_TRESHOLD) {
        if (msg->cursize > client->msg_dynamic_bytes) {
            Com_Error(ERR_FATAL, "%s: bad packet size", __func__);
        }
        client->msg_dynamic_bytes -= msg->cursize;
        Z_Free(msg);
    } else {
        List_Insert(&client->msg_free_list, &msg->entry);
    }
}

Referenced by finish_frame(), free_all_messages(), write_msg(), and write_reliables_old().

repack_unreliables()

static void repack_unreliables ( client_t *  client, size_t  maxsize  )

static

Definition at line 657 of file send.c.

{
    message_packet_t *msg, *next;
 
    if (msg_write.cursize + 4 > maxsize) {
        return;
    }
 
    // temp entities first
    FOR_EACH_MSG_SAFE(&client->msg_unreliable_list) {
        if (!msg->cursize || msg->data[0] != svc_temp_entity) {
            continue;
        }
        // ignore some low-priority effects, these checks come from r1q2
        if (msg->data[1] == TE_BLOOD || msg->data[1] == TE_SPLASH ||
            msg->data[1] == TE_GUNSHOT || msg->data[1] == TE_BULLET_SPARKS ||
            msg->data[1] == TE_SHOTGUN) {
            continue;
        }
        write_msg(client, msg, maxsize);
    }
 
    if (msg_write.cursize + 4 > maxsize) {
        return;
    }
 
    // then entity sounds
    FOR_EACH_MSG_SAFE(&client->msg_unreliable_list) {
        if (!msg->cursize) {
            write_snd(client, msg, maxsize);
        }
    }
 
    if (msg_write.cursize + 4 > maxsize) {
        return;
    }
 
    // then positioned sounds
    FOR_EACH_MSG_SAFE(&client->msg_unreliable_list) {
        if (msg->cursize && msg->data[0] == svc_sound) {
            write_msg(client, msg, maxsize);
        }
    }
 
    if (msg_write.cursize + 4 > maxsize) {
        return;
    }
 
    // then everything else left
    FOR_EACH_MSG_SAFE(&client->msg_unreliable_list) {
        if (msg->cursize) {
            write_msg(client, msg, maxsize);
        }
    }
}

Referenced by write_datagram_old().

SV_BroadcastCommand()

void SV_BroadcastCommand	(	const char *	fmt,
			...
	)

Definition at line 214 of file send.c.

{
    va_list     argptr;
    char        string[MAX_STRING_CHARS];
    client_t    *client;
    size_t      len;
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(string, sizeof(string), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(string)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    MSG_WriteByte(svc_stufftext);
    MSG_WriteData(string, len + 1);
 
    FOR_EACH_CLIENT(client) {
        SV_ClientAddMessage(client, MSG_RELIABLE);
    }
 
    SZ_Clear(&msg_write);
}

Referenced by SV_SpawnServer().

SV_BroadcastPrintf()

void SV_BroadcastPrintf	(	int	level,
		const char *	fmt,
			...
	)

Definition at line 154 of file send.c.

{
    va_list     argptr;
    char        string[MAX_STRING_CHARS];
    client_t    *client;
    size_t      len;
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(string, sizeof(string), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(string)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    MSG_WriteByte(svc_print);
    MSG_WriteByte(level);
    MSG_WriteData(string, len + 1);
 
    FOR_EACH_CLIENT(client) {
        if (client->state != cs_spawned)
            continue;
        if (level < client->messagelevel)
            continue;
        SV_ClientAddMessage(client, MSG_RELIABLE);
    }
 
    SZ_Clear(&msg_write);
}

Referenced by AC_ClientAnnounce(), AC_Drop(), print_drop_reason(), and SV_UserinfoChanged().

SV_CalcSendTime()

static void SV_CalcSendTime ( client_t *  client, size_t  size  )

static

Definition at line 88 of file send.c.

{
    // never drop over the loopback
    if (!client->rate) {
        client->send_time = svs.realtime;
        client->send_delta = 0;
        return;
    }
 
    if (client->state == cs_spawned)
        client->message_size[client->framenum % RATE_MESSAGES] = size;
 
    client->send_time = svs.realtime;
    client->send_delta = size * 1000 / client->rate;
}

Referenced by SV_SendAsyncPackets(), SV_SendClientMessages(), write_datagram_new(), and write_datagram_old().

SV_ClientAddMessage()

void SV_ClientAddMessage	(	client_t *	client,
		int	flags
	)

Definition at line 399 of file send.c.

{
    SV_DPrintf(1, "Added %sreliable message to %s: %"PRIz" bytes\n",
               (flags & MSG_RELIABLE) ? "" : "un", client->name, msg_write.cursize);
 
    if (!msg_write.cursize) {
        return;
    }
 
    if (compress_message(client, flags)) {
        goto clear;
    }
 
    client->AddMessage(client, msg_write.data, msg_write.cursize,
                       (flags & MSG_RELIABLE) ? qtrue : qfalse);
 
clear:
    if (flags & MSG_CLEAR) {
        SZ_Clear(&msg_write);
    }
}

Referenced by AC_Announce(), handle_filtercmd(), MVD_BroadcastPrintf(), MVD_ChangeLevel(), MVD_LayoutChannels(), MVD_LayoutClients(), MVD_LayoutFollow(), MVD_LayoutMenu(), MVD_LayoutScores(), MVD_ParseSound(), MVD_SwitchChannel(), MVD_UpdateConfigstring(), PF_bprintf(), PF_configstring(), PF_cprintf(), PF_StartSound(), PF_Unicast(), stuff_cmds(), SV_BeginDownload_f(), SV_BroadcastCommand(), SV_BroadcastPrintf(), SV_ClientCommand(), SV_ClientPrintf(), SV_DropClient(), SV_FlushRedirect(), SV_Multicast(), SV_New_f(), SV_StopDownload_f(), SV_Stuff_f(), SV_StuffAll_f(), write_cs_list(), write_plain_baselines(), and write_plain_configstrings().

SV_ClientCommand()

void SV_ClientCommand	(	client_t *	client,
		const char *	fmt,
			...
	)

Definition at line 185 of file send.c.

{
    va_list     argptr;
    char        string[MAX_STRING_CHARS];
    size_t      len;
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(string, sizeof(string), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(string)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    MSG_WriteByte(svc_stufftext);
    MSG_WriteData(string, len + 1);
 
    SV_ClientAddMessage(client, MSG_RELIABLE | MSG_CLEAR);
}

Referenced by MVD_Invuse_f(), stuff_junk(), SV_New_f(), SV_StuffCvar_f(), and SV_UpdateUserinfo().

SV_ClientPrintf()

void SV_ClientPrintf	(	client_t *	client,
		int	level,
		const char *	fmt,
			...
	)

Definition at line 121 of file send.c.

{
    va_list     argptr;
    char        string[MAX_STRING_CHARS];
    size_t      len;
 
    if (level < client->messagelevel)
        return;
 
    va_start(argptr, fmt);
    len = Q_vsnprintf(string, sizeof(string), fmt, argptr);
    va_end(argptr);
 
    if (len >= sizeof(string)) {
        Com_WPrintf("%s: overflow\n", __func__);
        return;
    }
 
    MSG_WriteByte(svc_print);
    MSG_WriteByte(level);
    MSG_WriteData(string, len + 1);
 
    SV_ClientAddMessage(client, MSG_RELIABLE | MSG_CLEAR);
}

Referenced by AC_ClientBegin(), AC_ParseFileViolation(), AC_ParseViolation(), gtv_forward_cmd(), MVD_Admin_f(), MVD_AutoFollow_f(), mvd_channel_list_f(), MVD_Commands_f(), MVD_Follow_f(), MVD_FollowStart(), MVD_Forward_f(), MVD_Join_f(), MVD_NotifyClient(), MVD_Observe_f(), MVD_Say_f(), MVD_SetPlayer(), MVD_TrySwitchChannel(), print_channel(), print_drop_reason(), SV_BeginDownload_f(), SV_ConSay_f(), SV_Lag_f(), and SV_UpdateUserinfo().

SV_FlushRedirect()

void SV_FlushRedirect	(	int	redirected,
		char *	outputbuf,
		size_t	len
	)

Definition at line 32 of file send.c.

{
    byte    buffer[MAX_PACKETLEN_DEFAULT];
 
    if (redirected == RD_PACKET) {
        memcpy(buffer, "\xff\xff\xff\xffprint\n", 10);
        memcpy(buffer + 10, outputbuf, len);
        NET_SendPacket(NS_SERVER, buffer, len + 10, &net_from);
    } else if (redirected == RD_CLIENT) {
        MSG_WriteByte(svc_print);
        MSG_WriteByte(PRINT_HIGH);
        MSG_WriteData(outputbuf, len);
        MSG_WriteByte(0);
        SV_ClientAddMessage(sv_client, MSG_RELIABLE | MSG_CLEAR);
    }
}

SV_InitClientSend()

void SV_InitClientSend

(

client_t *

newcl

)

Definition at line 1040 of file send.c.

{
    int i;
 
    List_Init(&newcl->msg_free_list);
    List_Init(&newcl->msg_unreliable_list);
    List_Init(&newcl->msg_reliable_list);
 
    newcl->msg_pool = SV_Malloc(sizeof(message_packet_t) * MSG_POOLSIZE);
    for (i = 0; i < MSG_POOLSIZE; i++) {
        List_Append(&newcl->msg_free_list, &newcl->msg_pool[i].entry);
    }
 
    // setup protocol
    if (newcl->netchan->type == NETCHAN_NEW) {
        newcl->AddMessage = add_message_new;
        newcl->WriteDatagram = write_datagram_new;
    } else {
        newcl->AddMessage = add_message_old;
        newcl->WriteDatagram = write_datagram_old;
    }
}

Referenced by SVC_DirectConnect().

SV_Multicast()

void SV_Multicast	(	vec3_t	origin,
		multicast_t	to
	)

Definition at line 255 of file send.c.

{
    client_t    *client;
    byte        mask[VIS_MAX_BYTES];
    mleaf_t     *leaf1, *leaf2;
    int         leafnum q_unused;
    int         flags;
    vec3_t      org;
 
    if (!sv.cm.cache) {
        Com_Error(ERR_DROP, "%s: no map loaded", __func__);
    }
 
    flags = 0;
 
    switch (to) {
    case MULTICAST_ALL_R:
        flags |= MSG_RELIABLE;
        // intentional fallthrough
    case MULTICAST_ALL:
        leaf1 = NULL;
        leafnum = 0;
        break;
    case MULTICAST_PHS_R:
        flags |= MSG_RELIABLE;
        // intentional fallthrough
    case MULTICAST_PHS:
        leaf1 = CM_PointLeaf(&sv.cm, origin);
        leafnum = leaf1 - sv.cm.cache->leafs;
        BSP_ClusterVis(sv.cm.cache, mask, leaf1->cluster, DVIS_PHS);
        break;
    case MULTICAST_PVS_R:
        flags |= MSG_RELIABLE;
        // intentional fallthrough
    case MULTICAST_PVS:
        leaf1 = CM_PointLeaf(&sv.cm, origin);
        leafnum = leaf1 - sv.cm.cache->leafs;
        BSP_ClusterVis(sv.cm.cache, mask, leaf1->cluster, DVIS_PVS2);
        break;
    default:
        Com_Error(ERR_DROP, "SV_Multicast: bad to: %i", to);
    }
 
    // send the data to all relevent clients
    FOR_EACH_CLIENT(client) {
        if (client->state < cs_primed) {
            continue;
        }
        // do not send unreliables to connecting clients
        if (!(flags & MSG_RELIABLE) && (client->state != cs_spawned ||
                                        client->download || client->nodata)) {
            continue;
        }
 
        if (leaf1) {
            // find the client's PVS
#if 0
            player_state_t *ps = &client->edict->client->ps;
            VectorMA(ps->viewoffset, 0.125f, ps->pmove.origin, org);
#else
            // FIXME: for some strange reason, game code assumes the server
            // uses entity origin for PVS/PHS culling, not the view origin
            VectorCopy(client->edict->s.origin, org);
#endif
            leaf2 = CM_PointLeaf(&sv.cm, org);
            if (!CM_AreasConnected(&sv.cm, leaf1->area, leaf2->area))
                continue;
            if (leaf2->cluster == -1)
                continue;
            if (!Q_IsBitSet(mask, leaf2->cluster))
                continue;
        }
 
        SV_ClientAddMessage(client, flags);
    }
 
    // add to MVD datagram
    SV_MvdMulticast(leafnum, to);
 
    // clear the buffer
    SZ_Clear(&msg_write);
}

Referenced by PF_PositionedSound(), and SV_InitGameProgs().

SV_RateDrop()

static qboolean SV_RateDrop ( client_t *  client )

static

Definition at line 57 of file send.c.

{
    size_t  total;
    int     i;
 
    // never drop over the loopback
    if (!client->rate) {
        return qfalse;
    }
 
    total = 0;
    for (i = 0; i < RATE_MESSAGES; i++) {
        total += client->message_size[i];
    }
 
#if USE_FPS
    total = total * sv.framediv / client->framediv;
#endif
 
    if (total > client->rate) {
        SV_DPrintf(0, "Frame %d suppressed for %s (total = %"PRIz")\n",
                   client->framenum, client->name, total);
        client->frameflags |= FF_SUPPRESSED;
        client->suppress_count++;
        client->message_size[client->framenum % RATE_MESSAGES] = 0;
        return qtrue;
    }
 
    return qfalse;
}

Referenced by SV_SendClientMessages().

SV_SendAsyncPackets()

void SV_SendAsyncPackets

(

void

)

Definition at line 987 of file send.c.

{
    qboolean    retransmit;
    client_t    *client;
    netchan_t   *netchan;
    size_t      cursize;
 
    FOR_EACH_CLIENT(client) {
        // don't overrun bandwidth
        if (svs.realtime - client->send_time < client->send_delta) {
            continue;
        }
 
        netchan = client->netchan;
 
        // make sure all fragments are transmitted first
        if (netchan->fragment_pending) {
            cursize = netchan->TransmitNextFragment(netchan);
            SV_DPrintf(0, "%s: frag: %"PRIz"\n", client->name, cursize);
            goto calctime;
        }
 
        // spawned clients are handled elsewhere
        if (client->state == cs_spawned && !client->download && !client->nodata && !SV_PAUSED) {
            continue;
        }
 
        // see if it's time to resend a (possibly dropped) packet
        retransmit = (com_localTime - netchan->last_sent > 1000);
 
        // don't write new reliables if not yet acknowledged
        if (netchan->reliable_length && !retransmit && client->state != cs_zombie) {
            continue;
        }
 
        // just update reliable if needed
        if (netchan->type == NETCHAN_OLD) {
            write_reliables_old(client, netchan->maxpacketlen);
        }
 
        // now fill up remaining buffer space with download
        write_pending_download(client);
 
        if (netchan->message.cursize || netchan->reliable_ack_pending ||
            netchan->reliable_length || retransmit) {
            cursize = netchan->Transmit(netchan, 0, NULL, 1);
            SV_DPrintf(0, "%s: send: %"PRIz"\n", client->name, cursize);
calctime:
            SV_CalcSendTime(client, cursize);
        }
    }
}

Referenced by MVD_ChangeLevel(), SV_Frame(), and SV_SpawnServer().

SV_SendClientMessages()

void SV_SendClientMessages

(

void

)

Definition at line 880 of file send.c.

{
    client_t    *client;
    size_t      cursize;
 
    // send a message to each connected client
    FOR_EACH_CLIENT(client) {
        if (client->state != cs_spawned || client->download || client->nodata)
            goto finish;
 
        if (!SV_CLIENTSYNC(client))
            continue;
 
#if (defined _DEBUG) && USE_FPS
        if (developer->integer)
            check_key_sync(client);
#endif
 
        // if the reliable message overflowed,
        // drop the client (should never happen)
        if (client->netchan->message.overflowed) {
            SZ_Clear(&client->netchan->message);
            SV_DropClient(client, "reliable message overflowed");
            goto finish;
        }
 
        // don't overrun bandwidth
        if (SV_RateDrop(client))
            goto advance;
 
        // don't write any frame data until all fragments are sent
        if (client->netchan->fragment_pending) {
            client->frameflags |= FF_SUPPRESSED;
            cursize = client->netchan->TransmitNextFragment(client->netchan);
            SV_CalcSendTime(client, cursize);
            goto advance;
        }
 
        // build the new frame and write it
        SV_BuildClientFrame(client);
        client->WriteDatagram(client);
 
advance:
        // advance for next frame
        client->framenum++;
 
finish:
        // clear all unreliable messages still left
        finish_frame(client);
    }
}

Referenced by SV_Frame(), and SV_SpawnServer().

SV_ShutdownClientSend()

void SV_ShutdownClientSend

(

client_t *

client

)

Definition at line 1063 of file send.c.

{
    free_all_messages(client);
 
    Z_Free(client->msg_pool);
    client->msg_pool = NULL;
 
    List_Init(&client->msg_free_list);
}

Referenced by SV_RemoveClient().

write_datagram_new()

static void write_datagram_new ( client_t *  client )

static

Definition at line 788 of file send.c.

{
    size_t cursize;
 
    // send over all the relevant entity_state_t
    // and the player_state_t
    client->WriteFrame(client);
 
    if (msg_write.overflowed) {
        // should never really happen
        Com_WPrintf("Frame overflowed for %s\n", client->name);
        SZ_Clear(&msg_write);
    }
 
    // now write unreliable messages
    // for this client out to the message
    // it is necessary for this to be after the WriteFrame
    // so that entity references will be current
    if (msg_write.cursize + client->msg_unreliable_bytes > msg_write.maxsize) {
        Com_WPrintf("Dumping datagram for %s\n", client->name);
    } else {
        write_unreliables(client, msg_write.maxsize);
    }
 
#ifdef _DEBUG
    if (sv_pad_packets->integer) {
        size_t pad = msg_write.cursize + sv_pad_packets->integer;
 
        if (pad > msg_write.maxsize) {
            pad = msg_write.maxsize;
        }
        for (; pad > 0; pad--) {
            MSG_WriteByte(svc_nop);
        }
    }
#endif
 
    // send the datagram
    cursize = client->netchan->Transmit(client->netchan,
                                        msg_write.cursize,
                                        msg_write.data,
                                        client->numpackets);
 
    // record the size for rate estimation
    SV_CalcSendTime(client, cursize);
 
    // clear the write buffer
    SZ_Clear(&msg_write);
}

Referenced by SV_InitClientSend().

write_datagram_old()

static void write_datagram_old ( client_t *  client )

static

Definition at line 713 of file send.c.

{
    message_packet_t *msg;
    size_t maxsize, cursize;
 
    // determine how much space is left for unreliable data
    maxsize = client->netchan->maxpacketlen;
    if (client->netchan->reliable_length) {
        // there is still unacked reliable message pending
        maxsize -= client->netchan->reliable_length;
    } else {
        // find at least one reliable message to send
        // and make sure to reserve space for it
        if (!LIST_EMPTY(&client->msg_reliable_list)) {
            msg = MSG_FIRST(&client->msg_reliable_list);
            maxsize -= msg->cursize;
        }
    }
 
    // send over all the relevant entity_state_t
    // and the player_state_t
    client->WriteFrame(client);
    if (msg_write.cursize > maxsize) {
        SV_DPrintf(0, "Frame %d overflowed for %s: %"PRIz" > %"PRIz"\n",
                   client->framenum, client->name, msg_write.cursize, maxsize);
        SZ_Clear(&msg_write);
    }
 
    // now write unreliable messages
    // it is necessary for this to be after the WriteFrame
    // so that entity references will be current
    if (msg_write.cursize + client->msg_unreliable_bytes > maxsize) {
        // throw out some low priority effects
        repack_unreliables(client, maxsize);
    } else {
        // all messages fit, write them in order
        write_unreliables(client, maxsize);
    }
 
    // write at least one reliable message
    write_reliables_old(client, client->netchan->maxpacketlen - msg_write.cursize);
 
    // send the datagram
    cursize = client->netchan->Transmit(client->netchan,
                                        msg_write.cursize,
                                        msg_write.data,
                                        client->numpackets);
 
    // record the size for rate estimation
    SV_CalcSendTime(client, cursize);
 
    // clear the write buffer
    SZ_Clear(&msg_write);
}

Referenced by SV_InitClientSend().

write_msg()

static void write_msg ( client_t *  client, message_packet_t *  msg, size_t  maxsize  )

inlinestatic

Definition at line 578 of file send.c.

{
    // if this msg fits, write it
    if (msg_write.cursize + msg->cursize <= maxsize) {
        MSG_WriteData(msg->data, msg->cursize);
    }
    free_msg_packet(client, msg);
}

Referenced by repack_unreliables(), and write_unreliables().

write_pending_download()

static void write_pending_download ( client_t *  client )

static

Definition at line 932 of file send.c.

{
    sizebuf_t   *buf;
    size_t      remaining;
    int         chunk, percent;
 
    if (!client->download)
        return;
 
    if (!client->downloadpending)
        return;
 
    if (client->netchan->reliable_length)
        return;
 
    buf = &client->netchan->message;
    if (buf->cursize > client->netchan->maxpacketlen)
        return;
 
    remaining = client->netchan->maxpacketlen - buf->cursize;
    if (remaining <= 4)
        return;
 
    chunk = client->downloadsize - client->downloadcount;
    if (chunk > remaining - 4)
        chunk = remaining - 4;
 
    client->downloadpending = qfalse;
    client->downloadcount += chunk;
 
    percent = client->downloadcount * 100 / client->downloadsize;
 
    SZ_WriteByte(buf, client->downloadcmd);
    SZ_WriteShort(buf, chunk);
    SZ_WriteByte(buf, percent);
    SZ_Write(buf, client->download + client->downloadcount - chunk, chunk);
 
    if (client->downloadcount == client->downloadsize) {
        SV_CloseDownload(client);
        SV_AlignKeyFrames(client);
    }
}

Referenced by SV_SendAsyncPackets().

write_reliables_old()

static void write_reliables_old ( client_t *  client, size_t  maxsize  )

static

Definition at line 624 of file send.c.

{
    message_packet_t *msg, *next;
    int count;
 
    if (client->netchan->reliable_length) {
        SV_DPrintf(1, "%s to %s: unacked\n", __func__, client->name);
        return;    // there is still outgoing reliable message pending
    }
 
    // find at least one reliable message to send
    count = 0;
    FOR_EACH_MSG_SAFE(&client->msg_reliable_list) {
        // stop if this msg doesn't fit (reliables must be delivered in order)
        if (client->netchan->message.cursize + msg->cursize > maxsize) {
            if (!count) {
                // this should never happen
                Com_WPrintf("%s to %s: overflow on the first message\n",
                            __func__, client->name);
            }
            break;
        }
 
        SV_DPrintf(1, "%s to %s: writing msg %d: %d bytes\n",
                   __func__, client->name, count, msg->cursize);
 
        SZ_Write(&client->netchan->message, msg->data, msg->cursize);
        free_msg_packet(client, msg);
        count++;
    }
}

Referenced by SV_SendAsyncPackets(), and write_datagram_old().

write_snd()

static void write_snd ( client_t *  client, message_packet_t *  msg, size_t  maxsize  )

inlinestatic

Definition at line 568 of file send.c.

{
    // if this msg fits, write it
    if (msg_write.cursize + MAX_SOUND_PACKET <= maxsize) {
        emit_snd(client, msg);
    }
    List_Remove(&msg->entry);
    List_Insert(&client->msg_free_list, &msg->entry);
}

Referenced by repack_unreliables(), and write_unreliables().

write_unreliables()

static void write_unreliables ( client_t *  client, size_t  maxsize  )

inlinestatic

Definition at line 587 of file send.c.

{
    message_packet_t    *msg, *next;
 
    FOR_EACH_MSG_SAFE(&client->msg_unreliable_list) {
        if (msg->cursize) {
            write_msg(client, msg, maxsize);
        } else {
            write_snd(client, msg, maxsize);
        }
    }
}

Referenced by write_datagram_new(), and write_datagram_old().

Variable Documentation

sv_outputbuf

char sv_outputbuf[SV_OUTPUTBUF_LENGTH]

Definition at line 30 of file send.c.