/* * 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. * */ /* net_wins.c */ #include #include #include #include #include #include #include #include #include #include #ifdef NeXT #include #endif #include "../qcommon/qcommon.h" #define LOOPBACK 0x7f000001 #define MAX_LOOPBACK 4 extern qboolean stdin_active; netadr_t net_local_adr; typedef struct { byte data [MAX_MSGLEN]; int datalen; } loopmsg_t; typedef struct { loopmsg_t msgs [MAX_LOOPBACK]; int get , send; } loopback_t; loopback_t loopbacks[2]; int ip_sockets [2]; int ipx_sockets[2]; int NET_Socket (char *net_interface, int port); char *NET_ErrorString(void); /* * =========================================================================== */ void NetadrToSockadr(netadr_t * a, struct sockaddr_in *s) { memset(s, 0, sizeof(*s)); if (a->type == NA_BROADCAST) { s->sin_family = AF_INET; s->sin_port = a->port; *(int *)&s->sin_addr = -1; } else if (a->type == NA_IP) { s->sin_family = AF_INET; *(int *)&s->sin_addr = *(int *)&a->ip; s->sin_port = a->port; } } void SockadrToNetadr(struct sockaddr_in *s, netadr_t * a) { *(int *)&a->ip = *(int *)&s->sin_addr; a->port = s->sin_port; a->type = NA_IP; } qboolean NET_CompareAdr(netadr_t a, netadr_t b) { if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3] && a.port == b.port) return true; return false; } /* * =================== NET_CompareBaseAdr * * Compares without the port =================== */ qboolean NET_CompareBaseAdr(netadr_t a, netadr_t b) { if (a.type != b.type) return false; if (a.type == NA_LOOPBACK) return true; if (a.type == NA_IP) { if (a.ip[0] == b.ip[0] && a.ip[1] == b.ip[1] && a.ip[2] == b.ip[2] && a.ip[3] == b.ip[3]) return true; return false; } if (a.type == NA_IPX) { if ((memcmp(a.ipx, b.ipx, 10) == 0)) return true; return false; } return false; } char * NET_AdrToString(netadr_t a) { static char s [64]; Com_sprintf(s, sizeof(s), "%i.%i.%i.%i:%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3], ntohs(a.port)); return s; } char * NET_BaseAdrToString(netadr_t a) { static char s [64]; Com_sprintf(s, sizeof(s), "%i.%i.%i.%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3]); return s; } /* * ============= NET_StringToAdr * * localhost idnewt idnewt:28000 192.246.40.70 192.246.40.70:28000 ============= */ qboolean NET_StringToSockaddr(char *s, struct sockaddr *sadr) { struct hostent *h; char *colon; char copy[128]; memset(sadr, 0, sizeof(*sadr)); ((struct sockaddr_in *)sadr)->sin_family = AF_INET; ((struct sockaddr_in *)sadr)->sin_port = 0; Q_strncpyz(copy, s, sizeof(copy)); /* strip off a trailing :port if present */ for (colon = copy; *colon; colon++) if (*colon == ':') { *colon = 0; ((struct sockaddr_in *)sadr)->sin_port = htons((short)atoi(colon + 1)); } if (copy[0] >= '0' && copy[0] <= '9') { *(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(copy); } else { if (!(h = gethostbyname(copy))) return 0; *(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0]; } return true; } /* * ============= NET_StringToAdr * * localhost idnewt idnewt:28000 192.246.40.70 192.246.40.70:28000 ============= */ qboolean NET_StringToAdr(char *s, netadr_t * a) { struct sockaddr_in sadr; if (!strcmp(s, "localhost")) { memset(a, 0, sizeof(*a)); a->type = NA_LOOPBACK; return true; } if (!NET_StringToSockaddr(s, (struct sockaddr *)&sadr)) return false; SockadrToNetadr(&sadr, a); return true; } qboolean NET_IsLocalAddress(netadr_t adr) { return NET_CompareAdr(adr, net_local_adr); } /* * * ============================================================================ * = * * LOOPBACK BUFFERS FOR LOCAL PLAYER * * ============================================================================= */ qboolean NET_GetLoopPacket(netsrc_t sock, netadr_t *from, sizebuf_t *message) { int i; loopback_t *loop; loop = &loopbacks[sock]; if (loop->send - loop->get > MAX_LOOPBACK) loop->get = loop->send - MAX_LOOPBACK; if (loop->get >= loop->send) return false; i = loop->get & (MAX_LOOPBACK - 1); loop->get++; memcpy(message->data, loop->msgs[i].data, loop->msgs[i].datalen); message->cursize = loop->msgs[i].datalen; *from = net_local_adr; return true; } void NET_SendLoopPacket(netsrc_t sock, int length, void *data, netadr_t to) { int i; loopback_t *loop; loop = &loopbacks[sock ^ 1]; i = loop->send & (MAX_LOOPBACK - 1); loop->send++; memcpy(loop->msgs[i].data, data, length); loop->msgs[i].datalen = length; } /* * =========================================================================== * == */ qboolean NET_GetPacket(netsrc_t sock, netadr_t *from, sizebuf_t *message) { int ret; struct sockaddr_in from_sock; socklen_t fromlen; int net_socket; int protocol; int err; if (NET_GetLoopPacket(sock, from, message)) return true; for (protocol = 0; protocol < 2; protocol++) { if (protocol == 0) net_socket = ip_sockets[sock]; else net_socket = ipx_sockets[sock]; if (!net_socket) continue; fromlen = sizeof(from_sock); ret = recvfrom(net_socket, message->data, message->maxsize ,0, (struct sockaddr *)&from_sock, &fromlen); SockadrToNetadr(&from_sock, from); if (ret == -1) { err = errno; if (err == EWOULDBLOCK || err == ECONNREFUSED) continue; Com_Printf("NET_GetPacket: %s from %s\n", NET_ErrorString(), NET_AdrToString(*from)); continue; } if (ret == message->maxsize) { Com_Printf("Oversize packet from %s\n", NET_AdrToString(*from)); continue; } message->cursize = ret; /* NiceAss: */ Net_History.RecsStartTime = Net_History.RecsTime[Net_History.RecsIndex % MAX_NET_HISTORY]; Net_History.RecsSize[Net_History.RecsIndex % MAX_NET_HISTORY] = ret; Net_History.RecsTime[Net_History.RecsIndex % MAX_NET_HISTORY] = Sys_Milliseconds(); Net_History.RecsIndex++; return true; } return false; } /* * =========================================================================== * == */ void NET_SendPacket(netsrc_t sock, int length, void *data, netadr_t to) { int ret; struct sockaddr_in addr; int net_socket; if (to.type == NA_LOOPBACK) { NET_SendLoopPacket(sock, length, data, to); return; } if (to.type == NA_BROADCAST) { net_socket = ip_sockets[sock]; if (!net_socket) return; } else if (to.type == NA_IP) { net_socket = ip_sockets[sock]; if (!net_socket) return; } else if (to.type == NA_IPX) { net_socket = ipx_sockets[sock]; if (!net_socket) return; } else if (to.type == NA_BROADCAST_IPX) { net_socket = ipx_sockets[sock]; if (!net_socket) return; } else { Com_Error(ERR_FATAL, "NET_SendPacket: bad address type"); return; } NetadrToSockadr(&to, &addr); ret = sendto(net_socket, data, length, 0, (struct sockaddr *)&addr, sizeof(addr)); if (ret == -1) { Com_Printf("NET_SendPacket ERROR: %s to %s\n", NET_ErrorString(), NET_AdrToString(to)); } /* NiceAss: */ Net_History.SendsStartTime = Net_History.SendsTime[Net_History.SendsIndex % MAX_NET_HISTORY]; Net_History.SendsSize[Net_History.SendsIndex % MAX_NET_HISTORY] = ret; Net_History.SendsTime[Net_History.SendsIndex % MAX_NET_HISTORY] = Sys_Milliseconds(); Net_History.SendsIndex++; } /* * =========================================================================== * == */ /* * ==================== NET_OpenIP ==================== */ void NET_OpenIP(void) { cvar_t *port, *ip; port = Cvar_Get("port", va("%i", PORT_SERVER), CVAR_NOSET); ip = Cvar_Get("ip", "localhost", CVAR_NOSET); if (!ip_sockets[NS_SERVER]) ip_sockets[NS_SERVER] = NET_Socket(ip->string, port->value); if (!ip_sockets[NS_CLIENT]) ip_sockets[NS_CLIENT] = NET_Socket(ip->string, PORT_ANY); } /* * ==================== NET_OpenIPX ==================== */ void NET_OpenIPX(void) { } /* * ==================== NET_Config * * A single player game will only use the loopback code ==================== */ void NET_Config(qboolean multiplayer) { int i; if (!multiplayer) { /* shut down any existing sockets */ for (i = 0; i < 2; i++) { if (ip_sockets[i]) { close(ip_sockets[i]); ip_sockets[i] = 0; } if (ipx_sockets[i]) { close(ipx_sockets[i]); ipx_sockets[i] = 0; } } } else { /* open sockets */ NET_OpenIP(); NET_OpenIPX(); } } /* =================================================================== */ /* * ==================== NET_Init ==================== */ void NET_Init(void) { } /* * ==================== NET_Socket ==================== */ int NET_Socket(char *net_interface, int port) { int newsocket; struct sockaddr_in address; qboolean _true = true; int i = 1; if ((newsocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1) { Com_Printf("ERROR: UDP_OpenSocket: socket: %s", NET_ErrorString()); return 0; } /* make it non-blocking */ if (ioctl(newsocket, FIONBIO, &_true) == -1) { Com_Printf("ERROR: UDP_OpenSocket: ioctl FIONBIO:%s\n", NET_ErrorString()); return 0; } /* make it broadcast capable */ if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1) { Com_Printf("ERROR: UDP_OpenSocket: setsockopt SO_BROADCAST:%s\n", NET_ErrorString()); return 0; } if (!net_interface || !net_interface[0] || !stricmp(net_interface, "localhost")) address.sin_addr.s_addr = INADDR_ANY; else NET_StringToSockaddr(net_interface, (struct sockaddr *)&address); if (port == PORT_ANY) address.sin_port = 0; else address.sin_port = htons((short)port); address.sin_family = AF_INET; if (bind(newsocket, (void *)&address, sizeof(address)) == -1) { Com_Printf("ERROR: UDP_OpenSocket: bind: %s\n", NET_ErrorString()); close(newsocket); return 0; } return newsocket; } /* * ==================== NET_Shutdown ==================== */ void NET_Shutdown(void) { NET_Config(false); /* close sockets */ } /* * ==================== NET_ErrorString ==================== */ char * NET_ErrorString(void) { int code; code = errno; return strerror(code); } /* sleeps msec or until net socket is ready */ void NET_Sleep(int msec) { struct timeval timeout; fd_set fdset; if (!ip_sockets[NS_SERVER] || (dedicated && !dedicated->value)) return; /* we're not a server, just run full speed */ FD_ZERO(&fdset); if (stdin_active) FD_SET(0, &fdset); /* stdin is processed too */ FD_SET(ip_sockets[NS_SERVER], &fdset); /* network socket */ timeout.tv_sec = msec / 1000; timeout.tv_usec = (msec % 1000) * 1000; select(ip_sockets[NS_SERVER] + 1, &fdset, NULL, NULL, &timeout); }