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 #include <arpa/inet.h>
  54
  55 /** List of listening sockets. */
  56 struct Listener* ListenerPollList = 0;
  57
  58 static void accept_connection(struct Event* ev);
  59
  60 /** Allocate and initialize a new Listener structure for a particular
  61  * socket address.
  62  * @param[in] port Port number to listen on.
  63  * @param[in] addr Local address to listen on.
  64  * @return Newly allocated and initialized Listener.
  65  */
  66 static struct Listener* make_listener(int port, const struct irc_in_addr *addr)
  67 {
  68   struct Listener* listener =
  69     (struct Listener*) MyMalloc(sizeof(struct Listener));
  70   assert(0 != listener);
  71
  72   memset(listener, 0, sizeof(struct Listener));
  73
  74   listener->fd          = -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
 139   assert(0 != sptr);
 140
 141   if (param)
 142     port = atoi(param);
 143
 144   for (listener = ListenerPollList; listener; listener = listener->next) {
 145     if (port && port != listener->addr.port)
 146       continue;
 147     flags[0] = (listener->server) ? 'S' : 'C';
 148     if (listener->hidden) {
 149       if (!show_hidden)
 150         continue;
 151       flags[1] = 'H';
 152       flags[2] = '\0';
 153     }
 154     else
 155       flags[1] = '\0';
 156
 157     send_reply(sptr, RPL_STATSPLINE, listener->addr.port, listener->ref_count,
 158                flags, (listener->active) ? "active" : "disabled");
 159     if (--count == 0)
 160       break;
 161   }
 162 }
 163
 164 /*
 165  * inetport - create a listener socket in the AF_INET domain,
 166  * bind it to the port given in 'port' and listen to it
 167  * returns true (1) if successful false (0) on error.
 168  *
 169  * If the operating system has a define for SOMAXCONN, use it, otherwise
 170  * use HYBRID_SOMAXCONN -Dianora
 171  * NOTE: Do this in os_xxxx.c files
 172  */
 173 #ifdef SOMAXCONN
 174 #define HYBRID_SOMAXCONN SOMAXCONN
 175 #else
 176 /** Maximum length of socket connection backlog. */
 177 #define HYBRID_SOMAXCONN 64
 178 #endif
 179
 180 /** Open listening socket for \a listener.
 181  * @param[in,out] listener Listener to make a socket for.
 182  * @return Non-zero on success, zero on failure.
 183  */
 184 static int inetport(struct Listener* listener)
 185 {
 186   int                fd;
 187
 188   /*
 189    * At first, open a new socket
 190    */
 191   fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener));
 192   if (fd < 0)
 193     return 0;
 194   /*
 195    * Set the buffer sizes for the listener. Accepted connections
 196    * inherit the accepting sockets settings for SO_RCVBUF S_SNDBUF
 197    * The window size is set during the SYN ACK so setting it anywhere
 198    * else has no effect whatsoever on the connection.
 199    * NOTE: this must be set before listen is called
 200    */
 201   if (!os_set_sockbufs(fd,
 202                        (listener->server) ? feature_int(FEAT_SOCKSENDBUF) : CLIENT_TCP_WINDOW,
 203                        (listener->server) ? feature_int(FEAT_SOCKRECVBUF) : CLIENT_TCP_WINDOW)) {
 204     report_error(SETBUFS_ERROR_MSG, get_listener_name(listener), errno);
 205     close(fd);
 206     return 0;
 207   }
 208   if (!os_set_listen(fd, HYBRID_SOMAXCONN)) {
 209     report_error(LISTEN_ERROR_MSG, get_listener_name(listener), errno);
 210     close(fd);
 211     return 0;
 212   }
 213   /*
 214    * Set the TOS bits - this is nonfatal if it doesn't stick.
 215    */
 216   if (!os_set_tos(fd,feature_int((listener->server)?FEAT_TOS_SERVER : FEAT_TOS_CLIENT))) {
 217     report_error(TOS_ERROR_MSG, get_listener_name(listener), errno);
 218   }
 219
 220   if (!socket_add(&listener->socket, accept_connection, (void*) listener,
 221                   SS_LISTENING, 0, fd)) {
 222     /* Error should already have been reported to the logs */
 223     close(fd);
 224     return 0;
 225   }
 226
 227   listener->fd = fd;
 228
 229   return 1;
 230 }
 231
 232 /** Find the listener (if any) for a particular port and address.
 233  * @param[in] port Port number to search for.
 234  * @param[in] addr Local address to search for.
 235  * @return Listener that matches (or NULL if none match).
 236  */
 237 static struct Listener* find_listener(int port, const struct irc_in_addr *addr)
 238 {
 239   struct Listener* listener;
 240   for (listener = ListenerPollList; listener; listener = listener->next) {
 241     if (port == listener->addr.port && !memcmp(addr, &listener->addr.addr, sizeof(*addr)))
 242       return listener;
 243   }
 244   return 0;
 245 }
 246
 247 /** Make sure we have a listener for \a port on \a vhost_ip.
 248  * If one does not exist, create it.  Then mark it as active and set
 249  * the peer mask, server, and hidden flags according to the other
 250  * arguments.
 251  * @param[in] port Port number to listen on.
 252  * @param[in] vhost_ip Local address to listen on.
 253  * @param[in] mask Address mask to accept connections from.
 254  * @param[in] is_server Non-zero if the port should only accept server connections.
 255  * @param[in] is_hidden Non-zero if the port should be hidden from /STATS P output.
 256  */
 257 void add_listener(int port, const char* vhost_ip, const char* mask,
 258                   int is_server, int is_hidden)
 259 {
 260   struct Listener* listener;
 261   struct irc_in_addr vaddr;
 262
 263   /*
 264    * if no port in conf line, don't bother
 265    */
 266   if (0 == port)
 267     return;
 268
 269   memset(&vaddr, 0, sizeof(vaddr));
 270
 271   if (!EmptyString(vhost_ip)
 272       && strcmp(vhost_ip, "*")
 273       && !ircd_aton(&vaddr, vhost_ip))
 274       return;
 275
 276   listener = find_listener(port, &vaddr);
 277   if (!listener)
 278     listener = make_listener(port, &vaddr);
 279   listener->active = 1;
 280   listener->hidden = is_hidden;
 281   listener->server = is_server;
 282   if (mask)
 283     ipmask_parse(mask, &listener->mask, &listener->mask_bits);
 284   else
 285     listener->mask_bits = 0;
 286
 287   if (listener->fd >= 0) {
 288     /* If the listener is already open, do not try to re-open. */
 289   }
 290   else if (inetport(listener)) {
 291     listener->next   = ListenerPollList;
 292     ListenerPollList = listener;
 293   }
 294   else
 295     free_listener(listener);
 296 }
 297
 298 /** Mark all listeners as closing (inactive).
 299  * This is done so unused listeners are closed after a rehash.
 300  */
 301 void mark_listeners_closing(void)
 302 {
 303   struct Listener* listener;
 304   for (listener = ListenerPollList; listener; listener = listener->next)
 305     listener->active = 0;
 306 }
 307
 308 /** Close a single listener.
 309  * @param[in] listener Listener to close.
 310  */
 311 void close_listener(struct Listener* listener)
 312 {
 313   assert(0 != listener);
 314   /*
 315    * remove from listener list
 316    */
 317   if (listener == ListenerPollList)
 318     ListenerPollList = listener->next;
 319   else {
 320     struct Listener* prev = ListenerPollList;
 321     for ( ; prev; prev = prev->next) {
 322       if (listener == prev->next) {
 323         prev->next = listener->next;
 324         break;
 325       }
 326     }
 327   }
 328   if (-1 < listener->fd)
 329     close(listener->fd);
 330   socket_del(&listener->socket);
 331 }
 332
 333 /** Close all inactive listeners. */
 334 void close_listeners()
 335 {
 336   struct Listener* listener;
 337   struct Listener* listener_next = 0;
 338   /*
 339    * close all 'extra' listening ports we have
 340    */
 341   for (listener = ListenerPollList; listener; listener = listener_next) {
 342     listener_next = listener->next;
 343     if (0 == listener->active && 0 == listener->ref_count)
 344       close_listener(listener);
 345   }
 346 }
 347
 348 /** Dereference the listener previously associated with a client.
 349  * @param[in] listener Listener to dereference.
 350  */
 351 void release_listener(struct Listener* listener)
 352 {
 353   assert(0 != listener);
 354   assert(0 < listener->ref_count);
 355   if (0 == --listener->ref_count && !listener->active)
 356     close_listener(listener);
 357 }
 358
 359 /** Accept a connection on a listener.
 360  * @param[in] ev Socket callback structure.
 361  */
 362 static void accept_connection(struct Event* ev)
 363 {
 364   struct Listener*    listener;
 365   struct irc_sockaddr addr;
 366   int                 fd;
 367
 368   assert(0 != ev_socket(ev));
 369   assert(0 != s_data(ev_socket(ev)));
 370
 371   listener = (struct Listener*) s_data(ev_socket(ev));
 372
 373   if (ev_type(ev) == ET_DESTROY) /* being destroyed */
 374     free_listener(listener);
 375   else {
 376     assert(ev_type(ev) == ET_ACCEPT || ev_type(ev) == ET_ERROR);
 377
 378     listener->last_accept = CurrentTime;
 379     /*
 380      * There may be many reasons for error return, but
 381      * in otherwise correctly working environment the
 382      * probable cause is running out of file descriptors
 383      * (EMFILE, ENFILE or others?). The man pages for
 384      * accept don't seem to list these as possible,
 385      * although it's obvious that it may happen here.
 386      * Thus no specific errors are tested at this
 387      * point, just assume that connections cannot
 388      * be accepted until some old is closed first.
 389      *
 390      * This piece of code implements multi-accept, based
 391      * on the idea that poll/select can only be efficient,
 392      * if we succeed in handling all available events,
 393      * i.e. accept all pending connections.
 394      *
 395      * http://www.hpl.hp.com/techreports/2000/HPL-2000-174.html
 396      */
 397     while (1)
 398     {
 399       if ((fd = os_accept(listener->fd, &addr)) == -1)
 400       {
 401         if (errno == EAGAIN ||
 402 #ifdef EWOULDBLOCK
 403             errno == EWOULDBLOCK)
 404 #endif
 405           return;
 406       /* Lotsa admins seem to have problems with not giving enough file
 407        * descriptors to their server so we'll add a generic warning mechanism
 408        * here.  If it turns out too many messages are generated for
 409        * meaningless reasons we can filter them back.
 410        */
 411       sendto_opmask_butone(0, SNO_TCPCOMMON,
 412                            "Unable to accept connection: %m");
 413       return;
 414       }
 415       /*
 416        * check for connection limit. If this fd exceeds the limit,
 417        * all further accept()ed connections will also exceed it.
 418        * Enable the server to clear out other connections before
 419        * continuing to accept() new connections.
 420        */
 421       if (fd > MAXCLIENTS - 1)
 422       {
 423         ++ServerStats->is_ref;
 424         send(fd, "ERROR :All connections in use\r\n", 32, 0);
 425         close(fd);
 426         return;
 427       }
 428       /*
 429        * check to see if listener is shutting down. Continue
 430        * to accept(), because it makes sense to clear our the
 431        * socket's queue as fast as possible.
 432        */
 433       if (!listener->active)
 434       {
 435         ++ServerStats->is_ref;
 436         send(fd, "ERROR :Use another port\r\n", 25, 0);
 437         close(fd);
 438         continue;
 439       }
 440       /*
 441        * check to see if connection is allowed for this address mask
 442        */
 443       if (!ipmask_check(&addr.addr, &listener->mask, listener->mask_bits))
 444       {
 445         ++ServerStats->is_ref;
 446         send(fd, "ERROR :Use another port\r\n", 25, 0);
 447         close(fd);
 448         continue;
 449       }
 450       ++ServerStats->is_ac;
 451       /* nextping = CurrentTime; */
 452       add_connection(listener, fd);
 453     }
 454   }
 455 }