/* * 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 "../qcommon/qcommon.h" #include #include #include #include #include #include #include #include #include #include #ifdef NeXT #include #endif netadr_t net_local_adr; #define LOOPBACK 0x7f000001 #define MAX_LOOPBACK 4 #define QUAKE2MCAST "ff12::666" #include 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 ip6_sockets[2]; int ipx_sockets[2]; char *multicast_interface = NULL; int NET_Socket (char *net_interface, int port, netsrc_t type, int family); char *NET_ErrorString(void); /* * =========================================================================== * == */ void NetadrToSockadr(netadr_t * a, struct sockaddr_storage *s) { struct sockaddr_in6 *s6; memset(s, 0, sizeof(*s)); switch (a->type) { case NA_BROADCAST: ((struct sockaddr_in *)s)->sin_family = AF_INET; ((struct sockaddr_in *)s)->sin_port = a->port; ((struct sockaddr_in *)s)->sin_addr.s_addr = (in_addr_t) INADDR_BROADCAST; break; case NA_IP: ((struct sockaddr_in *)s)->sin_family = AF_INET; *(int *)&((struct sockaddr_in *)s)->sin_addr = *(int *)&a->ip; ((struct sockaddr_in *)s)->sin_port = a->port; break; case NA_MULTICAST6: s6 = (struct sockaddr_in6 *)s; if (inet_pton(AF_INET6, QUAKE2MCAST, &s6->sin6_addr.s6_addr) != 1) { Com_Printf("NET_NetadrToSockadr: inet_pton: %s", strerror(errno)); return; } s6->sin6_family = AF_INET6; s6->sin6_port = a->port; #ifdef HAVE_SIN6_LEN s6->sin6_len = sizeof(struct sockaddr_in6); #endif /* * scope_id is important for link-local destination. TODO: * check in code for possible uninitialized netadr_t.scope_id * instances */ s6->sin6_scope_id = a->scope_id; break; case NA_IP6: if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)a->ip)) { #ifdef HAVE_SIN6_LEN s->ss_len = sizeof(struct sockaddr_in); #endif s->ss_family = AF_INET; memcpy(&((struct sockaddr_in *)s)->sin_addr, &((struct in6_addr *)a->ip)->s6_addr[12], sizeof(struct in_addr)); ((struct sockaddr_in *)s)->sin_port = a->port; } else { s6 = (struct sockaddr_in6 *)s; s6->sin6_family = AF_INET6; memcpy(&s6->sin6_addr, a->ip, sizeof(s6->sin6_addr)); s6->sin6_port = a->port; #ifdef HAVE_SIN6_LEN s6->sin6_len = sizeof(struct sockaddr_in6); #endif /* * scope_id is important for link-local destination. * TODO: check in code for possible uninitialized * netadr_t.scope_id instances */ s6->sin6_scope_id = a->scope_id; } break; case NA_LOOPBACK: case NA_IPX: case NA_BROADCAST_IPX: /* no handling of NA_LOOPBACK, NA_IPX, NA_BROADCAST_IPX */ break; } } void SockadrToNetadr(struct sockaddr_storage *s, netadr_t * a) { struct sockaddr_in6 *s6; if (s->ss_family == AF_INET) { *(int *)&a->ip = *(int *)&((struct sockaddr_in *)s)->sin_addr; a->port = ((struct sockaddr_in *)s)->sin_port; a->type = NA_IP; } else if (s->ss_family == AF_INET6) { s6 = (struct sockaddr_in6 *)s; if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)&s6->sin6_addr)) { memcpy(a->ip, (struct in_addr *)&s6->sin6_addr.s6_addr[12], sizeof(struct in_addr)); a->port = ((struct sockaddr_in *)s)->sin_port; a->type = NA_IP; } else { memcpy(a->ip, &s6->sin6_addr, sizeof(a->ip)); a->port = s6->sin6_port; a->type = NA_IP6; a->scope_id = s6->sin6_scope_id; } } else s = NULL; } qboolean NET_CompareAdr(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] && a.port == b.port) return true; } if (a.type == NA_IP6) { if ((memcmp(a.ip, b.ip, 16) == 0) && 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_IP6) { if ((memcmp(a.ip, b.ip, 16) == 0)) 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_BaseAdrToString(netadr_t a) { static char s [64], tmp[64]; struct sockaddr_storage ss; struct sockaddr_in6 *s6; int flags; switch (a.type) { case NA_IP: case NA_LOOPBACK: Com_sprintf(s, sizeof(s), "%i.%i.%i.%i", a.ip[0], a.ip[1], a.ip[2], a.ip[3]); break; case NA_BROADCAST: Com_sprintf(s, sizeof(s), "255.255.255.255"); break; case NA_IP6: case NA_MULTICAST6: memset(&ss, 0, sizeof(ss)); s6 = (struct sockaddr_in6 *)&ss; if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)a.ip)) { #ifdef HAVE_SIN6_LEN ss.ss_len = sizeof(struct sockaddr_in); #endif ss.ss_family = AF_INET; memcpy(&((struct sockaddr_in *)&ss)->sin_addr, &((struct in6_addr *)a.ip)->s6_addr[12], sizeof(struct in_addr)); } else { #ifdef HAVE_SIN6_LEN s6->sin6_len = sizeof(struct sockaddr_in6); #endif /* * Possible bug: a.scope_id may not have been * initialized. See comments below on better way to * handle this */ s6->sin6_scope_id = a.scope_id; s6->sin6_family = AF_INET6; memcpy(&s6->sin6_addr, a.ip, sizeof(struct in6_addr)); } flags = NI_NUMERICHOST; #ifdef HAVE_SIN6_LEN if (getnameinfo((struct sockaddr *)&ss, ss.ss_len, s, sizeof(s), NULL, 0, NI_NUMERICHOST)) #else if (getnameinfo((struct sockaddr *)&ss, sizeof(ss), s, sizeof(s), NULL, 0, NI_NUMERICHOST)) #endif Com_sprintf(s, sizeof(s), ""); else { if (a.type == NA_MULTICAST6 || IN6_IS_ADDR_LINKLOCAL(&((struct sockaddr_in6 *)&ss)->sin6_addr)) { /* * If the address is multicast (link) or a * link-local, need to carry the scope. The * string format of the IPv6 address is used * by the client to extablish the connect to * the server. */ /* * A better way to handle this is to always * use sockaddr_storage to represent an IP * (v4, v6) address */ Com_sprintf(tmp, sizeof(tmp), "%s%%%d", s, s6->sin6_scope_id); memcpy(s, tmp, sizeof(s)); } } break; default: Com_sprintf(s, sizeof(s), "invalid IP address family type"); break; } return s; } char * NET_AdrToString(netadr_t a) { static char s [64]; const char *base; base = NET_BaseAdrToString(a); Com_sprintf(s, sizeof(s), "[%s]:%d", base, ntohs(a.port)); return s; } /* * ============= NET_StringToAdr * * localhost idnewt idnewt:28000 192.246.40.70 192.246.40.70:28000 ============= */ qboolean NET_StringToSockaddr(char *s, struct sockaddr_storage *sadr) { char copy[128]; char *addrs, *space; char *ports = NULL; int err; struct addrinfo hints; struct addrinfo *resultp; memset(&hints, 0, sizeof(hints)); hints.ai_socktype = SOCK_DGRAM; hints.ai_family = PF_UNSPEC; Q_strncpyz(copy, s, sizeof(copy)); addrs = space = copy; if (*addrs == '[') { addrs++; for (; *space && *space != ']'; space++); if (!*space) { Com_Printf("NET_StringToSockaddr: invalid IPv6 address %s\n", s); return 0; } *space++ = '\0'; } for (; *space; space++) { if (*space == ':') { *space = '\0'; ports = space + 1; } } if ((err = getaddrinfo(addrs, ports, &hints, &resultp))) { /* Error */ Com_Printf("NET_StringToSockaddr: string %s:\n%s\n", s, gai_strerror(err)); return 0; } switch (resultp->ai_family) { case AF_INET: /* convert to ipv4 addr */ memset(sadr, 0, sizeof(struct sockaddr_storage)); memcpy(sadr, resultp->ai_addr, resultp->ai_addrlen); break; case AF_INET6: /* convert to ipv6 addr */ memset(sadr, 0, sizeof(struct sockaddr_storage)); memcpy(sadr, resultp->ai_addr, resultp->ai_addrlen); break; default: Com_Printf ("NET_StringToSockaddr: string %s:\nprotocol family %d not supported\n", s, resultp->ai_family); return 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_storage sadr; memset(a, 0, sizeof(*a)); if (!strcmp(s, "localhost")) { a->type = NA_LOOPBACK; return true; } if (!NET_StringToSockaddr(s, &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 * net_from, sizebuf_t * net_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(net_message->data, loop->msgs[i].data, loop->msgs[i].datalen); net_message->cursize = loop->msgs[i].datalen; *net_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 * net_from, sizebuf_t * net_message) { int ret; struct sockaddr_storage from; socklen_t fromlen; int net_socket; int protocol; int err; if (NET_GetLoopPacket(sock, net_from, net_message)) return true; for (protocol = 0; protocol < 3; protocol++) { if (protocol == 0) net_socket = ip_sockets[sock]; else if (protocol == 1) net_socket = ip6_sockets[sock]; else net_socket = ipx_sockets[sock]; if (!net_socket) continue; fromlen = sizeof(from); ret = recvfrom(net_socket, net_message->data, net_message->maxsize, 0, (struct sockaddr *)&from, &fromlen); SockadrToNetadr(&from, net_from); if (ret == -1) { err = errno; if (err == EWOULDBLOCK || err == ECONNREFUSED) continue; Com_Printf("NET_GetPacket: %s from %s\n", NET_ErrorString(), NET_AdrToString(*net_from)); continue; } if (ret == net_message->maxsize) { Com_Printf("Oversize packet from %s\n", NET_AdrToString(*net_from)); continue; } net_message->cursize = ret; return true; } return false; } /* * =========================================================================== * == */ void NET_SendPacket(netsrc_t sock, int length, void *data, netadr_t to) { int ret; struct sockaddr_storage addr; int net_socket; int addr_size = sizeof(struct sockaddr_in); switch (to.type) { case NA_LOOPBACK: NET_SendLoopPacket(sock, length, data, to); return; break; case NA_BROADCAST: case NA_IP: net_socket = ip_sockets[sock]; if (!net_socket) return; break; case NA_IP6: case NA_MULTICAST6: net_socket = ip6_sockets[sock]; addr_size = sizeof(struct sockaddr_in6); if (!net_socket) return; break; case NA_IPX: case NA_BROADCAST_IPX: net_socket = ipx_sockets[sock]; if (!net_socket) return; break; default: Com_Error(ERR_FATAL, "NET_SendPacket: bad address type"); return; break; } NetadrToSockadr(&to, &addr); /* * Re-check the address family. If to.type is NA_IP6 but contains an * IPv4 mapped address, NetadrToSockadr will return an AF_INET * struct. If so, switch back to AF_INET socket. */ if (to.type == NA_IP6 && addr.ss_family == AF_INET) { net_socket = ip_sockets[sock]; addr_size = sizeof(struct sockaddr_in); if (!net_socket) return; } if (addr.ss_family == AF_INET6) { struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&addr; /* * If multicast socket, must specify scope. So * multicast_interface must be specified */ if (IN6_IS_ADDR_MULTICAST(&s6->sin6_addr)) { struct addrinfo hints; struct addrinfo *res; char tmp [128], mcast_addr[128], mcast_port[10]; int error; if (multicast_interface != NULL) { /* * Do a getnameinfo/getaddrinfo cycle to * calculate the scope_id of the multicast * address. getaddrinfo is passed a multicast * address of the form * ff0x::xxx%multicast_interface */ #ifdef HAVE_SIN6_LEN error = getnameinfo((struct sockaddr *)s6, s6->sin6_len, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST); #else error = getnameinfo((struct sockaddr *)s6, sizeof(struct sockaddr_in6), tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST); #endif if (error) { Com_Printf("NET_SendPacket: getnameinfo: %s", gai_strerror(error)); return; } Com_sprintf(mcast_addr, sizeof(mcast_addr), "%s%%%s", tmp, multicast_interface); Com_sprintf(mcast_port, sizeof(mcast_port), "%d", ntohs(s6->sin6_port)); memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_INET6; hints.ai_socktype = SOCK_DGRAM; hints.ai_flags = AI_NUMERICHOST; error = getaddrinfo(mcast_addr, mcast_port, &hints, &res); if (error) { Com_Printf("NET_SendPacket: getaddrinfo: %s", gai_strerror(error)); return; } /* * sockaddr_in6 should now have a valid * scope_id. */ memcpy(s6, res->ai_addr, res->ai_addrlen); } else { Com_Printf("NET_SendPacket: IPv6 multicast destination but +set multicast not specified: %s\n", inet_ntop(AF_INET6, &s6->sin6_addr, tmp, sizeof(tmp))); return; } } } ret = sendto(net_socket, data, length, 0, (struct sockaddr *)&addr, addr_size); if (ret == -1) { Com_Printf("NET_SendPacket ERROR: %s to %s\n", NET_ErrorString(), NET_AdrToString(to)); } } /* * =========================================================================== * == */ /* * ==================== 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 (!ip6_sockets[NS_SERVER]) ip6_sockets[NS_SERVER] = NET_Socket(ip->string, port->value, NS_SERVER, AF_INET6); if (!ip6_sockets[NS_CLIENT]) ip6_sockets[NS_CLIENT] = NET_Socket(ip->string, PORT_ANY, NS_CLIENT, AF_INET6); if (!ip_sockets[NS_SERVER]) ip_sockets[NS_SERVER] = NET_Socket(ip->string, port->value, NS_SERVER, AF_INET); if (!ip_sockets[NS_CLIENT]) ip_sockets[NS_CLIENT] = NET_Socket(ip->string, PORT_ANY, NS_CLIENT, AF_INET); } /* * ==================== 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 (ip6_sockets[i]) { close(ip6_sockets[i]); ip6_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, netsrc_t type, int family) { char Buf[BUFSIZ], *Host, *Service; int newsocket , Error; struct sockaddr_storage ss; struct addrinfo hints, *res, *ai; qboolean _true = true; int i = 1; #ifdef IPV6_BINDV6ONLY int dummy; #endif struct ipv6_mreq mreq; cvar_t *mcast; memset(&hints, 0, sizeof(hints)); hints.ai_family = family; hints.ai_socktype = SOCK_DGRAM; hints.ai_protocol = IPPROTO_UDP; hints.ai_flags = AI_PASSIVE; if (!net_interface || !net_interface[0] || !stricmp(net_interface, "localhost")) Host = (family == AF_INET6) ? "::" : "0.0.0.0"; else Host = net_interface; if (port == PORT_ANY) Service = NULL; else { Com_sprintf(Buf, sizeof(Buf), "%5d", port); Service = Buf; } if ((Error = getaddrinfo(Host, Service, &hints, &res))) { /* * Com_Printf("NET_Socket: getaddrinfo: %s\n", gai_strerror * (Error)); */ return 0; } for (ai = res; ai != NULL; ai = ai->ai_next) { if ((newsocket = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)) == -1) { Com_Printf("NET_Socket: socket: %s\n", strerror(errno)); continue; } /* make it non-blocking */ if (ioctl(newsocket, FIONBIO, (char *)&_true) == -1) { Com_Printf("NET_Socket: ioctl FIONBIO: %s\n", strerror(errno)); continue; } #ifdef IPV6_BINDV6ONLY if (family == AF_INET6) if (setsockopt(newsocket, IPPROTO_IPV6, IPV6_BINDV6ONLY, &dummy, sizeof(dummy)) < 0) { Com_Printf("NET_Socket: setsockopt IPV6_BINDV6ONLY: %s\n", strerror(errno)); } #endif if (family == AF_INET) { /* make it broadcast capable */ if (setsockopt(newsocket, SOL_SOCKET, SO_BROADCAST, (char *)&i, sizeof(i)) == -1) { Com_Printf("ERROR: NET_Socket: setsockopt SO_BROADCAST:%s\n", NET_ErrorString()); return 0; } } if (bind(newsocket, ai->ai_addr, ai->ai_addrlen) < 0) { Com_Printf("NET_Socket: bind: %s\n", strerror(errno)); } else { memcpy(&ss, ai->ai_addr, ai->ai_addrlen); break; } } if (res != NULL) freeaddrinfo(res); if (ai == NULL) return 0; switch (ss.ss_family) { case AF_INET: break; case AF_INET6: /* * Multicast outgoing interface is specified for client and * server (+set multicast ) */ mcast = Cvar_Get("multicast", "NULL", CVAR_NOSET); multicast_interface = (strcmp(mcast->string, "NULL") ? mcast->string : NULL); if (multicast_interface != NULL) { /* * multicast_interface is a global variable. Also * used in NET_SendPacket() */ if ((mreq.ipv6mr_interface = if_nametoindex(multicast_interface)) == 0) { Com_Printf("NET_Socket: invalid interface: %s", multicast_interface); } if (setsockopt(newsocket, IPPROTO_IPV6, IPV6_MULTICAST_IF, &mreq.ipv6mr_interface, sizeof(mreq.ipv6mr_interface)) < 0) { Com_Printf("NET_Socket: IPV6_MULTICAST_IF: %s", strerror(errno)); } /* Join multicast group ONLY if server */ if (type == NS_SERVER) { if (inet_pton(AF_INET6, QUAKE2MCAST, &mreq.ipv6mr_multiaddr.s6_addr) != 1) { Com_Printf("NET_Socket: inet_pton: %s", strerror(errno)); } if (setsockopt(newsocket, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq, sizeof(mreq)) < 0) { Com_Printf("NET_Socket: IPV6_JOIN_GROUP: %s", strerror(errno)); } } } break; } 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; extern cvar_t *dedicated; extern qboolean stdin_active; if ((!ip_sockets[NS_SERVER] && !ip6_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); /* IPv4 network socket */ FD_SET(ip6_sockets[NS_SERVER], &fdset); /* IPv6 network socket */ timeout.tv_sec = msec / 1000; timeout.tv_usec = (msec % 1000) * 1000; select(MAX(ip_sockets[NS_SERVER], ip6_sockets[NS_SERVER]) + 1, &fdset, NULL, NULL, &timeout); }