X-Git-Url: http://git.pk910.de/?a=blobdiff_plain;f=ircd%2Flistener.c;h=5339fd9f52896cfc4f28c280a31fe70be750564f;hb=refs%2Fheads%2Fupstream;hp=c3f85dd698cc6f9418c430532c32a0c6664e233e;hpb=da712d65837b082fadf38f7ef573a3b9476c1883;p=ircu2.10.12-pk.git

diff --git a/ircd/listener.c b/ircd/listener.c
index c3f85dd..5339fd9 100644
--- a/ircd/listener.c
+++ b/ircd/listener.c
@@ -40,6 +40,7 @@
 #include "s_misc.h"
 #include "s_stats.h"
 #include "send.h"
+#include "ssl.h"
 #include "sys.h"         /* MAXCLIENTS */
 
 /* #include <assert.h> -- Now using assert in ircd_log.h */
@@ -70,7 +71,8 @@ static struct Listener* make_listener(int port, const struct irc_in_addr *addr)
 
   memset(listener, 0, sizeof(struct Listener));
 
-  listener->fd          = -1;
+  listener->fd_v4       = -1;
+  listener->fd_v6       = -1;
   listener->addr.port   = port;
   memcpy(&listener->addr.addr, addr, sizeof(listener->addr.addr));
 
@@ -130,10 +132,11 @@ void show_ports(struct Client* sptr, const struct StatDesc* sd,
                 char* param)
 {
   struct Listener *listener = 0;
-  char flags[8];
+  char flags[9];
   int show_hidden = IsOper(sptr);
   int count = (IsOper(sptr) || MyUser(sptr)) ? 100 : 8;
   int port = 0;
+  int len;
 
   assert(0 != sptr);
 
@@ -143,18 +146,35 @@ void show_ports(struct Client* sptr, const struct StatDesc* sd,
   for (listener = ListenerPollList; listener; listener = listener->next) {
     if (port && port != listener->addr.port)
       continue;
-    flags[0] = (listener->server) ? 'S' : 'C';
-    if (listener->hidden) {
+    len = 0;
+    flags[len++] = listener_server(listener) ? 'S' : 'C';
+    
+    if (FlagHas(&listener->flags, LISTEN_SSL))
+    {
+      flags[len++] = 'E';
+    }
+    if (FlagHas(&listener->flags, LISTEN_HIDDEN))
+    {
       if (!show_hidden)
         continue;
-      flags[1] = 'H';
-      flags[2] = '\0';
+      flags[len++] = 'H';
+    }
+    if (FlagHas(&listener->flags, LISTEN_IPV4))
+    {
+      flags[len++] = '4';
+      if (listener->fd_v4 < 0)
+        flags[len++] = '-';
+    }
+    if (FlagHas(&listener->flags, LISTEN_IPV6))
+    {
+      flags[len++] = '6';
+      if (listener->fd_v6 < 0)
+        flags[len++] = '-';
     }
-    else
-      flags[1] = '\0';
+    flags[len] = '\0';
 
     send_reply(sptr, RPL_STATSPLINE, listener->addr.port, listener->ref_count,
-	       flags, (listener->active) ? "active" : "disabled");
+	       flags, listener_active(listener) ? "active" : "disabled");
     if (--count == 0)
       break;
   }
@@ -176,20 +196,16 @@ void show_ports(struct Client* sptr, const struct StatDesc* sd,
 #define HYBRID_SOMAXCONN 64
 #endif
 
-/** Open listening socket for \a listener.
- * @param[in,out] listener Listener to make a socket for.
+/** Set or update socket options for \a listener.
+ * @param[in] listener Listener to determine socket option values.
+ * @param[in] fd File descriptor being updated.
  * @return Non-zero on success, zero on failure.
  */
-static int inetport(struct Listener* listener)
+static int set_listener_options(struct Listener *listener, int fd)
 {
-  int                fd;
+  int is_server;
 
-  /*
-   * At first, open a new socket
-   */
-  fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener));
-  if (fd < 0)
-    return 0;
+  is_server = listener_server(listener);
   /*
    * Set the buffer sizes for the listener. Accepted connections
    * inherit the accepting sockets settings for SO_RCVBUF S_SNDBUF
@@ -198,34 +214,55 @@ static int inetport(struct Listener* listener)
    * NOTE: this must be set before listen is called
    */
   if (!os_set_sockbufs(fd,
-                       (listener->server) ? feature_int(FEAT_SOCKSENDBUF) : CLIENT_TCP_WINDOW,
-                       (listener->server) ? feature_int(FEAT_SOCKRECVBUF) : CLIENT_TCP_WINDOW)) {
+                       is_server ? feature_int(FEAT_SOCKSENDBUF) : CLIENT_TCP_WINDOW,
+                       is_server ? feature_int(FEAT_SOCKRECVBUF) : CLIENT_TCP_WINDOW)) {
     report_error(SETBUFS_ERROR_MSG, get_listener_name(listener), errno);
     close(fd);
     return 0;
   }
-  if (!os_set_listen(fd, HYBRID_SOMAXCONN)) {
-    report_error(LISTEN_ERROR_MSG, get_listener_name(listener), errno);
-    close(fd);
-    return 0;
-  }
+
   /*
    * Set the TOS bits - this is nonfatal if it doesn't stick.
    */
-  if (!os_set_tos(fd,feature_int((listener->server)?FEAT_TOS_SERVER : FEAT_TOS_CLIENT))) {
+  if (!os_set_tos(fd,feature_int(is_server ? FEAT_TOS_SERVER : FEAT_TOS_CLIENT))) {
     report_error(TOS_ERROR_MSG, get_listener_name(listener), errno);
   }
 
-  if (!socket_add(&listener->socket, accept_connection, (void*) listener,
+  return 1;
+}
+
+/** Open listening socket for \a listener.
+ * @param[in,out] listener Listener to make a socket for.
+ * @param[in] family Socket address family to use.
+ * @return Negative on failure, file descriptor on success.
+ */
+static int inetport(struct Listener* listener, int family)
+{
+  struct Socket *sock;
+  int fd;
+
+  /*
+   * At first, open a new socket
+   */
+  fd = os_socket(&listener->addr, SOCK_STREAM, get_listener_name(listener), family);
+  if (fd < 0)
+    return -1;
+  if (!os_set_listen(fd, HYBRID_SOMAXCONN)) {
+    report_error(LISTEN_ERROR_MSG, get_listener_name(listener), errno);
+    close(fd);
+    return -1;
+  }
+  if (!set_listener_options(listener, fd))
+    return -1;
+  sock = (family == AF_INET) ? &listener->socket_v4 : &listener->socket_v6;
+  if (!socket_add(sock, accept_connection, (void*) listener,
 		  SS_LISTENING, 0, fd)) {
     /* Error should already have been reported to the logs */
     close(fd);
-    return 0;
+    return -1;
   }
 
-  listener->fd = fd;
-
-  return 1;
+  return fd;
 }
 
 /** Find the listener (if any) for a particular port and address.
@@ -250,14 +287,16 @@ static struct Listener* find_listener(int port, const struct irc_in_addr *addr)
  * @param[in] port Port number to listen on.
  * @param[in] vhost_ip Local address to listen on.
  * @param[in] mask Address mask to accept connections from.
- * @param[in] is_server Non-zero if the port should only accept server connections.
- * @param[in] is_hidden Non-zero if the port should be hidden from /STATS P output.
+ * @param[in] flags Flags describing listener options.
  */
 void add_listener(int port, const char* vhost_ip, const char* mask,
-                  int is_server, int is_hidden)
+                  const struct ListenerFlags *flags)
 {
   struct Listener* listener;
   struct irc_in_addr vaddr;
+  int okay = 0;
+  int new_listener = 0;
+  int fd;
 
   /*
    * if no port in conf line, don't bother
@@ -274,24 +313,65 @@ void add_listener(int port, const char* vhost_ip, const char* mask,
 
   listener = find_listener(port, &vaddr);
   if (!listener)
+  {
+    new_listener = 1;
     listener = make_listener(port, &vaddr);
-  listener->active = 1;
-  listener->hidden = is_hidden;
-  listener->server = is_server;
+    
+    
+  }
+  memcpy(&listener->flags, flags, sizeof(listener->flags));
+  
+  if(FlagHas(&listener->flags, LISTEN_SSL) && !listener->ssl_listener) {
+    listener->ssl_listener = ssl_create_listener();
+  } else if(!FlagHas(&listener->flags, LISTEN_SSL) && listener->ssl_listener) {
+    ssl_free_listener(listener->ssl_listener);
+    listener->ssl_listener = NULL;
+  }
+  
+  FlagSet(&listener->flags, LISTEN_ACTIVE);
   if (mask)
     ipmask_parse(mask, &listener->mask, &listener->mask_bits);
   else
     listener->mask_bits = 0;
 
-  if (listener->fd >= 0) {
-    /* If the listener is already open, do not try to re-open. */
+#ifdef IPV6
+  if (FlagHas(&listener->flags, LISTEN_IPV6)
+      && (irc_in_addr_unspec(&vaddr) || !irc_in_addr_is_ipv4(&vaddr))) {
+    if (listener->fd_v6 >= 0) {
+      set_listener_options(listener, listener->fd_v6);
+      okay = 1;
+    } else if ((fd = inetport(listener, AF_INET6)) >= 0) {
+      listener->fd_v6 = fd;
+      okay = 1;
+    }
+  } else if (-1 < listener->fd_v6) {
+    close(listener->fd_v6);
+    socket_del(&listener->socket_v6);
+    listener->fd_v6 = -1;
   }
-  else if (inetport(listener)) {
+#endif
+
+  if (FlagHas(&listener->flags, LISTEN_IPV4)
+      && (irc_in_addr_unspec(&vaddr) || irc_in_addr_is_ipv4(&vaddr))) {
+    if (listener->fd_v4 >= 0) {
+      set_listener_options(listener, listener->fd_v4);
+      okay = 1;
+    } else if ((fd = inetport(listener, AF_INET)) >= 0) {
+      listener->fd_v4 = fd;
+      okay = 1;
+    }
+  } else if (-1 < listener->fd_v4) {
+    close(listener->fd_v4);
+    socket_del(&listener->socket_v4);
+    listener->fd_v4 = -1;
+  }
+
+  if (!okay)
+    free_listener(listener);
+  else if (new_listener) {
     listener->next   = ListenerPollList;
     ListenerPollList = listener;
   }
-  else
-    free_listener(listener);
 }
 
 /** Mark all listeners as closing (inactive).
@@ -301,7 +381,7 @@ void mark_listeners_closing(void)
 {
   struct Listener* listener;
   for (listener = ListenerPollList; listener; listener = listener->next)
-    listener->active = 0;
+    FlagClr(&listener->flags, LISTEN_ACTIVE);
 }
 
 /** Close a single listener.
@@ -324,13 +404,21 @@ void close_listener(struct Listener* listener)
       }
     }
   }
-  if (-1 < listener->fd)
-    close(listener->fd);
-  socket_del(&listener->socket);
+  if (-1 < listener->fd_v4) {
+    close(listener->fd_v4);
+    socket_del(&listener->socket_v4);
+    listener->fd_v4 = -1;
+  }
+  if (-1 < listener->fd_v6) {
+    close(listener->fd_v6);
+    socket_del(&listener->socket_v6);
+    listener->fd_v6 = -1;
+  }
+  free_listener(listener);
 }
 
 /** Close all inactive listeners. */
-void close_listeners()
+void close_listeners(void)
 {
   struct Listener* listener;
   struct Listener* listener_next = 0;
@@ -339,7 +427,7 @@ void close_listeners()
    */
   for (listener = ListenerPollList; listener; listener = listener_next) {
     listener_next = listener->next;
-    if (0 == listener->active && 0 == listener->ref_count)
+    if (!listener_active(listener) && 0 == listener->ref_count)
       close_listener(listener);
   }
 }
@@ -351,7 +439,7 @@ void release_listener(struct Listener* listener)
 {
   assert(0 != listener);
   assert(0 < listener->ref_count);
-  if (0 == --listener->ref_count && !listener->active)
+  if (0 == --listener->ref_count && !listener_active(listener))
     close_listener(listener);
 }
 
@@ -370,7 +458,7 @@ static void accept_connection(struct Event* ev)
   listener = (struct Listener*) s_data(ev_socket(ev));
 
   if (ev_type(ev) == ET_DESTROY) /* being destroyed */
-    free_listener(listener);
+    return;
   else {
     assert(ev_type(ev) == ET_ACCEPT || ev_type(ev) == ET_ERROR);
 
@@ -395,7 +483,7 @@ static void accept_connection(struct Event* ev)
      */
     while (1)
     {
-      if ((fd = os_accept(listener->fd, &addr)) == -1)
+      if ((fd = os_accept(s_fd(ev_socket(ev)), &addr)) == -1)
       {
         if (errno == EAGAIN ||
 #ifdef EWOULDBLOCK
@@ -429,7 +517,7 @@ static void accept_connection(struct Event* ev)
        * to accept(), because it makes sense to clear our the
        * socket's queue as fast as possible.
        */
-      if (!listener->active)
+      if (!listener_active(listener))
       {
         ++ServerStats->is_ref;
         send(fd, "ERROR :Use another port\r\n", 25, 0);