X-Git-Url: http://git.pk910.de/?a=blobdiff_plain;f=ircd%2Flistener.c;h=5339fd9f52896cfc4f28c280a31fe70be750564f;hb=c13fbd5384338be6c99d529db9b6ba787afcb1c0;hp=fab23846c82ec68d7143fbfe812ac9329b54247e;hpb=f4858b15c06391be73006c63b42aa1d31fd4c87e;p=ircu2.10.12-pk.git diff --git a/ircd/listener.c b/ircd/listener.c index fab2384..5339fd9 100644 --- a/ircd/listener.c +++ b/ircd/listener.c @@ -15,25 +15,35 @@ * 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., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * $Id$ */ +/** @file + * @brief Implementation for handling listening sockets. + * @version $Id$ + */ +#include "config.h" + #include "listener.h" #include "client.h" #include "ircd.h" #include "ircd_alloc.h" +#include "ircd_events.h" +#include "ircd_features.h" +#include "ircd_log.h" #include "ircd_osdep.h" #include "ircd_reply.h" +#include "ircd_snprintf.h" #include "ircd_string.h" +#include "match.h" #include "numeric.h" #include "s_bsd.h" #include "s_conf.h" #include "s_misc.h" +#include "s_stats.h" #include "send.h" -#include "sprintf_irc.h" +#include "ssl.h" #include "sys.h" /* MAXCLIENTS */ -#include +/* #include -- Now using assert in ircd_log.h */ #include #include #include @@ -41,28 +51,30 @@ #include #include #include -#include - -#ifndef INADDR_NONE -#define INADDR_NONE ((unsigned int) 0xffffffff) -#endif - -int tos_server = 0x08; // Low delay -int tos_client = 0x08; // Low delay +/** List of listening sockets. */ struct Listener* ListenerPollList = 0; -static struct Listener* make_listener(int port, struct in_addr addr) +static void accept_connection(struct Event* ev); + +/** Allocate and initialize a new Listener structure for a particular + * socket address. + * @param[in] port Port number to listen on. + * @param[in] addr Local address to listen on. + * @return Newly allocated and initialized Listener. + */ +static struct Listener* make_listener(int port, const struct irc_in_addr *addr) { - struct Listener* listener = + struct Listener* listener = (struct Listener*) MyMalloc(sizeof(struct Listener)); assert(0 != listener); memset(listener, 0, sizeof(struct Listener)); - listener->fd = -1; - listener->port = port; - listener->addr.s_addr = addr.s_addr; + listener->fd_v4 = -1; + listener->fd_v6 = -1; + listener->addr.port = port; + memcpy(&listener->addr.addr, addr, sizeof(listener->addr.addr)); #ifdef NULL_POINTER_NOT_ZERO listener->next = NULL; @@ -71,28 +83,33 @@ static struct Listener* make_listener(int port, struct in_addr addr) return listener; } +/** Deallocate a Listener structure. + * @param[in] listener Listener to be freed. + */ static void free_listener(struct Listener* listener) { assert(0 != listener); MyFree(listener); } +/** Maximum length for a port number. */ #define PORTNAMELEN 10 /* ":31337" */ -/* - * get_listener_name - return displayable listener name and port - * returns "host.foo.org:6667" for a given listener +/** Return displayable listener name and port. + * @param[in] listener %Listener to format as a text string. + * @return Pointer to a static buffer that contains "server.name:6667". */ const char* get_listener_name(const struct Listener* listener) { static char buf[HOSTLEN + PORTNAMELEN + 4]; assert(0 != listener); - sprintf_irc(buf, "%s:%u", cli_name(&me), listener->port); + ircd_snprintf(0, buf, sizeof(buf), "%s:%u", cli_name(&me), listener->addr.port); return buf; } -/* - * count_listener_memory - count memory and listeners +/** Count allocated listeners and the memory they use. + * @param[out] count_out Receives number of allocated listeners. + * @param[out] size_out Receives bytes used by listeners. */ void count_listener_memory(int* count_out, size_t* size_out) { @@ -105,35 +122,59 @@ void count_listener_memory(int* count_out, size_t* size_out) *count_out = count; *size_out = count * sizeof(struct Listener); } - -/* - * show_ports - send port listing to a client - * inputs - pointer to client to show ports to - * output - none - * side effects - show ports - * author - Dianora + +/** Report listening ports to a client. + * @param[in] sptr Client requesting statistics. + * @param[in] sd Stats descriptor for request (ignored). + * @param[in] param Extra parameter from user (port number to search for). */ -void show_ports(struct Client* sptr, int show_hidden, int port, int count) +void show_ports(struct Client* sptr, const struct StatDesc* sd, + char* param) { - struct Listener* listener = 0; - char flags[8]; + struct Listener *listener = 0; + char flags[9]; + int show_hidden = IsOper(sptr); + int count = (IsOper(sptr) || MyUser(sptr)) ? 100 : 8; + int port = 0; + int len; + assert(0 != sptr); + if (param) + port = atoi(param); + for (listener = ListenerPollList; listener; listener = listener->next) { - if (port && port != listener->port) + if (port && port != listener->addr.port) continue; - flags[0] = (listener->server) ? 'S' : 'C'; - if (listener->hidden) { + len = 0; + flags[len++] = listener_server(listener) ? 'S' : 'C'; + + if (FlagHas(&listener->flags, LISTEN_SSL)) + { + flags[len++] = 'E'; + } + if (FlagHas(&listener->flags, LISTEN_HIDDEN)) + { if (!show_hidden) continue; - flags[1] = 'H'; - flags[2] = '\0'; + flags[len++] = 'H'; + } + if (FlagHas(&listener->flags, LISTEN_IPV4)) + { + flags[len++] = '4'; + if (listener->fd_v4 < 0) + flags[len++] = '-'; + } + if (FlagHas(&listener->flags, LISTEN_IPV6)) + { + flags[len++] = '6'; + if (listener->fd_v6 < 0) + flags[len++] = '-'; } - else - flags[1] = '\0'; + flags[len] = '\0'; - send_reply(sptr, RPL_STATSPLINE, listener->port, listener->ref_count, - flags, (listener->active) ? "active" : "disabled"); + send_reply(sptr, RPL_STATSPLINE, listener->addr.port, listener->ref_count, + flags, listener_active(listener) ? "active" : "disabled"); if (--count == 0) break; } @@ -151,46 +192,20 @@ void show_ports(struct Client* sptr, int show_hidden, int port, int count) #ifdef SOMAXCONN #define HYBRID_SOMAXCONN SOMAXCONN #else +/** Maximum length of socket connection backlog. */ #define HYBRID_SOMAXCONN 64 #endif -static int inetport(struct Listener* listener) +/** Set or update socket options for \a listener. + * @param[in] listener Listener to determine socket option values. + * @param[in] fd File descriptor being updated. + * @return Non-zero on success, zero on failure. + */ +static int set_listener_options(struct Listener *listener, int fd) { - struct sockaddr_in sin; - int fd; - - /* - * At first, open a new socket - */ - if (-1 == (fd = socket(AF_INET, SOCK_STREAM, 0))) { - report_error(SOCKET_ERROR_MSG, get_listener_name(listener), errno); - return 0; - } - else if (fd > MAXCLIENTS - 1) { - report_error(CONNLIMIT_ERROR_MSG, get_listener_name(listener), 0); - close(fd); - return 0; - } + int is_server; - if (!os_set_reuseaddr(fd)) { - report_error(REUSEADDR_ERROR_MSG, get_listener_name(listener), errno); - close(fd); - return 0; - } - /* - * Bind a port to listen for new connections if port is non-null, - * else assume it is already open and try get something from it. - */ - memset(&sin, 0, sizeof(sin)); - sin.sin_family = AF_INET; - sin.sin_addr = listener->addr; - sin.sin_port = htons(listener->port); - - if (bind(fd, (struct sockaddr*) &sin, sizeof(sin))) { - report_error(BIND_ERROR_MSG, get_listener_name(listener), errno); - close(fd); - return 0; - } + is_server = listener_server(listener); /* * Set the buffer sizes for the listener. Accepted connections * inherit the accepting sockets settings for SO_RCVBUF S_SNDBUF @@ -198,104 +213,90 @@ static int inetport(struct Listener* listener) * else has no effect whatsoever on the connection. * NOTE: this must be set before listen is called */ - if (!os_set_sockbufs(fd, (listener->server) ? SERVER_TCP_WINDOW : CLIENT_TCP_WINDOW)) { + if (!os_set_sockbufs(fd, + is_server ? feature_int(FEAT_SOCKSENDBUF) : CLIENT_TCP_WINDOW, + is_server ? feature_int(FEAT_SOCKRECVBUF) : CLIENT_TCP_WINDOW)) { report_error(SETBUFS_ERROR_MSG, get_listener_name(listener), errno); close(fd); return 0; } - if (!os_set_listen(fd, HYBRID_SOMAXCONN)) { - report_error(LISTEN_ERROR_MSG, get_listener_name(listener), errno); - close(fd); - return 0; - } - /* - * XXX - this should always work, performance will suck if it doesn't - */ - if (!os_set_nonblocking(fd)) { - report_error(NONB_ERROR_MSG, get_listener_name(listener), errno); - close(fd); - return 0; - } + /* * Set the TOS bits - this is nonfatal if it doesn't stick. */ - if (!os_set_tos(fd,(listener->server) ? tos_server : tos_client)) { + if (!os_set_tos(fd,feature_int(is_server ? FEAT_TOS_SERVER : FEAT_TOS_CLIENT))) { report_error(TOS_ERROR_MSG, get_listener_name(listener), errno); } - listener->fd = fd; return 1; } -/* - * find_listener - find a listener in the list - * - * XXX - this function does N comparisons so if the list is huge - * we may want to do something else for this. (rehash and init use this) +/** Open listening socket for \a listener. + * @param[in,out] listener Listener to make a socket for. + * @param[in] family Socket address family to use. + * @return Negative on failure, file descriptor on success. */ -static struct Listener* find_listener(int port, struct in_addr addr) +static int inetport(struct Listener* listener, int family) { - struct Listener* listener; - for (listener = ListenerPollList; listener; listener = listener->next) { - if (port == listener->port && addr.s_addr == listener->addr.s_addr) - return listener; - } - return 0; -} - -/* - * set_listener_mask - set the connection mask for this listener - */ -static void set_listener_mask(struct Listener* listener, const char* mask) -{ - int ad[4]; - char ipname[20]; + struct Socket *sock; + int fd; - assert(0 != listener); - - if (EmptyString(mask) || 0 == strcmp(mask, "*")) { - listener->mask.s_addr = 0; - return; - } - ad[0] = ad[1] = ad[2] = ad[3] = 0; /* - * do it this way because building ip# from separate values for each - * byte requires endian knowledge or some nasty messing. Also means - * easy conversion of "*" 0.0.0.0 or 134.* to 134.0.0.0 :-) + * At first, open a new socket */ - sscanf(mask, "%d.%d.%d.%d", &ad[0], &ad[1], &ad[2], &ad[3]); - sprintf_irc(ipname, "%d.%d.%d.%d", ad[0], ad[1], ad[2], ad[3]); - listener->mask.s_addr = inet_addr(ipname); + fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener), family); + if (fd < 0) + return -1; + if (!os_set_listen(fd, HYBRID_SOMAXCONN)) { + report_error(LISTEN_ERROR_MSG, get_listener_name(listener), errno); + close(fd); + return -1; + } + if (!set_listener_options(listener, fd)) + return -1; + sock = (family == AF_INET) ? &listener->socket_v4 : &listener->socket_v6; + if (!socket_add(sock, accept_connection, (void*) listener, + SS_LISTENING, 0, fd)) { + /* Error should already have been reported to the logs */ + close(fd); + return -1; + } + + return fd; } -/* - * connection_allowed - spin through mask and addr passed to see if connect - * allowed on a listener, uses mask generated by set_listener_mask +/** Find the listener (if any) for a particular port and address. + * @param[in] port Port number to search for. + * @param[in] addr Local address to search for. + * @return Listener that matches (or NULL if none match). */ -static int connection_allowed(const char* addr, const char* mask) +static struct Listener* find_listener(int port, const struct irc_in_addr *addr) { - int i = 4; - for ( ; i > 0; --i) { - if (*mask && *addr != *mask) - break; - ++addr; - ++mask; + struct Listener* listener; + for (listener = ListenerPollList; listener; listener = listener->next) { + if (port == listener->addr.port && !memcmp(addr, &listener->addr.addr, sizeof(*addr))) + return listener; } - return (0 == i); + return 0; } - -/* - * add_listener- create a new listener - * port - the port number to listen on - * vhost_ip - if non-null must contain a valid IP address string in - * the format "255.255.255.255" +/** Make sure we have a listener for \a port on \a vhost_ip. + * If one does not exist, create it. Then mark it as active and set + * the peer mask, server, and hidden flags according to the other + * arguments. + * @param[in] port Port number to listen on. + * @param[in] vhost_ip Local address to listen on. + * @param[in] mask Address mask to accept connections from. + * @param[in] flags Flags describing listener options. */ void add_listener(int port, const char* vhost_ip, const char* mask, - int is_server, int is_hidden) + const struct ListenerFlags *flags) { struct Listener* listener; - struct in_addr vaddr; + struct irc_in_addr vaddr; + int okay = 0; + int new_listener = 0; + int fd; /* * if no port in conf line, don't bother @@ -303,53 +304,88 @@ void add_listener(int port, const char* vhost_ip, const char* mask, if (0 == port) return; - vaddr.s_addr = INADDR_ANY; + memset(&vaddr, 0, sizeof(vaddr)); - if (!EmptyString(vhost_ip) && strcmp(vhost_ip,"*") != 0) { - vaddr.s_addr = inet_addr(vhost_ip); - if (INADDR_NONE == vaddr.s_addr) + if (!EmptyString(vhost_ip) + && strcmp(vhost_ip, "*") + && !ircd_aton(&vaddr, vhost_ip)) return; - } - if ((listener = find_listener(port, vaddr))) { - /* - * set active flag and change connect mask here, it's the only thing - * that can change on a rehash - */ - listener->active = 1; - set_listener_mask(listener, mask); - listener->hidden = is_hidden; - listener->server = is_server; - return; + listener = find_listener(port, &vaddr); + if (!listener) + { + new_listener = 1; + listener = make_listener(port, &vaddr); + + + } + memcpy(&listener->flags, flags, sizeof(listener->flags)); + + if(FlagHas(&listener->flags, LISTEN_SSL) && !listener->ssl_listener) { + listener->ssl_listener = ssl_create_listener(); + } else if(!FlagHas(&listener->flags, LISTEN_SSL) && listener->ssl_listener) { + ssl_free_listener(listener->ssl_listener); + listener->ssl_listener = NULL; } + + FlagSet(&listener->flags, LISTEN_ACTIVE); + if (mask) + ipmask_parse(mask, &listener->mask, &listener->mask_bits); + else + listener->mask_bits = 0; + +#ifdef IPV6 + if (FlagHas(&listener->flags, LISTEN_IPV6) + && (irc_in_addr_unspec(&vaddr) || !irc_in_addr_is_ipv4(&vaddr))) { + if (listener->fd_v6 >= 0) { + set_listener_options(listener, listener->fd_v6); + okay = 1; + } else if ((fd = inetport(listener, AF_INET6)) >= 0) { + listener->fd_v6 = fd; + okay = 1; + } + } else if (-1 < listener->fd_v6) { + close(listener->fd_v6); + socket_del(&listener->socket_v6); + listener->fd_v6 = -1; + } +#endif - listener = make_listener(port, vaddr); + if (FlagHas(&listener->flags, LISTEN_IPV4) + && (irc_in_addr_unspec(&vaddr) || irc_in_addr_is_ipv4(&vaddr))) { + if (listener->fd_v4 >= 0) { + set_listener_options(listener, listener->fd_v4); + okay = 1; + } else if ((fd = inetport(listener, AF_INET)) >= 0) { + listener->fd_v4 = fd; + okay = 1; + } + } else if (-1 < listener->fd_v4) { + close(listener->fd_v4); + socket_del(&listener->socket_v4); + listener->fd_v4 = -1; + } - if (inetport(listener)) { - listener->active = 1; - set_listener_mask(listener, mask); - listener->hidden = is_hidden; - listener->server = is_server; + if (!okay) + free_listener(listener); + else if (new_listener) { listener->next = ListenerPollList; - ListenerPollList = listener; + ListenerPollList = listener; } - else - free_listener(listener); } -/* - * mark_listeners_closing - iterate through listeners and mark them as - * inactive +/** Mark all listeners as closing (inactive). + * This is done so unused listeners are closed after a rehash. */ void mark_listeners_closing(void) { struct Listener* listener; for (listener = ListenerPollList; listener; listener = listener->next) - listener->active = 0; + FlagClr(&listener->flags, LISTEN_ACTIVE); } -/* - * close_listener - close a single listener +/** Close a single listener. + * @param[in] listener Listener to close. */ void close_listener(struct Listener* listener) { @@ -368,15 +404,21 @@ void close_listener(struct Listener* listener) } } } - if (-1 < listener->fd) - close(listener->fd); + if (-1 < listener->fd_v4) { + close(listener->fd_v4); + socket_del(&listener->socket_v4); + listener->fd_v4 = -1; + } + if (-1 < listener->fd_v6) { + close(listener->fd_v6); + socket_del(&listener->socket_v6); + listener->fd_v6 = -1; + } free_listener(listener); } - -/* - * close_listeners - close and free all listeners that are not being used - */ -void close_listeners() + +/** Close all inactive listeners. */ +void close_listeners(void) { struct Listener* listener; struct Listener* listener_next = 0; @@ -385,93 +427,116 @@ void close_listeners() */ for (listener = ListenerPollList; listener; listener = listener_next) { listener_next = listener->next; - if (0 == listener->active && 0 == listener->ref_count) + if (!listener_active(listener) && 0 == listener->ref_count) close_listener(listener); } } +/** Dereference the listener previously associated with a client. + * @param[in] listener Listener to dereference. + */ void release_listener(struct Listener* listener) { assert(0 != listener); assert(0 < listener->ref_count); - if (0 == --listener->ref_count && !listener->active) + if (0 == --listener->ref_count && !listener_active(listener)) close_listener(listener); } -/* - * accept_connection - accept a connection on a listener +/** Accept a connection on a listener. + * @param[in] ev Socket callback structure. */ -void accept_connection(struct Listener* listener) +static void accept_connection(struct Event* ev) { - struct sockaddr_in addr = { 0 }; - unsigned int addrlen = sizeof(struct sockaddr_in); - int fd; + struct Listener* listener; + struct irc_sockaddr addr; + int fd; - assert(0 != listener); + assert(0 != ev_socket(ev)); + assert(0 != s_data(ev_socket(ev))); - listener->last_accept = CurrentTime; - /* - * There may be many reasons for error return, but - * in otherwise correctly working environment the - * probable cause is running out of file descriptors - * (EMFILE, ENFILE or others?). The man pages for - * accept don't seem to list these as possible, - * although it's obvious that it may happen here. - * Thus no specific errors are tested at this - * point, just assume that connections cannot - * be accepted until some old is closed first. - */ - if (-1 == (fd = accept(listener->fd, (struct sockaddr*) &addr, &addrlen))) { - /* Lotsa admins seem to have problems with not giving enough file descriptors - * to their server so we'll add a generic warning mechanism here. If it - * turns out too many messages are generated for meaningless reasons we - * can filter them back. - */ - sendto_opmask_butone(0, SNO_TCPCOMMON, "Unable to accept connection: %m"); - return; - } - /* - * check for connection limit - */ - if (fd > MAXCLIENTS - 1) { - ++ServerStats->is_ref; - send(fd, "ERROR :All connections in use\r\n", 32, 0); - close(fd); - return; - } - /* - * check to see if listener is shutting down - */ - if (!listener->active) { - ++ServerStats->is_ref; - send(fd, "ERROR :Use another port\r\n", 25, 0); - close(fd); - return; - } - /* - * check to see if connection is allowed for this address mask - */ - if (!connection_allowed((const char*) &addr, (const char*) &listener->mask)) { - ++ServerStats->is_ref; - send(fd, "ERROR :Use another port\r\n", 25, 0); - close(fd); - return; - } -#if 0 - /* - * check conf for ip address access - */ - if (!conf_connect_allowed(addr.sin_addr)) { - ++ServerStats->is_ref; - send(fd, "ERROR :Not authorized\r\n", 23, 0); - close(fd); + listener = (struct Listener*) s_data(ev_socket(ev)); + + if (ev_type(ev) == ET_DESTROY) /* being destroyed */ return; - } -#endif - ++ServerStats->is_ac; - nextping = CurrentTime; + else { + assert(ev_type(ev) == ET_ACCEPT || ev_type(ev) == ET_ERROR); - add_connection(listener, fd); + listener->last_accept = CurrentTime; + /* + * There may be many reasons for error return, but + * in otherwise correctly working environment the + * probable cause is running out of file descriptors + * (EMFILE, ENFILE or others?). The man pages for + * accept don't seem to list these as possible, + * although it's obvious that it may happen here. + * Thus no specific errors are tested at this + * point, just assume that connections cannot + * be accepted until some old is closed first. + * + * This piece of code implements multi-accept, based + * on the idea that poll/select can only be efficient, + * if we succeed in handling all available events, + * i.e. accept all pending connections. + * + * http://www.hpl.hp.com/techreports/2000/HPL-2000-174.html + */ + while (1) + { + if ((fd = os_accept(s_fd(ev_socket(ev)), &addr)) == -1) + { + if (errno == EAGAIN || +#ifdef EWOULDBLOCK + errno == EWOULDBLOCK) +#endif + return; + /* Lotsa admins seem to have problems with not giving enough file + * descriptors to their server so we'll add a generic warning mechanism + * here. If it turns out too many messages are generated for + * meaningless reasons we can filter them back. + */ + sendto_opmask_butone(0, SNO_TCPCOMMON, + "Unable to accept connection: %m"); + return; + } + /* + * check for connection limit. If this fd exceeds the limit, + * all further accept()ed connections will also exceed it. + * Enable the server to clear out other connections before + * continuing to accept() new connections. + */ + if (fd > MAXCLIENTS - 1) + { + ++ServerStats->is_ref; + send(fd, "ERROR :All connections in use\r\n", 32, 0); + close(fd); + return; + } + /* + * check to see if listener is shutting down. Continue + * to accept(), because it makes sense to clear our the + * socket's queue as fast as possible. + */ + if (!listener_active(listener)) + { + ++ServerStats->is_ref; + send(fd, "ERROR :Use another port\r\n", 25, 0); + close(fd); + continue; + } + /* + * check to see if connection is allowed for this address mask + */ + if (!ipmask_check(&addr.addr, &listener->mask, listener->mask_bits)) + { + ++ServerStats->is_ref; + send(fd, "ERROR :Use another port\r\n", 25, 0); + close(fd); + continue; + } + ++ServerStats->is_ac; + /* nextping = CurrentTime; */ + add_connection(listener, fd); + } + } } - -