ircd/listener.c

   1 /************************************************************************
   2  *   IRC - Internet Relay Chat, src/listener.c
   3  *   Copyright (C) 1999 Thomas Helvey <tomh@inxpress.net>
   4  *
   5  *   This program is free software; you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 1, or (at your option)
   8  *   any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /** @file
  20  * @brief Implementation for handling listening sockets.
  21  * @version $Id$
  22  */
  23 #include "config.h"
  24
  25 #include "listener.h"
  26 #include "client.h"
  27 #include "ircd.h"
  28 #include "ircd_alloc.h"
  29 #include "ircd_events.h"
  30 #include "ircd_features.h"
  31 #include "ircd_log.h"
  32 #include "ircd_osdep.h"
  33 #include "ircd_reply.h"
  34 #include "ircd_snprintf.h"
  35 #include "ircd_string.h"
  36 #include "match.h"
  37 #include "numeric.h"
  38 #include "s_bsd.h"
  39 #include "s_conf.h"
  40 #include "s_misc.h"
  41 #include "s_stats.h"
  42 #include "send.h"
  43 #include "sys.h"         /* MAXCLIENTS */
  44
  45 /* #include <assert.h> -- Now using assert in ircd_log.h */
  46 #include <stdio.h>
  47 #include <string.h>
  48 #include <errno.h>
  49 #include <stdlib.h>
  50 #include <unistd.h>
  51 #include <netdb.h>
  52 #include <sys/socket.h>
  53
  54 /** List of listening sockets. */
  55 struct Listener* ListenerPollList = 0;
  56
  57 static void accept_connection(struct Event* ev);
  58
  59 /** Allocate and initialize a new Listener structure for a particular
  60  * socket address.
  61  * @param[in] port Port number to listen on.
  62  * @param[in] addr Local address to listen on.
  63  * @return Newly allocated and initialized Listener.
  64  */
  65 static struct Listener* make_listener(int port, const struct irc_in_addr *addr)
  66 {
  67   struct Listener* listener =
  68     (struct Listener*) MyMalloc(sizeof(struct Listener));
  69   assert(0 != listener);
  70
  71   memset(listener, 0, sizeof(struct Listener));
  72
  73   listener->fd_v4       = -1;
  74   listener->fd_v6       = -1;
  75   listener->addr.port   = port;
  76   memcpy(&listener->addr.addr, addr, sizeof(listener->addr.addr));
  77
  78 #ifdef NULL_POINTER_NOT_ZERO
  79   listener->next = NULL;
  80   listener->conf = NULL;
  81 #endif
  82   return listener;
  83 }
  84
  85 /** Deallocate a Listener structure.
  86  * @param[in] listener Listener to be freed.
  87  */
  88 static void free_listener(struct Listener* listener)
  89 {
  90   assert(0 != listener);
  91   MyFree(listener);
  92 }
  93
  94 /** Maximum length for a port number. */
  95 #define PORTNAMELEN 10  /* ":31337" */
  96
  97 /** Return displayable listener name and port.
  98  * @param[in] listener %Listener to format as a text string.
  99  * @return Pointer to a static buffer that contains "server.name:6667".
 100  */
 101 const char* get_listener_name(const struct Listener* listener)
 102 {
 103   static char buf[HOSTLEN + PORTNAMELEN + 4];
 104   assert(0 != listener);
 105   ircd_snprintf(0, buf, sizeof(buf), "%s:%u", cli_name(&me), listener->addr.port);
 106   return buf;
 107 }
 108
 109 /** Count allocated listeners and the memory they use.
 110  * @param[out] count_out Receives number of allocated listeners.
 111  * @param[out] size_out Receives bytes used by listeners.
 112  */
 113 void count_listener_memory(int* count_out, size_t* size_out)
 114 {
 115   struct Listener* l;
 116   int              count = 0;
 117   assert(0 != count_out);
 118   assert(0 != size_out);
 119   for (l = ListenerPollList; l; l = l->next)
 120     ++count;
 121   *count_out = count;
 122   *size_out  = count * sizeof(struct Listener);
 123 }
 124
 125 /** Report listening ports to a client.
 126  * @param[in] sptr Client requesting statistics.
 127  * @param[in] sd Stats descriptor for request (ignored).
 128  * @param[in] param Extra parameter from user (port number to search for).
 129  */
 130 void show_ports(struct Client* sptr, const struct StatDesc* sd,
 131                 char* param)
 132 {
 133   struct Listener *listener = 0;
 134   char flags[8];
 135   int show_hidden = IsOper(sptr);
 136   int count = (IsOper(sptr) || MyUser(sptr)) ? 100 : 8;
 137   int port = 0;
 138   int len;
 139
 140   assert(0 != sptr);
 141
 142   if (param)
 143     port = atoi(param);
 144
 145   for (listener = ListenerPollList; listener; listener = listener->next) {
 146     if (port && port != listener->addr.port)
 147       continue;
 148     len = 0;
 149     flags[len++] = listener_server(listener) ? 'S' : 'C';
 150     if (show_hidden && FlagHas(&listener->flags, LISTEN_HIDDEN))
 151       flags[len++] = 'H';
 152     if (FlagHas(&listener->flags, LISTEN_IPV4))
 153     {
 154       flags[len++] = '4';
 155       if (listener->fd_v4 < 0)
 156         flags[len++] = '-';
 157     }
 158     if (FlagHas(&listener->flags, LISTEN_IPV6))
 159     {
 160       flags[len++] = '6';
 161       if (listener->fd_v6 < 0)
 162         flags[len++] = '-';
 163     }
 164     flags[len] = '\0';
 165
 166     send_reply(sptr, RPL_STATSPLINE, listener->addr.port, listener->ref_count,
 167                flags, listener_active(listener) ? "active" : "disabled");
 168     if (--count == 0)
 169       break;
 170   }
 171 }
 172
 173 /*
 174  * inetport - create a listener socket in the AF_INET domain,
 175  * bind it to the port given in 'port' and listen to it
 176  * returns true (1) if successful false (0) on error.
 177  *
 178  * If the operating system has a define for SOMAXCONN, use it, otherwise
 179  * use HYBRID_SOMAXCONN -Dianora
 180  * NOTE: Do this in os_xxxx.c files
 181  */
 182 #ifdef SOMAXCONN
 183 #define HYBRID_SOMAXCONN SOMAXCONN
 184 #else
 185 /** Maximum length of socket connection backlog. */
 186 #define HYBRID_SOMAXCONN 64
 187 #endif
 188
 189 /** Set or update socket options for \a listener.
 190  * @param[in] listener Listener to determine socket option values.
 191  * @param[in] fd File descriptor being updated.
 192  * @return Non-zero on success, zero on failure.
 193  */
 194 static int set_listener_options(struct Listener *listener, int fd)
 195 {
 196   int is_server;
 197
 198   is_server = listener_server(listener);
 199   /*
 200    * Set the buffer sizes for the listener. Accepted connections
 201    * inherit the accepting sockets settings for SO_RCVBUF S_SNDBUF
 202    * The window size is set during the SYN ACK so setting it anywhere
 203    * else has no effect whatsoever on the connection.
 204    * NOTE: this must be set before listen is called
 205    */
 206   if (!os_set_sockbufs(fd,
 207                        is_server ? feature_int(FEAT_SOCKSENDBUF) : CLIENT_TCP_WINDOW,
 208                        is_server ? feature_int(FEAT_SOCKRECVBUF) : CLIENT_TCP_WINDOW)) {
 209     report_error(SETBUFS_ERROR_MSG, get_listener_name(listener), errno);
 210     close(fd);
 211     return 0;
 212   }
 213
 214   /*
 215    * Set the TOS bits - this is nonfatal if it doesn't stick.
 216    */
 217   if (!os_set_tos(fd,feature_int(is_server ? FEAT_TOS_SERVER : FEAT_TOS_CLIENT))) {
 218     report_error(TOS_ERROR_MSG, get_listener_name(listener), errno);
 219   }
 220
 221   return 1;
 222 }
 223
 224 /** Open listening socket for \a listener.
 225  * @param[in,out] listener Listener to make a socket for.
 226  * @param[in] family Socket address family to use.
 227  * @return Negative on failure, file descriptor on success.
 228  */
 229 static int inetport(struct Listener* listener, int family)
 230 {
 231   struct Socket *sock;
 232   int fd;
 233
 234   /*
 235    * At first, open a new socket
 236    */
 237   fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener), family);
 238   if (fd < 0)
 239     return -1;
 240   if (!os_set_listen(fd, HYBRID_SOMAXCONN)) {
 241     report_error(LISTEN_ERROR_MSG, get_listener_name(listener), errno);
 242     close(fd);
 243     return -1;
 244   }
 245   if (!set_listener_options(listener, fd))
 246     return -1;
 247   sock = (family == AF_INET) ? &listener->socket_v4 : &listener->socket_v6;
 248   if (!socket_add(sock, accept_connection, (void*) listener,
 249                   SS_LISTENING, 0, fd)) {
 250     /* Error should already have been reported to the logs */
 251     close(fd);
 252     return -1;
 253   }
 254
 255   return fd;
 256 }
 257
 258 /** Find the listener (if any) for a particular port and address.
 259  * @param[in] port Port number to search for.
 260  * @param[in] addr Local address to search for.
 261  * @return Listener that matches (or NULL if none match).
 262  */
 263 static struct Listener* find_listener(int port, const struct irc_in_addr *addr)
 264 {
 265   struct Listener* listener;
 266   for (listener = ListenerPollList; listener; listener = listener->next) {
 267     if (port == listener->addr.port && !memcmp(addr, &listener->addr.addr, sizeof(*addr)))
 268       return listener;
 269   }
 270   return 0;
 271 }
 272
 273 /** Make sure we have a listener for \a port on \a vhost_ip.
 274  * If one does not exist, create it.  Then mark it as active and set
 275  * the peer mask, server, and hidden flags according to the other
 276  * arguments.
 277  * @param[in] port Port number to listen on.
 278  * @param[in] vhost_ip Local address to listen on.
 279  * @param[in] mask Address mask to accept connections from.
 280  * @param[in] flags Flags describing listener options.
 281  */
 282 void add_listener(int port, const char* vhost_ip, const char* mask,
 283                   const struct ListenerFlags *flags)
 284 {
 285   struct Listener* listener;
 286   struct irc_in_addr vaddr;
 287   int okay = 0;
 288   int new_listener = 0;
 289   int fd;
 290
 291   /*
 292    * if no port in conf line, don't bother
 293    */
 294   if (0 == port)
 295     return;
 296
 297   memset(&vaddr, 0, sizeof(vaddr));
 298
 299   if (!EmptyString(vhost_ip)
 300       && strcmp(vhost_ip, "*")
 301       && !ircd_aton(&vaddr, vhost_ip))
 302       return;
 303
 304   listener = find_listener(port, &vaddr);
 305   if (!listener)
 306   {
 307     new_listener = 1;
 308     listener = make_listener(port, &vaddr);
 309   }
 310   memcpy(&listener->flags, flags, sizeof(listener->flags));
 311   FlagSet(&listener->flags, LISTEN_ACTIVE);
 312   if (mask)
 313     ipmask_parse(mask, &listener->mask, &listener->mask_bits);
 314   else
 315     listener->mask_bits = 0;
 316
 317 #ifdef IPV6
 318   if (FlagHas(&listener->flags, LISTEN_IPV6)
 319       && (irc_in_addr_unspec(&vaddr) || !irc_in_addr_is_ipv4(&vaddr))) {
 320     if (listener->fd_v6 >= 0) {
 321       set_listener_options(listener, listener->fd_v6);
 322       okay = 1;
 323     } else if ((fd = inetport(listener, AF_INET6)) >= 0) {
 324       listener->fd_v6 = fd;
 325       okay = 1;
 326     }
 327   } else if (-1 < listener->fd_v6) {
 328     close(listener->fd_v6);
 329     socket_del(&listener->socket_v6);
 330     listener->fd_v6 = -1;
 331   }
 332 #endif
 333
 334   if (FlagHas(&listener->flags, LISTEN_IPV4)
 335       && (irc_in_addr_unspec(&vaddr) || irc_in_addr_is_ipv4(&vaddr))) {
 336     if (listener->fd_v4 >= 0) {
 337       set_listener_options(listener, listener->fd_v4);
 338       okay = 1;
 339     } else if ((fd = inetport(listener, AF_INET)) >= 0) {
 340       listener->fd_v4 = fd;
 341       okay = 1;
 342     }
 343   } else if (-1 < listener->fd_v4) {
 344     close(listener->fd_v4);
 345     socket_del(&listener->socket_v4);
 346     listener->fd_v4 = -1;
 347   }
 348
 349   if (!okay)
 350     free_listener(listener);
 351   else if (new_listener) {
 352     listener->next   = ListenerPollList;
 353     ListenerPollList = listener;
 354   }
 355 }
 356
 357 /** Mark all listeners as closing (inactive).
 358  * This is done so unused listeners are closed after a rehash.
 359  */
 360 void mark_listeners_closing(void)
 361 {
 362   struct Listener* listener;
 363   for (listener = ListenerPollList; listener; listener = listener->next)
 364     FlagClr(&listener->flags, LISTEN_ACTIVE);
 365 }
 366
 367 /** Close a single listener.
 368  * @param[in] listener Listener to close.
 369  */
 370 void close_listener(struct Listener* listener)
 371 {
 372   assert(0 != listener);
 373   /*
 374    * remove from listener list
 375    */
 376   if (listener == ListenerPollList)
 377     ListenerPollList = listener->next;
 378   else {
 379     struct Listener* prev = ListenerPollList;
 380     for ( ; prev; prev = prev->next) {
 381       if (listener == prev->next) {
 382         prev->next = listener->next;
 383         break;
 384       }
 385     }
 386   }
 387   if (-1 < listener->fd_v4) {
 388     close(listener->fd_v4);
 389     socket_del(&listener->socket_v4);
 390     listener->fd_v4 = -1;
 391   }
 392   if (-1 < listener->fd_v6) {
 393     close(listener->fd_v6);
 394     socket_del(&listener->socket_v6);
 395     listener->fd_v6 = -1;
 396   }
 397   free_listener(listener);
 398 }
 399
 400 /** Close all inactive listeners. */
 401 void close_listeners(void)
 402 {
 403   struct Listener* listener;
 404   struct Listener* listener_next = 0;
 405   /*
 406    * close all 'extra' listening ports we have
 407    */
 408   for (listener = ListenerPollList; listener; listener = listener_next) {
 409     listener_next = listener->next;
 410     if (!listener_active(listener) && 0 == listener->ref_count)
 411       close_listener(listener);
 412   }
 413 }
 414
 415 /** Dereference the listener previously associated with a client.
 416  * @param[in] listener Listener to dereference.
 417  */
 418 void release_listener(struct Listener* listener)
 419 {
 420   assert(0 != listener);
 421   assert(0 < listener->ref_count);
 422   if (0 == --listener->ref_count && !listener_active(listener))
 423     close_listener(listener);
 424 }
 425
 426 /** Accept a connection on a listener.
 427  * @param[in] ev Socket callback structure.
 428  */
 429 static void accept_connection(struct Event* ev)
 430 {
 431   struct Listener*    listener;
 432   struct irc_sockaddr addr;
 433   int                 fd;
 434
 435   assert(0 != ev_socket(ev));
 436   assert(0 != s_data(ev_socket(ev)));
 437
 438   listener = (struct Listener*) s_data(ev_socket(ev));
 439
 440   if (ev_type(ev) == ET_DESTROY) /* being destroyed */
 441     return;
 442   else {
 443     assert(ev_type(ev) == ET_ACCEPT || ev_type(ev) == ET_ERROR);
 444
 445     listener->last_accept = CurrentTime;
 446     /*
 447      * There may be many reasons for error return, but
 448      * in otherwise correctly working environment the
 449      * probable cause is running out of file descriptors
 450      * (EMFILE, ENFILE or others?). The man pages for
 451      * accept don't seem to list these as possible,
 452      * although it's obvious that it may happen here.
 453      * Thus no specific errors are tested at this
 454      * point, just assume that connections cannot
 455      * be accepted until some old is closed first.
 456      *
 457      * This piece of code implements multi-accept, based
 458      * on the idea that poll/select can only be efficient,
 459      * if we succeed in handling all available events,
 460      * i.e. accept all pending connections.
 461      *
 462      * http://www.hpl.hp.com/techreports/2000/HPL-2000-174.html
 463      */
 464     while (1)
 465     {
 466       if ((fd = os_accept(s_fd(ev_socket(ev)), &addr)) == -1)
 467       {
 468         if (errno == EAGAIN ||
 469 #ifdef EWOULDBLOCK
 470             errno == EWOULDBLOCK)
 471 #endif
 472           return;
 473       /* Lotsa admins seem to have problems with not giving enough file
 474        * descriptors to their server so we'll add a generic warning mechanism
 475        * here.  If it turns out too many messages are generated for
 476        * meaningless reasons we can filter them back.
 477        */
 478       sendto_opmask_butone(0, SNO_TCPCOMMON,
 479                            "Unable to accept connection: %m");
 480       return;
 481       }
 482       /*
 483        * check for connection limit. If this fd exceeds the limit,
 484        * all further accept()ed connections will also exceed it.
 485        * Enable the server to clear out other connections before
 486        * continuing to accept() new connections.
 487        */
 488       if (fd > MAXCLIENTS - 1)
 489       {
 490         ++ServerStats->is_ref;
 491         send(fd, "ERROR :All connections in use\r\n", 32, 0);
 492         close(fd);
 493         return;
 494       }
 495       /*
 496        * check to see if listener is shutting down. Continue
 497        * to accept(), because it makes sense to clear our the
 498        * socket's queue as fast as possible.
 499        */
 500       if (!listener_active(listener))
 501       {
 502         ++ServerStats->is_ref;
 503         send(fd, "ERROR :Use another port\r\n", 25, 0);
 504         close(fd);
 505         continue;
 506       }
 507       /*
 508        * check to see if connection is allowed for this address mask
 509        */
 510       if (!ipmask_check(&addr.addr, &listener->mask, listener->mask_bits))
 511       {
 512         ++ServerStats->is_ref;
 513         send(fd, "ERROR :Use another port\r\n", 25, 0);
 514         close(fd);
 515         continue;
 516       }
 517       ++ServerStats->is_ac;
 518       /* nextping = CurrentTime; */
 519       add_connection(listener, fd);
 520     }
 521   }
 522 }