src/listener.c

   1 /*
   2  *  ircd-ratbox: A slightly useful ircd.
   3  *  listener.c: Listens on a port.
   4  *
   5  *  Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
   6  *  Copyright (C) 1996-2002 Hybrid Development Team
   7  *  Copyright (C) 2002-2005 ircd-ratbox development team
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  22  *  USA
  23  */
  24
  25 #include "stdinc.h"
  26 #include "setup.h"
  27 #include "listener.h"
  28 #include "client.h"
  29 #include "irc_string.h"
  30 #include "sprintf_irc.h"
  31 #include "ircd.h"
  32 #include "ircd_defs.h"
  33 #include "numeric.h"
  34 #include "commio.h"
  35 #include "s_conf.h"
  36 #include "s_newconf.h"
  37 #include "s_stats.h"
  38 #include "send.h"
  39 #include "memory.h"
  40 #include "s_auth.h"
  41 #include "reject.h"
  42
  43 #ifndef INADDR_NONE
  44 #define INADDR_NONE ((unsigned int) 0xffffffff)
  45 #endif
  46
  47 #if defined(NO_IN6ADDR_ANY) && defined(IPV6)
  48 static const struct in6_addr in6addr_any =
  49 { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } };
  50 #endif
  51
  52 static PF accept_connection;
  53
  54 static listener_t *ListenerPollList = NULL;
  55
  56 static listener_t *
  57 make_listener(struct irc_sockaddr_storage *addr)
  58 {
  59         listener_t *listener = (listener_t *) MyMalloc(sizeof(listener_t));
  60         s_assert(0 != listener);
  61
  62         listener->name = me.name;
  63         listener->fd = -1;
  64         memcpy(&listener->addr, addr, sizeof(struct irc_sockaddr_storage));
  65         listener->next = NULL;
  66         return listener;
  67 }
  68
  69 void
  70 free_listener(listener_t *listener)
  71 {
  72         s_assert(NULL != listener);
  73         if(listener == NULL)
  74                 return;
  75         /*
  76          * remove from listener list
  77          */
  78         if(listener == ListenerPollList)
  79                 ListenerPollList = listener->next;
  80         else
  81         {
  82                 listener_t *prev = ListenerPollList;
  83                 for (; prev; prev = prev->next)
  84                 {
  85                         if(listener == prev->next)
  86                         {
  87                                 prev->next = listener->next;
  88                                 break;
  89                         }
  90                 }
  91         }
  92
  93         /* free */
  94         MyFree(listener);
  95 }
  96
  97 #define PORTNAMELEN 6           /* ":31337" */
  98
  99 /*
 100  * get_listener_name - return displayable listener name and port
 101  * returns "host.foo.org:6667" for a given listener
 102  */
 103 const char *
 104 get_listener_name(const listener_t *listener)
 105 {
 106         static char buf[HOSTLEN + HOSTLEN + PORTNAMELEN + 4];
 107         int port = 0;
 108
 109         s_assert(NULL != listener);
 110         if(listener == NULL)
 111                 return NULL;
 112
 113 #ifdef IPV6
 114         if(listener->addr.ss_family == AF_INET6)
 115                 port = ntohs(((const struct sockaddr_in6 *)&listener->addr)->sin6_port);
 116         else
 117 #endif
 118                 port = ntohs(((const struct sockaddr_in *)&listener->addr)->sin_port);
 119
 120         ircsnprintf(buf, sizeof(buf), "%s[%s/%u]", me.name, listener->name, port);
 121         return buf;
 122 }
 123
 124 /*
 125  * show_ports - send port listing to a client
 126  * inputs       - pointer to client to show ports to
 127  * output       - none
 128  * side effects - show ports
 129  */
 130 void
 131 show_ports(struct Client *source_p)
 132 {
 133         listener_t *listener = 0;
 134
 135         for (listener = ListenerPollList; listener; listener = listener->next)
 136         {
 137                 sendto_one_numeric(source_p, RPL_STATSPLINE,
 138                                    form_str(RPL_STATSPLINE), 'P',
 139 #ifdef IPV6
 140                            ntohs(listener->addr.ss_family == AF_INET ? ((struct sockaddr_in *)&listener->addr)->sin_port :
 141                                  ((struct sockaddr_in6 *)&listener->addr)->sin6_port),
 142 #else
 143                            ntohs(((struct sockaddr_in *)&listener->addr)->sin_port),
 144 #endif
 145                            IsOperAdmin(source_p) ? listener->name : me.name,
 146                            listener->ref_count, (listener->active) ? "active" : "disabled");
 147         }
 148 }
 149
 150 /*
 151  * inetport - create a listener socket in the AF_INET or AF_INET6 domain,
 152  * bind it to the port given in 'port' and listen to it
 153  * returns true (1) if successful false (0) on error.
 154  *
 155  * If the operating system has a define for SOMAXCONN, use it, otherwise
 156  * use RATBOX_SOMAXCONN
 157  */
 158 #ifdef SOMAXCONN
 159 #undef RATBOX_SOMAXCONN
 160 #define RATBOX_SOMAXCONN SOMAXCONN
 161 #endif
 162
 163 static int
 164 inetport(listener_t *listener)
 165 {
 166         int fd;
 167         int opt = 1;
 168
 169         /*
 170          * At first, open a new socket
 171          */
 172
 173         fd = comm_socket(listener->addr.ss_family, SOCK_STREAM, 0, "Listener socket");
 174
 175 #ifdef IPV6
 176         if(listener->addr.ss_family == AF_INET6)
 177         {
 178                 struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)&listener->addr;
 179                 if(!IN6_ARE_ADDR_EQUAL(&in6->sin6_addr, &in6addr_any))
 180                 {
 181                         inetntop(AF_INET6, &in6->sin6_addr, listener->vhost, sizeof(listener->vhost));
 182                         listener->name = listener->vhost;
 183                 }
 184         } else
 185 #endif
 186         {
 187                 struct sockaddr_in *in = (struct sockaddr_in *)&listener->addr;
 188                 if(in->sin_addr.s_addr != INADDR_ANY)
 189                 {
 190                         inetntop(AF_INET, &in->sin_addr, listener->vhost, sizeof(listener->vhost));
 191                         listener->name = listener->vhost;
 192                 }
 193         }
 194
 195
 196         if(fd == -1)
 197         {
 198                 report_error("opening listener socket %s:%s",
 199                              get_listener_name(listener),
 200                              get_listener_name(listener), errno);
 201                 return 0;
 202         }
 203         else if((HARD_FDLIMIT - 10) < fd)
 204         {
 205                 report_error("no more connections left for listener %s:%s",
 206                              get_listener_name(listener),
 207                              get_listener_name(listener), errno);
 208                 comm_close(fd);
 209                 return 0;
 210         }
 211         /*
 212          * XXX - we don't want to do all this crap for a listener
 213          * set_sock_opts(listener);
 214          */
 215         if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char *) &opt, sizeof(opt)))
 216         {
 217                 report_error("setting SO_REUSEADDR for listener %s:%s",
 218                              get_listener_name(listener),
 219                              get_listener_name(listener), errno);
 220                 comm_close(fd);
 221                 return 0;
 222         }
 223
 224         /*
 225          * Bind a port to listen for new connections if port is non-null,
 226          * else assume it is already open and try get something from it.
 227          */
 228
 229         if(bind(fd, (struct sockaddr *) &listener->addr, GET_SS_LEN(listener->addr)))
 230         {
 231                 report_error("binding listener socket %s:%s",
 232                              get_listener_name(listener),
 233                              get_listener_name(listener), errno);
 234                 comm_close(fd);
 235                 return 0;
 236         }
 237
 238         if(listen(fd, RATBOX_SOMAXCONN))
 239         {
 240                 report_error("listen failed for %s:%s",
 241                              get_listener_name(listener),
 242                              get_listener_name(listener), errno);
 243                 comm_close(fd);
 244                 return 0;
 245         }
 246
 247         listener->fd = fd;
 248
 249         /* Listen completion events are READ events .. */
 250
 251         accept_connection(fd, listener);
 252         return 1;
 253 }
 254
 255 static listener_t *
 256 find_listener(struct irc_sockaddr_storage *addr)
 257 {
 258         listener_t *listener = NULL;
 259         listener_t *last_closed = NULL;
 260
 261         for (listener = ListenerPollList; listener; listener = listener->next)
 262         {
 263                 if(addr->ss_family != listener->addr.ss_family)
 264                         continue;
 265
 266                 switch(addr->ss_family)
 267                 {
 268                         case AF_INET:
 269                         {
 270                                 struct sockaddr_in *in4 = (struct sockaddr_in *)addr;
 271                                 struct sockaddr_in *lin4 = (struct sockaddr_in *)&listener->addr;
 272                                 if(in4->sin_addr.s_addr == lin4->sin_addr.s_addr &&
 273                                         in4->sin_port == lin4->sin_port )
 274                                 {
 275                                         if(listener->fd == -1)
 276                                                 last_closed = listener;
 277                                         else
 278                                                 return(listener);
 279                                 }
 280                                 break;
 281                         }
 282 #ifdef IPV6
 283                         case AF_INET6:
 284                         {
 285                                 struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
 286                                 struct sockaddr_in6 *lin6 =(struct sockaddr_in6 *)&listener->addr;
 287                                 if(IN6_ARE_ADDR_EQUAL(&in6->sin6_addr, &lin6->sin6_addr) &&
 288                                   in6->sin6_port == lin6->sin6_port)
 289                                 {
 290                                         if(listener->fd == -1)
 291                                                 last_closed = listener;
 292                                         else
 293                                                 return(listener);
 294                                 }
 295                                 break;
 296
 297                         }
 298 #endif
 299
 300                         default:
 301                                 break;
 302                 }
 303         }
 304         return last_closed;
 305 }
 306
 307
 308 /*
 309  * add_listener- create a new listener
 310  * port - the port number to listen on
 311  * vhost_ip - if non-null must contain a valid IP address string in
 312  * the format "255.255.255.255"
 313  */
 314 void
 315 add_listener(int port, const char *vhost_ip, int family)
 316 {
 317         listener_t *listener;
 318         struct irc_sockaddr_storage vaddr;
 319
 320         /*
 321          * if no port in conf line, don't bother
 322          */
 323         if(port == 0)
 324                 return;
 325         memset(&vaddr, 0, sizeof(vaddr));
 326         vaddr.ss_family = family;
 327
 328         if(vhost_ip != NULL)
 329         {
 330                 if(family == AF_INET)
 331                 {
 332                         if(inetpton(family, vhost_ip, &((struct sockaddr_in *)&vaddr)->sin_addr) <= 0)
 333                                 return;
 334                 }
 335 #ifdef IPV6
 336                 else
 337                 {
 338                         if(inetpton(family, vhost_ip, &((struct sockaddr_in6 *)&vaddr)->sin6_addr) <= 0)
 339                                 return;
 340
 341                 }
 342 #endif
 343         } else
 344         {
 345                 switch(family)
 346                 {
 347                         case AF_INET:
 348                                 ((struct sockaddr_in *)&vaddr)->sin_addr.s_addr = INADDR_ANY;
 349                                 break;
 350 #ifdef IPV6
 351                         case AF_INET6:
 352                                 memcpy(&((struct sockaddr_in6 *)&vaddr)->sin6_addr, &in6addr_any, sizeof(struct in6_addr));
 353                                 break;
 354                         default:
 355                                 return;
 356 #endif
 357                 }
 358         }
 359         switch(family)
 360         {
 361                 case AF_INET:
 362                         SET_SS_LEN(vaddr, sizeof(struct sockaddr_in));
 363                         ((struct sockaddr_in *)&vaddr)->sin_port = htons(port);
 364                         break;
 365 #ifdef IPV6
 366                 case AF_INET6:
 367                         SET_SS_LEN(vaddr, sizeof(struct sockaddr_in6));
 368                         ((struct sockaddr_in6 *)&vaddr)->sin6_port = htons(port);
 369                         break;
 370 #endif
 371                 default:
 372                         break;
 373         }
 374         if((listener = find_listener(&vaddr)))
 375         {
 376                 if(listener->fd > -1)
 377                         return;
 378         }
 379         else
 380         {
 381                 listener = make_listener(&vaddr);
 382                 listener->next = ListenerPollList;
 383                 ListenerPollList = listener;
 384         }
 385
 386         listener->fd = -1;
 387
 388         if(inetport(listener))
 389                 listener->active = 1;
 390         else
 391                 close_listener(listener);
 392 }
 393
 394 /*
 395  * close_listener - close a single listener
 396  */
 397 void
 398 close_listener(listener_t *listener)
 399 {
 400         s_assert(listener != NULL);
 401         if(listener == NULL)
 402                 return;
 403         if(listener->fd >= 0)
 404         {
 405                 comm_close(listener->fd);
 406                 listener->fd = -1;
 407         }
 408
 409         listener->active = 0;
 410
 411         if(listener->ref_count)
 412                 return;
 413
 414         free_listener(listener);
 415 }
 416
 417 /*
 418  * close_listeners - close and free all listeners that are not being used
 419  */
 420 void
 421 close_listeners()
 422 {
 423         listener_t *listener;
 424         listener_t *listener_next = 0;
 425         /*
 426          * close all 'extra' listening ports we have
 427          */
 428         for (listener = ListenerPollList; listener; listener = listener_next)
 429         {
 430                 listener_next = listener->next;
 431                 close_listener(listener);
 432         }
 433 }
 434
 435 #define DLINE_WARNING "ERROR :You have been D-lined.\r\n"
 436
 437 /*
 438  * add_connection - creates a client which has just connected to us on
 439  * the given fd. The sockhost field is initialized with the ip# of the host.
 440  * The client is sent to the auth module for verification, and not put in
 441  * any client list yet.
 442  */
 443 static void
 444 add_connection(listener_t *listener, int fd, struct sockaddr *sai)
 445 {
 446         struct Client *new_client;
 447         s_assert(NULL != listener);
 448
 449         /*
 450          * get the client socket name from the socket
 451          * the client has already been checked out in accept_connection
 452          */
 453         new_client = make_client(NULL);
 454
 455         memcpy(&new_client->localClient->ip, sai, sizeof(struct irc_sockaddr_storage));
 456
 457         /*
 458          * copy address to 'sockhost' as a string, copy it to host too
 459          * so we have something valid to put into error messages...
 460          */
 461         inetntop_sock((struct sockaddr *)&new_client->localClient->ip, new_client->sockhost,
 462                 sizeof(new_client->sockhost));
 463
 464
 465         strlcpy(new_client->host, new_client->sockhost, sizeof(new_client->host));
 466
 467 #ifdef IPV6
 468         if(new_client->localClient->ip.ss_family == AF_INET6 && ConfigFileEntry.dot_in_ip6_addr == 1)
 469         {
 470                 strlcat(new_client->host, ".", sizeof(new_client->host));
 471         }
 472 #endif
 473
 474         new_client->localClient->fd = fd;
 475
 476         new_client->localClient->listener = listener;
 477         ++listener->ref_count;
 478
 479         if(check_reject(new_client))
 480                 return;
 481         start_auth(new_client);
 482 }
 483
 484
 485 static void
 486 accept_connection(int pfd, void *data)
 487 {
 488         static time_t last_oper_notice = 0;
 489
 490         struct irc_sockaddr_storage sai;
 491         socklen_t addrlen = sizeof(sai);
 492         int fd;
 493         listener_t *listener = data;
 494     struct ConfItem *aconf;
 495     char buf[BUFSIZE];
 496
 497         s_assert(listener != NULL);
 498         if(listener == NULL)
 499                 return;
 500         /*
 501          * There may be many reasons for error return, but
 502          * in otherwise correctly working environment the
 503          * probable cause is running out of file descriptors
 504          * (EMFILE, ENFILE or others?). The man pages for
 505          * accept don't seem to list these as possible,
 506          * although it's obvious that it may happen here.
 507          * Thus no specific errors are tested at this
 508          * point, just assume that connections cannot
 509          * be accepted until some old is closed first.
 510          */
 511
 512         fd = comm_accept(listener->fd, (struct sockaddr *)&sai, &addrlen);
 513         if(fd < 0)
 514         {
 515                 /* Re-register a new IO request for the next accept .. */
 516                 comm_setselect(listener->fd, FDLIST_SERVICE,
 517                                COMM_SELECT_READ, accept_connection, listener, 0);
 518                 return;
 519         }
 520
 521         /* This needs to be done here, otherwise we break dlines */
 522         mangle_mapped_sockaddr((struct sockaddr *)&sai);
 523
 524         /*
 525          * check for connection limit
 526          */
 527         if((MAXCONNECTIONS - 10) < fd)
 528         {
 529                 ++ServerStats->is_ref;
 530                 /*
 531                  * slow down the whining to opers bit
 532                  */
 533                 if((last_oper_notice + 20) <= CurrentTime)
 534                 {
 535                         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 536                                              "All connections in use. (%s)",
 537                                              get_listener_name(listener));
 538                         last_oper_notice = CurrentTime;
 539                 }
 540
 541                 write(fd, "ERROR :All connections in use\r\n", 32);
 542                 comm_close(fd);
 543                 /* Re-register a new IO request for the next accept .. */
 544                 comm_setselect(listener->fd, FDLIST_SERVICE,
 545                                COMM_SELECT_READ, accept_connection, listener, 0);
 546                 return;
 547         }
 548
 549         /* Do an initial check we aren't connecting too fast or with too many
 550          * from this IP... */
 551         if((aconf = conf_connect_allowed((struct sockaddr *)&sai, sai.ss_family)) != NULL)
 552         {
 553                 ServerStats->is_ref++;
 554
 555         if(ConfigFileEntry.dline_with_reason)
 556         {
 557             if (ircsnprintf(buf, sizeof(buf), "ERROR :*** Banned: %s\r\n", aconf->passwd) >= (sizeof(buf)-1))
 558             {
 559                 buf[sizeof(buf) - 3] = '\r';
 560                 buf[sizeof(buf) - 2] = '\n';
 561                 buf[sizeof(buf) - 1] = '\0';
 562             }
 563         }
 564         else
 565            ircsprintf(buf, "ERROR :You have been D-lined.\r\n");
 566
 567         write(fd, buf, strlen(buf));
 568                 comm_close(fd);
 569
 570                 /* Re-register a new IO request for the next accept .. */
 571                 comm_setselect(listener->fd, FDLIST_SERVICE,
 572                                COMM_SELECT_READ, accept_connection, listener, 0);
 573                 return;
 574         }
 575
 576         ServerStats->is_ac++;
 577         add_connection(listener, fd, (struct sockaddr *)&sai);
 578
 579         /* Re-register a new IO request for the next accept .. */
 580         comm_setselect(listener->fd, FDLIST_SERVICE, COMM_SELECT_READ,
 581                        accept_connection, listener, 0);
 582 }