2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 // This is enables a simple IP banning mechanism
29 #include <sys/socket.h>
30 #include <arpa/inet.h>
32 #define AF_INET 2 /* internet */
37 struct { unsigned char s_b1,s_b2,s_b3,s_b4; } S_un_b;
38 struct { unsigned short s_w1,s_w2; } S_un_w;
42 #define s_addr S_un.S_addr /* can be used for most tcp & ip code */
46 unsigned short sin_port;
47 struct in_addr sin_addr;
50 char *inet_ntoa(struct in_addr in);
51 unsigned long inet_addr(const char *cp);
57 #include "net_master.h"
59 cvar_t cl_port = {CVAR_SAVE, "cl_port", "0"};
61 // these two macros are to make the code more readable
62 #define sfunc net_landrivers[sock->landriver]
63 #define dfunc net_landrivers[net_landriverlevel]
65 static int net_landriverlevel;
67 /* statistic counters */
69 int packetsReSent = 0;
70 int packetsReceived = 0;
71 int receivedDuplicateCount = 0;
72 int shortPacketCount = 0;
75 static int myDriverLevel;
80 unsigned int sequence;
81 qbyte data[MAX_DATAGRAM];
86 char *StrAddr (struct qsockaddr *addr)
89 qbyte *p = (qbyte *)addr;
92 for (n = 0; n < 16; n++)
93 sprintf (buf + n * 2, "%02x", *p++);
101 unsigned long banAddr = 0x00000000;
102 unsigned long banMask = 0xffffffff;
104 void NET_Ban_f (void)
108 void (*print) (const char *fmt, ...);
110 if (cmd_source == src_command)
114 Cmd_ForwardToServer ();
121 if (pr_global_struct->deathmatch)
123 print = SV_ClientPrintf;
129 if (((struct in_addr *)&banAddr)->s_addr)
131 strcpy(addrStr, inet_ntoa(*(struct in_addr *)&banAddr));
132 strcpy(maskStr, inet_ntoa(*(struct in_addr *)&banMask));
133 print("Banning %s [%s]\n", addrStr, maskStr);
136 print("Banning not active\n");
140 if (strcasecmp(Cmd_Argv(1), "off") == 0)
141 banAddr = 0x00000000;
143 banAddr = inet_addr(Cmd_Argv(1));
144 banMask = 0xffffffff;
148 banAddr = inet_addr(Cmd_Argv(1));
149 banMask = inet_addr(Cmd_Argv(2));
153 print("BAN ip_address [mask]\n");
160 int Datagram_SendMessage (qsocket_t *sock, sizebuf_t *data)
162 unsigned int packetLen;
163 unsigned int dataLen;
167 if (data->cursize == 0)
168 Sys_Error("Datagram_SendMessage: zero length message\n");
170 if (data->cursize > NET_MAXMESSAGE)
171 Sys_Error("Datagram_SendMessage: message too big %u\n", data->cursize);
173 if (sock->canSend == false)
174 Sys_Error("SendMessage: called with canSend == false\n");
177 memcpy(sock->sendMessage, data->data, data->cursize);
178 sock->sendMessageLength = data->cursize;
180 if (data->cursize <= MAX_DATAGRAM)
182 dataLen = data->cursize;
187 dataLen = MAX_DATAGRAM;
190 packetLen = NET_HEADERSIZE + dataLen;
192 packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
193 packetBuffer.sequence = BigLong(sock->sendSequence++);
194 memcpy (packetBuffer.data, sock->sendMessage, dataLen);
196 sock->canSend = false;
198 if (sfunc.Write (sock->socket, (qbyte *)&packetBuffer, packetLen, &sock->addr) == -1)
201 sock->lastSendTime = net_time;
207 int SendMessageNext (qsocket_t *sock)
209 unsigned int packetLen;
210 unsigned int dataLen;
213 if (sock->sendMessageLength <= MAX_DATAGRAM)
215 dataLen = sock->sendMessageLength;
220 dataLen = MAX_DATAGRAM;
223 packetLen = NET_HEADERSIZE + dataLen;
225 packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
226 packetBuffer.sequence = BigLong(sock->sendSequence++);
227 memcpy (packetBuffer.data, sock->sendMessage, dataLen);
229 sock->sendNext = false;
231 if (sfunc.Write (sock->socket, (qbyte *)&packetBuffer, packetLen, &sock->addr) == -1)
234 sock->lastSendTime = net_time;
240 int ReSendMessage (qsocket_t *sock)
242 unsigned int packetLen;
243 unsigned int dataLen;
246 if (sock->sendMessageLength <= MAX_DATAGRAM)
248 dataLen = sock->sendMessageLength;
253 dataLen = MAX_DATAGRAM;
256 packetLen = NET_HEADERSIZE + dataLen;
258 packetBuffer.length = BigLong(packetLen | (NETFLAG_DATA | eom));
259 packetBuffer.sequence = BigLong(sock->sendSequence - 1);
260 memcpy (packetBuffer.data, sock->sendMessage, dataLen);
262 sock->sendNext = false;
264 if (sfunc.Write (sock->socket, (qbyte *)&packetBuffer, packetLen, &sock->addr) == -1)
267 sock->lastSendTime = net_time;
273 qboolean Datagram_CanSendMessage (qsocket_t *sock)
276 SendMessageNext (sock);
278 return sock->canSend;
282 qboolean Datagram_CanSendUnreliableMessage (qsocket_t *sock)
288 int Datagram_SendUnreliableMessage (qsocket_t *sock, sizebuf_t *data)
293 if (data->cursize == 0)
294 Sys_Error("Datagram_SendUnreliableMessage: zero length message\n");
296 if (data->cursize > MAX_DATAGRAM)
297 Sys_Error("Datagram_SendUnreliableMessage: message too big %u\n", data->cursize);
300 packetLen = NET_HEADERSIZE + data->cursize;
302 packetBuffer.length = BigLong(packetLen | NETFLAG_UNRELIABLE);
303 packetBuffer.sequence = BigLong(sock->unreliableSendSequence++);
304 memcpy (packetBuffer.data, data->data, data->cursize);
306 if (sfunc.Write (sock->socket, (qbyte *)&packetBuffer, packetLen, &sock->addr) == -1)
314 int Datagram_GetMessage (qsocket_t *sock)
319 struct qsockaddr readaddr;
320 unsigned int sequence;
325 if ((net_time - sock->lastSendTime) > 1.0)
326 ReSendMessage (sock);
330 length = sfunc.Read (sock->socket, (qbyte *)&packetBuffer, NET_DATAGRAMSIZE, &readaddr);
335 if ((int)length == -1)
337 Con_Printf("Read error\n");
341 if ((temp = sfunc.AddrCompare(&readaddr, &sock->addr)) != 0)
343 char tempaddress1[64], tempaddress2[64];
346 if (developer_networking.integer)
348 dfunc.GetNameFromAddr (&sock->addr, tempaddress1);
349 dfunc.GetNameFromAddr (&readaddr, tempaddress2);
350 Con_Printf("Packet from wrong port received but accepted (Expected: %s Received: %s)\n", tempaddress1, tempaddress2);
355 dfunc.GetNameFromAddr (&sock->addr, tempaddress1);
356 dfunc.GetNameFromAddr (&readaddr, tempaddress2);
357 Con_Printf("Forged packet received (Expected: %s Received: %s)\n", tempaddress1, tempaddress2);
362 if (length < NET_HEADERSIZE)
368 length = BigLong(packetBuffer.length);
369 flags = length & (~NETFLAG_LENGTH_MASK);
370 length &= NETFLAG_LENGTH_MASK;
372 if (flags & NETFLAG_CTL)
375 sequence = BigLong(packetBuffer.sequence);
378 if (flags & NETFLAG_UNRELIABLE)
380 if (sequence < sock->unreliableReceiveSequence)
382 Con_DPrintf("Got a stale datagram\n");
386 if (sequence != sock->unreliableReceiveSequence)
388 count = sequence - sock->unreliableReceiveSequence;
389 droppedDatagrams += count;
390 Con_DPrintf("Dropped %u datagram(s)\n", count);
392 sock->unreliableReceiveSequence = sequence + 1;
394 length -= NET_HEADERSIZE;
396 SZ_Clear (&net_message);
397 SZ_Write (&net_message, packetBuffer.data, length);
403 if (flags & NETFLAG_ACK)
405 if (sequence != (sock->sendSequence - 1))
407 Con_DPrintf("Stale ACK received\n");
410 if (sequence == sock->ackSequence)
413 if (sock->ackSequence != sock->sendSequence)
414 Con_DPrintf("ack sequencing error\n");
418 Con_DPrintf("Duplicate ACK received\n");
421 sock->sendMessageLength -= MAX_DATAGRAM;
422 if (sock->sendMessageLength > 0)
424 memcpy(sock->sendMessage, sock->sendMessage+MAX_DATAGRAM, sock->sendMessageLength);
425 sock->sendNext = true;
429 sock->sendMessageLength = 0;
430 sock->canSend = true;
435 if (flags & NETFLAG_DATA)
437 packetBuffer.length = BigLong(NET_HEADERSIZE | NETFLAG_ACK);
438 packetBuffer.sequence = BigLong(sequence);
439 sfunc.Write (sock->socket, (qbyte *)&packetBuffer, NET_HEADERSIZE, &readaddr);
441 if (sequence != sock->receiveSequence)
443 receivedDuplicateCount++;
446 sock->receiveSequence++;
448 length -= NET_HEADERSIZE;
450 if (flags & NETFLAG_EOM)
452 SZ_Clear(&net_message);
453 SZ_Write(&net_message, sock->receiveMessage, sock->receiveMessageLength);
454 SZ_Write(&net_message, packetBuffer.data, length);
455 sock->receiveMessageLength = 0;
461 memcpy(sock->receiveMessage + sock->receiveMessageLength, packetBuffer.data, length);
462 sock->receiveMessageLength += length;
468 SendMessageNext (sock);
474 void PrintStats(qsocket_t *s)
476 Con_Printf("canSend = %4u \n", s->canSend);
477 Con_Printf("sendSeq = %4u ", s->sendSequence);
478 Con_Printf("recvSeq = %4u \n", s->receiveSequence);
482 void NET_Stats_f (void)
486 if (Cmd_Argc () == 1)
488 Con_Printf("unreliable messages sent = %i\n", unreliableMessagesSent);
489 Con_Printf("unreliable messages recv = %i\n", unreliableMessagesReceived);
490 Con_Printf("reliable messages sent = %i\n", messagesSent);
491 Con_Printf("reliable messages received = %i\n", messagesReceived);
492 Con_Printf("packetsSent = %i\n", packetsSent);
493 Con_Printf("packetsReSent = %i\n", packetsReSent);
494 Con_Printf("packetsReceived = %i\n", packetsReceived);
495 Con_Printf("receivedDuplicateCount = %i\n", receivedDuplicateCount);
496 Con_Printf("shortPacketCount = %i\n", shortPacketCount);
497 Con_Printf("droppedDatagrams = %i\n", droppedDatagrams);
499 else if (strcmp(Cmd_Argv(1), "*") == 0)
501 for (s = net_activeSockets; s; s = s->next)
506 for (s = net_activeSockets; s; s = s->next)
507 if (strcasecmp(Cmd_Argv(1), s->address) == 0)
516 static qboolean testInProgress = false;
517 static int testPollCount;
518 static int testDriver;
519 static int testSocket;
521 static void Test_Poll(void);
522 PollProcedure testPollProcedure = {NULL, 0.0, Test_Poll};
524 static void Test_Poll(void)
526 struct qsockaddr clientaddr;
537 net_landriverlevel = testDriver;
541 len = dfunc.Read (testSocket, net_message.data, net_message.maxsize, &clientaddr);
542 if (len < (int)sizeof(int))
545 net_message.cursize = len;
548 control = BigLong(*((int *)net_message.data));
552 if ((control & (~NETFLAG_LENGTH_MASK)) != (int)NETFLAG_CTL)
554 if ((control & NETFLAG_LENGTH_MASK) != len)
558 if (c != CCREP_PLAYER_INFO)
559 Sys_Error("Unexpected repsonse to Player Info request\n");
561 playerNumber = MSG_ReadByte();
562 strcpy(name, MSG_ReadString());
563 colors = MSG_ReadLong();
564 frags = MSG_ReadLong();
565 connectTime = MSG_ReadLong();
566 strcpy(address, MSG_ReadString());
568 Con_Printf("%s\n frags:%3i colors:%u %u time:%u\n %s\n", name, frags, colors >> 4, colors & 0x0f, connectTime / 60, address);
574 SchedulePollProcedure(&testPollProcedure, 0.1);
578 dfunc.CloseSocket(testSocket);
579 testInProgress = false;
583 static void Test_f (void)
586 int n, max = MAX_SCOREBOARD;
587 struct qsockaddr sendaddr;
594 if (host && hostCacheCount)
596 for (n = 0; n < hostCacheCount; n++)
597 if (strcasecmp (host, hostcache[n].name) == 0)
599 if (hostcache[n].driver != myDriverLevel)
601 net_landriverlevel = hostcache[n].ldriver;
602 max = hostcache[n].maxusers;
603 memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
606 if (n < hostCacheCount)
610 for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
612 if (!net_landrivers[net_landriverlevel].initialized)
615 // see if we can resolve the host name
616 if (dfunc.GetAddrFromName(host, &sendaddr) != -1)
619 if (net_landriverlevel == net_numlandrivers)
623 testSocket = dfunc.OpenSocket(0);
624 if (testSocket == -1)
627 testInProgress = true;
629 testDriver = net_landriverlevel;
631 for (n = 0; n < max; n++)
633 SZ_Clear(&net_message);
634 // save space for the header, filled in later
635 MSG_WriteLong(&net_message, 0);
636 MSG_WriteByte(&net_message, CCREQ_PLAYER_INFO);
637 MSG_WriteByte(&net_message, n);
638 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
639 dfunc.Write (testSocket, net_message.data, net_message.cursize, &sendaddr);
641 SZ_Clear(&net_message);
642 SchedulePollProcedure(&testPollProcedure, 0.1);
646 static qboolean test2InProgress = false;
647 static int test2Driver;
648 static int test2Socket;
650 static void Test2_Poll(void);
651 PollProcedure test2PollProcedure = {NULL, 0.0, Test2_Poll};
653 static void Test2_Poll(void)
655 struct qsockaddr clientaddr;
662 net_landriverlevel = test2Driver;
665 len = dfunc.Read (test2Socket, net_message.data, net_message.maxsize, &clientaddr);
666 if (len < (int)sizeof(int))
669 net_message.cursize = len;
672 control = BigLong(*((int *)net_message.data));
676 if ((control & (~NETFLAG_LENGTH_MASK)) != (int)NETFLAG_CTL)
678 if ((control & NETFLAG_LENGTH_MASK) != len)
682 if (c != CCREP_RULE_INFO)
685 strcpy(name, MSG_ReadString());
688 strcpy(value, MSG_ReadString());
690 Con_Printf("%-16.16s %-16.16s\n", name, value);
692 SZ_Clear(&net_message);
693 // save space for the header, filled in later
694 MSG_WriteLong(&net_message, 0);
695 MSG_WriteByte(&net_message, CCREQ_RULE_INFO);
696 MSG_WriteString(&net_message, name);
697 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
698 dfunc.Write (test2Socket, net_message.data, net_message.cursize, &clientaddr);
699 SZ_Clear(&net_message);
702 SchedulePollProcedure(&test2PollProcedure, 0.05);
706 Con_Printf("Unexpected repsonse to Rule Info request\n");
708 dfunc.CloseSocket(test2Socket);
709 test2InProgress = false;
713 static void Test2_f (void)
717 struct qsockaddr sendaddr;
724 if (host && hostCacheCount)
726 for (n = 0; n < hostCacheCount; n++)
727 if (strcasecmp (host, hostcache[n].name) == 0)
729 if (hostcache[n].driver != myDriverLevel)
731 net_landriverlevel = hostcache[n].ldriver;
732 memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
735 if (n < hostCacheCount)
739 for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
741 if (!net_landrivers[net_landriverlevel].initialized)
744 // see if we can resolve the host name
745 if (dfunc.GetAddrFromName(host, &sendaddr) != -1)
748 if (net_landriverlevel == net_numlandrivers)
752 test2Socket = dfunc.OpenSocket(0);
753 if (test2Socket == -1)
756 test2InProgress = true;
757 test2Driver = net_landriverlevel;
759 SZ_Clear(&net_message);
760 // save space for the header, filled in later
761 MSG_WriteLong(&net_message, 0);
762 MSG_WriteByte(&net_message, CCREQ_RULE_INFO);
763 MSG_WriteString(&net_message, "");
764 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
765 dfunc.Write (test2Socket, net_message.data, net_message.cursize, &sendaddr);
766 SZ_Clear(&net_message);
767 SchedulePollProcedure(&test2PollProcedure, 0.05);
771 int Datagram_Init (void)
776 myDriverLevel = net_driverlevel;
777 Cmd_AddCommand ("net_stats", NET_Stats_f);
778 Cvar_RegisterVariable (&cl_port);
780 if (COM_CheckParm("-nolan"))
783 for (i = 0; i < net_numlandrivers; i++)
785 csock = net_landrivers[i].Init ();
788 net_landrivers[i].initialized = true;
789 net_landrivers[i].controlSock = csock;
793 Cmd_AddCommand ("ban", NET_Ban_f);
795 //Cmd_AddCommand ("test", Test_f);
796 //Cmd_AddCommand ("test2", Test2_f);
802 void Datagram_Shutdown (void)
807 // shutdown the lan drivers
809 for (i = 0; i < net_numlandrivers; i++)
811 if (net_landrivers[i].initialized)
813 net_landrivers[i].Shutdown ();
814 net_landrivers[i].initialized = false;
820 void Datagram_Close (qsocket_t *sock)
822 sfunc.CloseSocket(sock->socket);
826 void Datagram_Listen (qboolean state)
830 for (i = 0; i < net_numlandrivers; i++)
831 if (net_landrivers[i].initialized)
832 net_landrivers[i].Listen (state);
836 static qsocket_t *_Datagram_CheckNewConnections (void)
838 struct qsockaddr clientaddr;
839 struct qsockaddr newaddr;
850 acceptsock = dfunc.CheckNewConnections();
851 if (acceptsock == -1)
854 SZ_Clear(&net_message);
856 len = dfunc.Read (acceptsock, net_message.data, net_message.maxsize, &clientaddr);
857 if (len < (int)sizeof(int))
859 net_message.cursize = len;
862 control = BigLong(*((int *)net_message.data));
865 // Messages starting by 0xFFFFFFFF are master server messages
866 if ((unsigned int)control == 0xFFFFFFFF)
868 int responsesize = Master_HandleMessage();
869 if (responsesize > 0)
871 dfunc.Write(acceptsock, net_message.data, responsesize, &clientaddr);
872 SZ_Clear(&net_message);
876 if ((control & (~NETFLAG_LENGTH_MASK)) != (int)NETFLAG_CTL)
878 if ((control & NETFLAG_LENGTH_MASK) != len)
881 command = MSG_ReadByte();
882 if (command == CCREQ_SERVER_INFO)
884 if (strcmp(MSG_ReadString(), "QUAKE") != 0)
887 Con_DPrintf("Datagram_CheckNewConnections: received CCREQ_SERVERINFO, replying.\n");
889 SZ_Clear(&net_message);
890 // save space for the header, filled in later
891 MSG_WriteLong(&net_message, 0);
892 MSG_WriteByte(&net_message, CCREP_SERVER_INFO);
893 dfunc.GetSocketAddr(acceptsock, &newaddr);
894 MSG_WriteString(&net_message, dfunc.AddrToString(&newaddr));
895 MSG_WriteString(&net_message, hostname.string);
896 MSG_WriteString(&net_message, sv.name);
897 MSG_WriteByte(&net_message, net_activeconnections);
898 MSG_WriteByte(&net_message, svs.maxclients);
899 MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
900 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
901 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
902 SZ_Clear(&net_message);
906 if (command == CCREQ_PLAYER_INFO)
913 playerNumber = MSG_ReadByte();
915 for (clientNumber = 0, client = svs.clients; clientNumber < svs.maxclients; clientNumber++, client++)
920 if (activeNumber == playerNumber)
924 if (clientNumber == svs.maxclients)
927 SZ_Clear(&net_message);
928 // save space for the header, filled in later
929 MSG_WriteLong(&net_message, 0);
930 MSG_WriteByte(&net_message, CCREP_PLAYER_INFO);
931 MSG_WriteByte(&net_message, playerNumber);
932 MSG_WriteString(&net_message, client->name);
933 MSG_WriteLong(&net_message, client->colors);
934 MSG_WriteLong(&net_message, (int)client->edict->v->frags);
935 MSG_WriteLong(&net_message, (int)(net_time - client->netconnection->connecttime));
936 MSG_WriteString(&net_message, client->netconnection->address);
937 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
938 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
939 SZ_Clear(&net_message);
944 if (command == CCREQ_RULE_INFO)
949 // find the search start location
950 prevCvarName = MSG_ReadString();
951 var = Cvar_FindVarAfter(prevCvarName, CVAR_NOTIFY);
955 SZ_Clear(&net_message);
956 // save space for the header, filled in later
957 MSG_WriteLong(&net_message, 0);
958 MSG_WriteByte(&net_message, CCREP_RULE_INFO);
961 MSG_WriteString(&net_message, var->name);
962 MSG_WriteString(&net_message, var->string);
964 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
965 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
966 SZ_Clear(&net_message);
971 if (command != CCREQ_CONNECT)
974 if (strcmp(MSG_ReadString(), "QUAKE") != 0)
978 if (c != NET_PROTOCOL_VERSION)
980 SZ_Clear(&net_message);
981 // save space for the header, filled in later
982 MSG_WriteLong(&net_message, 0);
983 MSG_WriteByte(&net_message, CCREP_REJECT);
984 MSG_WriteString(&net_message, "Incompatible version.\n");
985 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
986 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
987 SZ_Clear(&net_message);
993 if (clientaddr.sa_family == AF_INET)
995 unsigned long testAddr;
996 testAddr = ((struct sockaddr_in *)&clientaddr)->sin_addr.s_addr;
997 if ((testAddr & banMask) == banAddr)
999 SZ_Clear(&net_message);
1000 // save space for the header, filled in later
1001 MSG_WriteLong(&net_message, 0);
1002 MSG_WriteByte(&net_message, CCREP_REJECT);
1003 MSG_WriteString(&net_message, "You have been banned.\n");
1004 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
1005 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
1006 SZ_Clear(&net_message);
1012 // see if this guy is already connected
1013 for (s = net_activeSockets; s; s = s->next)
1015 if (s->driver != net_driverlevel)
1017 ret = dfunc.AddrCompare(&clientaddr, &s->addr);
1020 // is this a duplicate connection request?
1021 if (ret == 0 && net_time - s->connecttime < 2.0)
1023 // yes, so send a duplicate reply
1024 SZ_Clear(&net_message);
1025 // save space for the header, filled in later
1026 MSG_WriteLong(&net_message, 0);
1027 MSG_WriteByte(&net_message, CCREP_ACCEPT);
1028 dfunc.GetSocketAddr(s->socket, &newaddr);
1029 MSG_WriteLong(&net_message, dfunc.GetSocketPort(&newaddr));
1030 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
1031 // LordHavoc: send from s->socket instead of acceptsock, this
1032 // way routers usually identify the connection correctly
1033 // (thanks to faded for provoking me to recite a lengthy
1034 // explanation of NAT nightmares, and realize this easy
1035 // workaround for quake)
1036 dfunc.Write (s->socket, net_message.data, net_message.cursize, &clientaddr);
1037 // LordHavoc: also send from acceptsock, for good measure
1038 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
1039 SZ_Clear(&net_message);
1042 // it's somebody coming back in from a crash/disconnect
1043 // so close the old qsocket and let their retry get them back in
1049 // allocate a QSocket
1050 sock = NET_NewQSocket ();
1053 // no room; try to let him know
1054 SZ_Clear(&net_message);
1055 // save space for the header, filled in later
1056 MSG_WriteLong(&net_message, 0);
1057 MSG_WriteByte(&net_message, CCREP_REJECT);
1058 MSG_WriteString(&net_message, "Server is full.\n");
1059 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
1060 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
1061 SZ_Clear(&net_message);
1065 // allocate a network socket
1066 newsock = dfunc.OpenSocket(0);
1069 NET_FreeQSocket(sock);
1073 // connect to the client
1074 if (dfunc.Connect (newsock, &clientaddr) == -1)
1076 dfunc.CloseSocket(newsock);
1077 NET_FreeQSocket(sock);
1081 // everything is allocated, just fill in the details
1082 sock->socket = newsock;
1083 sock->landriver = net_landriverlevel;
1084 sock->addr = clientaddr;
1085 strcpy(sock->address, dfunc.AddrToString(&clientaddr));
1087 // send him back the info about the server connection he has been allocated
1088 SZ_Clear(&net_message);
1089 // save space for the header, filled in later
1090 MSG_WriteLong(&net_message, 0);
1091 MSG_WriteByte(&net_message, CCREP_ACCEPT);
1092 dfunc.GetSocketAddr(newsock, &newaddr);
1093 MSG_WriteLong(&net_message, dfunc.GetSocketPort(&newaddr));
1094 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
1095 // LordHavoc: send from sock->socket instead of acceptsock, this way routers
1096 // usually identify the connection correctly (thanks to faded for provoking
1097 // me to recite a lengthy explanation of NAT nightmares, and realize this
1098 // easy workaround for quake)
1099 dfunc.Write (sock->socket, net_message.data, net_message.cursize, &clientaddr);
1100 // LordHavoc: also send from acceptsock, for good measure
1101 dfunc.Write (acceptsock, net_message.data, net_message.cursize, &clientaddr);
1102 SZ_Clear(&net_message);
1107 qsocket_t *Datagram_CheckNewConnections (void)
1109 qsocket_t *ret = NULL;
1111 for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
1112 if (net_landrivers[net_landriverlevel].initialized)
1113 if ((ret = _Datagram_CheckNewConnections ()) != NULL)
1119 static qboolean Datagram_HandleServerInfo (struct qsockaddr *readaddr)
1121 //struct qsockaddr myaddr;
1126 if (net_message.cursize < (int)sizeof(int))
1129 // don't answer our own query
1130 //dfunc.GetSocketAddr (dfunc.controlSock, &myaddr);
1131 //if (dfunc.AddrCompare(readaddr, &myaddr) >= 0)
1134 // is the cache full?
1135 if (hostCacheCount == HOSTCACHESIZE)
1138 MSG_BeginReading ();
1139 control = BigLong(*((int *)net_message.data));
1143 if ((control & (~NETFLAG_LENGTH_MASK)) != (int)NETFLAG_CTL)
1145 if ((control & NETFLAG_LENGTH_MASK) != net_message.cursize)
1149 if (c != CCREP_SERVER_INFO)
1152 // LordHavoc: because the UDP driver reports 0.0.0.0:26000 as the address
1153 // string we just ignore it and keep the real address
1155 // hostcache only uses text addresses
1156 strcpy(cname, dfunc.AddrToString(readaddr));
1157 // search the cache for this server
1158 for (n = 0; n < hostCacheCount; n++)
1159 //if (dfunc.AddrCompare(readaddr, &hostcache[n].addr) == 0)
1160 if (!strcmp(cname, hostcache[n].cname))
1165 strcpy(hostcache[n].name, MSG_ReadString());
1166 strcpy(hostcache[n].map, MSG_ReadString());
1167 hostcache[n].users = MSG_ReadByte();
1168 hostcache[n].maxusers = MSG_ReadByte();
1170 if (c != NET_PROTOCOL_VERSION)
1172 strncpy(hostcache[n].cname, hostcache[n].name, sizeof(hostcache[n].cname) - 1);
1173 hostcache[n].cname[sizeof(hostcache[n].cname) - 1] = 0;
1174 strcpy(hostcache[n].name, "*");
1175 strncat(hostcache[n].name, hostcache[n].cname, sizeof(hostcache[n].name) - 1);
1176 hostcache[n].name[sizeof(hostcache[n].name) - 1] = 0;
1178 strcpy(hostcache[n].cname, cname);
1179 //memcpy(&hostcache[n].addr, readaddr, sizeof(struct qsockaddr));
1180 //hostcache[n].driver = net_driverlevel;
1181 //hostcache[n].ldriver = net_landriverlevel;
1184 // check for a name conflict
1185 for (i = 0; i < hostCacheCount; i++)
1189 if (strcasecmp (hostcache[n].name, hostcache[i].name) == 0)
1191 i = strlen(hostcache[n].name);
1192 if (i < 15 && hostcache[n].name[i-1] > '8')
1194 hostcache[n].name[i] = '0';
1195 hostcache[n].name[i+1] = 0;
1198 hostcache[n].name[i-1]++;
1208 static void _Datagram_SearchForHosts (qboolean xmit)
1211 struct qsockaddr readaddr;
1215 SZ_Clear(&net_message);
1216 // save space for the header, filled in later
1217 MSG_WriteLong(&net_message, 0);
1218 MSG_WriteByte(&net_message, CCREQ_SERVER_INFO);
1219 MSG_WriteString(&net_message, "QUAKE");
1220 MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
1221 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
1222 dfunc.Broadcast(dfunc.controlSock, net_message.data, net_message.cursize);
1223 SZ_Clear(&net_message);
1226 while ((ret = dfunc.Read (dfunc.controlSock, net_message.data, net_message.maxsize, &readaddr)) > 0)
1228 net_message.cursize = ret;
1229 Datagram_HandleServerInfo (&readaddr);
1233 void Datagram_SearchForHosts (qboolean xmit)
1235 for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
1237 if (hostCacheCount == HOSTCACHESIZE)
1239 if (net_landrivers[net_landriverlevel].initialized)
1240 _Datagram_SearchForHosts (xmit);
1245 static qboolean _Datagram_SearchForInetHosts (const char *master)
1247 qboolean result = false;
1248 struct qsockaddr masteraddr;
1249 struct qsockaddr readaddr;
1254 if (dfunc.GetAddrFromName(master, &masteraddr) != -1)
1257 const char* port = strrchr (master, ':');
1259 portnum = atoi (port + 1);
1261 portnum = MASTER_PORT;
1262 Con_DPrintf("Datagram_SearchForInetHosts: sending %d byte message to master %s port %i\n", net_message.cursize, master, portnum);
1263 dfunc.SetSocketPort (&masteraddr, portnum);
1264 dfunc.Write (dfunc.controlSock, net_message.data, net_message.cursize, &masteraddr);
1268 while ((ret = dfunc.Read (dfunc.controlSock, net_message.data, net_message.maxsize, &readaddr)) > 0)
1270 net_message.cursize = ret;
1271 Con_DPrintf("Datagram_SearchForInetHosts: Read received %d byte message\n", net_message.cursize);
1272 if (Datagram_HandleServerInfo (&readaddr))
1275 Master_ParseServerList (&dfunc);
1282 qboolean Datagram_SearchForInetHosts (const char *master)
1284 qboolean result = false;
1285 for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
1287 if (hostCacheCount == HOSTCACHESIZE)
1289 if (net_landrivers[net_landriverlevel].initialized)
1290 if (_Datagram_SearchForInetHosts (master))
1298 static qsocket_t *_Datagram_Connect (const char *host)
1300 struct qsockaddr sendaddr;
1301 struct qsockaddr readaddr;
1310 // see if we can resolve the host name
1311 if (dfunc.GetAddrFromName(host, &sendaddr) == -1)
1314 newsock = dfunc.OpenSocket (cl_port.integer);
1318 sock = NET_NewQSocket ();
1321 sock->socket = newsock;
1322 sock->landriver = net_landriverlevel;
1324 // connect to the host
1325 if (dfunc.Connect (newsock, &sendaddr) == -1)
1328 // send the connection request
1329 Con_Printf("trying...\n");CL_UpdateScreen();CL_UpdateScreen();
1330 start_time = net_time;
1332 for (reps = 0; reps < 3; reps++)
1334 SZ_Clear(&net_message);
1335 // save space for the header, filled in later
1336 MSG_WriteLong(&net_message, 0);
1337 MSG_WriteByte(&net_message, CCREQ_CONNECT);
1338 MSG_WriteString(&net_message, "QUAKE");
1339 MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
1340 *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
1341 dfunc.Write (newsock, net_message.data, net_message.cursize, &sendaddr);
1342 SZ_Clear(&net_message);
1345 ret = dfunc.Read (newsock, net_message.data, net_message.maxsize, &readaddr);
1346 // if we got something, validate it
1349 // is it from the right place?
1350 // we don't care if the port matches (this adds support for
1351 // the NAT fix in the server inspired by faded)
1352 if (sfunc.AddrCompare(&readaddr, &sendaddr) < 0)
1354 char tempaddress1[64], tempaddress2[64];
1355 dfunc.GetNameFromAddr (&sendaddr, tempaddress1);
1356 dfunc.GetNameFromAddr (&readaddr, tempaddress2);
1357 Con_Printf("wrong reply address (Expected: %s Received: %s)\n", tempaddress1, tempaddress2);
1364 if (ret < (int)sizeof(int))
1370 net_message.cursize = ret;
1371 MSG_BeginReading ();
1373 control = BigLong(*((int *)net_message.data));
1380 if ((control & (~NETFLAG_LENGTH_MASK)) != (int)NETFLAG_CTL)
1385 if ((control & NETFLAG_LENGTH_MASK) != ret)
1392 while (ret == 0 && (SetNetTime() - start_time) < 2.5);
1395 Con_Printf("still trying...\n");CL_UpdateScreen();CL_UpdateScreen();
1396 start_time = SetNetTime();
1401 reason = "No Response";
1402 Con_Printf("%s\n", reason);
1403 strcpy(m_return_reason, reason);
1409 reason = "Network Error";
1410 Con_Printf("%s\n", reason);
1411 strcpy(m_return_reason, reason);
1415 ret = MSG_ReadByte();
1416 if (ret == CCREP_REJECT)
1418 reason = MSG_ReadString();
1419 Con_Printf("%s", reason);
1420 strncpy(m_return_reason, reason, 31);
1424 if (ret == CCREP_ACCEPT)
1426 memcpy(&sock->addr, &sendaddr, sizeof(struct qsockaddr));
1427 dfunc.SetSocketPort (&sock->addr, MSG_ReadLong());
1431 reason = "Bad Response";
1432 Con_Printf("%s\n", reason);
1433 strcpy(m_return_reason, reason);
1437 dfunc.GetNameFromAddr (&sendaddr, sock->address);
1439 Con_Printf ("Connection accepted to %s\n", sock->address);
1440 sock->lastMessageTime = SetNetTime();
1442 // switch the connection to the specified address
1443 if (dfunc.Connect (newsock, &sock->addr) == -1)
1445 reason = "Connect to Game failed";
1446 Con_Printf("%s\n", reason);
1447 strcpy(m_return_reason, reason);
1451 m_return_onerror = false;
1455 NET_FreeQSocket(sock);
1457 dfunc.CloseSocket(newsock);
1458 if (m_return_onerror)
1460 key_dest = key_menu;
1461 m_state = m_return_state;
1462 m_return_onerror = false;
1467 qsocket_t *Datagram_Connect (const char *host)
1469 qsocket_t *ret = NULL;
1471 for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
1472 if (net_landrivers[net_landriverlevel].initialized)
1473 if ((ret = _Datagram_Connect (host)) != NULL)
1478 static void _Datagram_Heartbeat (const char *master)
1480 struct qsockaddr masteraddr;
1484 if (dfunc.GetAddrFromName(master, &masteraddr) == -1)
1488 port = strrchr (master, ':');
1490 portnum = atoi (port + 1);
1492 portnum = MASTER_PORT;
1493 dfunc.SetSocketPort (&masteraddr, portnum);
1495 // FIXME: this is the only use of UDP_Send in the entire engine, add a dfunc.acceptSock to get rid of this function!
1496 dfunc.Send (net_message.data, net_message.cursize, &masteraddr);
1499 void Datagram_Heartbeat (const char *master)
1501 for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
1502 if (net_landrivers[net_landriverlevel].initialized)
1503 _Datagram_Heartbeat (master);