From: Michael Poole Date: Thu, 7 Dec 2006 03:35:31 +0000 (+0000) Subject: Convert listeners to use a flagset in preparation for IPv4/IPv6 selection. X-Git-Url: http://git.pk910.de/?p=ircu2.10.12-pk.git;a=commitdiff_plain;h=ef4270d668183cf9e9a3d96cab7f305c5c5f1aa7 Convert listeners to use a flagset in preparation for IPv4/IPv6 selection. git-svn-id: file:///home/klmitch/undernet-ircu/undernet-ircu-svn/ircu2/branches/u2_10_12_branch@1731 c9e4aea6-c8fd-4c43-8297-357d70d61c8c --- diff --git a/ChangeLog b/ChangeLog index 3f937d9..7cb258c 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,31 @@ +2006-12-06 Michael Poole + + * include/listener.h (enum ListenerFlag): New enum. + (struct Listener): Convert "active", "hidden" and "server" to a + flagset. + (add_listener): Convert "is_server" and "is_hidden" arguments to + use the same flagset structure. + + * ircd/ircd_parser.y (listen_flags): New variable. + (general_vhost): Consolidate references to $3 to use a variable. + (portblock): Use listen_flags instead of tconn and tping. + (portserver): Likewise. + (porthidden): Likewise. + + * ircd/listener.c (show_ports): Use new field in Listener. + (set_listener_options): New function. + (inetport): Use it. + (add_listener): Use new field in Listener. When reusing an extant + listener, call set_listener_options() so the options are updated. + (mark_listeners_closing): Use new field in Listener. + (close_listeners): Use new helper macro to check activeness. + (release_listener): Likewise. + (accept_connection): Likewise. + + * ircd/s_bsd.c (report_error): Use the standard snotice rate + limiting here. + (add_connection): Use new helper macro to check serverness. + 2006-11-04 Michael Poole * ircd/m_nick.c (m_nick): If we get NICK on a server port, tell diff --git a/include/listener.h b/include/listener.h index 4433025..4dd74db 100644 --- a/include/listener.h +++ b/include/listener.h @@ -30,6 +30,9 @@ #ifndef INCLUDED_res_h #include "res.h" #endif +#ifndef INCLUDED_client_h +#include "client.h" /* flagset stuff. oh well. */ +#endif #ifndef INCLUDED_sys_types_h #include /* size_t, broken BSD system headers */ #define INCLUDED_sys_types_h @@ -38,14 +41,25 @@ struct Client; struct StatDesc; +enum ListenerFlag { + /** Port is currently accepting connections. */ + LISTEN_ACTIVE, + /** Port is hidden from /STATS P output. */ + LISTEN_HIDDEN, + /** Port accepts only server connections. */ + LISTEN_SERVER, + /** Sentinel for counting listener flags. */ + LISTEN_LAST_FLAG +}; + +DECLARE_FLAGSET(ListenerFlags, LISTEN_LAST_FLAG); + /** Describes a single listening port. */ struct Listener { struct Listener* next; /**< list node pointer */ + struct ListenerFlags flags; /**< on-off flags for listener */ int fd; /**< file descriptor */ int ref_count; /**< number of connection references */ - unsigned char active; /**< current state of listener */ - unsigned char hidden; /**< hidden in stats output for clients */ - unsigned char server; /**< 1 if port is a server listener */ unsigned char mask_bits; /**< number of bits in mask address */ int index; /**< index into poll array */ time_t last_accept; /**< last time listener accepted */ @@ -54,9 +68,12 @@ struct Listener { struct Socket socket; /**< describe socket to event system */ }; +#define listener_server(LISTENER) FlagHas(&(LISTENER)->flags, LISTEN_SERVER) +#define listener_active(LISTENER) FlagHas(&(LISTENER)->flags, LISTEN_ACTIVE) + extern void add_listener(int port, const char* vaddr_ip, - const char* mask, int is_server, - int is_hidden); + const char* mask, + const struct ListenerFlags *flags); extern void close_listener(struct Listener* listener); extern void close_listeners(void); extern void count_listener_memory(int* count_out, size_t* size_out); diff --git a/ircd/ircd_parser.y b/ircd/ircd_parser.y index 4f47c95..2b7103d 100644 --- a/ircd/ircd_parser.y +++ b/ircd/ircd_parser.y @@ -71,6 +71,7 @@ int tping, tconn, maxlinks, sendq, port, invert, stringno, flags; char *name, *pass, *host, *ip, *username, *origin, *hub_limit; char *stringlist[MAX_STRINGS]; + struct ListenerFlags listen_flags; struct ConnectionClass *c_class; struct DenyConf *dconf; struct ServerConf *sconf; @@ -309,16 +310,18 @@ generaldesc: DESCRIPTION '=' QSTRING ';' generalvhost: VHOST '=' QSTRING ';' { struct irc_in_addr addr; - if (!strcmp($3, "*")) { + char *vhost = $3; + + if (!strcmp(vhost, "*")) { /* This traditionally meant bind to all interfaces and connect * from the default. */ - } else if (!ircd_aton(&addr, $3)) - parse_error("Invalid virtual host '%s'.", $3); + } else if (!ircd_aton(&addr, vhost)) + parse_error("Invalid virtual host '%s'.", vhost); else if (irc_in_addr_is_ipv4(&addr)) memcpy(&VirtualHost_v4.addr, &addr, sizeof(addr)); else memcpy(&VirtualHost_v6.addr, &addr, sizeof(addr)); - MyFree($3); + MyFree(vhost); }; adminblock: ADMIN @@ -632,13 +635,14 @@ yesorno: YES { $$ = 1; } | NO { $$ = 0; }; portblock: PORT '{' portitems '}' ';' { if (port > 0 && port <= 0xFFFF) - add_listener(port, host, pass, tconn, tping); + add_listener(port, host, pass, &listen_flags); else parse_error("Port %d is out of range", port); MyFree(host); MyFree(pass); + memset(&listen_flags, 0, sizeof(listen_flags)); host = pass = NULL; - port = tconn = tping = 0; + port = 0; }; portitems: portitem portitems | portitem; portitem: portnumber | portvhost | portmask | portserver | porthidden; @@ -661,18 +665,18 @@ portmask: MASK '=' QSTRING ';' portserver: SERVER '=' YES ';' { - tconn = -1; + FlagSet(&listen_flags, LISTEN_SERVER); } | SERVER '=' NO ';' { - tconn = 0; + FlagClr(&listen_flags, LISTEN_SERVER); }; porthidden: HIDDEN '=' YES ';' { - tping = -1; + FlagSet(&listen_flags, LISTEN_HIDDEN); } | HIDDEN '=' NO ';' { - tping = 0; + FlagClr(&listen_flags, LISTEN_HIDDEN); }; clientblock: CLIENT diff --git a/ircd/listener.c b/ircd/listener.c index fa188d9..0f30a3d 100644 --- a/ircd/listener.c +++ b/ircd/listener.c @@ -134,6 +134,7 @@ void show_ports(struct Client* sptr, const struct StatDesc* sd, int show_hidden = IsOper(sptr); int count = (IsOper(sptr) || MyUser(sptr)) ? 100 : 8; int port = 0; + int len; assert(0 != sptr); @@ -143,18 +144,14 @@ void show_ports(struct Client* sptr, const struct StatDesc* sd, for (listener = ListenerPollList; listener; listener = listener->next) { if (port && port != listener->addr.port) continue; - flags[0] = (listener->server) ? 'S' : 'C'; - if (listener->hidden) { - if (!show_hidden) - continue; - flags[1] = 'H'; - flags[2] = '\0'; - } - else - flags[1] = '\0'; + len = 0; + flags[len++] = listener_server(listener) ? 'S' : 'C'; + if (show_hidden && FlagHas(&listener->flags, LISTEN_HIDDEN)) + flags[len++] = 'H'; + flags[len] = '\0'; send_reply(sptr, RPL_STATSPLINE, listener->addr.port, listener->ref_count, - flags, (listener->active) ? "active" : "disabled"); + flags, listener_active(listener) ? "active" : "disabled"); if (--count == 0) break; } @@ -176,20 +173,16 @@ void show_ports(struct Client* sptr, const struct StatDesc* sd, #define HYBRID_SOMAXCONN 64 #endif -/** Open listening socket for \a listener. - * @param[in,out] listener Listener to make a socket for. +/** 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 inetport(struct Listener* listener) +static int set_listener_options(struct Listener *listener, int fd) { - int fd; + int is_server; - /* - * At first, open a new socket - */ - fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener), 0); - if (fd < 0) - 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,24 +191,44 @@ static int inetport(struct Listener* listener) * NOTE: this must be set before listen is called */ if (!os_set_sockbufs(fd, - (listener->server) ? feature_int(FEAT_SOCKSENDBUF) : CLIENT_TCP_WINDOW, - (listener->server) ? feature_int(FEAT_SOCKRECVBUF) : CLIENT_TCP_WINDOW)) { + 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; - } + /* * Set the TOS bits - this is nonfatal if it doesn't stick. */ - if (!os_set_tos(fd,feature_int((listener->server)?FEAT_TOS_SERVER : FEAT_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); } + return 1; +} + +/** Open listening socket for \a listener. + * @param[in,out] listener Listener to make a socket for. + * @return Non-zero on success, zero on failure. + */ +static int inetport(struct Listener* listener) +{ + int fd; + + /* + * At first, open a new socket + */ + fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener), 0); + if (fd < 0) + return 0; + if (!os_set_listen(fd, HYBRID_SOMAXCONN)) { + report_error(LISTEN_ERROR_MSG, get_listener_name(listener), errno); + close(fd); + return 0; + } + if (!set_listener_options(listener, fd)) + return 0; if (!socket_add(&listener->socket, accept_connection, (void*) listener, SS_LISTENING, 0, fd)) { /* Error should already have been reported to the logs */ @@ -250,11 +263,10 @@ static struct Listener* find_listener(int port, const struct irc_in_addr *addr) * @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] is_server Non-zero if the port should only accept server connections. - * @param[in] is_hidden Non-zero if the port should be hidden from /STATS P output. + * @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 irc_in_addr vaddr; @@ -275,16 +287,18 @@ void add_listener(int port, const char* vhost_ip, const char* mask, listener = find_listener(port, &vaddr); if (!listener) listener = make_listener(port, &vaddr); - listener->active = 1; - listener->hidden = is_hidden; - listener->server = is_server; + memcpy(&listener->flags, flags, sizeof(listener->flags)); + FlagSet(&listener->flags, LISTEN_ACTIVE); if (mask) ipmask_parse(mask, &listener->mask, &listener->mask_bits); else listener->mask_bits = 0; if (listener->fd >= 0) { - /* If the listener is already open, do not try to re-open. */ + /* If the listener is already open, do not try to re-open. + * Only update the socket options. + */ + set_listener_options(listener, listener->fd); } else if (inetport(listener)) { listener->next = ListenerPollList; @@ -301,7 +315,7 @@ void mark_listeners_closing(void) { struct Listener* listener; for (listener = ListenerPollList; listener; listener = listener->next) - listener->active = 0; + FlagClr(&listener->flags, LISTEN_ACTIVE); } /** Close a single listener. @@ -339,7 +353,7 @@ void close_listeners(void) */ 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); } } @@ -351,7 +365,7 @@ 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); } @@ -429,7 +443,7 @@ static void accept_connection(struct Event* ev) * to accept(), because it makes sense to clear our the * socket's queue as fast as possible. */ - if (!listener->active) + if (!listener_active(listener)) { ++ServerStats->is_ref; send(fd, "ERROR :Use another port\r\n", 25, 0); diff --git a/ircd/s_bsd.c b/ircd/s_bsd.c index b076c0e..71706e5 100644 --- a/ircd/s_bsd.c +++ b/ircd/s_bsd.c @@ -132,13 +132,7 @@ void report_error(const char* text, const char* who, int err) if (EmptyString(who)) who = "unknown"; - if (last_notice + 20 < CurrentTime) { - /* - * pace error messages so opers don't get flooded by transients - */ - sendto_opmask_butone(0, SNO_OLDSNO, text, who, errmsg); - last_notice = CurrentTime; - } + sendto_opmask_butone_ratelimited(0, SNO_OLDSNO, &last_notice, text, who, errmsg); log_write(LS_SOCKET, L_ERROR, 0, text, who, errmsg); errno = errtmp; } @@ -499,7 +493,7 @@ void add_connection(struct Listener* listener, int fd) { */ os_disable_options(fd); - if (listener->server) + if (listener_server(listener)) { new_client = make_client(0, STAT_UNKNOWN_SERVER); }