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