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