X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=src%2Fserver.c;h=9dc0c29b57969c59bfc0a5222f2d33e6dffef3b6;hb=d723b45fc42e04b9179ba29c65efc9484ec2924c;hp=827b99b4f3b47050f4b0c068fcadb88f006fecb1;hpb=6b301bd735bbbe384057a463ede871616efb5861;p=umurmur.git diff --git a/src/server.c b/src/server.c index 827b99b..9dc0c29 100644 --- a/src/server.c +++ b/src/server.c @@ -44,68 +44,114 @@ #include "client.h" #include "conf.h" #include "log.h" +#include "memory.h" #include "timer.h" #include "version.h" - -#define LISTEN_SOCK 0 -#define TCP_SOCK 0 -#define UDP_SOCK 1 - -#define TCP6_SOCK 2 -#define UDP6_SOCK 3 +#include "util.h" +#include "sharedmemory.h" /* globals */ -int udpsock; bool_t shutdown_server; extern char *bindaddr; extern char *bindaddr6; extern int bindport; extern int bindport6; +int* udpsocks; +bool_t hasv4 = true, hasv6 = true; + +const int on = 1; +int nofServerSocks = 4; + +/* Check which IP versions are supported by the system. */ +void checkIPversions() +{ + int testsocket = -1; + + testsocket = socket(PF_INET, SOCK_STREAM, 0); + hasv4 = (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT) ? false : true; + if (!(testsocket < 0)) close(testsocket); + + testsocket = socket(PF_INET6, SOCK_STREAM, 0); + hasv6 = (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT) ? false : true; + if (!(testsocket < 0)) close(testsocket); + + if(!hasv4) + { + Log_info("IPv4 is not supported by this system"); + nofServerSocks -= 2; + } + + if(!hasv6) + { + Log_info("IPv6 is not supported by this system"); + nofServerSocks -= 2; + } + if(nofServerSocks == 0) + { + Log_fatal("Neither IPv4 nor IPv6 are supported by this system"); + } +} +/* Initialize the address structures for IPv4 and IPv6 */ struct sockaddr_storage** Server_setupAddressesAndPorts() { - struct sockaddr_storage** addresses; + struct sockaddr_storage** addresses = Memory_safeCalloc(2, sizeof(void*)); - struct sockaddr_storage* v4address = calloc(1, sizeof(struct sockaddr_storage)); - v4address->ss_family = AF_INET; - v4address->ss_len = sizeof(struct sockaddr_storage); - struct sockaddr_storage* v6address = calloc(1, sizeof(struct sockaddr_storage)); - v6address->ss_family = AF_INET; - v6address->ss_len = sizeof(struct sockaddr_storage); + struct sockaddr_storage* v4address = Memory_safeCalloc(1, sizeof(struct sockaddr_storage)); + v4address->ss_family = AF_INET; + struct sockaddr_storage* v6address = Memory_safeCalloc(1, sizeof(struct sockaddr_storage)); + v6address->ss_family = AF_INET6; - int error = 0; +#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) + v4address->ss_len = sizeof(struct sockaddr_storage); + v6address->ss_len = sizeof(struct sockaddr_storage); +#endif - error = inet_pton(AF_INET, (!bindaddr) ? ((getStrConf(BINDADDR)) ? getStrConf(BINDADDR) : "0.0.0.0") - : bindaddr, &(((struct sockaddr_in*)v4address)->sin_addr)); - if (error == 0) Log_fatal("Invalid IPv4 address supplied!"); + int error = 0; - error = inet_pton(AF_INET, (!bindaddr6) ? ((getStrConf(BINDADDR6)) ? getStrConf(BINDADDR6) : "::") - : bindaddr6, &(((struct sockaddr_in6*)v6address)->sin6_addr)); - if (error == 0) Log_fatal("Invalid IPv6 address supplied!"); + error = inet_pton(AF_INET, (!bindaddr) ? ((getStrConf(BINDADDR)) ? getStrConf(BINDADDR) : "0.0.0.0") + : bindaddr, &(((struct sockaddr_in*)v4address)->sin_addr)); + if (error == 0) + Log_fatal("Invalid IPv4 address supplied!"); + else if (error == -1) + Log_warn("Could not allocate IPv4 address"); - ((struct sockaddr_in*)v4address)->sin_port = htons((bindport) ? bindport : getIntConf(BINDPORT)); - ((struct sockaddr_in6*)v6address)->sin6_port = htons((bindport) ? bindport : getIntConf(BINDPORT)); + error = inet_pton(AF_INET6, (!bindaddr6) ? ((getStrConf(BINDADDR6)) ? getStrConf(BINDADDR6) : "::") + : bindaddr6, &(((struct sockaddr_in6*)v6address)->sin6_addr)); + if (error == 0) + Log_fatal("Invalid IPv6 address supplied!"); + else if (error == -1) + Log_warn("Could not allocate IPv6 address"); - addresses[0] = v4address; - addresses[1] = v6address; + ((struct sockaddr_in*)v4address)->sin_port = htons((bindport) ? bindport : getIntConf(BINDPORT)); + ((struct sockaddr_in6*)v6address)->sin6_port = htons((bindport6) ? bindport6 : getIntConf(BINDPORT6)); - return addresses; + addresses[0] = v4address; + addresses[1] = v6address; + + return addresses; } void Server_runLoop(struct pollfd* pollfds) - { - int timeout = 1000, rc, clientcount; - etimer_t janitorTimer; +{ + int timeout, rc, clientcount; + etimer_t janitorTimer; Timer_init(&janitorTimer); while (!shutdown_server) { - struct sockaddr_in remote; + struct sockaddr_storage remote; int i; - pollfds[UDP_SOCK].revents = 0; - pollfds[TCP_SOCK].revents = 0; - clientcount = Client_getfds(&pollfds[2]); +#ifdef USE_SHAREDMEMORY_API + Sharedmemory_alivetick(); +#endif + + for(i = 0; i < nofServerSocks; i++) { + pollfds[i].revents = 0; + } + + clientcount = Client_getfds(&pollfds[nofServerSocks]); timeout = (int)(1000000LL - (int64_t)Timer_elapsed(&janitorTimer)) / 1000LL; if (timeout <= 0) { @@ -113,9 +159,9 @@ void Server_runLoop(struct pollfd* pollfds) Timer_restart(&janitorTimer); timeout = (int)(1000000LL - (int64_t)Timer_elapsed(&janitorTimer)) / 1000LL; } - rc = poll(pollfds, clientcount + 2, timeout); - if (rc == 0) { /* Timeout */ - /* Do maintenance */ + rc = poll(pollfds, clientcount + nofServerSocks, timeout); + if (rc == 0) { + /* Poll timed out, do maintenance */ Timer_restart(&janitorTimer); Client_janitor(); continue; @@ -124,106 +170,176 @@ void Server_runLoop(struct pollfd* pollfds) if (errno == EINTR) /* signal */ continue; else - Log_fatal("poll: error %d", errno); + Log_fatal("poll: error %d (%s)", errno, strerror(errno)); } - if (pollfds[LISTEN_SOCK].revents) { /* New tcp connection */ - int tcpfd, flag = 1; - uint32_t addrlen; - addrlen = sizeof(struct sockaddr_in); - tcpfd = accept(pollfds[LISTEN_SOCK].fd, (struct sockaddr*)&remote, &addrlen); - fcntl(tcpfd, F_SETFL, O_NONBLOCK); - setsockopt(tcpfd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)); - Log_debug("Connection from %s port %d\n", inet_ntoa(remote.sin_addr), - ntohs(remote.sin_port)); - if (Client_add(tcpfd, &remote) < 0) - close(tcpfd); + + /* Check for new connection */ + for (i = 0; i < nofServerSocks / 2; i++) { + if (pollfds[i].revents) { + int tcpfd; + uint32_t addrlen = sizeof(struct sockaddr_storage); + tcpfd = accept(pollfds[i].fd, (struct sockaddr *)&remote, &addrlen); + fcntl(tcpfd, F_SETFL, O_NONBLOCK); + setsockopt(tcpfd, IPPROTO_TCP, TCP_NODELAY, (char *) &on, sizeof(int)); + char *addressString = Util_addressToString(&remote); + Log_debug("Connection from %s port %d\n", addressString, Util_addressToPort(&remote)); + free(addressString); + if (Client_add(tcpfd, &remote) < 0) + close(tcpfd); + } } - if (pollfds[UDP_SOCK].revents) { - Client_read_udp(); + for (i = nofServerSocks / 2; i < nofServerSocks; i++) { + if (pollfds[i].revents) + Client_read_udp(udpsocks[i - nofServerSocks / 2]); } + for (i = 0; i < clientcount; i++) { - if (pollfds[i + 2].revents & POLLIN) { - Client_read_fd(pollfds[i + 2].fd); - } - if (pollfds[i + 2].revents & POLLOUT) { - Client_write_fd(pollfds[i + 2].fd); - } + if (pollfds[nofServerSocks + i].revents & POLLIN) + Client_read_fd(pollfds[nofServerSocks + i].fd); + + if (pollfds[nofServerSocks + i].revents & POLLOUT) + Client_write_fd(pollfds[nofServerSocks + i].fd); } +#ifdef USE_SHAREDMEMORY_API + Sharedmemory_update(); +#endif } - } +} + +void Server_setupTCPSockets(struct sockaddr_storage* addresses[2], struct pollfd* pollfds) +{ + int yes = 1; + int sockets[2]; + + if (hasv4) { + /* IPv4 socket setup */ + sockets[0] = socket(PF_INET, SOCK_STREAM, 0); + if (sockets[0] < 0) + Log_fatal("socket IPv4"); + if (setsockopt(sockets[0], SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) != 0) + Log_fatal("setsockopt IPv4: %s", strerror(errno)); + if (bind(sockets[0], (struct sockaddr *)addresses[0], sizeof (struct sockaddr_in)) < 0) { + char *addressString = Util_addressToString(addresses[0]); + Log_fatal("bind %s %d: %s", addressString, Util_addressToPort(addresses[0]), strerror(errno)); + free(addressString); + } + if (listen(sockets[0], 3) < 0) + Log_fatal("listen IPv4"); + fcntl(sockets[0], F_SETFL, O_NONBLOCK); + + pollfds[0].fd = sockets[0]; + pollfds[0].events = POLLIN; + } + + if (hasv6) { + /* IPv6 socket setup */ + sockets[1] = socket(PF_INET6, SOCK_STREAM, 0); + if (sockets[1] < 0) + Log_fatal("socket IPv6: %s", strerror(errno)); + if (setsockopt(sockets[1], SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) != 0) + Log_fatal("setsockopt IPv6: %s", strerror(errno)); + if (setsockopt(sockets[1], IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof(int)) != 0) + Log_fatal("setsockopt IPv6: %s", strerror(errno)); + if (bind(sockets[1], (struct sockaddr *)addresses[1], sizeof (struct sockaddr_in6)) < 0) { + char *addressString = Util_addressToString(addresses[1]); + Log_fatal("bind %s %d: %s", addressString, Util_addressToPort(addresses[1]), strerror(errno)); + free(addressString); + } + if (listen(sockets[1], 3) < 0) + Log_fatal("listen IPv6"); + fcntl(sockets[1], F_SETFL, O_NONBLOCK); + + + /* If there is an IPv4 address, then IPv6 will use the second socket, otherwise it uses the first */ + pollfds[(hasv4) ? 1 : 0].fd = sockets[1]; + pollfds[(hasv4) ? 1 : 0].events = POLLIN; + } +} + +void Server_setupUDPSockets(struct sockaddr_storage* addresses[2], struct pollfd* pollfds) +{ + int val = 0; + int sockets[2] = {-1, -1}; + + udpsocks = Memory_safeCalloc(nofServerSocks / 2, sizeof(int)); + + if (hasv4) { + sockets[0] = socket(PF_INET, SOCK_DGRAM, 0); + if (bind(sockets[0], (struct sockaddr *) addresses[0], sizeof (struct sockaddr_in)) < 0) { + char *addressString = Util_addressToString(addresses[0]); + Log_fatal("bind %s %d: %s", addressString, Util_addressToPort(addresses[0]), strerror(errno)); + free(addressString); + } + val = 0xe0; + if (setsockopt(sockets[0], IPPROTO_IP, IP_TOS, &val, sizeof(val)) < 0) + Log_warn("Server: Failed to set TOS for UDP Socket"); + val = 0x80; + if (setsockopt(sockets[0], IPPROTO_IP, IP_TOS, &val, sizeof(val)) < 0) + Log_warn("Server: Failed to set TOS for UDP Socket"); + + fcntl(sockets[0], F_SETFL, O_NONBLOCK); + pollfds[(hasv6) ? 2 : 1].fd = sockets[0]; + pollfds[(hasv6) ? 2 : 1].events = POLLIN | POLLHUP | POLLERR; + udpsocks[0] = sockets[0]; + } + + if (hasv6) { + sockets[1] = socket(PF_INET6, SOCK_DGRAM, 0); + if (setsockopt(sockets[1], IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(int)) != 0) + Log_fatal("setsockopt IPv6: %s", strerror(errno)); + if (bind(sockets[1], (struct sockaddr *) addresses[1], sizeof (struct sockaddr_in6)) < 0) { + char *addressString = Util_addressToString(addresses[1]); + Log_fatal("bind %s %d: %s", addressString, Util_addressToPort(addresses[1]), strerror(errno)); + free(addressString); + } + val = 0xe0; + if (setsockopt(sockets[1], IPPROTO_IPV6, IPV6_TCLASS, &val, sizeof(val)) < 0) + Log_warn("Server: Failed to set TOS for UDP Socket"); + val = 0x80; + if (setsockopt(sockets[1], IPPROTO_IPV6, IPV6_TCLASS, &val, sizeof(val)) < 0) + Log_warn("Server: Failed to set TOS for UDP Socket"); + + fcntl(sockets[1], F_SETFL, O_NONBLOCK); + pollfds[(hasv4) ? 3 : 1].fd = sockets[1]; + pollfds[(hasv4) ? 3 : 1].events = POLLIN | POLLHUP | POLLERR; + udpsocks[(hasv4) ? 1 : 0] = sockets[1]; + } + +} void Server_run() { - int rc; struct pollfd *pollfds; - int tcpsock, sockopt = 1; - struct sockaddr_in sin; - int val; - unsigned short port; - in_addr_t inet_address; - /* max clients + listen sock + udp sock + client connecting that will be disconnected */ - pollfds = malloc((getIntConf(MAX_CLIENTS) + 3) * sizeof(struct pollfd)); - if (pollfds == NULL) - Log_fatal("out of memory"); + checkIPversions(); + + /* max clients + server sokets + client connecting that will be disconnected */ + pollfds = Memory_safeCalloc((getIntConf(MAX_CLIENTS) + nofServerSocks + 1) , sizeof(struct pollfd)); /* Figure out bind address and port */ - struct sockaddr_storage** addresses = Server_setupAddressesAndPorts(); - - /* Prepare TCP socket */ - memset(&sin, 0, sizeof(sin)); - tcpsock = socket(PF_INET, SOCK_STREAM, 0); - if (tcpsock < 0) - Log_fatal("socket"); - if (setsockopt(tcpsock, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(int)) != 0) - Log_fatal("setsockopt: %s", strerror(errno)); - sin.sin_family = AF_INET; - sin.sin_port = port; - sin.sin_addr.s_addr = inet_address; - - rc = bind(tcpsock, (struct sockaddr *) &sin, sizeof (struct sockaddr_in)); - if (rc < 0) Log_fatal("bind: %s", strerror(errno)); - rc = listen(tcpsock, 3); - if (rc < 0) Log_fatal("listen"); - fcntl(tcpsock, F_SETFL, O_NONBLOCK); - - pollfds[LISTEN_SOCK].fd = tcpsock; - pollfds[LISTEN_SOCK].events = POLLIN; - - /* Prepare UDP socket */ - memset(&sin, 0, sizeof(sin)); - udpsock = socket(PF_INET, SOCK_DGRAM, 0); - sin.sin_family = AF_INET; - sin.sin_port = port; - sin.sin_addr.s_addr = inet_address; - - rc = bind(udpsock, (struct sockaddr *) &sin, sizeof (struct sockaddr_in)); - if (rc < 0) - Log_fatal("bind %d %s: %s", getIntConf(BINDPORT), getStrConf(BINDADDR), strerror(errno)); - val = 0xe0; - rc = setsockopt(udpsock, IPPROTO_IP, IP_TOS, &val, sizeof(val)); - if (rc < 0) - Log_warn("Server: Failed to set TOS for UDP Socket"); - val = 0x80; - rc = setsockopt(udpsock, IPPROTO_IP, IP_TOS, &val, sizeof(val)); - if (rc < 0) - Log_warn("Server: Failed to set TOS for UDP Socket"); - - fcntl(udpsock, F_SETFL, O_NONBLOCK); - pollfds[UDP_SOCK].fd = udpsock; - pollfds[UDP_SOCK].events = POLLIN | POLLHUP | POLLERR; + struct sockaddr_storage** addresses = Server_setupAddressesAndPorts(); + + /* Prepare TCP sockets */ + Server_setupTCPSockets(addresses, pollfds); + + /* Prepare UDP sockets */ + Server_setupUDPSockets(addresses, pollfds); Log_info("uMurmur version %s ('%s') protocol version %d.%d.%d", - UMURMUR_VERSION, UMURMUR_CODENAME, PROTVER_MAJOR, PROTVER_MINOR, PROTVER_PATCH); + UMURMUR_VERSION, UMURMUR_CODENAME, PROTVER_MAJOR, PROTVER_MINOR, PROTVER_PATCH); Log_info("Visit http://code.google.com/p/umurmur/"); /* Main server loop */ - Server_runLoop(pollfds); + Server_runLoop(pollfds); - /* Disconnect clients */ + /* Disconnect clients and cleanup memory */ Client_disconnect_all(); free(pollfds); + free(addresses[0]); + free(addresses[1]); + free(addresses); + free(udpsocks); } void Server_shutdown()