Changeset 478 for vendor/current/lib

Timestamp:

Aug 2, 2010, 6:40:21 PM (15 years ago)

Author:

Silvan Scherrer

Message:

Samba 3.5: vendor update to 3.5.4

Location:

vendor/current/lib

Files:

• replace/libreplace_network.m4 (modified) (2 diffs)
• replace/system/network.h (modified) (1 diff)
• tsocket/tsocket.h (modified) (19 diffs)
• tsocket/tsocket_bsd.c (modified) (25 diffs)
• tsocket/tsocket_helpers.c (modified) (3 diffs)
• util/time.c (modified) (2 diffs)
• util/time.h (modified) (1 diff)

vendor/current/lib/replace/libreplace_network.m4

@@ -351 +351 @@
 fi
 
+dnl Some old Linux systems have broken header files and
+dnl miss the IPV6_V6ONLY define in netinet/in.h,
+dnl but have it in linux/in6.h.
+dnl We can't include both files so we just check if the value
+dnl if defined and do the replacement in system/network.h
+AC_CACHE_CHECK([for IPV6_V6ONLY support],libreplace_cv_HAVE_IPV6_V6ONLY,[
+        AC_TRY_COMPILE([
+#include <stdlib.h> /* for NULL */
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netdb.h>
+#include <netinet/in.h>
+                ],
+                [
+#ifndef IPV6_V6ONLY
+#error no IPV6_V6ONLY
+#endif
+                ],[
+                libreplace_cv_HAVE_IPV6_V6ONLY=yes
+                ],[
+                libreplace_cv_HAVE_IPV6_V6ONLY=no
+                ])
+])
+if test x"$libreplace_cv_HAVE_IPV6_V6ONLY" != x"yes"; then
+   dnl test for IPV6_V6ONLY
+   AC_CACHE_CHECK([for IPV6_V6ONLY in linux/in6.h],libreplace_cv_HAVE_LINUX_IPV6_V6ONLY_26,[
+        AC_TRY_COMPILE([
+        #include <linux/in6.h>
+                ],
+                [
+        #if (IPV6_V6ONLY != 26)
+        #error no linux IPV6_V6ONLY
+        #endif
+                ],[
+                libreplace_cv_HAVE_LINUX_IPV6_V6ONLY_26=yes
+                ],[
+                libreplace_cv_HAVE_LINUX_IPV6_V6ONLY_26=no
+                ])
+        ])
+        if test x"$libreplace_cv_HAVE_LINUX_IPV6_V6ONLY_26" = x"yes"; then
+                AC_DEFINE(HAVE_LINUX_IPV6_V6ONLY_26,1,[Whether the system has IPV6_V6ONLY in linux/in6.h])
+        fi
+fi
+
 dnl test for ipv6
 AC_CACHE_CHECK([for ipv6 support],libreplace_cv_HAVE_IPV6,[
@@ -371 +415 @@
 }
 freeaddrinfo(ai);
+{
+        int val = 1;
+        #ifdef HAVE_LINUX_IPV6_V6ONLY_26
+        #define IPV6_V6ONLY 26
+        #endif
+        ret = setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY,
+                         (const void *)&val, sizeof(val));
+}
                 ],[
                 libreplace_cv_HAVE_IPV6=yes

vendor/current/lib/replace/system/network.h

@@ -361 +361 @@
 #endif
 
+/* Some old Linux systems have broken header files */
+#ifdef HAVE_IPV6
+#ifdef HAVE_LINUX_IPV6_V6ONLY_26
+#define IPV6_V6ONLY 26
+#endif /* HAVE_LINUX_IPV6_V6ONLY_26 */
+#endif /* HAVE_IPV6 */
+
 #ifdef SOCKET_WRAPPER
 #ifndef SOCKET_WRAPPER_DISABLE

vendor/current/lib/tsocket/tsocket.h

@@ -33 +33 @@
 struct iovec;
 
-/*
- * tsocket_address related functions
+/**
+ * @mainpage
+ *
+ * The tsocket abstraction is an API ...
+ */
+
+/**
+ * @defgroup tsocket The tsocket API
+ *
+ * The tsocket abstraction is split into two different kinds of
+ * communication interfaces.
+ *
+ * There's the "tstream_context" interface with abstracts the communication
+ * through a bidirectional byte stream between two endpoints.
+ *
+ * And there's the "tdgram_context" interface with abstracts datagram based
+ * communication between any number of endpoints.
+ *
+ * Both interfaces share the "tsocket_address" abstraction for endpoint
+ * addresses.
+ *
+ * The whole library is based on the talloc(3) and 'tevent' libraries and
+ * provides "tevent_req" based "foo_send()"/"foo_recv()" functions pairs for
+ * all abstracted methods that need to be async.
+ *
+ * @section vsock Virtual Sockets
+ *
+ * The abstracted layout of tdgram_context and tstream_context allow
+ * implementations around virtual sockets for encrypted tunnels (like TLS,
+ * SASL or GSSAPI) or named pipes over smb.
+ *
+ * @section npa Named Pipe Auth (NPA) Sockets
+ *
+ * Samba has an implementation to abstract named pipes over smb (within the
+ * server side). See libcli/named_pipe_auth/npa_tstream.[ch] for the core code.
+ * The current callers are located in source4/ntvfs/ipc/vfs_ipc.c and
+ * source4/rpc_server/service_rpc.c for the users.
+ */
+
+/**
+ * @defgroup tsocket_address The tsocket_address abstraction
+ * @ingroup tsocket
+ *
+ * The tsocket_address represents an socket endpoint genericly.
+ * As it's like an abstract class it has no specific constructor.
+ * The specific constructors are descripted in later sections.
+ *
+ * @{
+ */
+
+/**
+ * @brief Get a string representaion of the endpoint.
+ *
+ * This function creates a string representation of the endpoint for debugging.
+ * The output will look as followed:
+ *      prefix:address:port
+ *
+ * e.g.
+ *      ipv4:192.168.1.1:143
+ *
+ * Callers should not try to parse the string! The should use additional methods
+ * of the specific tsocket_address implemention to get more details.
+ *
+ * @param[in]  addr     The address to convert.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to allocate the memory.
+ *
+ * @return              The address as a string representation, NULL on error.
+ *
+ * @see tsocket_address_inet_addr_string()
+ * @see tsocket_address_inet_port()
  */
 char *tsocket_address_string(const struct tsocket_address *addr,
                              TALLOC_CTX *mem_ctx);
 
+#ifdef DOXYGEN
+/**
+ * @brief This creates a copy of a tsocket_address.
+ *
+ * This is useful when before doing modifications to a socket via additional
+ * methods of the specific tsocket_address implementation.
+ *
+ * @param[in]  addr     The address to create the copy from.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @return              A newly allocated copy of addr (tsocket_address *), NULL
+ *                      on error.
+ */
+struct tsocket_address *tsocket_address_copy(const struct tsocket_address *addr,
+                TALLOC_CTX *mem_ctx);
+#else
 struct tsocket_address *_tsocket_address_copy(const struct tsocket_address *addr,
                                               TALLOC_CTX *mem_ctx,
@@ -45 +131 @@
 #define tsocket_address_copy(addr, mem_ctx) \
         _tsocket_address_copy(addr, mem_ctx, __location__)
-
-/*
- * tdgram_context related functions
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup tdgram_context The tdgram_context abstraction
+ * @ingroup tsocket
+ *
+ * The tdgram_context is like an abstract class for datagram based sockets. The
+ * interface provides async 'tevent_req' based functions on top functionality
+ * is similar to the recvfrom(2)/sendto(2)/close(2) syscalls.
+ *
+ * @note You can always use talloc_free(tdgram) to cleanup the resources
+ * of the tdgram_context on a fatal error.
+ * @{
+ */
+
+/**
+ * @brief Ask for next available datagram on the abstracted tdgram_context.
+ *
+ * It returns a 'tevent_req' handle, where the caller can register
+ * a callback with tevent_req_set_callback(). The callback is triggered
+ * when a datagram is available or an error happened.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  dgram    The dgram context to work on.
+ *
+ * @return              Returns a 'tevent_req' handle, where the caller can
+ *                      register a callback with tevent_req_set_callback().
+ *                      NULL on fatal error.
+ *
+ * @see tdgram_inet_udp_socket()
+ * @see tdgram_unix_socket()
  */
 struct tevent_req *tdgram_recvfrom_send(TALLOC_CTX *mem_ctx,
                                         struct tevent_context *ev,
                                         struct tdgram_context *dgram);
+
+/**
+ * @brief Receive the next available datagram on the abstracted tdgram_context.
+ *
+ * This function should be called by the callback when a datagram is available
+ * or an error happened.
+ *
+ * The caller can only have one outstanding tdgram_recvfrom_send() at a time
+ * otherwise the caller will get '*perrno = EBUSY'.
+ *
+ * @param[in]  req      The tevent request from tdgram_recvfrom_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @param[in]  mem_ctx  The memory context to use.
+ *
+ * @param[out] buf      This will hold the buffer of the datagram.
+ *
+ * @param[out] src      The abstracted tsocket_address of the sender of the
+ *                      received datagram.
+ *
+ * @return              The length of the datagram (0 is never returned!),
+ *                      -1 on error with perrno set to the actual errno.
+ *
+ * @see tdgram_recvfrom_send()
+ */
 ssize_t tdgram_recvfrom_recv(struct tevent_req *req,
                              int *perrno,
@@ -58 +205 @@
                              struct tsocket_address **src);
 
+/**
+ * @brief Send a datagram to a destination endpoint.
+ *
+ * The function can be called to send a datagram (specified by a buf/len) to a
+ * destination endpoint (specified by dst). It's not allowed for len to be 0.
+ *
+ * It returns a 'tevent_req' handle, where the caller can register a callback
+ * with tevent_req_set_callback(). The callback is triggered when the specific
+ * implementation (assumes it) has delivered the datagram to the "wire".
+ *
+ * The callback is then supposed to get the result by calling
+ * tdgram_sendto_recv() on the 'tevent_req'.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  dgram    The dgram context to work on.
+ *
+ * @param[in]  buf      The buffer to send.
+ *
+ * @param[in]  len      The length of the buffer to send. It has to be bigger
+ *                      than 0.
+ *
+ * @param[in]  dst      The destination to send the datagram to in form of a
+ *                      tsocket_address.
+ *
+ * @return              Returns a 'tevent_req' handle, where the caller can
+ *                      register a callback with tevent_req_set_callback().
+ *                      NULL on fatal error.
+ *
+ * @see tdgram_inet_udp_socket()
+ * @see tdgram_unix_socket()
+ * @see tdgram_sendto_recv()
+ */
 struct tevent_req *tdgram_sendto_send(TALLOC_CTX *mem_ctx,
                                       struct tevent_context *ev,
@@ -63 +245 @@
                                       const uint8_t *buf, size_t len,
                                       const struct tsocket_address *dst);
+
+/**
+ * @brief Receive the result of the sent datagram.
+ *
+ * The caller can only have one outstanding tdgram_sendto_send() at a time
+ * otherwise the caller will get '*perrno = EBUSY'.
+ *
+ * @param[in]  req      The tevent request from tdgram_sendto_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @return              The length of the datagram (0 is never returned!), -1 on
+ *                      error with perrno set to the actual errno.
+ *
+ * @see tdgram_sendto_send()
+ */
 ssize_t tdgram_sendto_recv(struct tevent_req *req,
                            int *perrno);
 
+/**
+ * @brief Shutdown/close an abstracted socket.
+ *
+ * It returns a 'tevent_req' handle, where the caller can register a callback
+ * with tevent_req_set_callback(). The callback is triggered when the specific
+ * implementation (assumes it) has delivered the datagram to the "wire".
+ *
+ * The callback is then supposed to get the result by calling
+ * tdgram_sendto_recv() on the 'tevent_req'.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  dgram    The dgram context diconnect from.
+ *
+ * @return              Returns a 'tevent_req' handle, where the caller can
+ *                      register a callback with tevent_req_set_callback().
+ *                      NULL on fatal error.
+ *
+ * @see tdgram_disconnect_recv()
+ */
 struct tevent_req *tdgram_disconnect_send(TALLOC_CTX *mem_ctx,
                                           struct tevent_context *ev,
                                           struct tdgram_context *dgram);
+
+/**
+ * @brief Receive the result from a tdgram_disconnect_send() request.
+ *
+ * The caller should make sure there're no outstanding tdgram_recvfrom_send()
+ * and tdgram_sendto_send() calls otherwise the caller will get
+ * '*perrno = EBUSY'.
+ *
+ * @param[in]  req      The tevent request from tdgram_disconnect_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @return              The length of the datagram (0 is never returned!), -1 on
+ *                      error with perrno set to the actual errno.
+ *
+ * @see tdgram_disconnect_send()
+ */
 int tdgram_disconnect_recv(struct tevent_req *req,
                            int *perrno);
 
-/*
- * tstream_context related functions
+/**
+ * @}
+ */
+
+/**
+ * @defgroup tstream_context The tstream_context abstraction
+ * @ingroup tsocket
+ *
+ * The tstream_context is like an abstract class for stream based sockets. The
+ * interface provides async 'tevent_req' based functions on top functionality
+ * is similar to the readv(2)/writev(2)/close(2) syscalls.
+ *
+ * @note You can always use talloc_free(tstream) to cleanup the resources
+ * of the tstream_context on a fatal error.
+ *
+ * @{
+ */
+
+/**
+ * @brief Report the number of bytes received but not consumed yet.
+ *
+ * The tstream_pending_bytes() function reports how much bytes of the incoming
+ * stream have been received but not consumed yet.
+ *
+ * @param[in]  stream   The tstream_context to check for pending bytes.
+ *
+ * @return              The number of bytes received, -1 on error with errno
+ *                      set.
  */
 ssize_t tstream_pending_bytes(struct tstream_context *stream);
 
+/**
+ * @brief Read a specific amount of bytes from a stream socket.
+ *
+ * The function can be called to read for a specific amount of bytes from the
+ * stream into given buffers. The caller has to preallocate the buffers.
+ *
+ * The caller might need to use tstream_pending_bytes() if the protocol doesn't
+ * have a fixed pdu header containing the pdu size.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  stream   The tstream context to work on.
+ *
+ * @param[out] vector   A preallocated iovec to store the data to read.
+ *
+ * @param[in]  count    The number of buffers in the vector allocated.
+ *
+ * @return              A 'tevent_req' handle, where the caller can register
+ *                      a callback with tevent_req_set_callback(). NULL on
+ *                      fatal error.
+ *
+ * @see tstream_unix_connect_send()
+ * @see tstream_inet_tcp_connect_send()
+ */
 struct tevent_req *tstream_readv_send(TALLOC_CTX *mem_ctx,
                                       struct tevent_context *ev,
@@ -82 +371 @@
                                       struct iovec *vector,
                                       size_t count);
+
+/**
+ * @brief Get the result of a tstream_readv_send().
+ *
+ * The caller can only have one outstanding tstream_readv_send()
+ * at a time otherwise the caller will get *perrno = EBUSY.
+ *
+ * @param[in]  req      The tevent request from tstream_readv_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @return              The length of the stream (0 is never returned!), -1 on
+ *                      error with perrno set to the actual errno.
+ */
 int tstream_readv_recv(struct tevent_req *req,
                        int *perrno);
 
+/**
+ * @brief Write buffers from a vector into a stream socket.
+ *
+ * The function can be called to write buffers from a given vector
+ * to a stream socket.
+ *
+ * You have to ensure that the vector is not empty.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  stream   The tstream context to work on.
+ *
+ * @param[in]  vector   The iovec vector with data to write on a stream socket.
+ *
+ * @param[in]  count    The number of buffers in the vector to write.
+ *
+ * @return              A 'tevent_req' handle, where the caller can register
+ *                      a callback with tevent_req_set_callback(). NULL on
+ *                      fatal error.
+ */
 struct tevent_req *tstream_writev_send(TALLOC_CTX *mem_ctx,
                                        struct tevent_context *ev,
@@ -90 +415 @@
                                        const struct iovec *vector,
                                        size_t count);
+
+/**
+ * @brief Get the result of a tstream_writev_send().
+ *
+ * The caller can only have one outstanding tstream_writev_send()
+ * at a time otherwise the caller will get *perrno = EBUSY.
+ *
+ * @param[in]  req      The tevent request from tstream_writev_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @return              The length of the stream (0 is never returned!), -1 on
+ *                      error with perrno set to the actual errno.
+ */
 int tstream_writev_recv(struct tevent_req *req,
                         int *perrno);
 
+/**
+ * @brief Shutdown/close an abstracted socket.
+ *
+ * It returns a 'tevent_req' handle, where the caller can register a callback
+ * with tevent_req_set_callback(). The callback is triggered when the specific
+ * implementation (assumes it) has delivered the stream to the "wire".
+ *
+ * The callback is then supposed to get the result by calling
+ * tdgram_sendto_recv() on the 'tevent_req'.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  stream   The tstream context to work on.
+ *
+ * @return              A 'tevent_req' handle, where the caller can register
+ *                      a callback with tevent_req_set_callback(). NULL on
+ *                      fatal error.
+ */
 struct tevent_req *tstream_disconnect_send(TALLOC_CTX *mem_ctx,
                                            struct tevent_context *ev,
                                            struct tstream_context *stream);
+
+/**
+ * @brief Get the result of a tstream_disconnect_send().
+ *
+ * The caller can only have one outstanding tstream_writev_send()
+ * at a time otherwise the caller will get *perrno = EBUSY.
+ *
+ * @param[in]  req      The tevent request from tstream_disconnect_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @return              The length of the stream (0 is never returned!), -1 on
+ *                      error with perrno set to the actual errno.
+ */
 int tstream_disconnect_recv(struct tevent_req *req,
                             int *perrno);
 
-/*
- * BSD sockets: inet, inet6 and unix
- */
-
+/**
+ * @}
+ */
+
+
+/**
+ * @defgroup tsocket_bsd  tsocket_bsd - inet, inet6 and unix
+ * @ingroup tsocket
+ *
+ * The main tsocket library comes with implentations for BSD style ipv4, ipv6
+ * and unix sockets.
+ *
+ * @{
+ */
+
+#if DOXYGEN
+/**
+ * @brief Create a tsocket_address for ipv4 and ipv6 endpoint addresses.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  fam      The family can be can be "ipv4", "ipv6" or "ip". With
+ *                      "ip" is autodetects "ipv4" or "ipv6" based on the
+ *                      addr.
+ *
+ * @param[in]  addr     A valid ip address string based on the selected family
+ *                      (dns names are not allowed!). It's valid to pass NULL,
+ *                      which gets mapped to "0.0.0.0" or "::".
+ *
+ * @param[in]  port     A valid port number.
+ *
+ * @param[out] _addr    A tsocket_address pointer to store the information.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ */
+int tsocket_address_inet_from_strings(TALLOC_CTX *mem_ctx,
+                                      const char *fam,
+                                      const char *addr,
+                                      uint16_t port,
+                                      struct tsocket_address **_addr);
+#else
 int _tsocket_address_inet_from_strings(TALLOC_CTX *mem_ctx,
                                        const char *fam,
@@ -109 +519 @@
                                        struct tsocket_address **_addr,
                                        const char *location);
+
 #define tsocket_address_inet_from_strings(mem_ctx, fam, addr, port, _addr) \
         _tsocket_address_inet_from_strings(mem_ctx, fam, addr, port, _addr, \
                                            __location__)
-
+#endif
+
+/**
+ * @brief Get the address of an 'inet' tsocket_address as a string.
+ *
+ * @param[in]  addr     The address to convert to a string.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @return              A newly allocated string of the address, NULL on error
+ *                      with errno set.
+ */
 char *tsocket_address_inet_addr_string(const struct tsocket_address *addr,
                                        TALLOC_CTX *mem_ctx);
+
+/**
+ * @brief Get the port number as an integer from an 'inet' tsocket_address.
+ *
+ * @param[in]  addr     The tsocket address to use.
+ *
+ * @return              The port number, 0 on error with errno set.
+ */
 uint16_t tsocket_address_inet_port(const struct tsocket_address *addr);
+
+/**
+ * @brief Set the port number of an existing 'inet' tsocket_address.
+ *
+ * @param[in]  addr     The existing tsocket_address to use.
+ *
+ * @param[in]  port     The valid port number to set.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ */
 int tsocket_address_inet_set_port(struct tsocket_address *addr,
                                   uint16_t port);
 
+#ifdef DOXYGEN
+/**
+ * @brief Create a tsocket_address for a unix domain endpoint addresses.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  path     The filesystem path, NULL will map "".
+ *
+ * @param[in]  _addr    The tsocket_address pointer to store the information.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ */
+int tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
+                                   const char *path,
+                                   struct tsocket_address **_addr);
+#else
 int _tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
                                     const char *path,
                                     struct tsocket_address **_addr,
                                     const char *location);
+
 #define tsocket_address_unix_from_path(mem_ctx, path, _addr) \
         _tsocket_address_unix_from_path(mem_ctx, path, _addr, \
                                         __location__)
+#endif
+
+/**
+ * @brief Get the address of an 'unix' tsocket_address.
+ *
+ * @param[in]  addr     A valid 'unix' tsocket_address.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @return              The path of the unix domain socket, NULL on error or if
+ *                      the tsocket_address doesn't represent an unix domain
+ *                      endpoint path.
+ */
 char *tsocket_address_unix_path(const struct tsocket_address *addr,
                                 TALLOC_CTX *mem_ctx);
 
+#ifdef DOXYGEN
+/**
+ * @brief Create a tdgram_context for a ipv4 or ipv6 UDP communication.
+ *
+ * @param[in]  local    An 'inet' tsocket_address for the local endpoint.
+ *
+ * @param[in]  remote   An 'inet' tsocket_address for the remote endpoint or
+ *                      NULL (??? to create a listener?).
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  dgram    The tdgram_context pointer to setup the udp
+ *                      communication. The function will allocate the memory.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ */
+int tdgram_inet_udp_socket(const struct tsocket_address *local,
+                            const struct tsocket_address *remote,
+                            TALLOC_CTX *mem_ctx,
+                            struct tdgram_context **dgram);
+#else
 int _tdgram_inet_udp_socket(const struct tsocket_address *local,
                             const struct tsocket_address *remote,
@@ -136 +627 @@
 #define tdgram_inet_udp_socket(local, remote, mem_ctx, dgram) \
         _tdgram_inet_udp_socket(local, remote, mem_ctx, dgram, __location__)
-
+#endif
+
+#ifdef DOXYGEN
+/**
+ * @brief Create a tdgram_context for unix domain datagram communication.
+ *
+ * @param[in]  local    An 'unix' tsocket_address for the local endpoint.
+ *
+ * @param[in]  remote   An 'unix' tsocket_address for the remote endpoint or
+ *                      NULL (??? to create a listener?).
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  dgram    The tdgram_context pointer to setup the udp
+ *                      communication. The function will allocate the memory.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ */
+int tdgram_unix_socket(const struct tsocket_address *local,
+                        const struct tsocket_address *remote,
+                        TALLOC_CTX *mem_ctx,
+                        struct tdgram_context **dgram);
+#else
 int _tdgram_unix_socket(const struct tsocket_address *local,
                         const struct tsocket_address *remote,
@@ -142 +655 @@
                         struct tdgram_context **dgram,
                         const char *location);
+
 #define tdgram_unix_socket(local, remote, mem_ctx, dgram) \
         _tdgram_unix_socket(local, remote, mem_ctx, dgram, __location__)
-
-struct tevent_req * tstream_inet_tcp_connect_send(TALLOC_CTX *mem_ctx,
+#endif
+
+/**
+ * @brief Connect async to a TCP endpoint and create a tstream_context for the
+ * stream based communication.
+ *
+ * Use this function to connenct asynchronously to a remote ipv4 or ipv6 TCP
+ * endpoint and create a tstream_context for the stream based communication.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  local    An 'inet' tsocket_address for the local endpoint.
+ *
+ * @param[in]  remote   An 'inet' tsocket_address for the remote endpoint.
+ *
+ * @return              A 'tevent_req' handle, where the caller can register a
+ *                      callback with tevent_req_set_callback(). NULL on a fatal
+ *                      error.
+ *
+ * @see tstream_inet_tcp_connect_recv()
+ */
+struct tevent_req *tstream_inet_tcp_connect_send(TALLOC_CTX *mem_ctx,
                                         struct tevent_context *ev,
                                         const struct tsocket_address *local,
                                         const struct tsocket_address *remote);
+
+#ifdef DOXYGEN
+/**
+ * @brief Receive the result from a tstream_inet_tcp_connect_send().
+ *
+ * @param[in]  req      The tevent request from tstream_inet_tcp_connect_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  stream   A tstream_context pointer to setup the tcp communication
+ *                      on. This function will allocate the memory.
+ *
+ * @return              0 on success, -1 on error with perrno set.
+ */
+int tstream_inet_tcp_connect_recv(struct tevent_req *req,
+                                  int *perrno,
+                                  TALLOC_CTX *mem_ctx,
+                                  struct tstream_context **stream);
+#else
 int _tstream_inet_tcp_connect_recv(struct tevent_req *req,
                                    int *perrno,
@@ -157 +714 @@
         _tstream_inet_tcp_connect_recv(req, perrno, mem_ctx, stream, \
                                        __location__)
-
+#endif
+
+/**
+ * @brief Connect async to a unix domain endpoint and create a tstream_context
+ * for the stream based communication.
+ *
+ * Use this function to connenct asynchronously to a unix domainendpoint and
+ * create a tstream_context for the stream based communication.
+ *
+ * The callback is triggered when a socket is connected and ready for IO or an
+ * error happened.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  local    An 'unix' tsocket_address for the local endpoint.
+ *
+ * @param[in]  remote   An 'unix' tsocket_address for the remote endpoint.
+ *
+ * @return              A 'tevent_req' handle, where the caller can register a
+ *                      callback with tevent_req_set_callback(). NULL on a falal
+ *                      error.
+ *
+ * @see tstream_unix_connect_recv()
+ */
 struct tevent_req * tstream_unix_connect_send(TALLOC_CTX *mem_ctx,
                                         struct tevent_context *ev,
                                         const struct tsocket_address *local,
                                         const struct tsocket_address *remote);
+
+#ifdef DOXYGEN
+/**
+ * @brief Receive the result from a tstream_unix_connect_send().
+ *
+ * @param[in]  req      The tevent request from tstream_inet_tcp_connect_send().
+ *
+ * @param[out] perrno   The error number, set if an error occurred.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  stream   The tstream context to work on.
+ *
+ * @return              0 on success, -1 on error with perrno set.
+ */
+int tstream_unix_connect_recv(struct tevent_req *req,
+                              int *perrno,
+                              TALLOC_CTX *mem_ctx,
+                              struct tstream_context **stream);
+#else
 int _tstream_unix_connect_recv(struct tevent_req *req,
                                int *perrno,
@@ -170 +772 @@
         _tstream_unix_connect_recv(req, perrno, mem_ctx, stream, \
                                           __location__)
-
+#endif
+
+#ifdef DOXYGEN
+/**
+ * @brief Create two connected 'unix' tsocket_contexts for stream based
+ *        communication.
+ *
+ * @param[in]  mem_ctx1 The talloc memory context to use for stream1.
+ *
+ * @param[in]  stream1  The first stream to connect.
+ *
+ * @param[in]  mem_ctx2 The talloc memory context to use for stream2.
+ *
+ * @param[in]  stream2  The second stream to connect.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ */
+int tstream_unix_socketpair(TALLOC_CTX *mem_ctx1,
+                            struct tstream_context **stream1,
+                            TALLOC_CTX *mem_ctx2,
+                            struct tstream_context **stream2);
+#else
 int _tstream_unix_socketpair(TALLOC_CTX *mem_ctx1,
                              struct tstream_context **_stream1,
@@ -176 +799 @@
                              struct tstream_context **_stream2,
                              const char *location);
+
 #define tstream_unix_socketpair(mem_ctx1, stream1, mem_ctx2, stream2) \
         _tstream_unix_socketpair(mem_ctx1, stream1, mem_ctx2, stream2, \
                                  __location__)
+#endif
 
 struct sockaddr;
 
+#ifdef DOXYGEN
+/**
+ * @brief Convert a tsocket address to a bsd socket address.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  sa       The sockaddr structure to convert.
+ *
+ * @param[in]  sa_socklen   The lenth of the sockaddr sturucte.
+ *
+ * @param[out] addr     The tsocket pointer to allocate and fill.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ */
+int tsocket_address_bsd_from_sockaddr(TALLOC_CTX *mem_ctx,
+                                      struct sockaddr *sa,
+                                      size_t sa_socklen,
+                                      struct tsocket_address **addr);
+#else
 int _tsocket_address_bsd_from_sockaddr(TALLOC_CTX *mem_ctx,
                                        struct sockaddr *sa,
@@ -187 +831 @@
                                        struct tsocket_address **_addr,
                                        const char *location);
+
 #define tsocket_address_bsd_from_sockaddr(mem_ctx, sa, sa_socklen, _addr) \
         _tsocket_address_bsd_from_sockaddr(mem_ctx, sa, sa_socklen, _addr, \
                                            __location__)
-
+#endif
+
+/**
+ * @brief Fill a bsd sockaddr structure.
+ *
+ * @param[in]  addr     The tsocket address structure to use.
+ *
+ * @param[in]  sa       The bsd sockaddr structure to fill out.
+ *
+ * @param[in]  sa_socklen   The length of the  bsd sockaddr structure to fill out.
+ *
+ * @return              The actual size of the sockaddr structure, -1 on error
+ *                      with errno set. The size could differ from sa_socklen.
+ *
+ * @code
+ *   ssize_t socklen;
+ *   struct sockaddr_storage ss;
+ *
+ *   socklen = tsocket_address_bsd_sockaddr(taddr,
+ *                    (struct sockaddr *) &ss,
+ *                    sizeof(struct sockaddr_storage));
+ *   if (socklen < 0) {
+ *     return -1;
+ *   }
+ * @endcode
+ */
 ssize_t tsocket_address_bsd_sockaddr(const struct tsocket_address *addr,
                                      struct sockaddr *sa,
                                      size_t sa_socklen);
 
+#ifdef DOXYGEN
+/**
+ * @brief Wrap an existing file descriptors into the tstream abstraction.
+ *
+ * You can use this function to wrap an existing file descriptors into the
+ * tstream abstraction. After that you're not able to use this file descriptor
+ * for anything else. The file descriptor will be closed when the stream gets
+ * freed. If you still want to use the fd you have have to create a duplicate.
+ *
+ * @param[in]  mem_ctx      The talloc memory context to use.
+ *
+ * @param[in]  fd           The non blocking fd to use!
+ *
+ * @param[in]  stream       The filed tstream_context you allocated before.
+ *
+ * @return              0 on success, -1 on error with errno set.
+ *
+ * @warning You should read the tsocket_bsd.c code and unterstand it in order
+ * use this function.
+ */
+int tstream_bsd_existing_socket(TALLOC_CTX *mem_ctx,
+                                int fd,
+                                struct tstream_context **stream);
+#else
 int _tstream_bsd_existing_socket(TALLOC_CTX *mem_ctx,
                                  int fd,
@@ -202 +896 @@
         _tstream_bsd_existing_socket(mem_ctx, fd, stream, \
                                      __location__)
-
-/*
- * Queue and PDU helpers
- */
-
+#endif
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup tsocket_helper Queue and PDU helpers
+ * @ingroup tsocket
+ *
+ * In order to make the live easier for callers which want to implement a
+ * function to receive a full PDU with a single async function pair, there're
+ * some helper functions.
+ *
+ * There're some cases where the caller wants doesn't care about the order of
+ * doing IO on the abstracted sockets.
+ *
+ * @{
+ */
+
+/**
+ * @brief Queue a dgram blob for sending through the socket.
+ *
+ * This function queues a blob for sending to destination through an existing
+ * dgram socket. The async callback is triggered when the whole blob is
+ * delivered to the underlying system socket.
+ *
+ * The caller needs to make sure that all non-scalar input parameters hang
+ * around for the whole lifetime of the request.
+ *
+ * @param[in]  mem_ctx  The memory context for the result.
+ *
+ * @param[in]  ev       The event context the operation should work on.
+ *
+ * @param[in]  dgram    The tdgram_context to send the message buffer.
+ *
+ * @param[in]  queue    The existing dgram queue.
+ *
+ * @param[in]  buf      The message buffer to send.
+ *
+ * @param[in]  len      The message length.
+ *
+ * @param[in]  dst      The destination socket address.
+ *
+ * @return              The async request handle. NULL on fatal error.
+ *
+ * @see tdgram_sendto_queue_recv()
+ */
 struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
                                             struct tevent_context *ev,
@@ -214 +951 @@
                                             size_t len,
                                             struct tsocket_address *dst);
+
+/**
+ * @brief Receive the result of the sent dgram blob.
+ *
+ * @param[in]  req      The tevent request from tdgram_sendto_queue_send().
+ *
+ * @param[out] perrno   The error set to the actual errno.
+ *
+ * @return              The length of the datagram (0 is never returned!), -1 on
+ *                      error with perrno set to the actual errno.
+ */
 ssize_t tdgram_sendto_queue_recv(struct tevent_req *req, int *perrno);
 
@@ -221 +969 @@
                                                struct iovec **vector,
                                                size_t *count);
+
 struct tevent_req *tstream_readv_pdu_send(TALLOC_CTX *mem_ctx,
                                 struct tevent_context *ev,
@@ -228 +977 @@
 int tstream_readv_pdu_recv(struct tevent_req *req, int *perrno);
 
+/**
+ * @brief Queue a read request for a PDU on the socket.
+ *
+ * This function queues a read request for a PDU on a stream socket. The async
+ * callback is triggered when a full PDU has been read from the socket.
+ *
+ * The caller needs to make sure that all non-scalar input parameters hang
+ * around for the whole lifetime of the request.
+ *
+ * @param[in]  mem_ctx  The memory context for the result
+ *
+ * @param[in]  ev       The tevent_context to run on
+ *
+ * @param[in]  stream   The stream to send data through
+ *
+ * @param[in]  queue    The existing send queue
+ *
+ * @param[in]  next_vector_fn  The next vector function
+ *
+ * @param[in]  next_vector_private  The private_data of the next vector function
+ *
+ * @return              The async request handle. NULL on fatal error.
+ *
+ * @see tstream_readv_pdu_queue_recv()
+ */
 struct tevent_req *tstream_readv_pdu_queue_send(TALLOC_CTX *mem_ctx,
                                 struct tevent_context *ev,
@@ -234 +1008 @@
                                 tstream_readv_pdu_next_vector_t next_vector_fn,
                                 void *next_vector_private);
+
+/**
+ * @brief Receive the PDU blob read from the stream.
+ *
+ * @param[in]  req      The tevent request from tstream_readv_pdu_queue_send().
+ *
+ * @param[out] perrno   The error set to the actual errno.
+ *
+ * @return              The number of bytes read on success, -1 on error with
+ *                      perrno set to the actual errno.
+ */
 int tstream_readv_pdu_queue_recv(struct tevent_req *req, int *perrno);
 
+/**
+ * @brief Queue an iovector for sending through the socket
+ *
+ * This function queues an iovector for sending to destination through an
+ * existing stream socket. The async callback is triggered when the whole
+ * vectror has been delivered to the underlying system socket.
+ *
+ * The caller needs to make sure that all non-scalar input parameters hang
+ * around for the whole lifetime of the request.
+ *
+ * @param[in]  mem_ctx  The memory context for the result.
+ *
+ * @param[in]  ev       The tevent_context to run on.
+ *
+ * @param[in]  stream   The stream to send data through.
+ *
+ * @param[in]  queue    The existing send queue.
+ *
+ * @param[in]  vector   The iovec vector so write.
+ *
+ * @param[in]  count    The size of the vector.
+ *
+ * @return              The async request handle. NULL on fatal error.
+ */
 struct tevent_req *tstream_writev_queue_send(TALLOC_CTX *mem_ctx,
                                              struct tevent_context *ev,
@@ -242 +1051 @@
                                              const struct iovec *vector,
                                              size_t count);
+
+/**
+ * @brief Receive the result of the sent iovector.
+ *
+ * @param[in]  req      The tevent request from tstream_writev_queue_send().
+ *
+ * @param[out] perrno   The error set to the actual errno.
+ *
+ * @return              The length of the iovector (0 is never returned!), -1 on
+ *                      error with perrno set to the actual errno.
+ */
 int tstream_writev_queue_recv(struct tevent_req *req, int *perrno);
 
+/**
+ * @}
+ */
+
 #endif /* _TSOCKET_H */
 

vendor/current/lib/tsocket/tsocket_bsd.c

@@ -191 +191 @@
 
 struct tsocket_address_bsd {
+        socklen_t sa_socklen;
         union {
                 struct sockaddr sa;
@@ -211 +212 @@
         struct tsocket_address_bsd *bsda;
 
+        if (sa_socklen < sizeof(sa->sa_family)) {
+                errno = EINVAL;
+                return -1;
+        }
+
         switch (sa->sa_family) {
         case AF_UNIX:
-                if (sa_socklen < sizeof(struct sockaddr_un)) {
-                        errno = EINVAL;
-                        return -1;
+                if (sa_socklen > sizeof(struct sockaddr_un)) {
+                        sa_socklen = sizeof(struct sockaddr_un);
                 }
                 break;
@@ -223 +228 @@
                         return -1;
                 }
+                sa_socklen = sizeof(struct sockaddr_in);
                 break;
 #ifdef HAVE_IPV6
@@ -230 +236 @@
                         return -1;
                 }
+                sa_socklen = sizeof(struct sockaddr_in6);
                 break;
 #endif
@@ -256 +263 @@
         memcpy(&bsda->u.ss, sa, sa_socklen);
 
+        bsda->sa_socklen = sa_socklen;
+
         *_addr = addr;
         return 0;
@@ -266 +275 @@
         struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
                                            struct tsocket_address_bsd);
-        ssize_t rlen = 0;
 
         if (!bsda) {
@@ -273 +281 @@
         }
 
-        switch (bsda->u.sa.sa_family) {
-        case AF_UNIX:
-                rlen = sizeof(struct sockaddr_un);
-                break;
-        case AF_INET:
-                rlen = sizeof(struct sockaddr_in);
-                break;
-#ifdef HAVE_IPV6
-        case AF_INET6:
-                rlen = sizeof(struct sockaddr_in6);
-                break;
-#endif
-        default:
-                errno = EAFNOSUPPORT;
-                return -1;
-        }
-
-        if (sa_socklen < rlen) {
+        if (sa_socklen < bsda->sa_socklen) {
                 errno = EINVAL;
                 return -1;
         }
 
-        if (sa_socklen > sizeof(struct sockaddr_storage)) {
+        if (sa_socklen > bsda->sa_socklen) {
                 memset(sa, 0, sa_socklen);
-                sa_socklen = sizeof(struct sockaddr_storage);
+                sa_socklen = bsda->sa_socklen;
         }
 
         memcpy(sa, &bsda->u.ss, sa_socklen);
-        return rlen;
+        return sa_socklen;
 }
 
@@ -583 +574 @@
         ret = _tsocket_address_bsd_from_sockaddr(mem_ctx,
                                                  &bsda->u.sa,
-                                                 sizeof(bsda->u.ss),
+                                                 bsda->sa_socklen,
                                                  &copy,
                                                  location);
@@ -822 +813 @@
         struct tsocket_address_bsd *bsda;
         ssize_t ret;
-        struct sockaddr *sa = NULL;
-        socklen_t sa_socklen = 0;
         int err;
         bool retry;
@@ -857 +846 @@
 
         ZERO_STRUCTP(bsda);
-
-        sa = &bsda->u.sa;
-        sa_socklen = sizeof(bsda->u.ss);
-        /*
-         * for unix sockets we can't use the size of sockaddr_storage
-         * we would get EINVAL
-         */
-        if (bsda->u.sa.sa_family == AF_UNIX) {
-                sa_socklen = sizeof(bsda->u.un);
-        }
-
-        ret = recvfrom(bsds->fd, state->buf, state->len, 0, sa, &sa_socklen);
+        bsda->sa_socklen = sizeof(bsda->u.ss);
+
+        ret = recvfrom(bsds->fd, state->buf, state->len, 0,
+                       &bsda->u.sa, &bsda->sa_socklen);
         err = tsocket_bsd_error_from_errno(ret, errno, &retry);
         if (retry) {
@@ -1014 +995 @@
 
                 sa = &bsda->u.sa;
-                sa_socklen = sizeof(bsda->u.ss);
-                /*
-                 * for unix sockets we can't use the size of sockaddr_storage
-                 * we would get EINVAL
-                 */
-                if (bsda->u.sa.sa_family == AF_UNIX) {
-                        sa_socklen = sizeof(bsda->u.un);
-                }
+                sa_socklen = bsda->sa_socklen;
         }
 
@@ -1147 +1121 @@
         bool is_inet = false;
         int sa_fam = lbsda->u.sa.sa_family;
-        socklen_t sa_socklen = sizeof(lbsda->u.ss);
 
         if (remote) {
@@ -1164 +1137 @@
                         do_bind = true;
                 }
-                /*
-                 * for unix sockets we can't use the size of sockaddr_storage
-                 * we would get EINVAL
-                 */
-                sa_socklen = sizeof(lbsda->u.un);
                 break;
         case AF_INET:
@@ -1179 +1147 @@
                 }
                 is_inet = true;
-                sa_socklen = sizeof(rbsda->u.in);
                 break;
 #ifdef HAVE_IPV6
@@ -1193 +1160 @@
                 }
                 is_inet = true;
-                sa_socklen = sizeof(rbsda->u.in6);
                 do_ipv6only = true;
                 break;
@@ -1206 +1172 @@
                 switch (sa_fam) {
                 case AF_INET:
-                        sa_socklen = sizeof(rbsda->u.in);
                         do_ipv6only = false;
                         break;
 #ifdef HAVE_IPV6
                 case AF_INET6:
-                        sa_socklen = sizeof(rbsda->u.in6);
                         do_ipv6only = true;
                         break;
@@ -1285 +1249 @@
 
         if (do_bind) {
-                ret = bind(fd, &lbsda->u.sa, sa_socklen);
+                ret = bind(fd, &lbsda->u.sa, lbsda->sa_socklen);
                 if (ret == -1) {
                         int saved_errno = errno;
@@ -1301 +1265 @@
                 }
 
-                ret = connect(fd, &rbsda->u.sa, sa_socklen);
+                ret = connect(fd, &rbsda->u.sa, rbsda->sa_socklen);
                 if (ret == -1) {
                         int saved_errno = errno;
@@ -1994 +1958 @@
         bool is_inet = false;
         int sa_fam = lbsda->u.sa.sa_family;
-        socklen_t sa_socklen = sizeof(rbsda->u.ss);
 
         req = tevent_req_create(mem_ctx, &state,
@@ -2018 +1981 @@
                         do_bind = true;
                 }
-                /*
-                 * for unix sockets we can't use the size of sockaddr_storage
-                 * we would get EINVAL
-                 */
-                sa_socklen = sizeof(rbsda->u.un);
                 break;
         case AF_INET:
@@ -2033 +1991 @@
                 }
                 is_inet = true;
-                sa_socklen = sizeof(rbsda->u.in);
                 break;
 #ifdef HAVE_IPV6
@@ -2047 +2004 @@
                 }
                 is_inet = true;
-                sa_socklen = sizeof(rbsda->u.in6);
                 do_ipv6only = true;
                 break;
@@ -2060 +2016 @@
                 switch (sa_fam) {
                 case AF_INET:
-                        sa_socklen = sizeof(rbsda->u.in);
                         do_ipv6only = false;
                         break;
 #ifdef HAVE_IPV6
                 case AF_INET6:
-                        sa_socklen = sizeof(rbsda->u.in6);
                         do_ipv6only = true;
                         break;
@@ -2109 +2063 @@
 
         if (do_bind) {
-                ret = bind(state->fd, &lbsda->u.sa, sa_socklen);
+                ret = bind(state->fd, &lbsda->u.sa, lbsda->sa_socklen);
                 if (ret == -1) {
                         tevent_req_error(req, errno);
@@ -2121 +2075 @@
         }
 
-        ret = connect(state->fd, &rbsda->u.sa, sa_socklen);
+        ret = connect(state->fd, &rbsda->u.sa, rbsda->sa_socklen);
         err = tsocket_bsd_error_from_errno(ret, errno, &retry);
         if (retry) {

vendor/current/lib/tsocket/tsocket_helpers.c

@@ -43 +43 @@
 static void tdgram_sendto_queue_done(struct tevent_req *subreq);
 
-/**
- * @brief Queue a dgram blob for sending through the socket
- * @param[in] mem_ctx   The memory context for the result
- * @param[in] ev        The event context the operation should work on
- * @param[in] dgram     The tdgram_context to send the message buffer
- * @param[in] queue     The existing dgram queue
- * @param[in] buf       The message buffer
- * @param[in] len       The message length
- * @param[in] dst       The destination socket address
- * @retval              The async request handle
- *
- * This function queues a blob for sending to destination through an existing
- * dgram socket. The async callback is triggered when the whole blob is
- * delivered to the underlying system socket.
- *
- * The caller needs to make sure that all non-scalar input parameters hang
- * arround for the whole lifetime of the request.
- */
 struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
                                             struct tevent_context *ev,
@@ -336 +318 @@
 static void tstream_readv_pdu_queue_done(struct tevent_req *subreq);
 
-/**
- * @brief Queue a dgram blob for sending through the socket
- * @param[in] mem_ctx   The memory context for the result
- * @param[in] ev        The tevent_context to run on
- * @param[in] stream    The stream to send data through
- * @param[in] queue     The existing send queue
- * @param[in] next_vector_fn    The next vector function
- * @param[in] next_vector_private       The private_data of the next vector function
- * @retval              The async request handle
- *
- * This function queues a blob for sending to destination through an existing
- * dgram socket. The async callback is triggered when the whole blob is
- * delivered to the underlying system socket.
- *
- * The caller needs to make sure that all non-scalar input parameters hang
- * arround for the whole lifetime of the request.
- */
 struct tevent_req *tstream_readv_pdu_queue_send(TALLOC_CTX *mem_ctx,
                                 struct tevent_context *ev,
@@ -460 +425 @@
 static void tstream_writev_queue_done(struct tevent_req *subreq);
 
-/**
- * @brief Queue a dgram blob for sending through the socket
- * @param[in] mem_ctx   The memory context for the result
- * @param[in] ev        The tevent_context to run on
- * @param[in] stream    The stream to send data through
- * @param[in] queue     The existing send queue
- * @param[in] vector    The iovec vector so write
- * @param[in] count     The size of the vector
- * @retval              The async request handle
- *
- * This function queues a blob for sending to destination through an existing
- * dgram socket. The async callback is triggered when the whole blob is
- * delivered to the underlying system socket.
- *
- * The caller needs to make sure that all non-scalar input parameters hang
- * arround for the whole lifetime of the request.
- */
 struct tevent_req *tstream_writev_queue_send(TALLOC_CTX *mem_ctx,
                                              struct tevent_context *ev,

vendor/current/lib/util/time.c

@@ -28 +28 @@
  */
 
-#ifndef TIME_T_MIN
-/* we use 0 here, because (time_t)-1 means error */
-#define TIME_T_MIN 0
-#endif
-
 #if (SIZEOF_LONG == 8)
 #define TIME_FIXUP_CONSTANT_INT 11644473600L
@@ -40 +35 @@
 
 
-
-/*
- * we use the INT32_MAX here as on 64 bit systems,
- * gmtime() fails with INT64_MAX
- */
-
-#ifndef TIME_T_MAX
-#define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t))
-#endif
 
 /**

vendor/current/lib/util/time.h

@@ -24 +24 @@
 #endif
 
+#ifndef TIME_T_MIN
+/* we use 0 here, because (time_t)-1 means error */
+#define TIME_T_MIN 0
+#endif
+
+/*
+ * we use the INT32_MAX here as on 64 bit systems,
+ * gmtime() fails with INT64_MAX
+ */
+#ifndef TIME_T_MAX
+#define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t))
+#endif
+
+
 /* 64 bit time (100 nanosec) 1601 - cifs6.txt, section 3.5, page 30, 4 byte aligned */
 typedef uint64_t NTTIME;