{CVAR_SAVE, "sv_master2", ""},
{CVAR_SAVE, "sv_master3", ""},
{CVAR_SAVE, "sv_master4", ""},
- {0, "sv_masterextra1", "69.59.212.88"},
+ {0, "sv_masterextra1", "ghdigital.com"},
+ {0, "sv_masterextra2", "dpmaster.deathmask.net"},
{0, NULL, NULL}
};
cvar_t hostname = {CVAR_SAVE, "hostname", "UNNAMED"};
cvar_t developer_networking = {0, "developer_networking", "0"};
-cvar_t cl_fakelocalping_min = {0, "cl_fakelocalping_min","0"};
-cvar_t cl_fakelocalping_max = {0, "cl_fakelocalping_max","0"};
-static cvar_t cl_fakepacketloss_receive = {0, "cl_fakepacketloss_receive","0"};
-static cvar_t cl_fakepacketloss_send = {0, "cl_fakepacketloss_send","0"};
-static cvar_t sv_fakepacketloss_receive = {0, "sv_fakepacketloss_receive","0"};
-static cvar_t sv_fakepacketloss_send = {0, "sv_fakepacketloss_send","0"};
+cvar_t cl_netlocalping_min = {0, "cl_netlocalping_min","0"};
+cvar_t cl_netlocalping_max = {0, "cl_netlocalping_max","0"};
+static cvar_t cl_netpacketloss_receive = {0, "cl_netpacketloss_receive","0"};
+static cvar_t cl_netpacketloss_send = {0, "cl_netpacketloss_send","0"};
+static cvar_t sv_netpacketloss_receive = {0, "sv_netpacketloss_receive","0"};
+static cvar_t sv_netpacketloss_send = {0, "sv_netpacketloss_send","0"};
/* statistic counters */
int hostCacheCount = 0;
hostcache_t hostcache[HOSTCACHESIZE];
-static qbyte sendbuffer[NET_MAXMESSAGE];
-static qbyte readbuffer[NET_MAXMESSAGE];
+static qbyte sendbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
+static qbyte readbuffer[NET_HEADERSIZE+NET_MAXMESSAGE];
int cl_numsockets;
lhnetsocket_t *cl_sockets[16];
mempool_t *netconn_mempool = NULL;
cvar_t cl_netport = {0, "cl_port", "0"};
-cvar_t cl_netaddress = {0, "cl_netaddress", "0.0.0.0"};
-cvar_t cl_netaddress_ipv6 = {0, "cl_netaddress_ipv6", "[0:0:0:0:0:0:0:0]:0"};
-
cvar_t sv_netport = {0, "port", "26000"};
-cvar_t sv_netaddress = {0, "sv_netaddress", "0.0.0.0"};
-cvar_t sv_netaddress_ipv6 = {0, "sv_netaddress_ipv6", "[0:0:0:0:0:0:0:0]:26000"};
+cvar_t net_address = {0, "net_address", "0.0.0.0"};
+//cvar_t net_netaddress_ipv6 = {0, "net_address_ipv6", "[0:0:0:0:0:0:0:0]"};
int NetConn_Read(lhnetsocket_t *mysocket, void *data, int maxlength, lhnetaddress_t *peeraddress)
{
int length = LHNET_Read(mysocket, data, maxlength, peeraddress);
int i;
- if (cl_fakepacketloss_receive.integer)
+ if (cl_netpacketloss_receive.integer)
for (i = 0;i < cl_numsockets;i++)
- if (cl_sockets[i] == mysocket && (rand() % 100) < cl_fakepacketloss_receive.integer)
+ if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_receive.integer)
return 0;
- if (sv_fakepacketloss_receive.integer)
+ if (sv_netpacketloss_receive.integer)
for (i = 0;i < cl_numsockets;i++)
- if (sv_sockets[i] == mysocket && (rand() % 100) < sv_fakepacketloss_receive.integer)
+ if (sv_sockets[i] == mysocket && (rand() % 100) < sv_netpacketloss_receive.integer)
return 0;
if (developer_networking.integer && length != 0)
{
{
int ret;
int i;
- if (cl_fakepacketloss_send.integer)
+ if (cl_netpacketloss_send.integer)
for (i = 0;i < cl_numsockets;i++)
- if (cl_sockets[i] == mysocket && (rand() % 100) < cl_fakepacketloss_send.integer)
+ if (cl_sockets[i] == mysocket && (rand() % 100) < cl_netpacketloss_send.integer)
return length;
- if (sv_fakepacketloss_send.integer)
+ if (sv_netpacketloss_send.integer)
for (i = 0;i < cl_numsockets;i++)
- if (sv_sockets[i] == mysocket && (rand() % 100) < sv_fakepacketloss_send.integer)
+ if (sv_sockets[i] == mysocket && (rand() % 100) < sv_netpacketloss_send.integer)
return length;
ret = LHNET_Write(mysocket, data, length, peeraddress);
if (developer_networking.integer)
if (data->cursize == 0)
Sys_Error("Datagram_SendMessage: zero length message\n");
- if (data->cursize > NET_MAXMESSAGE)
- Sys_Error("Datagram_SendMessage: message too big %u\n", data->cursize);
+ if (data->cursize > (int)sizeof(conn->sendMessage))
+ Sys_Error("Datagram_SendMessage: message too big (%u > %u)\n", data->cursize, sizeof(conn->sendMessage));
if (conn->canSend == false)
Sys_Error("SendMessage: called with canSend == false\n");
header = (void *)sendbuffer;
header[0] = BigLong(packetLen | (NETFLAG_DATA | eom));
header[1] = BigLong(conn->sendSequence);
- memcpy(sendbuffer + 8, conn->sendMessage, dataLen);
+ memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
conn->sendSequence++;
conn->canSend = false;
header = (void *)sendbuffer;
header[0] = BigLong(packetLen | (NETFLAG_DATA | eom));
header[1] = BigLong(conn->sendSequence);
- memcpy(sendbuffer + 8, conn->sendMessage, dataLen);
+ memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
conn->sendSequence++;
conn->sendNext = false;
header = (void *)sendbuffer;
header[0] = BigLong(packetLen | (NETFLAG_DATA | eom));
header[1] = BigLong(conn->sendSequence - 1);
- memcpy(sendbuffer + 8, conn->sendMessage, dataLen);
+ memcpy(sendbuffer + NET_HEADERSIZE, conn->sendMessage, dataLen);
conn->sendNext = false;
int packetLen;
int *header;
-#ifdef DEBUG
+ packetLen = NET_HEADERSIZE + data->cursize;
+
+//#ifdef DEBUG
if (data->cursize == 0)
Sys_Error("Datagram_SendUnreliableMessage: zero length message\n");
- if (data->cursize > MAX_DATAGRAM)
+ if (packetLen > (int)sizeof(sendbuffer))
Sys_Error("Datagram_SendUnreliableMessage: message too big %u\n", data->cursize);
-#endif
-
- packetLen = NET_HEADERSIZE + data->cursize;
+//#endif
header = (void *)sendbuffer;
header[0] = BigLong(packetLen | NETFLAG_UNRELIABLE);
header[1] = BigLong(conn->unreliableSendSequence);
- memcpy(sendbuffer + 8, data->data, data->cursize);
+ memcpy(sendbuffer + NET_HEADERSIZE, data->data, data->cursize);
conn->unreliableSendSequence++;
if (cl_netport.integer != port)
Cvar_SetValueQuick(&cl_netport, port);
Con_Printf("Client using port %i\n", port);
- NetConn_OpenClientPort("local", port);
- NetConn_OpenClientPort(cl_netaddress.string, port);
- NetConn_OpenClientPort(cl_netaddress_ipv6.string, port);
+ NetConn_OpenClientPort("local:2", 0);
+ NetConn_OpenClientPort(net_address.string, port);
+ //NetConn_OpenClientPort(net_address_ipv6.string, port);
}
void NetConn_CloseServerPorts(void)
if (sv_netport.integer != port)
Cvar_SetValueQuick(&sv_netport, port);
if (cls.state != ca_dedicated)
- NetConn_OpenServerPort("local", port);
+ NetConn_OpenServerPort("local:1", 0);
if (opennetports)
{
- NetConn_OpenServerPort(sv_netaddress.string, port);
- NetConn_OpenServerPort(sv_netaddress_ipv6.string, port);
+ NetConn_OpenServerPort(net_address.string, port);
+ //NetConn_OpenServerPort(net_address_ipv6.string, port);
}
if (sv_numsockets == 0)
Host_Error("NetConn_OpenServerPorts: unable to open any ports!\n");
conn = Mem_Alloc(netconn_mempool, sizeof(*conn));
conn->mysocket = mysocket;
conn->peeraddress = *peeraddress;
+ // updated by receiving "rate" command from client
+ conn->rate = NET_MINRATE;
+ // no limits for local player
+ if (LHNETADDRESS_GetAddressType(peeraddress) == LHNETADDRESSTYPE_LOOP)
+ conn->rate = 1000000000;
conn->canSend = true;
conn->connecttime = realtime;
conn->lastMessageTime = realtime;
{
clientport2 = cl_netport.integer;
if (cls.state == ca_connected)
- Con_Printf("Changing \"cl_port\" will not take effect until you reconnect.\n");
+ Con_Print("Changing \"cl_port\" will not take effect until you reconnect.\n");
}
if (cls.state == ca_disconnected && clientport != clientport2)
{
{
hostport = sv_netport.integer;
if (sv.active)
- Con_Printf("Changing \"port\" will not take effect until \"map\" command is executed.\n");
+ Con_Print("Changing \"port\" will not take effect until \"map\" command is executed.\n");
}
}
}
}
else
- Con_DPrintf("Got a stale datagram\n");
+ Con_DPrint("Got a stale datagram\n");
return 1;
}
else if (flags & NETFLAG_ACK)
{
conn->ackSequence++;
if (conn->ackSequence != conn->sendSequence)
- Con_DPrintf("ack sequencing error\n");
+ Con_DPrint("ack sequencing error\n");
conn->lastMessageTime = realtime;
conn->timeout = realtime + net_messagetimeout.value;
conn->sendMessageLength -= MAX_PACKETFRAGMENT;
}
}
else
- Con_DPrintf("Duplicate ACK received\n");
+ Con_DPrint("Duplicate ACK received\n");
}
else
- Con_DPrintf("Stale ACK received\n");
+ Con_DPrint("Stale ACK received\n");
return 1;
}
else if (flags & NETFLAG_DATA)
length -= 18;
masterreplycount++;
if (m_state != m_slist)
- Con_Printf("received server list...\n");
+ Con_Print("received server list...\n");
while (length >= 7 && data[0] == '\\' && (data[1] != 0xFF || data[2] != 0xFF || data[3] != 0xFF || data[4] != 0xFF) && data[5] * 256 + data[6] != 0)
{
snprintf (ipstring, sizeof (ipstring), "%u.%u.%u.%u:%u", data[1], data[2], data[3], data[4], (data[5] << 8) | data[6]);
hostcache[n].ping = 100000;
hostcache[n].querytime = realtime;
// build description strings for the things users care about
- snprintf(hostcache[n].line1, sizeof(hostcache[n].line1), "?");
- snprintf(hostcache[n].line2, sizeof(hostcache[n].line2), "%s", ipstring);
+ strlcpy (hostcache[n].line1, "?", sizeof (hostcache[n].line1));
+ strlcpy (hostcache[n].line2, ipstring, sizeof (hostcache[n].line2));
// if not in the slist menu we should print the server to console
if (m_state != m_slist)
Con_Printf("querying %s\n", ipstring);
if (m_state == m_slist)
strcpy (m_return_reason, "Connect: Failed");
else
- Con_Printf("Connect failed\n");
+ Con_Print("Connect failed\n");
return;
}
if (cls.connect_nextsendtime)
if (m_state == m_slist)
strcpy (m_return_reason, "Connect: Still trying");
else
- Con_Printf("Still trying...\n");
+ Con_Print("Still trying...\n");
}
else
{
if (m_state == m_slist)
strcpy (m_return_reason, "Connect: Trying");
else
- Con_Printf("Trying...\n");
+ Con_Print("Trying...\n");
}
cls.connect_nextsendtime = realtime + 1;
cls.connect_remainingtries--;
NetConn_ClientParsePacket(cl_sockets[i], readbuffer, length, &peeraddress);
if (cls.netcon && realtime > cls.netcon->timeout)
{
- Con_Printf("Connection timed out\n");
+ Con_Print("Connection timed out\n");
CL_Disconnect();
+ Host_ShutdownServer (false);
}
for (conn = netconn_list;conn;conn = conn->next)
NetConn_ReSendMessage(conn);
if (clientnum < svs.maxclients)
{
// prepare the client struct
- if ((client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_clients_mempool)))
+ if ((conn = NetConn_Open(mysocket, peeraddress)))
{
- if ((conn = NetConn_Open(mysocket, peeraddress)))
- {
- // allocated connection
- LHNETADDRESS_ToString(peeraddress, conn->address, sizeof(conn->address), true);
- if (developer.integer)
- Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", conn->address);
- NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
- // now set up the client
- SV_ConnectClient(clientnum, conn);
- NetConn_Heartbeat(1);
- }
- else
- EntityFrame4_FreeDatabase(client->entitydatabase4);
+ // allocated connection
+ LHNETADDRESS_ToString(peeraddress, conn->address, sizeof(conn->address), true);
+ if (developer.integer)
+ Con_Printf("Datagram_ParseConnectionless: sending \"accept\" to %s.\n", conn->address);
+ NetConn_WriteString(mysocket, "\377\377\377\377accept", peeraddress);
+ // now set up the client
+ SV_ConnectClient(clientnum, conn);
+ NetConn_Heartbeat(1);
}
}
else
}
if (!masterquerycount)
{
- Con_Printf("Unable to query master servers, no suitable network sockets active.\n");
+ Con_Print("Unable to query master servers, no suitable network sockets active.\n");
strcpy(m_return_reason, "No network");
}
}
if (sv.active)
NetConn_Heartbeat(2);
else
- Con_Printf("No server running, can not heartbeat to master server.\n");
+ Con_Print("No server running, can not heartbeat to master server.\n");
}
void PrintStats(netconn_t *conn)
Con_Printf("packetsReceived = %i\n", packetsReceived);
Con_Printf("receivedDuplicateCount = %i\n", receivedDuplicateCount);
Con_Printf("droppedDatagrams = %i\n", droppedDatagrams);
- Con_Printf("connections =\n");
+ Con_Print("connections =\n");
for (conn = netconn_list;conn;conn = conn->next)
PrintStats(conn);
}
hostCacheCount = 0;
memset(&pingcache, 0, sizeof(pingcache));
if (m_state != m_slist)
- Con_Printf("Sending requests to master servers\n");
+ Con_Print("Sending requests to master servers\n");
NetConn_QueryMasters();
if (m_state != m_slist)
- Con_Printf("Listening for replies...\n");
+ Con_Print("Listening for replies...\n");
}
void NetConn_Init(void)
{
int i;
lhnetaddress_t tempaddress;
- netconn_mempool = Mem_AllocPool("Networking");
+ netconn_mempool = Mem_AllocPool("Networking", 0, NULL);
Cmd_AddCommand("net_stats", Net_Stats_f);
Cmd_AddCommand("net_slist", Net_Slist_f);
Cmd_AddCommand("heartbeat", Net_Heartbeat_f);
Cvar_RegisterVariable(&net_messagetimeout);
Cvar_RegisterVariable(&net_messagerejointimeout);
Cvar_RegisterVariable(&net_connecttimeout);
- Cvar_RegisterVariable(&cl_fakelocalping_min);
- Cvar_RegisterVariable(&cl_fakelocalping_max);
- Cvar_RegisterVariable(&cl_fakepacketloss_receive);
- Cvar_RegisterVariable(&cl_fakepacketloss_send);
- Cvar_RegisterVariable(&sv_fakepacketloss_receive);
- Cvar_RegisterVariable(&sv_fakepacketloss_send);
+ Cvar_RegisterVariable(&cl_netlocalping_min);
+ Cvar_RegisterVariable(&cl_netlocalping_max);
+ Cvar_RegisterVariable(&cl_netpacketloss_receive);
+ Cvar_RegisterVariable(&cl_netpacketloss_send);
+ Cvar_RegisterVariable(&sv_netpacketloss_receive);
+ Cvar_RegisterVariable(&sv_netpacketloss_send);
Cvar_RegisterVariable(&hostname);
Cvar_RegisterVariable(&developer_networking);
Cvar_RegisterVariable(&cl_netport);
- Cvar_RegisterVariable(&cl_netaddress);
- Cvar_RegisterVariable(&cl_netaddress_ipv6);
Cvar_RegisterVariable(&sv_netport);
- Cvar_RegisterVariable(&sv_netaddress);
- Cvar_RegisterVariable(&sv_netaddress_ipv6);
+ Cvar_RegisterVariable(&net_address);
+ //Cvar_RegisterVariable(&net_address_ipv6);
Cvar_RegisterVariable(&sv_public);
Cvar_RegisterVariable(&sv_heartbeatperiod);
for (i = 0;sv_masters[i].name;i++)
Cvar_RegisterVariable(&sv_masters[i]);
+// COMMANDLINEOPTION: -ip <ipaddress> sets the ip address of this machine for purposes of networking (default 0.0.0.0 also known as INADDR_ANY), use only if you have multiple network adapters and need to choose one specifically.
if ((i = COM_CheckParm("-ip")) && i + 1 < com_argc)
{
if (LHNETADDRESS_FromString(&tempaddress, com_argv[i + 1], 0) == 1)
{
- Con_Printf("-ip option used, setting cl_netaddress and sv_netaddress to address \"%s\"\n");
- Cvar_SetQuick(&cl_netaddress, com_argv[i + 1]);
- Cvar_SetQuick(&sv_netaddress, com_argv[i + 1]);
+ Con_Printf("-ip option used, setting net_address to \"%s\"\n");
+ Cvar_SetQuick(&net_address, com_argv[i + 1]);
}
else
Con_Printf("-ip option used, but unable to parse the address \"%s\"\n", com_argv[i + 1]);
}
+// COMMANDLINEOPTION: -port <portnumber> sets the port to use for a server (default 26000, the same port as QUAKE itself), useful if you host multiple servers on your machine
if (((i = COM_CheckParm("-port")) || (i = COM_CheckParm("-ipport")) || (i = COM_CheckParm("-udpport"))) && i + 1 < com_argc)
{
i = atoi(com_argv[i + 1]);
projects / xonotic / darkplaces.git / blobdiff