path: root/source/sv_send.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.

*/
// sv_send.c

#include "sv_local.h"
#include "mvd_local.h"

/*
=============================================================================

MISC

=============================================================================
*/

char sv_outputbuf[SV_OUTPUTBUF_LENGTH];

void SV_FlushRedirect( int redirected, char *outputbuf, size_t len ) {
	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, &net_from, len + 10, buffer );
	} else if( redirected == RD_CLIENT ) {
		MSG_WriteByte( svc_print );
		MSG_WriteByte( PRINT_HIGH );
		MSG_WriteData( outputbuf, len );
        MSG_WriteByte( 0 );
        //Sys_Printf("redirect: %d bytes: %s", outputbuf);
		SV_ClientAddMessage( sv_client, MSG_RELIABLE|MSG_CLEAR );
	}
}

/*
=======================
SV_RateDrop

Returns qtrue if the client is over its current
bandwidth estimation and should not be sent another packet
=======================
*/
static qboolean SV_RateDrop( client_t *client ) {
	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( total > client->rate ) {
		client->surpressCount++;
		client->message_size[sv.framenum % RATE_MESSAGES] = 0;
		return qtrue;
	}

	return qfalse;
}

void SV_CalcSendTime( client_t *client, size_t size ) {
	// never drop over the loopback
	if( !client->rate ) {
        client->send_time = svs.realtime;
        client->send_delta = 0;
		return;
	}

	client->message_size[sv.framenum % RATE_MESSAGES] = size;

    client->send_time = svs.realtime;
	client->send_delta = size * 1000 / client->rate;
}

/*
=============================================================================

EVENT MESSAGES

=============================================================================
*/


/*
=================
SV_ClientPrintf

Sends text across to be displayed if the level passes.
NOT archived in MVD stream.
=================
*/
void SV_ClientPrintf( client_t *client, int level, const char *fmt, ... ) {
	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 );

	MSG_WriteByte( svc_print );
	MSG_WriteByte( level );
	MSG_WriteData( string, len + 1 );

	SV_ClientAddMessage( client, MSG_RELIABLE|MSG_CLEAR );
}

/*
=================
SV_BroadcastPrintf

Sends text to all active clients, including MVD clients.
NOT archived in MVD stream.
=================
*/
void SV_BroadcastPrintf( int level, const char *fmt, ... ) {
	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 );

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

void SV_ClientCommand( client_t *client, const char *fmt, ... ) {
	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 );

	MSG_WriteByte( svc_stufftext );
	MSG_WriteData( string, len + 1 );

	SV_ClientAddMessage( client, MSG_RELIABLE|MSG_CLEAR );
}

/*
=================
SV_BroadcastCommand

Sends command to all active clients.
NOT archived in MVD stream.
=================
*/
void SV_BroadcastCommand( const char *fmt, ... ) {
	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 );

	MSG_WriteByte( svc_stufftext );
	MSG_WriteData( string, len + 1 );

    FOR_EACH_CLIENT( client ) {
    	SV_ClientAddMessage( client, MSG_RELIABLE );
	}

	SZ_Clear( &msg_write );
}


/*
=================
SV_Multicast

Sends the contents of the write buffer to a subset of the clients,
then clears the write buffer.

Archived in MVD stream.

MULTICAST_ALL	same as broadcast (origin can be NULL)
MULTICAST_PVS	send to clients potentially visible from org
MULTICAST_PHS	send to clients potentially hearable from org
=================
*/
void SV_Multicast( vec3_t origin, multicast_t to ) {
	client_t	*client;
	byte		*mask;
	cleaf_t		*leaf;
    int         leafnum;
	int			cluster;
	int			area1, area2;
	int			flags;
	vec3_t		org;
	player_state_t	*ps;
    sizebuf_t   *buf;

	flags = 0;
    buf = &sv.mvd.datagram;

	switch( to ) {
	case MULTICAST_ALL_R:
		flags |= MSG_RELIABLE;	// intentional fallthrough
        buf = &sv.mvd.message;
	case MULTICAST_ALL:
		area1 = 0;
        leafnum = 0;
		cluster = 0;
		mask = NULL;
		break;
	case MULTICAST_PHS_R:
		flags |= MSG_RELIABLE;	// intentional fallthrough
        buf = &sv.mvd.message;
	case MULTICAST_PHS:
		leaf = CM_PointLeaf( &sv.cm, origin );
        leafnum = leaf - sv.cm.cache->leafs;
		area1 = CM_LeafArea( leaf );
		cluster = CM_LeafCluster( leaf );
		mask = CM_ClusterPHS( &sv.cm, cluster );
		break;
	case MULTICAST_PVS_R:
		flags |= MSG_RELIABLE;	// intentional fallthrough
        buf = &sv.mvd.message;
	case MULTICAST_PVS:
		leaf = CM_PointLeaf( &sv.cm, origin );
        leafnum = leaf - sv.cm.cache->leafs;
		area1 = CM_LeafArea( leaf );
		cluster = CM_LeafCluster( leaf );
		mask = CM_ClusterPVS( &sv.cm, cluster );
		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->flags & CF_NODATA ) ) )
        {
			continue; 
		}

		if( mask ) {
			// find the client's PVS
			ps = &client->edict->client->ps;
			VectorMA( ps->viewoffset, 0.125f, ps->pmove.origin, org );
			leaf = CM_PointLeaf( &sv.cm, org );
			area2 = CM_LeafArea( leaf );
			if( !CM_AreasConnected( &sv.cm, area1, area2 ) ) {
				continue;
            }
			cluster = CM_LeafCluster( leaf );
			if( !Q_IsBitSet( mask, cluster ) ) {
				continue;
			}
		}

		SV_ClientAddMessage( client, flags );

	}

    // add to MVD datagram
    if( svs.mvd.dummy && sv.mvd.paused < PAUSED_FRAMES ) {
	    SV_MvdMulticast( buf, leafnum, mvd_multicast_all + to );
    }

	// clear the buffer 
	SZ_Clear( &msg_write );
}



/*
=======================
SV_ClientAddMessage

Adds contents of the current write buffer to client's message list.
Does NOT clean the buffer for multicast delivery purpose,
unless told otherwise.
=======================
*/
void SV_ClientAddMessage( client_t *client, int flags ) {
    if( sv_debug_send->integer > 1 ) {
        Com_Printf( S_COLOR_BLUE"%s: add%c: %"PRIz"\n", client->name,
            ( flags & MSG_RELIABLE ) ? 'r' : 'u', msg_write.cursize );
    }

	if( !msg_write.cursize ) {
		return;
	}

//    if( client->state > cs_zombie ) {
        client->AddMessage( client, msg_write.data, msg_write.cursize,
            ( flags & MSG_RELIABLE ) ? qtrue : qfalse );
  //  }

	if( flags & MSG_CLEAR ) {
		SZ_Clear( &msg_write );
	}
}

static inline void SV_PacketizedRemove( client_t *client, message_packet_t *msg ) {
	List_Remove( &msg->entry );

	if( msg->cursize > MSG_TRESHOLD ) {
		Z_Free( msg );
    } else {
        List_Insert( &client->msg_free, &msg->entry );
    }
}

void SV_PacketizedClear( client_t *client ) {
	message_packet_t	*msg, *next;

    LIST_FOR_EACH_SAFE( message_packet_t, msg, next, &client->msg_used[0], entry ) {
		SV_PacketizedRemove( client, msg );
	}
    LIST_FOR_EACH_SAFE( message_packet_t, msg, next, &client->msg_used[1], entry ) {
		SV_PacketizedRemove( client, msg );
	}
    LIST_FOR_EACH_SAFE( message_packet_t, msg, next, &client->msg_sound, entry ) {
		SV_PacketizedRemove( client, msg );
	}
}

message_packet_t *SV_PacketizedAdd( client_t *client, byte *data,
							  size_t len, qboolean reliable )
{
	message_packet_t	*msg;

	if( len > MSG_TRESHOLD ) {
		if( len > MAX_MSGLEN ) {
			Com_Error( ERR_FATAL, "%s: oversize packet", __func__ );
		}
		msg = SV_Malloc( sizeof( *msg ) + len - MSG_TRESHOLD );
	} else {
        if( LIST_EMPTY( &client->msg_free ) ) {
            Com_WPrintf( "Out of message slots for %s!\n", client->name );
            if( reliable ) {
                SV_PacketizedClear( client );
                SV_DropClient( client, "no slot for reliable message" );
            }
            return NULL;
        }
        msg = LIST_FIRST( message_packet_t, &client->msg_free, entry );
    	List_Remove( &msg->entry );
	}

	memcpy( msg->data, data, len );
	msg->cursize = ( uint16_t )len;

    List_Append( &client->msg_used[reliable], &msg->entry );

    return msg;
}

static void SV_AddClientSounds( client_t *client, size_t maxsize ) {
    sound_packet_t *msg, *next;
    edict_t *edict;
    entity_state_t *state;
    vec3_t origin;
    client_frame_t *frame;
    int flags, entnum;
    int i, j;

	frame = &client->frames[sv.framenum & UPDATE_MASK];

    LIST_FOR_EACH_SAFE( sound_packet_t, msg, next, &client->msg_sound, entry ) {
        entnum = msg->sendchan >> 3;
        flags = msg->flags;

        edict = EDICT_POOL( client, entnum );
        
        // send origin for invisible entities
        if( edict->svflags & SVF_NOCLIENT ) {
            flags |= SND_POS;
        }

        // default client doesn't know that bmodels have weird origins
        if( edict->solid == SOLID_BSP && client->protocol == PROTOCOL_VERSION_DEFAULT ) {
            flags |= SND_POS;
        }

        // check if position needs to be explicitly sent
        if( ( flags & SND_POS ) == 0 ) {
            for( i = 0; i < frame->numEntities; i++ ) {
                j = ( frame->firstEntity + i ) % svs.numEntityStates;
                state = &svs.entityStates[j];
                if( state->number == entnum ) {
                    break;
                }
            }
            if( i == frame->numEntities ) {
                if( sv_debug_send->integer ) {
                    Com_Printf( S_COLOR_BLUE "Forcing position on entity %d for %s\n",
                        entnum, client->name );
                }
                flags |= SND_POS;   // entity is not present in frame
            }
        }

		// if this msg fits, write it
		if( msg_write.cursize + 16 > maxsize ) {
            break;
        }

        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 ) {
            // use the entity origin unless it is a bmodel
            if( edict->solid == SOLID_BSP ) {
                VectorAvg( edict->mins, edict->maxs, origin );
                VectorAdd( edict->s.origin, origin, origin );
            } else {
                VectorCopy( edict->s.origin, origin );
            }

            MSG_WritePos( origin );
        }

        // move message to the free pool
	    List_Remove( &msg->entry );
        List_Insert( &client->msg_free, &msg->entry );
    }
}

/*
===============================================================================

FRAME UPDATES - DEFAULT, R1Q2 AND Q2PRO CLIENTS (OLD NETCHAN)

===============================================================================
*/

#define FOR_EACH_MSG( list )     LIST_FOR_EACH_SAFE( message_packet_t, msg, next, list, entry )

void SV_OldClientAddMessage( client_t *client, byte *data,
							  size_t len, qboolean reliable )
{
	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;
	}

    SV_PacketizedAdd( client, data, len, reliable );
}

/*
=======================
SV_OldClient_SendReliableMessages

This should be the only place data is
ever written to client->netchan.message
=======================
*/
void SV_OldClientWriteReliableMessages( client_t *client, size_t maxsize ) {
	message_packet_t	*msg, *next;
    int count;

	if( client->netchan->reliable_length ) {
		if( sv_debug_send->integer > 1 ) {
			Com_Printf( S_COLOR_BLUE"%s: unacked\n", client->name );
		}
		return;	// there is still outgoing reliable message pending
	}

	// find at least one reliable message to send
    count = 0;
    FOR_EACH_MSG( &client->msg_used[1] ) {
		// stop if this msg doesn't fit (reliables must be delivered in order)
		if( client->netchan->message.cursize + msg->cursize > maxsize ) {
			if( !count ) {
				Com_WPrintf( "Overflow on the first reliable message "
					"for %s (should not happen).\n", client->name );
			}
			break;
		}

		if( sv_debug_send->integer > 1 ) {
			Com_Printf( S_COLOR_BLUE"%s: wrt%d: %d\n",
                client->name, count, msg->cursize );
		}

		SZ_Write( &client->netchan->message, msg->data, msg->cursize );
		SV_PacketizedRemove( client, msg );
        count++;
	}
}

static inline void write_msg( client_t *client, message_packet_t *msg, size_t maxsize ) {
    // if this msg fits, write it
    if( msg_write.cursize + msg->cursize <= maxsize ) {
        MSG_WriteData( msg->data, msg->cursize );
    }
	SV_PacketizedRemove( client, msg );
}


/*
=======================
OldClient_SendDatagram
=======================
*/
void SV_OldClientWriteDatagram( client_t *client ) {
	message_packet_t	*msg, *next;
	size_t maxsize, cursize;

	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_used[1] ) ) {
            msg = LIST_FIRST( message_packet_t, &client->msg_used[1], entry );
            maxsize -= msg->cursize;
        }
	}

	// send over all the relevant entity_state_t
	// and the player_state_t
	client->WriteFrame( client );
	if( msg_write.cursize > maxsize ) {
		if( sv_debug_send->integer ) {
			Com_Printf( S_COLOR_BLUE"Frame overflowed for %s: %"PRIz" > %"PRIz"\n",
                client->name, msg_write.cursize, maxsize );
		}
		SZ_Clear( &msg_write );
	}

	// now try to write unreliable messages
	// it is necessary for this to be after the WriteEntities
	// so that entity references will be current
	if( msg_write.cursize + 4 <= maxsize ) {
		// temp entities first
        FOR_EACH_MSG( &client->msg_used[0] ) {
			if( 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 ) {
            // then entity sounds
            SV_AddClientSounds( client, maxsize );

			// then positioned sounds
		    if( msg_write.cursize + 4 <= maxsize ) {
                FOR_EACH_MSG( &client->msg_used[0] ) {
                    if( msg->data[0] != svc_sound ) {
                        continue;
                    }
                    write_msg( client, msg, maxsize );
                }

                if( msg_write.cursize + 4 <= maxsize ) {
                    // then everything else left
                    FOR_EACH_MSG( &client->msg_used[0] ) {
                        write_msg( client, msg, maxsize );
                    }
                }
            }
		}
	}
	
    // write at least one reliable message
	SV_OldClientWriteReliableMessages( client,
        client->netchan->maxpacketlen - msg_write.cursize );

	// send the datagram
	cursize = client->netchan->Transmit( client->netchan,
        msg_write.cursize, msg_write.data );

	// record the size for rate estimation
	SV_CalcSendTime( client, cursize );

	SZ_Clear( &msg_write );
}

void SV_OldClientFinishFrame( client_t *client ) {
	message_packet_t	*msg, *next;

	// clear all unreliable messages still left
    FOR_EACH_MSG( &client->msg_used[0] ) {
		SV_PacketizedRemove( client, msg );
	}

    FOR_EACH_MSG( &client->msg_sound ) {
		SV_PacketizedRemove( client, msg );
	}
}

/*
===============================================================================

FRAME UPDATES - Q2PRO CLIENTS (NEW NETCHAN)

===============================================================================
*/

void SV_NewClientAddMessage( client_t *client, byte *data,
							  size_t length, qboolean reliable )
{
	sizebuf_t *buf = reliable ? &client->netchan->message : &client->datagram;
	SZ_Write( buf, data, length );
}

void SV_NewClientWriteDatagram( client_t *client ) {
	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 );
	}

	// copy the accumulated multicast datagram
	// for this client out to the message
	// it is necessary for this to be after the WriteEntities
	// so that entity references will be current
	if( client->datagram.overflowed ) {
		Com_WPrintf( "Datagram overflowed for %s\n", client->name );
	} else if( msg_write.cursize + client->datagram.cursize > msg_write.maxsize ) {
		Com_WPrintf( "Dumping datagram for %s\n", client->name );
	} else {
		MSG_WriteData( client->datagram.data, client->datagram.cursize );
	}

    SV_AddClientSounds( client, msg_write.maxsize );

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

	// send the datagram
	cursize = client->netchan->Transmit( client->netchan,
        msg_write.cursize, msg_write.data );

	// record the size for rate estimation
	SV_CalcSendTime( client, cursize );

	// clear the write buffer
	SZ_Clear( &msg_write );
}

void SV_NewClientFinishFrame( client_t *client ) {
	message_packet_t	*msg, *next;

	// clear all unreliable messages still left
	SZ_Clear( &client->datagram );

    FOR_EACH_MSG( &client->msg_sound ) {
		SV_PacketizedRemove( client, msg );
	}
}

/*
===============================================================================

COMMON STUFF

===============================================================================
*/

/*
=======================
SV_SendClientMessages

Called each game frame, sends svc_frame messages to spawned clients only.
Clients in earlier connection state are handled in SV_SendAsyncPackets.
=======================
*/
void SV_SendClientMessages( void ) {
	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->flags & CF_NODATA ) )
            goto finish;

		// if the reliable message overflowed,
		// drop the client (should never happen)
		if( client->netchan->message.overflowed ) {
			SZ_Clear( &client->netchan->message );
			SV_DropClient( client, "overflowed" );
		}

		// don't overrun bandwidth
		if( SV_RateDrop( client ) ) {
			if( sv_debug_send->integer ) {
				Com_Printf( "Frame %d surpressed for %s\n",
                    sv.framenum, client->name );
			}
			client->surpressCount++;
		} else {
            // don't write any frame data until all fragments are sent
            if( client->netchan->fragment_pending ) {
                cursize = client->netchan->TransmitNextFragment( client->netchan );
                SV_CalcSendTime( client, cursize );
            } else {
                // build the new frame and write it
                SV_BuildClientFrame( client );
                client->WriteDatagram( client );
            }
        }

finish:
        // clear the unreliable datagram
        client->FinishFrame( client );
	}

}