cvar_t developer_networking = {0, "developer_networking", "0", "prints all received and sent packets (recommended only for debugging)"};
cvar_t cl_netlocalping = {0, "cl_netlocalping","0", "lags local loopback connection by this much ping time (useful to play more fairly on your own server with people with higher pings)"};
-static cvar_t cl_netpacketloss = {0, "cl_netpacketloss","0", "drops this percentage of packets (incoming and outgoing), useful for testing network protocol robustness (effects failing to start, sounds failing to play, etc)"};
+static cvar_t cl_netpacketloss_send = {0, "cl_netpacketloss_send","0", "drops this percentage of outgoing packets, useful for testing network protocol robustness (jerky movement, prediction errors, etc)"};
+static cvar_t cl_netpacketloss_receive = {0, "cl_netpacketloss_receive","0", "drops this percentage of incoming packets, useful for testing network protocol robustness (jerky movement, effects failing to start, sounds failing to play, etc)"};
static cvar_t net_slist_queriespersecond = {0, "net_slist_queriespersecond", "20", "how many server information requests to send per second"};
static cvar_t net_slist_queriesperframe = {0, "net_slist_queriesperframe", "4", "maximum number of server information requests to send each rendered frame (guards against low framerates causing problems)"};
static cvar_t net_slist_timeout = {0, "net_slist_timeout", "4", "how long to listen for a server information response before giving up"};
case SLIF_NUMHUMANS:
result = A->info.numhumans - B->info.numhumans;
break;
+ case SLIF_FREESLOTS:
+ result = A->info.freeslots - B->info.freeslots;
+ break;
case SLIF_PROTOCOL:
result = A->info.protocol - B->info.protocol;
break;
return false;
if( !_ServerList_CompareInt( info->numhumans, mask->tests[SLIF_NUMHUMANS], mask->info.numhumans ) )
return false;
+ if( !_ServerList_CompareInt( info->freeslots, mask->tests[SLIF_FREESLOTS], mask->info.freeslots ) )
+ return false;
if( !_ServerList_CompareInt( info->protocol, mask->tests[SLIF_PROTOCOL], mask->info.protocol ))
return false;
if( *mask->info.cname
int i;
if (length == 0)
return 0;
- if (cl_netpacketloss.integer)
+ if (cl_netpacketloss_receive.integer)
for (i = 0;i < cl_numsockets;i++)
- if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss.integer)
+ if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_receive.integer)
return 0;
if (developer_networking.integer)
{
{
int ret;
int i;
- if (cl_netpacketloss.integer)
+ if (cl_netpacketloss_send.integer)
for (i = 0;i < cl_numsockets;i++)
- if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss.integer)
+ if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_send.integer)
return length;
ret = LHNET_Write(mysocket, data, length, peeraddress);
if (developer_networking.integer)
}
}
-int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate)
+int NetConn_SendUnreliableMessage(netconn_t *conn, sizebuf_t *data, protocolversion_t protocol, int rate, qboolean quakesignon_suppressreliables)
{
int totallen = 0;
packetsSent++;
unreliableMessagesSent++;
- totallen += packetLen + 18;
+ totallen += packetLen + 28;
}
else
{
packetsReSent++;
}
- totallen += packetLen + 18;
+ totallen += packetLen + 28;
}
// if we have a new reliable message to send, do so
- if (!conn->sendMessageLength && conn->message.cursize)
+ if (!conn->sendMessageLength && conn->message.cursize && !quakesignon_suppressreliables)
{
if (conn->message.cursize > (int)sizeof(conn->sendMessage))
{
packetsSent++;
reliableMessagesSent++;
- totallen += packetLen + 18;
+ totallen += packetLen + 28;
}
// if we have an unreliable message to send, do so
- //if (data->cursize)
+ if (data->cursize)
{
packetLen = NET_HEADERSIZE + data->cursize;
packetsSent++;
unreliableMessagesSent++;
- if (data->cursize)
- totallen += packetLen + 18;
+ totallen += packetLen + 28;
}
}
return 0;
}
+qboolean NetConn_HaveClientPorts(void)
+{
+ return !!cl_numsockets;
+}
+
+qboolean NetConn_HaveServerPorts(void)
+{
+ return !!sv_numsockets;
+}
+
void NetConn_CloseClientPorts(void)
{
for (;cl_numsockets > 0;cl_numsockets--)
if (length < 8)
return 0;
- // TODO: add netgraph stuff rather than just packetloss counting...
-
if (protocol == PROTOCOL_QUAKEWORLD)
{
int sequence, sequence_ack;
cls.signon = 0; // need all the signon messages before playing
cls.protocol = initialprotocol;
// reset move sequence numbering on this new connection
- cls.movesequence = 0;
+ cls.movesequence = 1;
cls.servermovesequence = 0;
if (cls.protocol == PROTOCOL_QUAKEWORLD)
Cmd_ForwardStringToServer("new");
msg.data = buf;
msg.maxsize = sizeof(buf);
MSG_WriteChar(&msg, clc_nop);
- NetConn_SendUnreliableMessage(cls.netcon, &msg, cls.protocol, 10000);
+ NetConn_SendUnreliableMessage(cls.netcon, &msg, cls.protocol, 10000, false);
}
}
if ((s = SearchInfostring(string, "sv_maxclients")) != NULL) info->maxplayers = atoi(s);
if ((s = SearchInfostring(string, "gameversion" )) != NULL) info->gameversion = atoi(s);
info->numhumans = info->numplayers - max(0, info->numbots);
+ info->freeslots = info->maxplayers - info->numplayers;
NetConn_ClientParsePacket_ServerList_UpdateCache(n);
while (cl_sockets[i] && (length = NetConn_Read(cl_sockets[i], readbuffer, sizeof(readbuffer), &peeraddress)) > 0)
NetConn_ClientParsePacket(cl_sockets[i], readbuffer, length, &peeraddress);
NetConn_QueryQueueFrame();
- if (cls.netcon && realtime > cls.netcon->timeout)
+ if (cls.netcon && realtime > cls.netcon->timeout && !sv.active)
{
Con_Print("Connection timed out\n");
CL_Disconnect();
{
int i;
char *s = string + 5;
+ char *endpos = string + length + 1; // one behind the NUL, so adding strlen+1 will eventually reach it
char password[64];
for (i = 0;*s > ' ';s++)
if (i < (int)sizeof(password) - 1)
password[i++] = *s;
+ if(*s <= ' ' && s != endpos) // skip leading ugly space
+ ++s;
password[i] = 0;
if (password[0] > ' ' && !strcmp(rcon_password.string, password))
{
// looks like a legitimate rcon command with the correct password
- Con_Printf("server received rcon command from %s:\n%s\n", host_client ? host_client->name : addressstring2, s);
+ char *s_ptr = s;
+ Con_Printf("server received rcon command from %s:\n", host_client ? host_client->name : addressstring2);
+ while(s_ptr != endpos)
+ {
+ size_t l = strlen(s_ptr);
+ if(l)
+ Con_Printf(" %s;", s_ptr);
+ s_ptr += l + 1;
+ }
+ Con_Printf("\n");
rcon_redirect = true;
rcon_redirect_bufferpos = 0;
- Cmd_ExecuteString(s, src_command);
+ while(s != endpos)
+ {
+ size_t l = strlen(s);
+ if(l)
+ Cmd_ExecuteString(s, src_command);
+ s += l + 1;
+ }
rcon_redirect_buffer[rcon_redirect_bufferpos] = 0;
rcon_redirect = false;
// print resulting text to client
// protocol
// (this protects more modern protocols against being used for
// Quake packet flood Denial Of Service attacks)
- if (length >= 5 && (i = BigLong(*((int *)data))) && (i & (~NETFLAG_LENGTH_MASK)) == (int)NETFLAG_CTL && (i & NETFLAG_LENGTH_MASK) == length && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3))
+ if (length >= 5 && (i = BigLong(*((int *)data))) && (i & (~NETFLAG_LENGTH_MASK)) == (int)NETFLAG_CTL && (i & NETFLAG_LENGTH_MASK) == length && (sv.protocol == PROTOCOL_QUAKE || sv.protocol == PROTOCOL_QUAKEDP || sv.protocol == PROTOCOL_NEHAHRAMOVIE || sv.protocol == PROTOCOL_NEHAHRABJP || sv.protocol == PROTOCOL_NEHAHRABJP2 || sv.protocol == PROTOCOL_NEHAHRABJP3 || sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3))
{
int c;
int protocolnumber;
Cvar_RegisterVariable(&net_connecttimeout);
Cvar_RegisterVariable(&net_connectfloodblockingtimeout);
Cvar_RegisterVariable(&cl_netlocalping);
- Cvar_RegisterVariable(&cl_netpacketloss);
+ Cvar_RegisterVariable(&cl_netpacketloss_send);
+ Cvar_RegisterVariable(&cl_netpacketloss_receive);
Cvar_RegisterVariable(&hostname);
Cvar_RegisterVariable(&developer_networking);
Cvar_RegisterVariable(&cl_netport);