* 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 "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 "send.h"
#include "sys.h" /* MAXCLIENTS */
-#include <assert.h>
+/* #include <assert.h> -- Now using assert in ircd_log.h */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/socket.h>
-#include <arpa/inet.h>
-
-#ifndef INADDR_NONE
-#define INADDR_NONE ((unsigned int) 0xffffffff)
-#endif
+/** List of listening sockets. */
struct Listener* ListenerPollList = 0;
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 =
memset(listener, 0, sizeof(struct Listener));
- listener->fd = -1;
+ listener->fd_v4 = -1;
+ listener->fd_v6 = -1;
listener->addr.port = port;
memcpy(&listener->addr.addr, addr, sizeof(listener->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)
{
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)
{
*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, struct StatDesc* sd, int stat,
+void show_ports(struct Client* sptr, const struct StatDesc* sd,
char* param)
{
struct Listener *listener = 0;
int show_hidden = IsOper(sptr);
int count = (IsOper(sptr) || MyUser(sptr)) ? 100 : 8;
int port = 0;
+ int len;
assert(0 != sptr);
for (listener = ListenerPollList; listener; listener = listener->next) {
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_HIDDEN))
+ {
if (!show_hidden)
continue;
- flags[1] = 'H';
- flags[2] = '\0';
+ flags[len++] = 'H';
}
- else
- flags[1] = '\0';
+ 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++] = '-';
+ }
+ 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;
}
#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)
{
- int fd;
+ int is_server;
- /*
- * At first, open a new socket
- */
- fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener));
- 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
* 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);
}
- if (!socket_add(&listener->socket, accept_connection, (void*) listener,
+ return 1;
+}
+
+/** 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 int inetport(struct Listener* listener, int family)
+{
+ struct Socket *sock;
+ int fd;
+
+ /*
+ * At first, open a new socket
+ */
+ 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 0;
+ return -1;
}
- listener->fd = fd;
-
- return 1;
+ return fd;
}
-/*
- * 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)
+/** 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 struct Listener* find_listener(int port, const struct irc_in_addr *addr)
{
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 irc_in_addr vaddr;
+ int okay = 0;
+ int new_listener = 0;
+ int fd;
/*
* if no port in conf line, don't bother
&& !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;
- if (mask)
- ipmask_parse(mask, &listener->mask, &listener->mask_bits);
- else
- listener->mask_bits = 0;
- 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));
+ 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;
- if (mask)
- ipmask_parse(mask, &listener->mask, &listener->mask_bits);
- else
- listener->mask_bits = 0;
- listener->hidden = is_hidden;
- listener->server = is_server;
+ if (!okay)
+ free_listener(listener);
+ else if (new_listener) {
listener->next = ListenerPollList;
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)
{
}
}
}
- if (-1 < listener->fd)
- close(listener->fd);
- socket_del(&listener->socket);
+ 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;
*/
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.
*/
static void accept_connection(struct Event* ev)
{
listener = (struct Listener*) s_data(ev_socket(ev));
if (ev_type(ev) == ET_DESTROY) /* being destroyed */
- free_listener(listener);
+ return;
else {
assert(ev_type(ev) == ET_ACCEPT || ev_type(ev) == ET_ERROR);
*/
while (1)
{
- if ((fd = os_accept(listener->fd, &addr)) == -1)
+ if ((fd = os_accept(s_fd(ev_socket(ev)), &addr)) == -1)
{
if (errno == EAGAIN ||
#ifdef EWOULDBLOCK
* 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);