ircd/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 "match.h"
  30 #include "ircd.h"
  31 #include "ircd_defs.h"
  32 #include "numeric.h"
  33 #include "s_conf.h"
  34 #include "s_newconf.h"
  35 #include "s_stats.h"
  36 #include "send.h"
  37 #include "authd.h"
  38 #include "reject.h"
  39 #include "s_conf.h"
  40 #include "hostmask.h"
  41 #include "sslproc.h"
  42 #include "wsproc.h"
  43 #include "hash.h"
  44 #include "s_assert.h"
  45 #include "logger.h"
  46
  47 #ifndef INADDR_NONE
  48 #define INADDR_NONE ((unsigned int) 0xffffffff)
  49 #endif
  50
  51 #if defined(NO_IN6ADDR_ANY) && defined(RB_IPV6)
  52 static const struct in6_addr in6addr_any =
  53 { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } };
  54 #endif
  55
  56 static struct Listener *ListenerPollList = NULL;
  57 static int accept_precallback(rb_fde_t *F, struct sockaddr *addr, rb_socklen_t addrlen, void *data);
  58 static void accept_callback(rb_fde_t *F, int status, struct sockaddr *addr, rb_socklen_t addrlen, void *data);
  59
  60 static struct Listener *
  61 make_listener(struct rb_sockaddr_storage *addr)
  62 {
  63         struct Listener *listener = (struct Listener *) rb_malloc(sizeof(struct Listener));
  64         s_assert(0 != listener);
  65         listener->name = me.name;
  66         listener->F = NULL;
  67
  68         memcpy(&listener->addr, addr, sizeof(struct rb_sockaddr_storage));
  69         listener->next = NULL;
  70         return listener;
  71 }
  72
  73 void
  74 free_listener(struct Listener *listener)
  75 {
  76         s_assert(NULL != listener);
  77         if(listener == NULL)
  78                 return;
  79         /*
  80          * remove from listener list
  81          */
  82         if(listener == ListenerPollList)
  83                 ListenerPollList = listener->next;
  84         else
  85         {
  86                 struct Listener *prev = ListenerPollList;
  87                 for (; prev; prev = prev->next)
  88                 {
  89                         if(listener == prev->next)
  90                         {
  91                                 prev->next = listener->next;
  92                                 break;
  93                         }
  94                 }
  95         }
  96
  97         /* free */
  98         rb_free(listener);
  99 }
 100
 101 #define PORTNAMELEN 6           /* ":31337" */
 102
 103 /*
 104  * get_listener_port - return displayable listener port
 105  */
 106 static uint16_t
 107 get_listener_port(const struct Listener *listener)
 108 {
 109         return ntohs(GET_SS_PORT(&listener->addr));
 110 }
 111
 112 /*
 113  * get_listener_name - return displayable listener name and port
 114  * returns "host.foo.org:6667" for a given listener
 115  */
 116 const char *
 117 get_listener_name(const struct Listener *listener)
 118 {
 119         static char buf[HOSTLEN + HOSTLEN + PORTNAMELEN + 4];
 120
 121         s_assert(NULL != listener);
 122         if(listener == NULL)
 123                 return NULL;
 124
 125         snprintf(buf, sizeof(buf), "%s[%s/%u]",
 126                         me.name, listener->name, get_listener_port(listener));
 127         return buf;
 128 }
 129
 130 /*
 131  * show_ports - send port listing to a client
 132  * inputs       - pointer to client to show ports to
 133  * output       - none
 134  * side effects - show ports
 135  */
 136 void
 137 show_ports(struct Client *source_p)
 138 {
 139         struct Listener *listener = 0;
 140
 141         for (listener = ListenerPollList; listener; listener = listener->next)
 142         {
 143                 sendto_one_numeric(source_p, RPL_STATSPLINE,
 144                            form_str(RPL_STATSPLINE), 'P',
 145                            get_listener_port(listener),
 146                            IsOperAdmin(source_p) ? listener->name : me.name,
 147                            listener->ref_count, (listener->active) ? "active" : "disabled",
 148                            listener->ssl ? " ssl" : "");
 149         }
 150 }
 151
 152 /*
 153  * inetport - create a listener socket in the AF_INET or AF_INET6 domain,
 154  * bind it to the port given in 'port' and listen to it
 155  * returns true (1) if successful false (0) on error.
 156  *
 157  * If the operating system has a define for SOMAXCONN, use it, otherwise
 158  * use CHARYBDIS_SOMAXCONN
 159  */
 160 #ifdef SOMAXCONN
 161 #undef CHARYBDIS_SOMAXCONN
 162 #define CHARYBDIS_SOMAXCONN SOMAXCONN
 163 #endif
 164
 165 static int
 166 inetport(struct Listener *listener)
 167 {
 168         rb_fde_t *F;
 169         int opt = 1;
 170         const char *errstr;
 171
 172         /*
 173          * At first, open a new socket
 174          */
 175
 176         F = rb_socket(GET_SS_FAMILY(&listener->addr), SOCK_STREAM, 0, "Listener socket");
 177
 178 #ifdef RB_IPV6
 179         if(GET_SS_FAMILY(&listener->addr) == AF_INET6)
 180         {
 181                 struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)&listener->addr;
 182                 if(!IN6_ARE_ADDR_EQUAL(&in6->sin6_addr, &in6addr_any))
 183                 {
 184                         rb_inet_ntop(AF_INET6, &in6->sin6_addr, listener->vhost, sizeof(listener->vhost));
 185                         listener->name = listener->vhost;
 186                 }
 187         } else
 188 #endif
 189         {
 190                 struct sockaddr_in *in = (struct sockaddr_in *)&listener->addr;
 191                 if(in->sin_addr.s_addr != INADDR_ANY)
 192                 {
 193                         rb_inet_ntop(AF_INET, &in->sin_addr, listener->vhost, sizeof(listener->vhost));
 194                         listener->name = listener->vhost;
 195                 }
 196         }
 197
 198         if(F == NULL)
 199         {
 200                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 201                                 "Cannot open socket for listener on port %d",
 202                                 get_listener_port(listener));
 203                 ilog(L_MAIN, "Cannot open socket for listener %s",
 204                                 get_listener_name(listener));
 205                 return 0;
 206         }
 207         else if((maxconnections - 10) < rb_get_fd(F)) /* XXX this is kinda bogus*/
 208         {
 209                 ilog_error("no more connections left for listener");
 210                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 211                                 "No more connections left for listener on port %d",
 212                                 get_listener_port(listener));
 213                 ilog(L_MAIN, "No more connections left for listener %s",
 214                                 get_listener_name(listener));
 215                 rb_close(F);
 216                 return 0;
 217         }
 218
 219         /*
 220          * XXX - we don't want to do all this crap for a listener
 221          * set_sock_opts(listener);
 222          *
 223          * FIXME - doesn't this belong in librb? --Elizafox
 224          */
 225         if(setsockopt(rb_get_fd(F), SOL_SOCKET, SO_REUSEADDR, (char *) &opt, sizeof(opt)))
 226         {
 227                 errstr = strerror(rb_get_sockerr(F));
 228                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 229                                 "Cannot set SO_REUSEADDR for listener on port %d: %s",
 230                                 get_listener_port(listener), errstr);
 231                 ilog(L_MAIN, "Cannot set SO_REUSEADDR for listener %s: %s",
 232                                 get_listener_name(listener), errstr);
 233                 rb_close(F);
 234                 return 0;
 235         }
 236
 237         /* FIXME - doesn't this belong in librb? --Elizafox */
 238         if(bind(rb_get_fd(F), (struct sockaddr *) &listener->addr, GET_SS_LEN(&listener->addr)))
 239         {
 240                 errstr = strerror(rb_get_sockerr(F));
 241                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 242                                 "Cannot bind for listener on port %d: %s",
 243                                 get_listener_port(listener), errstr);
 244                 ilog(L_MAIN, "Cannot bind for listener %s: %s",
 245                                 get_listener_name(listener), errstr);
 246                 rb_close(F);
 247                 return 0;
 248         }
 249
 250         if(rb_listen(F, CHARYBDIS_SOMAXCONN, listener->defer_accept))
 251         {
 252                 errstr = strerror(rb_get_sockerr(F));
 253                 sendto_realops_snomask(SNO_GENERAL, L_ALL,
 254                                 "Cannot listen() for listener on port %d: %s",
 255                                 get_listener_port(listener), errstr);
 256                 ilog(L_MAIN, "Cannot listen() for listener %s: %s",
 257                                 get_listener_name(listener), errstr);
 258                 rb_close(F);
 259                 return 0;
 260         }
 261
 262         listener->F = F;
 263
 264         rb_accept_tcp(listener->F, accept_precallback, accept_callback, listener);
 265         return 1;
 266 }
 267
 268 static struct Listener *
 269 find_listener(struct rb_sockaddr_storage *addr)
 270 {
 271         struct Listener *listener = NULL;
 272         struct Listener *last_closed = NULL;
 273
 274         for (listener = ListenerPollList; listener; listener = listener->next)
 275         {
 276                 if(GET_SS_FAMILY(addr) != GET_SS_FAMILY(&listener->addr))
 277                         continue;
 278
 279                 switch(GET_SS_FAMILY(addr))
 280                 {
 281                         case AF_INET:
 282                         {
 283                                 struct sockaddr_in *in4 = (struct sockaddr_in *)addr;
 284                                 struct sockaddr_in *lin4 = (struct sockaddr_in *)&listener->addr;
 285                                 if(in4->sin_addr.s_addr == lin4->sin_addr.s_addr &&
 286                                         in4->sin_port == lin4->sin_port )
 287                                 {
 288                                         if(listener->F == NULL)
 289                                                 last_closed = listener;
 290                                         else
 291                                                 return(listener);
 292                                 }
 293                                 break;
 294                         }
 295 #ifdef RB_IPV6
 296                         case AF_INET6:
 297                         {
 298                                 struct sockaddr_in6 *in6 = (struct sockaddr_in6 *)addr;
 299                                 struct sockaddr_in6 *lin6 =(struct sockaddr_in6 *)&listener->addr;
 300                                 if(IN6_ARE_ADDR_EQUAL(&in6->sin6_addr, &lin6->sin6_addr) &&
 301                                   in6->sin6_port == lin6->sin6_port)
 302                                 {
 303                                         if(listener->F == NULL)
 304                                                 last_closed = listener;
 305                                         else
 306                                                 return(listener);
 307                                 }
 308                                 break;
 309
 310                         }
 311 #endif
 312
 313                         default:
 314                                 break;
 315                 }
 316         }
 317         return last_closed;
 318 }
 319
 320
 321 /*
 322  * add_listener- create a new listener
 323  * port - the port number to listen on
 324  * vhost_ip - if non-null must contain a valid IP address string in
 325  * the format "255.255.255.255"
 326  */
 327 void
 328 add_listener(int port, const char *vhost_ip, int family, int ssl, int defer_accept, int wsock)
 329 {
 330         struct Listener *listener;
 331         struct rb_sockaddr_storage vaddr;
 332
 333         /*
 334          * if no port in conf line, don't bother
 335          */
 336         if(port == 0)
 337                 return;
 338         memset(&vaddr, 0, sizeof(vaddr));
 339         SET_SS_FAMILY(&vaddr, family);
 340
 341         if(vhost_ip != NULL)
 342         {
 343                 if(family == AF_INET)
 344                 {
 345                         if(rb_inet_pton(family, vhost_ip, &((struct sockaddr_in *)&vaddr)->sin_addr) <= 0)
 346                                 return;
 347                 }
 348 #ifdef RB_IPV6
 349                 else
 350                 {
 351                         if(rb_inet_pton(family, vhost_ip, &((struct sockaddr_in6 *)&vaddr)->sin6_addr) <= 0)
 352                                 return;
 353
 354                 }
 355 #endif
 356         } else
 357         {
 358                 switch(family)
 359                 {
 360                         case AF_INET:
 361                                 ((struct sockaddr_in *)&vaddr)->sin_addr.s_addr = INADDR_ANY;
 362                                 break;
 363 #ifdef RB_IPV6
 364                         case AF_INET6:
 365                                 memcpy(&((struct sockaddr_in6 *)&vaddr)->sin6_addr, &in6addr_any, sizeof(struct in6_addr));
 366                                 break;
 367                         default:
 368                                 return;
 369 #endif
 370                 }
 371         }
 372         switch(family)
 373         {
 374                 case AF_INET:
 375                         SET_SS_LEN(&vaddr, sizeof(struct sockaddr_in));
 376                         SET_SS_FAMILY(&vaddr, AF_INET);
 377                         SET_SS_PORT(&vaddr, htons(port));
 378                         break;
 379 #ifdef RB_IPV6
 380                 case AF_INET6:
 381                         SET_SS_LEN(&vaddr, sizeof(struct sockaddr_in6));
 382                         SET_SS_FAMILY(&vaddr, AF_INET6);
 383                         SET_SS_PORT(&vaddr, htons(port));
 384                         break;
 385 #endif
 386                 default:
 387                         break;
 388         }
 389         if((listener = find_listener(&vaddr)))
 390         {
 391                 if(listener->F != NULL)
 392                         return;
 393         }
 394         else
 395         {
 396                 listener = make_listener(&vaddr);
 397                 listener->next = ListenerPollList;
 398                 ListenerPollList = listener;
 399         }
 400
 401         listener->F = NULL;
 402         listener->ssl = ssl;
 403         listener->defer_accept = defer_accept;
 404         listener->wsock = wsock;
 405
 406         if(inetport(listener))
 407                 listener->active = 1;
 408         else
 409                 close_listener(listener);
 410 }
 411
 412 /*
 413  * close_listener - close a single listener
 414  */
 415 void
 416 close_listener(struct Listener *listener)
 417 {
 418         s_assert(listener != NULL);
 419         if(listener == NULL)
 420                 return;
 421         if(listener->F != NULL)
 422         {
 423                 rb_close(listener->F);
 424                 listener->F = NULL;
 425         }
 426
 427         listener->active = 0;
 428
 429         if(listener->ref_count)
 430                 return;
 431
 432         free_listener(listener);
 433 }
 434
 435 /*
 436  * close_listeners - close and free all listeners that are not being used
 437  */
 438 void
 439 close_listeners()
 440 {
 441         struct Listener *listener;
 442         struct Listener *listener_next = 0;
 443         /*
 444          * close all 'extra' listening ports we have
 445          */
 446         for (listener = ListenerPollList; listener; listener = listener_next)
 447         {
 448                 listener_next = listener->next;
 449                 close_listener(listener);
 450         }
 451 }
 452
 453 #define DLINE_WARNING "ERROR :You have been D-lined.\r\n"
 454
 455 /*
 456  * add_connection - creates a client which has just connected to us on
 457  * the given fd. The sockhost field is initialized with the ip# of the host.
 458  * The client is sent to the auth module for verification, and not put in
 459  * any client list yet.
 460  */
 461 static void
 462 add_connection(struct Listener *listener, rb_fde_t *F, struct sockaddr *sai, struct sockaddr *lai)
 463 {
 464         struct Client *new_client;
 465         s_assert(NULL != listener);
 466
 467         /*
 468          * get the client socket name from the socket
 469          * the client has already been checked out in accept_connection
 470          */
 471         new_client = make_client(NULL);
 472
 473         if (listener->ssl)
 474         {
 475                 rb_fde_t *xF[2];
 476                 if(rb_socketpair(AF_UNIX, SOCK_STREAM, 0, &xF[0], &xF[1], "Incoming ssld Connection") == -1)
 477                 {
 478                         free_client(new_client);
 479                         return;
 480                 }
 481                 new_client->localClient->ssl_ctl = start_ssld_accept(F, xF[1], connid_get(new_client));        /* this will close F for us */
 482                 if(new_client->localClient->ssl_ctl == NULL)
 483                 {
 484                         free_client(new_client);
 485                         return;
 486                 }
 487                 F = xF[0];
 488                 SetSSL(new_client);
 489         }
 490
 491         if (listener->wsock)
 492         {
 493                 rb_fde_t *xF[2];
 494                 if(rb_socketpair(AF_UNIX, SOCK_STREAM, 0, &xF[0], &xF[1], "Incoming wsockd Connection") == -1)
 495                 {
 496                         free_client(new_client);
 497                         return;
 498                 }
 499                 new_client->localClient->ws_ctl = start_wsockd_accept(F, xF[1], connid_get(new_client));        /* this will close F for us */
 500                 if(new_client->localClient->ws_ctl == NULL)
 501                 {
 502                         free_client(new_client);
 503                         return;
 504                 }
 505                 F = xF[0];
 506         }
 507
 508         memcpy(&new_client->localClient->ip, sai, sizeof(struct rb_sockaddr_storage));
 509         memcpy(&new_client->preClient->lip, lai, sizeof(struct rb_sockaddr_storage));
 510
 511         /*
 512          * copy address to 'sockhost' as a string, copy it to host too
 513          * so we have something valid to put into error messages...
 514          */
 515         rb_inet_ntop_sock((struct sockaddr *)&new_client->localClient->ip, new_client->sockhost,
 516                 sizeof(new_client->sockhost));
 517
 518
 519         rb_strlcpy(new_client->host, new_client->sockhost, sizeof(new_client->host));
 520
 521         new_client->localClient->F = F;
 522         new_client->localClient->listener = listener;
 523
 524         ++listener->ref_count;
 525
 526         authd_initiate_client(new_client);
 527 }
 528
 529 static const char *toofast = "ERROR :Reconnecting too fast, throttled.\r\n";
 530
 531 static int
 532 accept_precallback(rb_fde_t *F, struct sockaddr *addr, rb_socklen_t addrlen, void *data)
 533 {
 534         struct Listener *listener = (struct Listener *)data;
 535         char buf[BUFSIZE];
 536         struct ConfItem *aconf;
 537         static time_t last_oper_notice = 0;
 538         int len;
 539
 540         if(listener->ssl && (!ircd_ssl_ok || !get_ssld_count()))
 541         {
 542                 rb_close(F);
 543                 return 0;
 544         }
 545
 546         if((maxconnections - 10) < rb_get_fd(F)) /* XXX this is kinda bogus */
 547         {
 548                 ++ServerStats.is_ref;
 549                 /*
 550                  * slow down the whining to opers bit
 551                  */
 552                 if((last_oper_notice + 20) <= rb_current_time())
 553                 {
 554                         sendto_realops_snomask(SNO_GENERAL, L_ALL,
 555                                              "All connections in use. (%s)",
 556                                              get_listener_name(listener));
 557                         last_oper_notice = rb_current_time();
 558                 }
 559
 560                 rb_write(F, "ERROR :All connections in use\r\n", 31);
 561                 rb_close(F);
 562                 return 0;
 563         }
 564
 565         aconf = find_dline(addr, addr->sa_family);
 566         if(aconf != NULL && (aconf->status & CONF_EXEMPTDLINE))
 567                 return 1;
 568
 569         /* Do an initial check we aren't connecting too fast or with too many
 570          * from this IP... */
 571         if(aconf != NULL)
 572         {
 573                 ServerStats.is_ref++;
 574
 575                 if(ConfigFileEntry.dline_with_reason)
 576                 {
 577                         len = snprintf(buf, sizeof(buf), "ERROR :*** Banned: %s\r\n", get_user_ban_reason(aconf));
 578                         if (len >= (int)(sizeof(buf)-1))
 579                         {
 580                                 buf[sizeof(buf) - 3] = '\r';
 581                                 buf[sizeof(buf) - 2] = '\n';
 582                                 buf[sizeof(buf) - 1] = '\0';
 583                         }
 584                 }
 585                 else
 586                         strcpy(buf, "ERROR :You have been D-lined.\r\n");
 587
 588                 rb_write(F, buf, strlen(buf));
 589                 rb_close(F);
 590                 return 0;
 591         }
 592
 593         if(check_reject(F, addr))
 594                 return 0;
 595
 596         if(throttle_add(addr))
 597         {
 598                 rb_write(F, toofast, strlen(toofast));
 599                 rb_close(F);
 600                 return 0;
 601         }
 602
 603         return 1;
 604 }
 605
 606 static void
 607 accept_callback(rb_fde_t *F, int status, struct sockaddr *addr, rb_socklen_t addrlen, void *data)
 608 {
 609         struct Listener *listener = data;
 610         struct rb_sockaddr_storage lip;
 611         unsigned int locallen = sizeof(struct rb_sockaddr_storage);
 612
 613         ServerStats.is_ac++;
 614
 615         if(getsockname(rb_get_fd(F), (struct sockaddr *) &lip, &locallen) < 0)
 616         {
 617                 /* this can fail if the connection disappeared in the meantime */
 618                 rb_close(F);
 619                 return;
 620         }
 621
 622         add_connection(listener, F, addr, (struct sockaddr *)&lip);
 623 }