diff options
Diffstat (limited to 'src/master/servers.c')
| -rw-r--r-- | src/master/servers.c | 666 |
1 files changed, 666 insertions, 0 deletions
diff --git a/src/master/servers.c b/src/master/servers.c new file mode 100644 index 0000000..a8412a1 --- /dev/null +++ b/src/master/servers.c @@ -0,0 +1,666 @@ +/* + servers.c + + Server list and address mapping management for dpmaster + + Copyright (C) 2004 Mathieu Olivier + + 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 +*/ + + +#include "common.h" +#include "servers.h" + + +// ---------- Constants ---------- // + +// Address hash bitmask +#define HASH_BITMASK (hash_table_size - 1) + + +// ---------- Variables ---------- // + +// All server structures are allocated in one block in the "servers" array. +// Each used slot is also part of a linked list in "hash_table". A simple +// hash of the address and port of a server gives its index in the table. +static server_t* servers = NULL; +static size_t max_nb_servers = DEFAULT_MAX_NB_SERVERS; +static size_t nb_servers = 0; +static server_t** hash_table = NULL; +static size_t hash_table_size = (1 << DEFAULT_HASH_SIZE); + +// Last allocated entry in the "servers" array. +// Used as a start index for finding a free slot in "servers" more quickly +static unsigned int last_alloc; + +// Variables for Sv_GetFirst, Sv_GetNext and Sv_RemoveCurrentAndGetNext +static server_t* crt_server = NULL; +static server_t** prev_pointer = NULL; +static int crt_hash_ind = -1; + +// List of address mappings. They are sorted by "from" field (IP, then port) +static addrmap_t* addrmaps = NULL; + + +// ---------- Private functions ---------- // + +/* +==================== +Sv_AddressHash + +Compute the hash of a server address +==================== +*/ +static unsigned int Sv_AddressHash (const struct sockaddr_in* address) +{ + qbyte* addr = (qbyte*)&address->sin_addr.s_addr; + qbyte* port = (qbyte*)&address->sin_port; + qbyte hash; + + hash = addr[0] ^ addr[1] ^ addr[2] ^ addr[3] ^ port[0] ^ port[1]; + return hash & HASH_BITMASK; +} + + +/* +==================== +Sv_RemoveAndGetNextPtr + +Remove a server from the list and returns its "next" pointer +==================== +*/ +static server_t* Sv_RemoveAndGetNextPtr (server_t* sv, server_t** prev) +{ + nb_servers--; + MsgPrint (MSG_NORMAL, + "%s:%hu timed out; %u servers currently registered\n", + inet_ntoa (sv->address.sin_addr), ntohs (sv->address.sin_port), + nb_servers); + + // Mark this structure as "free" + sv->active = qfalse; + + *prev = sv->next; + return sv->next; +} + + +/* +==================== +Sv_ResolveAddr + +Resolve an internet address +name may include a port number, after a ':' +==================== +*/ +static qboolean Sv_ResolveAddr (const char* name, struct sockaddr_in* addr) +{ + char *namecpy, *port; + struct hostent* host; + + // Create a work copy + namecpy = strdup (name); + if (namecpy == NULL) + { + MsgPrint (MSG_ERROR, + "ERROR: can't allocate enough memory to resolve %s\n", + name); + return qfalse; + } + + // Find the port in the address + port = strchr (namecpy, ':'); + if (port != NULL) + *port++ = '\0'; + + // Resolve the address + host = gethostbyname (namecpy); + if (host == NULL) + { + MsgPrint (MSG_ERROR, "ERROR: can't resolve %s\n", namecpy); + free (namecpy); + return qfalse; + } + if (host->h_addrtype != AF_INET) + { + MsgPrint (MSG_ERROR, "ERROR: %s is not an IPv4 address\n", + namecpy); + free (namecpy); + return qfalse; + } + + // Build the structure + memset (addr, 0, sizeof (*addr)); + addr->sin_family = AF_INET; + memcpy (&addr->sin_addr.s_addr, host->h_addr, + sizeof (addr->sin_addr.s_addr)); + if (port != NULL) + addr->sin_port = htons ((unsigned short)atoi (port)); + + MsgPrint (MSG_DEBUG, "\"%s\" resolved to %s:%hu\n", + name, inet_ntoa (addr->sin_addr), ntohs (addr->sin_port)); + + free (namecpy); + return qtrue; +} + + +/* +==================== +Sv_InsertAddrmapIntoList + +Insert an addrmap structure to the addrmaps list +==================== +*/ +static void Sv_InsertAddrmapIntoList (addrmap_t* new_map) +{ + addrmap_t* addrmap = addrmaps; + addrmap_t** prev = &addrmaps; + + // Stop at the end of the list, or if the addresses become too high + while (addrmap != NULL && + addrmap->from.sin_addr.s_addr <= new_map->from.sin_addr.s_addr) + { + // If we found the right place + if (addrmap->from.sin_addr.s_addr == new_map->from.sin_addr.s_addr && + addrmap->from.sin_port >= new_map->from.sin_port) + { + // If a mapping is already recorded for this address + if (addrmap->from.sin_port == new_map->from.sin_port) + { + MsgPrint (MSG_WARNING, + "WARNING: Address %s:%hu has several mappings\n", + inet_ntoa (new_map->from.sin_addr), + ntohs (new_map->from.sin_port)); + + *prev = addrmap->next; + free (addrmap); + } + break; + } + + prev = &addrmap->next; + addrmap = addrmap->next; + } + + // Insert it + new_map->next = *prev; + *prev = new_map; + + MsgPrint (MSG_NORMAL, "Address \"%s\" mapped to \"%s\" (%s:%hu)\n", + new_map->from_string, new_map->to_string, + inet_ntoa (new_map->to.sin_addr), ntohs (new_map->to.sin_port)); +} + + +/* +==================== +Sv_GetAddrmap + +Look for an address mapping corresponding to addr +==================== +*/ +static const addrmap_t* Sv_GetAddrmap (const struct sockaddr_in* addr) +{ + const addrmap_t* addrmap = addrmaps; + const addrmap_t* found = NULL; + + // Stop at the end of the list, or if the addresses become too high + while (addrmap != NULL && + addrmap->from.sin_addr.s_addr <= addr->sin_addr.s_addr) + { + // If it's the right address + if (addrmap->from.sin_addr.s_addr == addr->sin_addr.s_addr) + { + // If the exact mapping isn't there + if (addrmap->from.sin_port > addr->sin_port) + return found; + + // If we found the exact address + if (addrmap->from.sin_port == addr->sin_port) + return addrmap; + + // General mapping + // Store it in case we don't find the exact address mapping + if (addrmap->from.sin_port == 0) + found = addrmap; + } + + addrmap = addrmap->next; + } + + return found; +} + + +/* +==================== +Sv_ResolveAddrmap + +Resolve an addrmap structure and check the parameters validity +==================== +*/ +static qboolean Sv_ResolveAddrmap (addrmap_t* addrmap) +{ + // Resolve the addresses + if (!Sv_ResolveAddr (addrmap->from_string, &addrmap->from) || + !Sv_ResolveAddr (addrmap->to_string, &addrmap->to)) + return qfalse; + + // 0.0.0.0 addresses are forbidden + if (addrmap->from.sin_addr.s_addr == 0 || + addrmap->to.sin_addr.s_addr == 0) + { + MsgPrint (MSG_ERROR, + "ERROR: Mapping from or to 0.0.0.0 is forbidden\n"); + return qfalse; + } + + // Do NOT allow mapping to loopback addresses + if ((ntohl (addrmap->to.sin_addr.s_addr) >> 24) == 127) + { + MsgPrint (MSG_ERROR, + "ERROR: Mapping to a loopback address is forbidden\n"); + return qfalse; + } + + return qtrue; +} + + +/* +==================== +Sv_IsActive + +Return qtrue if a server is active. +Test if the server has timed out and remove it if it's the case. +==================== +*/ +static qboolean Sv_IsActive (server_t* server) +{ + + // If the entry isn't even used + if (! server->active) + return qfalse; + + // If the server has timed out + if (server->timeout < crt_time) + { + unsigned int hash; + server_t **prev, *sv; + + hash = Sv_AddressHash (&server->address); + prev = &hash_table[hash]; + sv = hash_table[hash]; + + while (sv != server) + { + prev = &sv->next; + sv = sv->next; + } + + Sv_RemoveAndGetNextPtr (sv, prev); + return qfalse; + } + + return qtrue; +} + + +// ---------- Public functions (servers) ---------- // + +/* +==================== +Sv_SetHashSize + +Set a new hash size value +==================== +*/ +qboolean Sv_SetHashSize (unsigned int size) +{ + // Too late? + if (hash_table != NULL) + return qfalse; + + // Too big? + if (size > MAX_HASH_SIZE) + return qfalse; + + hash_table_size = 1 << size; + return qtrue; +} + + +/* +==================== +Sv_SetMaxNbServers + +Set a new hash size value +==================== +*/ +qboolean Sv_SetMaxNbServers (unsigned int nb) +{ + // Too late? + if (servers != NULL) + return qfalse; + + max_nb_servers = nb; + return qtrue; +} + + +/* +==================== +Sv_Init + +Initialize the server list and hash table +==================== +*/ +qboolean Sv_Init (void) +{ + size_t array_size; + + // Allocate "servers" and clean it + array_size = max_nb_servers * sizeof (servers[0]); + servers = malloc (array_size); + if (!servers) + { + MsgPrint (MSG_ERROR, + "ERROR: can't allocate the servers array (%s)\n", + strerror (errno)); + return qfalse; + } + last_alloc = max_nb_servers - 1; + memset (servers, 0, array_size); + MsgPrint (MSG_NORMAL, "%u server records allocated\n", max_nb_servers); + + // Allocate "hash_table" and clean it + array_size = hash_table_size * sizeof (hash_table[0]); + hash_table = malloc (array_size); + if (!hash_table) + { + MsgPrint (MSG_ERROR, "ERROR: can't allocate the hash table (%s)\n", + strerror (errno)); + free (servers); + return qfalse; + } + memset (hash_table, 0, array_size); + MsgPrint (MSG_NORMAL, + "Hash table allocated (%u entries)\n", hash_table_size); + + return qtrue; +} + + +/* +==================== +Sv_GetByAddr + +Search for a particular server in the list; add it if necessary +==================== +*/ +server_t* Sv_GetByAddr (const struct sockaddr_in* address, qboolean add_it) +{ + server_t **prev, *sv; + unsigned int hash; + const addrmap_t* addrmap = Sv_GetAddrmap (address); + unsigned int startpt; + + // Allow servers on a loopback address ONLY if a mapping is defined for them + if ((ntohl (address->sin_addr.s_addr) >> 24) == 127 && addrmap == NULL) + { + MsgPrint (MSG_WARNING, + "WARNING: server %s isn't allowed (loopback address)\n", + peer_address); + return NULL; + } + + hash = Sv_AddressHash (address); + prev = &hash_table[hash]; + sv = hash_table[hash]; + + while (sv != NULL) + { + // We check the timeout values while browsing this list + if (sv->timeout < crt_time) + { + sv = Sv_RemoveAndGetNextPtr (sv, prev); + continue; + } + + // Found! + if (sv->address.sin_addr.s_addr == address->sin_addr.s_addr && + sv->address.sin_port == address->sin_port) + { + // Put it on top of the list (it's useful because heartbeats + // are almost always followed by infoResponses) + *prev = sv->next; + sv->next = hash_table[hash]; + hash_table[hash] = sv; + + return sv; + } + + prev = &sv->next; + sv = sv->next; + } + + if (! add_it) + return NULL; + + // Look for the first free entry in "servers" + startpt = last_alloc; + for (;;) + { + last_alloc = (last_alloc + 1) % max_nb_servers; + + // Free entry found? + if (!Sv_IsActive (&servers[last_alloc])) + break; + + // No more room + if (last_alloc == startpt) + return NULL; + } + sv = &servers[last_alloc]; + + // Initialize the structure + memset (sv, 0, sizeof (*sv)); + memcpy (&sv->address, address, sizeof (sv->address)); + sv->addrmap = addrmap; + + // Add it to the list it belongs to + sv->next = hash_table[hash]; + hash_table[hash] = sv; + nb_servers++; + + MsgPrint (MSG_NORMAL, + "New server added: %s; %u servers are currently registered\n", + peer_address, nb_servers); + MsgPrint (MSG_DEBUG, + " - index: %u\n" + " - hash: 0x%02X\n", + last_alloc, hash); + + return sv; +} + + +/* +==================== +Sv_GetFirst + +Get the first server in the list +==================== +*/ +server_t* Sv_GetFirst (void) +{ + crt_server = NULL; + prev_pointer = NULL; + crt_hash_ind = -1; + + return Sv_GetNext (); +} + + +/* +==================== +Sv_GetNext + +Get the next server in the list +==================== +*/ +server_t* Sv_GetNext (void) +{ + for (;;) + { + // If there is a current server, follow the link + if (crt_server != NULL) + { + prev_pointer = &crt_server->next; + crt_server = crt_server->next; + } + + // If we don't have the next server yet + if (crt_server == NULL) + { + // Search the hash table for the next server + while (crt_hash_ind < (int)(hash_table_size - 1)) + { + crt_hash_ind++; + + if (hash_table[crt_hash_ind] != NULL) + { + crt_server = hash_table[crt_hash_ind]; + prev_pointer = &hash_table[crt_hash_ind]; + break; + } + } + } + + // Did we hit the end of the list? + if (crt_server == NULL) + return NULL; + + // If the new current server has timed out, remove it + if (crt_server->timeout < crt_time) + crt_server = Sv_RemoveAndGetNextPtr (crt_server, prev_pointer); + else + return crt_server; + } +} + + +// ---------- Public functions (address mappings) ---------- // + +/* +==================== +Sv_AddAddressMapping + +Add an unresolved address mapping to the list +mapping must be of the form "addr1:port1=addr2:port2", ":portX" are optional +==================== +*/ +qboolean Sv_AddAddressMapping (const char* mapping) +{ + char *map_string, *to_ip; + addrmap_t* addrmap; + + // Get a working copy of the mapping string + map_string = strdup (mapping); + if (map_string == NULL) + { + MsgPrint (MSG_ERROR, + "ERROR: can't allocate address mapping string\n"); + return qfalse; + } + + // Find the '=' + to_ip = strchr (map_string, '='); + if (to_ip == NULL) + { + MsgPrint (MSG_ERROR, + "ERROR: invalid syntax in address mapping string\n"); + free (map_string); + return qfalse; + } + *to_ip++ = '\0'; + + // Allocate the structure + addrmap = malloc (sizeof (*addrmap)); + if (addrmap == NULL) + { + MsgPrint (MSG_ERROR, + "ERROR: can't allocate address mapping structure\n"); + free (map_string); + return qfalse; + } + memset (addrmap, 0, sizeof (*addrmap)); + addrmap->from_string = strdup (map_string); + addrmap->to_string = strdup (to_ip); + if (addrmap->from_string == NULL || addrmap->to_string == NULL) + { + MsgPrint (MSG_ERROR, + "ERROR: can't allocate address mapping strings\n"); + free (addrmap->to_string); + free (addrmap->from_string); + free (map_string); + return qfalse; + } + + // Add it on top of "addrmaps" + addrmap->next = addrmaps; + addrmaps = addrmap; + + return qtrue; +} + + +/* +==================== +Sv_ResolveAddressMappings + +Resolve the address mapping list +==================== +*/ +qboolean Sv_ResolveAddressMappings (void) +{ + addrmap_t* unresolved = addrmaps; + addrmap_t* addrmap; + qboolean succeeded = qtrue; + + addrmaps = NULL; + + while (unresolved != NULL) + { + // Remove it from the unresolved list + addrmap = unresolved; + unresolved = unresolved->next; + + // Continue the resolution, even if there's an error + if (!Sv_ResolveAddrmap (addrmap)) + { + free (addrmap->from_string); + free (addrmap->to_string); + free (addrmap); + succeeded = qfalse; + } + else + Sv_InsertAddrmapIntoList (addrmap); + } + + return succeeded; +} |