audiod: Fix error checking in init_default_filters().

[paraslash.git] / net.c

diff --git a/net.c b/net.c
index b7806a18e075f091c87611b0c64e43bdf711500b..91200fc040bcfebafccf9e737fb65514af9ff8f2 100644 (file)
--- a/net.c
+++ b/net.c
@@ -1,16 +1,8 @@
-/*
- * Copyright (C) 2005-2013 Andre Noll <maan@systemlinux.org>
- *
- * Licensed under the GPL v2. For licencing details see COPYING.
- */
+/* Copyright (C) 2005 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */

 
 /** \file net.c Networking-related helper functions. */
 
 
 /** \file net.c Networking-related helper functions. */
 

-/*
- * Since glibc 2.8, the _GNU_SOURCE feature test macro must be defined in order
- * to obtain the definition of the ucred structure.
- */
-#define _GNU_SOURCE
+#include "para.h"

 
 #include <netinet/in.h>
 #include <arpa/inet.h>
 
 #include <netinet/in.h>
 #include <arpa/inet.h>


@@ -18,21 +10,8 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netdb.h>

-
-/* At least NetBSD needs these. */
-#ifndef AI_V4MAPPED
-#define AI_V4MAPPED 0
-#endif
-#ifndef AI_ALL
-#define AI_ALL 0
-#endif
-#ifndef AI_ADDRCONFIG
-#define AI_ADDRCONFIG 0
-#endif
-

 #include <regex.h>
 
 #include <regex.h>
 

-#include "para.h"

 #include "error.h"
 #include "net.h"
 #include "string.h"
 #include "error.h"
 #include "net.h"
 #include "string.h"


@@ -48,8 +27,8 @@
  * \param netmask Value of the netmask part in \a cidr or the
  *               default of 32 if not specified.
  *
  * \param netmask Value of the netmask part in \a cidr or the
  *               default of 32 if not specified.
  *

- * \return Pointer to \a addr if succesful, NULL on error.
- * \sa RFC 4632
+ * \return Pointer to \a addr if successful, NULL on error.
+ * \sa RFC 4632.

  */
 char *parse_cidr(const char *cidr,
                 char    *addr, ssize_t addrlen,
  */
 char *parse_cidr(const char *cidr,
                 char    *addr, ssize_t addrlen,


@@ -109,7 +88,7 @@ static bool is_v4_dot_quad(const char *address)
  * \param host The host string to check.
  * \return True if \a host passes the syntax checks.
  *
  * \param host The host string to check.
  * \return True if \a host passes the syntax checks.
  *

- * \sa RFC 3986, 3.2.2; RFC 1123, 2.1; RFC 1034, 3.5
+ * \sa RFC 3986, 3.2.2; RFC 1123, 2.1; RFC 1034, 3.5.

  */
 static bool host_string_ok(const char *host)
 {
  */
 static bool host_string_ok(const char *host)
 {


@@ -151,7 +130,7 @@ static bool host_string_ok(const char *host)
  * \a host and \a port are undefined. If no port number was present in \a url,
  * \a port is set to -1.
  *
  * \a host and \a port are undefined. If no port number was present in \a url,
  * \a port is set to -1.
  *

- * \sa RFC 3986, 3.2.2/3.2.3
+ * \sa RFC 3986, 3.2.2/3.2.3.

  */
 char *parse_url(const char *url,
                char    *host, ssize_t hostlen,
  */
 char *parse_url(const char *url,
                char    *host, ssize_t hostlen,


@@ -180,8 +159,7 @@ char *parse_url(const char *url,
        }
 
        if (*o == ':')
        }
 
        if (*o == ':')

-               if (para_atoi32(++o, port) < 0 ||
-                   *port < 0 || *port > 0xffff)
+               if (para_atoi32(++o, port) < 0 || *port < 0 || *port > 0xffff)

                        goto failed;
        if (host_string_ok(host))
                return host;
                        goto failed;
        if (host_string_ok(host))
                return host;


@@ -190,13 +168,44 @@ failed:
        return NULL;
 }
 
        return NULL;
 }
 

+/**
+ * Pretty-print a host/port pair.
+ *
+ * \param url NULL, or any string accepted by \ref parse_url().
+ * \param default_port Applies if url has no port.
+ *
+ * If the url argument is NULL, the function returns the string
+ * 0.0.0.0:default_port. Otherwise it calls \ref parse_url() to check the
+ * syntax of the input string given by url. On errors the string "?" is
+ * returned. Otherwise, if url contains a port, a copy of url is returned. If
+ * no port was supplied, a colon and the default port are appended to url.
+ *
+ * \return In all cases the returned string is a allocated with malloc(3) and
+ * has to be freed by the caller.
+ */
+char *format_url(const char *url, int default_port)
+{
+       char host[MAX_HOSTLEN];
+       int url_port;
+
+       if (!url)
+               return make_message("0.0.0.0:%d", default_port);
+       if (!parse_url(url, host, sizeof(host), &url_port))
+               return make_message("?");
+       if (url_port < 0)
+               return make_message("%s:%d", url, default_port);
+       else
+               return para_strdup(url);
+}
+

 /**
  * Stringify port number, resolve into service name where defined.
 /**
  * Stringify port number, resolve into service name where defined.

+ *

  * \param port 2-byte port number, in host-byte-order.
  * \param transport Transport protocol name (e.g. "udp", "tcp"), or NULL.
  * \return Pointer to static result buffer.
  *
  * \param port 2-byte port number, in host-byte-order.
  * \param transport Transport protocol name (e.g. "udp", "tcp"), or NULL.
  * \return Pointer to static result buffer.
  *

- * \sa getservent(3), services(5), nsswitch.conf(5)
+ * \sa getservent(3), services(5), nsswitch.conf(5).

  */
 const char *stringify_port(int port, const char *transport)
 {
  */
 const char *stringify_port(int port, const char *transport)
 {


@@ -208,7 +217,7 @@ const char *stringify_port(int port, const char *transport)
                struct servent *se = getservbyport(htons(port), transport);
 
                if (se == NULL)
                struct servent *se = getservbyport(htons(port), transport);
 
                if (se == NULL)

-                       snprintf(service, sizeof(service), "%u", port);
+                       snprintf(service, sizeof(service), "%d", port);

                else
                        snprintf(service, sizeof(service), "%s", se->s_name);
        }
                else
                        snprintf(service, sizeof(service), "%s", se->s_name);
        }


@@ -220,7 +229,7 @@ const char *stringify_port(int port, const char *transport)
  *
  * \param l4type The symbolic name of the transport-layer protocol.
  *
  *
  * \param l4type The symbolic name of the transport-layer protocol.
  *

- * \sa ip(7), socket(2)
+ * \sa ip(7), socket(2).

  */
 static inline int sock_type(const unsigned l4type)
 {
  */
 static inline int sock_type(const unsigned l4type)
 {


@@ -252,7 +261,7 @@ static const char *layer4_name(const unsigned l4type)
  * directly after makesock(). The 'pre_conn_opt' structure is for internal use
  * only and should not be visible elsewhere.
  *
  * directly after makesock(). The 'pre_conn_opt' structure is for internal use
  * only and should not be visible elsewhere.
  *

- * \sa setsockopt(2), makesock()
+ * \sa setsockopt(2), \ref makesock().

  */
 struct pre_conn_opt {
        int             sock_level;     /**< Second argument to setsockopt() */
  */
 struct pre_conn_opt {
        int             sock_level;     /**< Second argument to setsockopt() */


@@ -293,7 +302,7 @@ struct flowopts *flowopt_new(void)
  * \param val  The value to set \a opt to.
  * \param len  Length of \a val.
  *
  * \param val  The value to set \a opt to.
  * \param len  Length of \a val.
  *

- *  \sa setsockopt(2)
+ *  \sa setsockopt(2).

  */
 void flowopt_add(struct flowopts *fo, int lev, int opt,
                const char *name, const void *val, int len)
  */
 void flowopt_add(struct flowopts *fo, int lev, int opt,
                const char *name, const void *val, int len)


@@ -333,7 +342,14 @@ static void flowopt_setopts(int sockfd, struct flowopts *fo)
                }
 }
 
                }
 }
 

-static void flowopt_cleanup(struct flowopts *fo)
+/**
+ * Deallocate all resources of a flowopts structure.
+ *
+ * \param fo A pointer as returned from flowopt_new().
+ *
+ * It's OK to pass \p NULL here in which case the function does nothing.
+ */
+void flowopt_cleanup(struct flowopts *fo)

 {
        struct pre_conn_opt *cur, *next;
 
 {
        struct pre_conn_opt *cur, *next;
 


@@ -348,7 +364,7 @@ static void flowopt_cleanup(struct flowopts *fo)
        free(fo);
 }
 
        free(fo);
 }
 

-/*
+/**

  * Resolve an IPv4/IPv6 address.
  *
  * \param l4type The layer-4 type (\p IPPROTO_xxx).
  * Resolve an IPv4/IPv6 address.
  *
  * \param l4type The layer-4 type (\p IPPROTO_xxx).


@@ -366,7 +382,7 @@ static void flowopt_cleanup(struct flowopts *fo)
  *
  * \sa getaddrinfo(3).
  */
  *
  * \sa getaddrinfo(3).
  */

-static int lookup_address(unsigned l4type, bool passive, const char *host,
+int lookup_address(unsigned l4type, bool passive, const char *host,

                int port_number, struct addrinfo **result)
 {
        int ret;
                int port_number, struct addrinfo **result)
 {
        int ret;


@@ -374,7 +390,7 @@ static int lookup_address(unsigned l4type, bool passive, const char *host,
        struct addrinfo *addr = NULL, hints;
 
        *result = NULL;
        struct addrinfo *addr = NULL, hints;
 
        *result = NULL;

-       sprintf(port, "%u", port_number & 0xffff);
+       sprintf(port, "%d", port_number & 0xffff);

        /* Set up address hint structure */
        memset(&hints, 0, sizeof(hints));
        hints.ai_family = AF_UNSPEC;
        /* Set up address hint structure */
        memset(&hints, 0, sizeof(hints));
        hints.ai_family = AF_UNSPEC;


@@ -402,7 +418,7 @@ static int lookup_address(unsigned l4type, bool passive, const char *host,
        return 1;
 }
 
        return 1;
 }
 

-/*
+/**

  * Create an active or passive socket.
  *
  * \param l4type \p IPPROTO_TCP, \p IPPROTO_UDP, or \p IPPROTO_DCCP.
  * Create an active or passive socket.
  *
  * \param l4type \p IPPROTO_TCP, \p IPPROTO_UDP, or \p IPPROTO_DCCP.


@@ -412,48 +428,53 @@ static int lookup_address(unsigned l4type, bool passive, const char *host,
  *
  * bind(2) is called on passive sockets, and connect(2) on active sockets. The
  * algorithm tries all possible address combinations until it succeeds. If \a
  *
  * bind(2) is called on passive sockets, and connect(2) on active sockets. The
  * algorithm tries all possible address combinations until it succeeds. If \a

- * fo is supplied, options are set and cleanup is performed.
+ * fo is supplied, options are set but cleanup must be performed in the caller.

  *
  * \return File descriptor on success, \p E_MAKESOCK on errors.
  *
  * \sa \ref lookup_address(), \ref makesock(), ip(7), ipv6(7), bind(2),
  * connect(2).
  */
  *
  * \return File descriptor on success, \p E_MAKESOCK on errors.
  *
  * \sa \ref lookup_address(), \ref makesock(), ip(7), ipv6(7), bind(2),
  * connect(2).
  */

-static int makesock_addrinfo(unsigned l4type, bool passive, struct addrinfo *ai,
+int makesock_addrinfo(unsigned l4type, bool passive, struct addrinfo *ai,

                struct flowopts *fo)
 {
                struct flowopts *fo)
 {

-       int ret = -E_MAKESOCK, on = 1, sockfd = -1;
+       int ret = -E_MAKESOCK, on = 1;

 
        for (; ai; ai = ai->ai_next) {
 
        for (; ai; ai = ai->ai_next) {

+               int fd;

                ret = socket(ai->ai_family, sock_type(l4type), l4type);
                ret = socket(ai->ai_family, sock_type(l4type), l4type);

-               if (ret < 0)
+               if (ret < 0) {
+                       PARA_NOTICE_LOG("socket(): %s\n", strerror(errno));

                        continue;
                        continue;

-               sockfd = ret;
-               flowopt_setopts(sockfd, fo);
+               }
+               fd = ret;
+               flowopt_setopts(fd, fo);

                if (!passive) {
                if (!passive) {

-                       if (connect(sockfd, ai->ai_addr, ai->ai_addrlen) == 0)
-                               return sockfd;
-                       close(sockfd);
-                       continue;
+                       if (connect(fd, ai->ai_addr, ai->ai_addrlen) < 0) {
+                               PARA_NOTICE_LOG("connect(): %s\n",
+                                       strerror(errno));
+                               close(fd);
+                               continue;
+                       }
+                       return fd;

                }
                /*
                 * Reuse the address on passive sockets to avoid failure on
                 * restart (protocols using listen()) and when creating
                 * multiple listener instances (UDP multicast).
                 */
                }
                /*
                 * Reuse the address on passive sockets to avoid failure on
                 * restart (protocols using listen()) and when creating
                 * multiple listener instances (UDP multicast).
                 */

-               if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on,
+               if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on,

                                sizeof(on)) == -1) {
                                sizeof(on)) == -1) {

-                       ret = -ERRNO_TO_PARA_ERROR(errno);
-                       close(sockfd);
-                       PARA_ERROR_LOG("can not set SO_REUSEADDR: %s\n",
-                               para_strerror(-ret));
-                       return ret;
+                       PARA_NOTICE_LOG("setsockopt(): %s\n", strerror(errno));
+                       close(fd);
+                       continue;

                }
                }

-               if (bind(sockfd, ai->ai_addr, ai->ai_addrlen) < 0) {
-                       close(sockfd);
+               if (bind(fd, ai->ai_addr, ai->ai_addrlen) < 0) {
+                       PARA_NOTICE_LOG("bind(): %s\n", strerror(errno));
+                       close(fd);

                        continue;
                }
                        continue;
                }

-               return sockfd;
+               return fd;

        }
        return -E_MAKESOCK;
 }
        }
        return -E_MAKESOCK;
 }


@@ -487,7 +508,6 @@ int makesock(unsigned l4type, bool passive, const char *host, uint16_t port_numb
                ret = makesock_addrinfo(l4type, passive, ai, fo);
        if (ai)
                freeaddrinfo(ai);
                ret = makesock_addrinfo(l4type, passive, ai, fo);
        if (ai)
                freeaddrinfo(ai);

-       flowopt_cleanup(fo);

        if (ret < 0) {
                PARA_ERROR_LOG("can not create %s socket %s#%d.\n",
                layer4_name(l4type), host? host : (passive?
        if (ret < 0) {
                PARA_ERROR_LOG("can not create %s socket %s#%d.\n",
                layer4_name(l4type), host? host : (passive?


@@ -500,18 +520,28 @@ int makesock(unsigned l4type, bool passive, const char *host, uint16_t port_numb
  * Create a passive / listening socket.
  *
  * \param l4type The transport-layer type (\p IPPROTO_xxx).
  * Create a passive / listening socket.
  *
  * \param l4type The transport-layer type (\p IPPROTO_xxx).

- * \param port The decimal port number to listen on.
- * \param fo Flowopts (if any) to set before starting to listen.
+ * \param addr Passed to \ref parse_url() if not NULL.
+ * \param port Ignored if addr contains a port number.

  *
  * \return Positive integer (socket descriptor) on success, negative value
  * otherwise.
  *
  *
  * \return Positive integer (socket descriptor) on success, negative value
  * otherwise.
  *

- * \sa makesock(), ip(7), ipv6(7), bind(2), listen(2).
+ * \sa \ref makesock(), ip(7), ipv6(7), bind(2), listen(2).

  */
  */

-int para_listen(unsigned l4type, uint16_t port, struct flowopts *fo)
+int para_listen(unsigned l4type, const char *addr, uint16_t port)

 {
 {

-       int ret, fd = makesock(l4type, 1, NULL, port, fo);
-
+       char host[MAX_HOSTLEN];
+       int ret, fd, addr_port;
+
+       if (addr) {
+               if (!parse_url(addr, host, sizeof(host), &addr_port))
+                       return -ERRNO_TO_PARA_ERROR(EINVAL);
+               if (addr_port > 0)
+                       port = addr_port;
+               addr = host;
+       }
+       fd = makesock(l4type, true /* passive */, addr, port,
+               NULL /* no flowopts */);

        if (fd > 0) {
                ret = listen(fd, BACKLOG);
                if (ret < 0) {
        if (fd > 0) {
                ret = listen(fd, BACKLOG);
                if (ret < 0) {


@@ -525,6 +555,22 @@ int para_listen(unsigned l4type, uint16_t port, struct flowopts *fo)
        return fd;
 }
 
        return fd;
 }
 

+/**
+ * Create a socket which listens on all network addresses.
+ *
+ * \param l4type See \ref para_listen().
+ * \param port See \ref para_listen().
+ *
+ * This is a simple wrapper for \ref para_listen() which passes a NULL pointer
+ * as the address information.
+ *
+ * \return See \ref para_listen().
+ */
+int para_listen_simple(unsigned l4type, uint16_t port)
+{
+       return para_listen(l4type, NULL, port);
+}
+

 /**
  * Determine IPv4/v6 socket address length.
  * \param sa Container of IPv4 or IPv6 address.
 /**
  * Determine IPv4/v6 socket address length.
  * \param sa Container of IPv4 or IPv6 address.


@@ -552,7 +598,7 @@ static bool SS_IS_ADDR_V4MAPPED(const struct sockaddr_storage *ss)
  * \param ss Container of IPv4/6 address.
  * \return Pointer to normalized address (may be static storage).
  *
  * \param ss Container of IPv4/6 address.
  * \return Pointer to normalized address (may be static storage).
  *

- * \sa RFC 3493
+ * \sa RFC 3493.

  */
 static const struct sockaddr *
 normalize_ip_address(const struct sockaddr_storage *ss)
  */
 static const struct sockaddr *
 normalize_ip_address(const struct sockaddr_storage *ss)


@@ -597,14 +643,14 @@ static inline int estimated_header_overhead(const int af_type)
  *
  * \param sockfd The socket file descriptor.
  *
  *
  * \param sockfd The socket file descriptor.
  *

- * The socket must be connected. See RFC 1122, 3.3.3. If the protocol familiy
+ * The socket must be connected. See RFC 1122, 3.3.3. If the protocol family

  * could not be determined, \p AF_INET is assumed.
  *
  * \return The maximum message size of the address family type.
  */
 int generic_max_transport_msg_size(int sockfd)
 {
  * could not be determined, \p AF_INET is assumed.
  *
  * \return The maximum message size of the address family type.
  */
 int generic_max_transport_msg_size(int sockfd)
 {

-       struct sockaddr_storage ss;
+       struct sockaddr_storage ss = {.ss_family = 0};

        socklen_t sslen = sizeof(ss);
        int af_type = AF_INET;
 
        socklen_t sslen = sizeof(ss);
        int af_type = AF_INET;
 


@@ -618,28 +664,26 @@ int generic_max_transport_msg_size(int sockfd)
 }
 
 /**
 }
 
 /**

- * Look up the local or remote side of a connected socket structure.
+ * Look up the remote side of a connected socket structure.

  *
  * \param fd The socket descriptor of the connected socket.
  *
  * \param fd The socket descriptor of the connected socket.

- * \param getname Either \p getsockname() for local, or \p getpeername() for
- * remote side.

  *
  * \return A static character string identifying hostname and port of the
  * chosen side in numeric host:port format.
  *
  *
  * \return A static character string identifying hostname and port of the
  * chosen side in numeric host:port format.
  *

- * \sa getsockname(2), getpeername(2), parse_url(), getnameinfo(3),
+ * \sa getsockname(2), getpeername(2), \ref parse_url(), getnameinfo(3),

  * services(5), nsswitch.conf(5).
  */
  * services(5), nsswitch.conf(5).
  */

-static char *__get_sock_name(int fd, typeof(getsockname) getname)
+char *remote_name(int fd)

 {
 {

-       struct sockaddr_storage ss;
+       struct sockaddr_storage ss = {.ss_family = 0};

        const struct sockaddr *sa;
        socklen_t sslen = sizeof(ss);
        char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
        static char output[sizeof(hbuf) + sizeof(sbuf) + 4];
        int ret;
 
        const struct sockaddr *sa;
        socklen_t sslen = sizeof(ss);
        char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
        static char output[sizeof(hbuf) + sizeof(sbuf) + 4];
        int ret;
 

-       if (getname(fd, (struct sockaddr *)&ss, &sslen) < 0) {
+       if (getpeername(fd, (struct sockaddr *)&ss, &sslen) < 0) {

                PARA_ERROR_LOG("can not determine address from fd %d: %s\n",
                        fd, strerror(errno));
                snprintf(output, sizeof(output), "(unknown)");
                PARA_ERROR_LOG("can not determine address from fd %d: %s\n",
                        fd, strerror(errno));
                snprintf(output, sizeof(output), "(unknown)");


@@ -659,36 +703,6 @@ static char *__get_sock_name(int fd, typeof(getsockname) getname)
        return output;
 }
 
        return output;
 }
 

-/**
- * Look up the local side of a connected socket structure.
- *
- * \param sockfd The file descriptor of the socket.
- *
- * \return A pointer to a static buffer containing hostname an port. This
- * buffer must not be freed by the caller.
- *
- * \sa remote_name().
- */
-char *local_name(int sockfd)
-{
-       return __get_sock_name(sockfd, getsockname);
-}
-
-/**
- * Look up the remote side of a connected socket structure.
- *
- * \param sockfd The file descriptor of the socket.
- *
- * \return Analogous to the return value of \ref local_name() but for the
- * remote side.
- *
- * \sa local_name().
- */
-char *remote_name(int sockfd)
-{
-       return __get_sock_name(sockfd, getpeername);
-}
-

 /**
  * Extract IPv4 or IPv6-mapped-IPv4 address from sockaddr_storage.
  *
 /**
  * Extract IPv4 or IPv6-mapped-IPv4 address from sockaddr_storage.
  *


@@ -706,6 +720,32 @@ void extract_v4_addr(const struct sockaddr_storage *ss, struct in_addr *ia)
                *ia = ((struct sockaddr_in *)sa)->sin_addr;
 }
 
                *ia = ((struct sockaddr_in *)sa)->sin_addr;
 }
 

+/**
+ * Compare the address part of IPv4/6 addresses.
+ *
+ * \param sa1 First address.
+ * \param sa2 Second address.
+ *
+ * \return True iff the IP address of \a sa1 and \a sa2 match.
+ */
+bool sockaddr_equal(const struct sockaddr *sa1, const struct sockaddr *sa2)
+{
+       if (!sa1 || !sa2)
+               return false;
+       if (sa1->sa_family != sa2->sa_family)
+               return false;
+       if (sa1->sa_family == AF_INET) {
+               struct sockaddr_in *a1 = (typeof(a1))sa1,
+                       *a2 = (typeof (a2))sa2;
+               return a1->sin_addr.s_addr == a2->sin_addr.s_addr;
+       } else if (sa1->sa_family == AF_INET6) {
+               struct sockaddr_in6 *a1 = (typeof(a1))sa1,
+                       *a2 = (typeof (a2))sa2;
+               return !memcmp(a1, a2, sizeof(*a1));
+       } else
+               return false;
+}
+

 /**
  * Receive data from a file descriptor.
  *
 /**
  * Receive data from a file descriptor.
  *


@@ -742,7 +782,7 @@ __must_check int recv_bin_buffer(int fd, char *buf, size_t size)
  *
  * \return The return value of the underlying call to \a recv_bin_buffer().
  *
  *
  * \return The return value of the underlying call to \a recv_bin_buffer().
  *

- * \sa recv_bin_buffer()
+ * \sa \ref recv_bin_buffer()

  */
 int recv_buffer(int fd, char *buf, size_t size)
 {
  */
 int recv_buffer(int fd, char *buf, size_t size)
 {


@@ -825,63 +865,88 @@ int dccp_available_ccids(uint8_t **ccid_array)
        return nccids;
 }
 
        return nccids;
 }
 

-/**
- * Prepare a structure for \p AF_UNIX socket addresses.
- *
- * \param u Pointer to the struct to be prepared.
- * \param name The socket pathname.
+/*
+ * Prepare a structure for AF_UNIX socket addresses.

  *
  *

- * This just copies \a name to the sun_path component of \a u.
+ * This just copies name to the sun_path component of u, prepending a zero byte
+ * if abstract sockets are supported.

  *
  *

- * \return Positive on success, \p -E_NAME_TOO_LONG if \a name is longer
- * than \p UNIX_PATH_MAX.
+ * The first call to this function tries to bind a socket to the abstract name
+ * space. The result of this test is stored in a static variable. Subsequent
+ * calls read this variable and create abstract sockets on systems that support
+ * them. If a NULL pointer is passed as the name, the function only
+ * initializes the static variable.

  */
 static int init_unix_addr(struct sockaddr_un *u, const char *name)
 {
  */
 static int init_unix_addr(struct sockaddr_un *u, const char *name)
 {

-       if (strlen(name) >= UNIX_PATH_MAX)
-               return -E_NAME_TOO_LONG;
+       static int use_abstract;
+

        memset(u->sun_path, 0, UNIX_PATH_MAX);
        u->sun_family = PF_UNIX;
        memset(u->sun_path, 0, UNIX_PATH_MAX);
        u->sun_family = PF_UNIX;

-       strcpy(u->sun_path, name);
+       if (use_abstract == 0) { /* executed only once */
+               int fd = socket(PF_UNIX, SOCK_STREAM, 0);
+               memcpy(u->sun_path, "\0x\0", 3);
+               if (bind(fd, (struct sockaddr *)u, sizeof(*u)) == 0)
+                       use_abstract = 1; /* yes */
+               else
+                       use_abstract = -1; /* no */
+               close(fd);
+               PARA_NOTICE_LOG("%susing abstract socket namespace\n",
+                       use_abstract == 1? "" : "not ");
+       }
+       if (!name)
+               return 0;
+       if (strlen(name) + 1 >= UNIX_PATH_MAX)
+               return -E_NAME_TOO_LONG;
+       strcpy(u->sun_path + (use_abstract == 1? 1 : 0), name);

        return 1;
 }
 
 /**
        return 1;
 }
 
 /**

- * Prepare, create, and bind a socket for local communication.
+ * Create a socket for local communication and listen on it.

  *
  * \param name The socket pathname.
  *
  * \param name The socket pathname.

- * \param unix_addr Pointer to the \p AF_UNIX socket structure.
- * \param mode The desired mode of the socket.

  *
  *

- * This function creates a local socket for sequenced, reliable,
- * two-way, connection-based byte streams.
+ * This function creates a passive local socket for sequenced, reliable,
+ * two-way, connection-based byte streams. The socket file descriptor is set to
+ * nonblocking mode and listen(2) is called to prepare the socket for
+ * accepting incoming connection requests.

  *
  *

- * \return The file descriptor, on success, negative on errors.
+ * \return The file descriptor on success, negative error code on failure.

  *
  *

- * \sa socket(2)
- * \sa bind(2)
- * \sa chmod(2)
+ * \sa socket(2), \sa bind(2), \sa chmod(2), listen(2), unix(7).

  */
  */

-int create_local_socket(const char *name, struct sockaddr_un *unix_addr,
-               mode_t mode)
+int create_local_socket(const char *name)

 {
 {

+       struct sockaddr_un unix_addr;

        int fd, ret;
 
        int fd, ret;
 

-       ret = init_unix_addr(unix_addr, name);
-       if (ret < 0)
+       ret = init_unix_addr(&unix_addr, name);
+       if (ret <= 0) /* error, or name was NULL */

                return ret;
        ret = socket(PF_UNIX, SOCK_STREAM, 0);
        if (ret < 0)
                return -ERRNO_TO_PARA_ERROR(errno);
        fd = ret;
                return ret;
        ret = socket(PF_UNIX, SOCK_STREAM, 0);
        if (ret < 0)
                return -ERRNO_TO_PARA_ERROR(errno);
        fd = ret;

-       ret = bind(fd, (struct sockaddr *) unix_addr, UNIX_PATH_MAX);
+       ret = mark_fd_nonblocking(fd);
+       if (ret < 0)
+               goto err;
+       ret = bind(fd, (struct sockaddr *)&unix_addr, sizeof(unix_addr));

        if (ret < 0) {
                ret = -ERRNO_TO_PARA_ERROR(errno);
                goto err;
        }
        if (ret < 0) {
                ret = -ERRNO_TO_PARA_ERROR(errno);
                goto err;
        }

-       ret = -E_CHMOD;
-       if (chmod(name, mode) < 0)
+       if (unix_addr.sun_path[0] != 0) { /* pathname socket */
+               mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
+                       | S_IROTH | S_IWOTH;
+               ret = -E_CHMOD;
+               if (chmod(name, mode) < 0)
+                       goto err;
+       }
+       if (listen(fd , 5) < 0) {
+               ret = -ERRNO_TO_PARA_ERROR(errno);

                goto err;
                goto err;

+       }

        return fd;
 err:
        close(fd);
        return fd;
 err:
        close(fd);


@@ -899,7 +964,7 @@ err:
  * \return The file descriptor of the connected socket on success, negative on
  * errors.
  *
  * \return The file descriptor of the connected socket on success, negative on
  * errors.
  *

- * \sa create_local_socket(), unix(7), connect(2).
+ * \sa \ref create_local_socket(), unix(7), connect(2).

  */
 int connect_local_socket(const char *name)
 {
  */
 int connect_local_socket(const char *name)
 {


@@ -907,17 +972,15 @@ int connect_local_socket(const char *name)
        int fd, ret;
 
        PARA_DEBUG_LOG("connecting to %s\n", name);
        int fd, ret;
 
        PARA_DEBUG_LOG("connecting to %s\n", name);

-       ret = init_unix_addr(&unix_addr, name);
-       if (ret < 0)
-               return ret;

        fd = socket(PF_UNIX, SOCK_STREAM, 0);
        if (fd < 0)
                return -ERRNO_TO_PARA_ERROR(errno);
        fd = socket(PF_UNIX, SOCK_STREAM, 0);
        if (fd < 0)
                return -ERRNO_TO_PARA_ERROR(errno);

-       if (connect(fd, (struct sockaddr *)&unix_addr, sizeof(unix_addr)) == -1) {
-               ret = -ERRNO_TO_PARA_ERROR(errno);
+       ret = init_unix_addr(&unix_addr, name);
+       if (ret < 0)

                goto err;
                goto err;

-       }
-       return fd;
+       if (connect(fd, (struct sockaddr *)&unix_addr, sizeof(unix_addr)) != -1)
+               return fd;
+       ret = -ERRNO_TO_PARA_ERROR(errno);

 err:
        close(fd);
        return ret;
 err:
        close(fd);
        return ret;


@@ -933,16 +996,17 @@ int recv_cred_buffer(int fd, char *buf, size_t size)
        return recv_buffer(fd, buf, size) > 0? 1 : -E_RECVMSG;
 }
 #else /* HAVE_UCRED */
        return recv_buffer(fd, buf, size) > 0? 1 : -E_RECVMSG;
 }
 #else /* HAVE_UCRED */

+

 /**
 /**

- * Send \p NULL-terminated buffer and Unix credentials of the current process.
+ * Send a buffer and the credentials of the current process to a socket.

  *
  *

- * \param sock The socket file descriptor.
- * \param buf The buffer to be sent.
+ * \param sock The file descriptor of the sending socket.
+ * \param buf The zero-terminated buffer to send.

  *
  *

- * \return On success, this call returns the number of characters sent.  On
- * error, \p -E_SENDMSG is returned.
+ * \return On success, this call returns the number of bytes sent. On errors,
+ * \p -E_SENDMSG is returned.

  *
  *

- * \sa sendmsg(2), okir's Black Hats Manual.
+ * \sa \ref recv_cred_buffer, sendmsg(2), socket(7), unix(7).

  */
 ssize_t send_cred_buffer(int sock, char *buf)
 {
  */
 ssize_t send_cred_buffer(int sock, char *buf)
 {


@@ -955,7 +1019,7 @@ ssize_t send_cred_buffer(int sock, char *buf)
 
        /* Response data */
        iov.iov_base = buf;
 
        /* Response data */
        iov.iov_base = buf;

-       iov.iov_len  = strlen(buf);
+       iov.iov_len = strlen(buf);

        c.pid = getpid();
        c.uid = getuid();
        c.gid = getgid();
        c.pid = getpid();
        c.uid = getuid();
        c.gid = getgid();


@@ -973,7 +1037,7 @@ ssize_t send_cred_buffer(int sock, char *buf)
        *(struct ucred *)CMSG_DATA(cmsg) = c;
        msg.msg_controllen = cmsg->cmsg_len;
        ret = sendmsg(sock, &msg, 0);
        *(struct ucred *)CMSG_DATA(cmsg) = c;
        msg.msg_controllen = cmsg->cmsg_len;
        ret = sendmsg(sock, &msg, 0);

-       if (ret  < 0)
+       if (ret < 0)

                ret = -E_SENDMSG;
        return ret;
 }
                ret = -E_SENDMSG;
        return ret;
 }


@@ -989,17 +1053,17 @@ static void dispose_fds(int *fds, unsigned num)
 /**
  * Receive a buffer and the Unix credentials of the sending process.
  *
 /**
  * Receive a buffer and the Unix credentials of the sending process.
  *

- * \param fd the socket file descriptor.
- * \param buf the buffer to store the message.
- * \param size the size of \a buffer.
+ * \param fd The file descriptor of the receiving socket.
+ * \param buf The buffer to store the received message.
+ * \param size The length of \a buf in bytes.

  *
  *

- * \return negative on errors, the user id on success.
+ * \return Negative on errors, the user id of the sending process on success.

  *
  *

- * \sa recvmsg(2), okir's Black Hats Manual.
+ * \sa \ref send_cred_buffer and the references given there.

  */
 int recv_cred_buffer(int fd, char *buf, size_t size)
 {
  */
 int recv_cred_buffer(int fd, char *buf, size_t size)
 {

-       char control[255];
+       char control[255] __a_aligned(8);

        struct msghdr msg;
        struct cmsghdr *cmsg;
        struct iovec iov;
        struct msghdr msg;
        struct cmsghdr *cmsg;
        struct iovec iov;


@@ -1028,7 +1092,7 @@ int recv_cred_buffer(int fd, char *buf, size_t size)
                } else
                        if (cmsg->cmsg_level == SOL_SOCKET
                                        && cmsg->cmsg_type == SCM_RIGHTS) {
                } else
                        if (cmsg->cmsg_level == SOL_SOCKET
                                        && cmsg->cmsg_type == SCM_RIGHTS) {

-                               dispose_fds((int *) CMSG_DATA(cmsg),
+                               dispose_fds((int *)CMSG_DATA(cmsg),

                                        (cmsg->cmsg_len - CMSG_LEN(0))
                                        / sizeof(int));
                        }
                                        (cmsg->cmsg_len - CMSG_LEN(0))
                                        / sizeof(int));
                        }