/*
============
Cbuf_InsertText
Adds command text immediately after the current command
Adds a \n to the text
FIXME: actually change the command buffer to do less copying
============
*/
void Cbuf_InsertText (const char *text)
{
char *temp;
int templen;
// copy off any commands still remaining in the exec buffer
templen = cmd_text.cursize;
if (templen)
{
temp = (char *) Z_Malloc (templen, Z_MAINZONE);
memcpy (temp, cmd_text.data, templen);
SZ_Clear (&cmd_text);
}
else
temp = NULL; // shut up compiler
// add the entire text of the file
Cbuf_AddText (text);
SZ_Write (&cmd_text, "\n", 1);
// add the copied off data
if (templen)
{
SZ_Write (&cmd_text, temp, templen);
Z_Free (temp);
}
}
void ClientReliableWrite_SZ(client_t *cl, void *data, int len)
{
if (cl->num_backbuf) {
SZ_Write(&cl->backbuf, data, len);
ClientReliable_FinishWrite(cl);
} else
SZ_Write(&cl->netchan.message, data, len);
}
// flush data from client's reliable buffers to netchan
void SV_FlushBackbuf (client_t *cl)
{
int i;
// check to see if we have a backbuf to stick into the reliable
if (cl->num_backbuf) {
// will it fit?
if (cl->netchan.message.cursize + cl->backbuf_size[0] <
cl->netchan.message.maxsize) {
Com_DPrintf ("%s: backbuf %d bytes\n",
cl->name, cl->backbuf_size[0]);
// it'll fit
SZ_Write (&cl->netchan.message, cl->backbuf_data[0],
cl->backbuf_size[0]);
// move along, move along
for (i = 1; i < cl->num_backbuf; i++) {
memcpy(cl->backbuf_data[i - 1], cl->backbuf_data[i],
cl->backbuf_size[i]);
cl->backbuf_size[i - 1] = cl->backbuf_size[i];
}
cl->num_backbuf--;
if (cl->num_backbuf) {
SZ_Init (&cl->backbuf, cl->backbuf_data[cl->num_backbuf - 1],
sizeof(cl->backbuf_data[cl->num_backbuf - 1]));
cl->backbuf.cursize = cl->backbuf_size[cl->num_backbuf - 1];
}
}
}
}
/*
==================
SV_NextDownload_f
==================
*/
void SV_NextDownload_f(void){
int percent, size, r;
if(!sv_client->download)
return;
r = sv_client->downloadsize - sv_client->downloadcount;
if(r > 1024)
r = 1024;
MSG_WriteByte(&sv_client->netchan.message, svc_download);
MSG_WriteShort(&sv_client->netchan.message, r);
sv_client->downloadcount += r;
size = sv_client->downloadsize;
if(!size)
size = 1;
percent = sv_client->downloadcount * 100 / size;
MSG_WriteByte(&sv_client->netchan.message, percent);
SZ_Write(&sv_client->netchan.message,
sv_client->download + sv_client->downloadcount - r, r);
if(sv_client->downloadcount != sv_client->downloadsize)
return;
FS_FreeFile(sv_client->download);
sv_client->download = NULL;
}
/*
==================
SV_NextDownload_f
==================
*/
static void SV_NextDownload_f (void)
{
byte buffer[1024];
int r;
int percent;
int size;
if (!host_client->download)
return;
r = host_client->downloadsize - host_client->downloadcount;
if (r > 1024)
r = 1024;
r = fread (buffer, 1, r, host_client->download);
MSG_WriteByte (&host_client->netchan.message, svc_download);
MSG_WriteShort (&host_client->netchan.message, r);
host_client->downloadcount += r;
size = host_client->downloadsize;
if (!size)
size = 1;
percent = host_client->downloadcount*100/size;
MSG_WriteByte (&host_client->netchan.message, percent);
SZ_Write (&host_client->netchan.message, buffer, r);
if (host_client->downloadcount != host_client->downloadsize)
return;
fclose (host_client->download);
host_client->download = NULL;
}
/**
* @brief Adds command text immediately after the current command
* @note Adds a @c \\n to the text
* @todo actually change the command buffer to do less copying
*/
void Cbuf_InsertText (const char *text)
{
char *temp;
int templen;
if (!text || !*text)
return;
/* copy off any commands still remaining in the exec buffer */
templen = cmd_text.cursize;
if (templen) {
temp = (char *)Mem_Alloc(templen);
memcpy(temp, cmd_text.data, templen);
SZ_Clear(&cmd_text);
} else
temp = NULL; /* shut up compiler */
/* add the entire text of the file */
Cbuf_AddText(text);
/* add the copied off data */
if (templen) {
SZ_Write(&cmd_text, temp, templen);
Mem_Free(temp);
}
}
void CConsole::AddCommandToHead(char *sCommand)
{
char *temp;
int templen;
// skopiuj wszystkie czekajace komendy
templen = m_CmdText.cursize;
if ( templen )
{
temp = (char *)new char[ templen ];
memcpy( temp, m_CmdText.data, templen );
SZ_Clear( &m_CmdText );
}
else
temp = NULL;
// najpier dodajemy zadana komende
AddCommand( sCommand );
// a potem skopiowana reszte
if (templen)
{
SZ_Write( &m_CmdText, temp, templen );
delete[] temp;
}
}
/*
* Adds command text immediately after the current command
* Adds a \n to the text
*/
void
Cbuf_InsertText(char *text)
{
char *temp;
int templen;
/* copy off any commands still remaining in the exec buffer */
templen = cmd_text.cursize;
if (templen)
{
temp = Z_Malloc(templen);
memcpy(temp, cmd_text.data, templen);
SZ_Clear(&cmd_text);
}
else
{
temp = NULL;
}
/* add the entire text of the file */
Cbuf_AddText(text);
/* add the copied off data */
if (templen)
{
SZ_Write(&cmd_text, temp, templen);
Z_Free(temp);
}
}
/*
============
Cbuf_AddText
Adds command text at the end of the buffer
============
*/
void EXPORT Cbuf_AddText (const char *text)
{
int l;
if (!text[0])
return;
l = (int)strlen (text);
/* if (commandsource == pendingcommands[pendingcommandindex].source)
cmd_text = pendingcommands[pendingcommandindex].buffer;
else
pendingcommandindex++;
if (pendingcommandindex == MAX_PENDING_BUFFERS-1)
{
Com_Printf ("Cbuf_AddText: no free buffers\n", LOG_GENERAL);
return;
}
*/
if (cmd_text.cursize + l >= cmd_text.maxsize)
{
Com_Printf ("Cbuf_AddText: overflow\n", LOG_GENERAL);
return;
}
SZ_Write (&cmd_text, text, l);
//Com_DPrintf ("Wrote %d bytes to cmd_text: %s\n", l, text);
}
int Loop_GetMessage (qsocket_t *sock)
{
int ret;
int length;
if (sock->receiveMessageLength == 0)
return 0;
ret = sock->receiveMessage[0];
length = sock->receiveMessage[1] + (sock->receiveMessage[2] << 8);
// alignment byte skipped here
SZ_Clear (&net_message);
SZ_Write (&net_message, &sock->receiveMessage[4], length);
length = IntAlign(length + 4);
sock->receiveMessageLength -= length;
if (sock->receiveMessageLength)
Q_memcpy(sock->receiveMessage, &sock->receiveMessage[length], sock->receiveMessageLength);
if (sock->driverdata && ret == 1)
((qsocket_t *)sock->driverdata)->canSend = TRUE;
return ret;
}
void MSG_WriteBuf(sizebuf_t *sb, int len, const void *buf) {
if(buf == NULL) {
Con_Printf("MSG_WriteBuf: Passed null buffer");
return;
}
SZ_Write(sb, buf, len);
}
//
// SV_AcknowledgePacket
//
void SV_AcknowledgePacket(player_t &player)
{
client_t *cl = &player.client;
int sequence = MSG_ReadLong();
cl->compressor.packet_acked(sequence);
// packet is missed
if (sequence - cl->last_sequence > 1)
{
// resend
for (int seq = cl->last_sequence+1; seq < sequence; seq++)
{
int n;
bool needfullupdate = true;
for (n=0; n<256; n++)
if (cl->packetseq[n] == seq)
{
needfullupdate = false;
break;
}
if (needfullupdate)
{
// do full update
Printf(PRINT_HIGH, "need full update\n");
cl->last_sequence = sequence;
return;
}
MSG_WriteMarker(&cl->reliablebuf, svc_missedpacket);
MSG_WriteLong(&cl->reliablebuf, seq);
MSG_WriteShort(&cl->reliablebuf, cl->packetsize[n]);
if (cl->packetsize[n])
SZ_Write (&cl->reliablebuf, cl->relpackets.data,
cl->packetbegin[n], cl->packetsize[n]);
if (cl->reliablebuf.overflowed)
{
// do full update
Printf(PRINT_HIGH, "reliablebuf overflowed, need full update\n");
cl->last_sequence = sequence;
return;
}
if (cl->reliablebuf.cursize > 600)
SV_SendPacket(player);
}
}
cl->last_sequence = sequence;
}
/*
============
Cbuf_AddText
Adds command text at the end of the buffer
============
*/
void Cbuf_AddText(const char * text)
{
int l;
l = strlen(text);
if (cmd_text.cursize + l >= cmd_text.maxsize)
{
Com_Printf("Cbuf_AddText: overflow\n");
return;
}
SZ_Write(&cmd_text, text, strlen(text));
}
// As new commands are generated from the console or keybindings,
// the text is added to the end of the command buffer.
void Cbuf_AddText(char *text)
{
int len = Q_strlen(text);
if (cmd_text.cursize + len >= cmd_text.maxsize)
{
Con_Printf(__FUNCTION__ ": overflow\n");
return;
}
SZ_Write(&cmd_text, text, len);
}
/*
* Sends an out-of-band datagram
*/
void
Netchan_OutOfBand ( q_int32_t net_socket, netadr_t adr, q_int32_t 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 );
}
/*
============
Cbuf_AddText
Adds command text at the end of the buffer
============
*/
void Cbuf_AddText (const char *text)
{
int l;
l = strlen (text);
if (cmd_text.cursize + l >= cmd_text.maxsize)
{
Con_Printf ("%s: overflow\n", __thisfunc__);
return;
}
SZ_Write (&cmd_text, text, l);
}
/* <5c15> ../engine/cmd.c:1181 */
qboolean Cmd_ForwardToServerInternal(sizebuf_t *pBuf)
{
const char *cmd_name = Cmd_Argv(0);
if (g_pcls.state <= ca_disconnected)
{
if (Q_stricmp(cmd_name, "setinfo"))
{
Con_Printf("Can't \"%s\", not connected\n", cmd_name);
}
return FALSE;
}
if (g_pcls.demoplayback || g_bIsDedicatedServer)
{
return FALSE;
}
char tempData[4096];
sizebuf_t tempBuf;
tempBuf.buffername = __FUNCTION__ "::tempBuf";
tempBuf.data = (byte *)tempData;
tempBuf.maxsize = 4096;
tempBuf.cursize = 0;
tempBuf.flags = SIZEBUF_ALLOW_OVERFLOW;
MSG_WriteByte(&tempBuf, clc_stringcmd);
if (Q_stricmp(cmd_name, "cmd"))
{
SZ_Print(&tempBuf, cmd_name);
SZ_Print(&tempBuf, " ");
}
SZ_Print(&tempBuf, Cmd_Argc() <= 1 ? "\n" : Cmd_Args());
if (tempBuf.flags & SIZEBUF_OVERFLOWED)
{
return FALSE;
}
if (tempBuf.cursize + pBuf->cursize <= pBuf->maxsize)
{
SZ_Write(pBuf, tempBuf.data, tempBuf.cursize);
return TRUE;
}
return FALSE;
}
/*
-----------------------------------------------------------------------------
Function: Cbuf_AddText -Adds command text at the end of the buffer.
Parameters: text -[in] Ponter to NUL-terminated string.
Returns: Nothing.
Notes:
-----------------------------------------------------------------------------
*/
PUBLIC void Cbuf_AddText( const char *text )
{
W32 length;
length = strlen( text );
if( cmd_text.cursize + length >= cmd_text.maxsize )
{
Com_Printf( "Cbuf_AddText: overflow\n" );
return;
}
SZ_Write( &cmd_text, (void *)text, length );
}
/*
===============
Netchan_OutOfBandProxy
Sends an out-of-band datagram
================
*/
void Netchan_OutOfBandProxy (netsrc_t net_socket, netadr_t *adr, int length, const byte *data)
{
sizebuf_t send;
byte send_buf[MAX_MSGLEN];
//byte send_buf[MAX_MSGLEN*4+32];
// write the packet header
SZ_Init (&send, send_buf, sizeof(send_buf));
SZ_WriteLong (&send, -2); // -1 sequence means out of band
SZ_Write (&send, data, length);
// send the datagram
NET_SendPacket (net_socket, send.cursize, send.data, adr);
}
void CConsole::AddCommand(char *sCommand)
{
int l;
l = strlen (sCommand);
// jesli overflow, napisz w konsoli
if (m_CmdText.cursize + l >= m_CmdText.maxsize)
{
//Con_Printf ("Cbuf_AddText: overflow");
return;
}
// dodaj na koniec
SZ_Write( &m_CmdText, sCommand, strlen (sCommand) );
}
void SV_AddToReliable (client_t *cl, const byte *data, int size)
{
/* +1 is so that there's always space for the disconnect message (FIXME) */
if (!cl->num_backbuf &&
cl->netchan.message.cursize + size + 1 <= cl->netchan.message.maxsize)
{
// it will fit into the current message
SZ_Write (&cl->netchan.message, data, size);
}
else
{
// save it for next
SV_AddToBackbuf (cl, data, size);
}
}
static void
Host_PreSpawn_f (void)
{
if (cmd_source == src_command) {
Sys_Printf ("prespawn is not valid from the console\n");
return;
}
if (host_client->spawned) {
Sys_Printf ("prespawn not valid -- already spawned\n");
return;
}
SZ_Write (&host_client->message, sv.signon.data, sv.signon.cursize);
MSG_WriteByte (&host_client->message, svc_signonnum);
MSG_WriteByte (&host_client->message, 2);
host_client->sendsignon = true;
}
/* <4f05> ../engine/cmd.c:148 */
void Cbuf_InsertTextLines(char *text)
{
int addLen = Q_strlen(text);
int currLen = cmd_text.cursize;
if (cmd_text.cursize + addLen + 2 >= cmd_text.maxsize)
{
Con_Printf(__FUNCTION__ ": overflow\n");
return;
}
#ifdef REHLDS_FIXES
if (currLen)
Q_memmove(cmd_text.data + addLen + 1, cmd_text.data, currLen);
cmd_text.data[0] = '\n'; // TODO: Why we need leading \n, if there is no commands in the start?
Q_memcpy(&cmd_text.data[1], text, addLen);
cmd_text.data[addLen + 1] = '\n';
cmd_text.cursize += addLen + 2;
#else
char *temp = NULL;
if (currLen)
{
temp = (char *)Z_Malloc(currLen);
Q_memcpy(temp, cmd_text.data, currLen);
SZ_Clear(&cmd_text);
}
Cbuf_AddText("\n"); // TODO: Why we need leading \n, if there is no commands in the start?
Cbuf_AddText(text);
Cbuf_AddText("\n");
if (currLen)
{
SZ_Write(&cmd_text, temp, currLen);
Z_Free(temp);
}
#endif // REHLDS_FIXES
}
/*
Netchan_OutOfBand
Sends an out-of-band datagram
*/
void
Netchan_OutOfBand (netadr_t adr, int length, byte * data)
{
byte send_buf[MAX_MSGLEN + PACKET_HEADER];
sizebuf_t send;
// write the packet header
send.data = send_buf;
send.maxsize = sizeof (send_buf);
send.cursize = 0;
MSG_WriteLong (&send, -1); // -1 sequence means out of band
SZ_Write (&send, data, length);
// send the datagram
// zoid, no input in demo playback mode
if (!net_blocksend)
Netchan_SendPacket (send.cursize, send.data, adr);
}
/* <66786> ../engine/net_chan.c:1723 */
qboolean Netchan_CopyNormalFragments(netchan_t *chan)
{
fragbuf_t *p, *n;
if (!chan->incomingready[FRAG_NORMAL_STREAM])
return FALSE;
if (!chan->incomingbufs[FRAG_NORMAL_STREAM])
{
Con_Printf("Netchan_CopyNormalFragments: Called with no fragments readied\n");
chan->incomingready[FRAG_NORMAL_STREAM] = FALSE;
return FALSE;
}
p = chan->incomingbufs[FRAG_NORMAL_STREAM];
SZ_Clear(&net_message);
MSG_BeginReading();
while (p)
{
n = p->next;
SZ_Write(&net_message, p->frag_message.data, p->frag_message.cursize);
Mem_Free(p);
p = n;
}
if (*(uint32 *)net_message.data == MAKEID('B', 'Z', '2', '\0'))
{
char uncompressed[65536];
unsigned int uncompressedSize = 65536;
BZ2_bzBuffToBuffDecompress(uncompressed, &uncompressedSize, (char*)net_message.data + 4, net_message.cursize - 4, 1, 0);
Q_memcpy(net_message.data, uncompressed, uncompressedSize);
net_message.cursize = uncompressedSize;
}
chan->incomingbufs[FRAG_NORMAL_STREAM] = NULL;
chan->incomingready[FRAG_NORMAL_STREAM] = false;
return TRUE;
}
static void
write_msg (sizebuf_t *msg, int type, int to, float time, sizebuf_t *dst)
{
int msec;
static double prevtime;
msec = (time - prevtime) * 1000;
prevtime += msec * 0.001;
if (msec > 255)
msec = 255;
if (msec < 2)
msec = 0;
MSG_WriteByte (dst, msec);
if (rec.lasttype != type || rec.lastto != to) {
rec.lasttype = type;
rec.lastto = to;
switch (rec.lasttype) {
case dem_all:
MSG_WriteByte (dst, dem_all);
break;
case dem_multiple:
MSG_WriteByte (dst, dem_multiple);
MSG_WriteLong (dst, rec.lastto);
break;
case dem_single:
case dem_stats:
MSG_WriteByte (dst, rec.lasttype | (rec.lastto << 3));
break;
default:
while (sv.recorders)
SVR_RemoveUser (sv.recorders);
Sys_Printf ("bad demo message type:%d", type);
return;
}
} else {
MSG_WriteByte (dst, dem_read);
}
MSG_WriteLong (dst, msg->cursize);
SZ_Write (dst, msg->data, msg->cursize);
}
void Netchan_OutOfBand(netsrc_t sock, netadr_t adr, int length, byte *data)
{
sizebuf_t send;
byte send_buf[NET_MAX_PAYLOAD];
send.buffername = "Netchan_OutOfBand";
send.data = send_buf;
send.maxsize = sizeof(send_buf);
send.cursize = 0;
send.flags = SIZEBUF_ALLOW_OVERFLOW;
MSG_WriteLong(&send, -1);
SZ_Write(&send, data, length);
if (!g_pcls.demoplayback)
{
NET_SendPacket(sock, send.cursize, send.data, adr);
}
}
// Sends resource to all other players, optionally skipping originating player.
void SV_Customization(client_t *pPlayer, resource_t *pResource, qboolean bSkipPlayer)
{
int i;
int nPlayerNumber;
client_t *pHost;
// Get originating player id
for (i = 0, pHost = g_psvs.clients; i < g_psvs.maxclients; i++, pHost++)
{
if (pHost == pPlayer)
break;
}
if (i == g_psvs.maxclients)
{
Sys_Error("Couldn't find player index for customization.");
}
nPlayerNumber = i;
// Send resource to all other active players
for (i = 0, pHost = g_psvs.clients; i < g_psvs.maxclients; i++, pHost++)
{
if (!pHost->active && !pHost->spawned || pHost->fakeclient)
continue;
if (pHost == pPlayer && bSkipPlayer)
continue;
MSG_WriteByte(&pHost->netchan.message, svc_customization);
MSG_WriteByte(&pHost->netchan.message, nPlayerNumber);
MSG_WriteByte(&pHost->netchan.message, pResource->type);
MSG_WriteString(&pHost->netchan.message, pResource->szFileName);
MSG_WriteShort(&pHost->netchan.message, pResource->nIndex);
MSG_WriteLong(&pHost->netchan.message, pResource->nDownloadSize);
MSG_WriteByte(&pHost->netchan.message, pResource->ucFlags);
if (pResource->ucFlags & RES_CUSTOM)
{
SZ_Write(&pHost->netchan.message, pResource->rgucMD5_hash, 16);
}
}
}
/**
* @brief Adds command text at the end of the buffer
* @note Normally when a command is generate from the console or keyBindings, it will be added to the end of the command buffer.
*/
void Cbuf_AddText (const char *text)
{
int l;
if (cmdClosed) {
text = strstr(text, "cmdopen");
if (text == NULL) {
Com_DPrintf(DEBUG_COMMANDS, "Cbuf_AddText: currently closed\n");
return;
}
}
l = strlen(text);
if (cmd_text.cursize + l >= cmd_text.maxsize) {
Com_Printf("Cbuf_AddText: overflow (%i) (%s)\n", cmd_text.maxsize, text);
Com_Printf("buffer content: %s\n", cmd_text_buf);
return;
}
SZ_Write(&cmd_text, text, l);
}
/*
===============
Netchan_OutOfBand
Sends an out-of-band datagram
================
*/
void Netchan_OutOfBand(int s, struct sockaddr_in *adr, int length, byte *data)
{
sizebuf_t send1;
byte send_buf[MAX_MSGLEN + PACKET_HEADER];
SZ_InitEx(&send1, send_buf, sizeof(send_buf), true);
// write the packet header
MSG_WriteLong(&send1, -1); // -1 sequence means out of band
// write data
SZ_Write(&send1, data, length);
if (send1.overflowed)
{
Sys_Printf("Netchan_OutOfBand: overflowed\n");
return; // ah, should not happens
}
// send the datagram
NET_SendPacket(s, send1.cursize, send1.data, adr);
}
