Changeset 740 for vendor/current/lib

vendor/current/lib/README

-              r414
+              r740
 compression - Various compression algorithms (MSZIP, lzxpress)
+dnspython - Python module for working with DNS.
 nss_wrapper - Wrapper for the user and group NSS API allowing the use
               of other data sources.
 …
 socket_wrapper - Wrapper library allowing TCP/IP traffic to be redirected
                  over Unix domain sockets.
+subunit - Utilities and bindings for working with the Subunit test result
+          reporting protocol.
 talloc - Hierarchical pool based memory allocator
 tdb - Simple but fast key/value database library, supporting multiple writers

vendor/current/lib/async_req/async_sock.c

-              r414
+              r740
 #endif
 struct async_send_state {
+struct sendto_state {
         int fd;
         const void *buf;
         size_t len;
         int flags;
+        const struct sockaddr_storage *addr;
+        socklen_t addr_len;
         ssize_t sent;
 };
 static void async_send_handler(struct tevent_context *ev,
+static void sendto_handler(struct tevent_context *ev,
                                struct tevent_fd *fde,
                                uint16_t flags, void *private_data);
+struct tevent_req *async_send_send(TALLOC_CTX *mem_ctx,
+                                   struct tevent_context *ev,
+                                   int fd, const void *buf, size_t len,
+                                   int flags)
+struct tevent_req *sendto_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
+                               int fd, const void *buf, size_t len, int flags,
+                               const struct sockaddr_storage *addr)
+{
         struct tevent_req *result;
         struct async_send_state *state;
+        struct sendto_state *state;
         struct tevent_fd *fde;
         result = tevent_req_create(mem_ctx, &state, struct async_send_state);
+        result = tevent_req_create(mem_ctx, &state, struct sendto_state);
         if (result == NULL) {
                 return result;
 …
         state->len = len;
         state->flags = flags;
+        fde = tevent_add_fd(ev, state, fd, TEVENT_FD_WRITE, async_send_handler,
+        state->addr = addr;
+        switch (addr->ss_family) {
+        case AF_INET:
+                state->addr_len = sizeof(struct sockaddr_in);
+                break;
+#if defined(HAVE_IPV6)
+        case AF_INET6:
+                state->addr_len = sizeof(struct sockaddr_in6);
+                break;
+#endif
+        case AF_UNIX:
+                state->addr_len = sizeof(struct sockaddr_un);
+                break;
+        default:
+                state->addr_len = sizeof(struct sockaddr_storage);
+                break;
+        }
+        fde = tevent_add_fd(ev, state, fd, TEVENT_FD_WRITE, sendto_handler,
                             result);
         if (fde == NULL) {
 …
+}
 static void async_send_handler(struct tevent_context *ev,
+static void sendto_handler(struct tevent_context *ev,
                                struct tevent_fd *fde,
                                uint16_t flags, void *private_data)
 …
         struct tevent_req *req = talloc_get_type_abort(
                 private_data, struct tevent_req);
+        struct async_send_state *state =
+                tevent_req_data(req, struct async_send_state);
+        state->sent = send(state->fd, state->buf, state->len, state->flags);
+        struct sendto_state *state =
+                tevent_req_data(req, struct sendto_state);
+        state->sent = sendto(state->fd, state->buf, state->len, state->flags,
+                             (struct sockaddr *)state->addr, state->addr_len);
         if ((state->sent == -1) && (errno == EINTR)) {
                 /* retry */
 …
+}
 ssize_t async_send_recv(struct tevent_req *req, int *perrno)
+{
         struct async_send_state *state =
                 tevent_req_data(req, struct async_send_state);
+ssize_t sendto_recv(struct tevent_req *req, int *perrno)
+{
+        struct sendto_state *state =
+                tevent_req_data(req, struct sendto_state);
         if (tevent_req_is_unix_error(req, perrno)) {
 …
+}
 struct async_recv_state {
+struct recvfrom_state {
         int fd;
         void *buf;
         size_t len;
         int flags;
+        struct sockaddr_storage *addr;
+        socklen_t *addr_len;
         ssize_t received;
 };
 static void async_recv_handler(struct tevent_context *ev,
+static void recvfrom_handler(struct tevent_context *ev,
                                struct tevent_fd *fde,
                                uint16_t flags, void *private_data);
+struct tevent_req *async_recv_send(TALLOC_CTX *mem_ctx,
+                                   struct tevent_context *ev,
+                                   int fd, void *buf, size_t len, int flags)
+struct tevent_req *recvfrom_send(TALLOC_CTX *mem_ctx,
+                                 struct tevent_context *ev,
+                                 int fd, void *buf, size_t len, int flags,
+                                 struct sockaddr_storage *addr,
+                                 socklen_t *addr_len)
+{
         struct tevent_req *result;
         struct async_recv_state *state;
+        struct recvfrom_state *state;
         struct tevent_fd *fde;
         result = tevent_req_create(mem_ctx, &state, struct async_recv_state);
+        result = tevent_req_create(mem_ctx, &state, struct recvfrom_state);
         if (result == NULL) {
                 return result;
 …
         state->len = len;
         state->flags = flags;
+        fde = tevent_add_fd(ev, state, fd, TEVENT_FD_READ, async_recv_handler,
+        state->addr = addr;
+        state->addr_len = addr_len;
+        fde = tevent_add_fd(ev, state, fd, TEVENT_FD_READ, recvfrom_handler,
                             result);
         if (fde == NULL) {
 …
+}
 static void async_recv_handler(struct tevent_context *ev,
+static void recvfrom_handler(struct tevent_context *ev,
                                struct tevent_fd *fde,
                                uint16_t flags, void *private_data)
 …
         struct tevent_req *req = talloc_get_type_abort(
                 private_data, struct tevent_req);
+        struct async_recv_state *state =
+                tevent_req_data(req, struct async_recv_state);
+        state->received = recv(state->fd, state->buf, state->len,
+                               state->flags);
+        struct recvfrom_state *state =
+                tevent_req_data(req, struct recvfrom_state);
+        state->received = recvfrom(state->fd, state->buf, state->len,
+                                   state->flags, (struct sockaddr *)state->addr,
+                                   state->addr_len);
         if ((state->received == -1) && (errno == EINTR)) {
                 /* retry */
 …
+}
 ssize_t async_recv_recv(struct tevent_req *req, int *perrno)
+{
         struct async_recv_state *state =
                 tevent_req_data(req, struct async_recv_state);
+ssize_t recvfrom_recv(struct tevent_req *req, int *perrno)
+{
+        struct recvfrom_state *state =
+                tevent_req_data(req, struct recvfrom_state);
         if (tevent_req_is_unix_error(req, perrno)) {
 …
         size_t total_size;
         uint16_t flags;
+        bool err_on_readability;
 };
 …
                 goto fail;
+        }
+        state->flags = TEVENT_FD_WRITE;
+        if (err_on_readability) {
+                state->flags |= TEVENT_FD_READ;
+        }
+        state->flags = TEVENT_FD_WRITE|TEVENT_FD_READ;
+        state->err_on_readability = err_on_readability;
         if (queue == NULL) {
 …
         if ((state->flags & TEVENT_FD_READ) && (flags & TEVENT_FD_READ)) {
+                tevent_req_error(req, EPIPE);
+                return;
+                int ret, value;
+                if (state->err_on_readability) {
+                        /* Readable and the caller wants an error on read. */
+                        tevent_req_error(req, EPIPE);
+                        return;
+                }
+                /* Might be an error. Check if there are bytes to read */
+                ret = ioctl(state->fd, FIONREAD, &value);
+                /* FIXME - should we also check
+                   for ret == 0 and value == 0 here ? */
+                if (ret == -1) {
+                        /* There's an error. */
+                        tevent_req_error(req, EPIPE);
+                        return;
+                }
+                /* A request for TEVENT_FD_READ will succeed from now and
+                   forevermore until the bytes are read so if there was
+                   an error we'll wait until we do read, then get it in
+                   the read callback function. Until then, remove TEVENT_FD_READ
+                   from the flags we're waiting for. */
+                state->flags &= ~TEVENT_FD_READ;
+                TEVENT_FD_NOT_READABLE(fde);
+                /* If not writable, we're done. */
+                if (!(flags & TEVENT_FD_WRITE)) {
+                        return;
+                }
+        }

vendor/current/lib/async_req/async_sock.h

-              r414
+              r740
 #include <tevent.h>
+struct tevent_req *async_send_send(TALLOC_CTX *mem_ctx,
+                                   struct tevent_context *ev,
+                                   int fd, const void *buf, size_t len,
+                                   int flags);
+ssize_t async_send_recv(struct tevent_req *req, int *perrno);
+struct tevent_req *sendto_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
+                               int fd, const void *buf, size_t len, int flags,
+                               const struct sockaddr_storage *addr);
+ssize_t sendto_recv(struct tevent_req *req, int *perrno);
+struct tevent_req *async_recv_send(TALLOC_CTX *mem_ctx,
+                                   struct tevent_context *ev,
+                                   int fd, void *buf, size_t len, int flags);
+ssize_t async_recv_recv(struct tevent_req *req, int *perrno);
+struct tevent_req *recvfrom_send(TALLOC_CTX *mem_ctx,
+                                 struct tevent_context *ev,
+                                 int fd, void *buf, size_t len, int flags,
+                                 struct sockaddr_storage *addr,
+                                 socklen_t *addr_len);
+ssize_t recvfrom_recv(struct tevent_req *req, int *perrno);
 struct tevent_req *async_connect_send(TALLOC_CTX *mem_ctx,

vendor/current/lib/compression/lzxpress.c

-              r414
+              r740
 #include "replace.h"
 #include "lzxpress.h"
+#include "../lib/util/byteorder.h"
 …
         uncompressed_pos = 0;
         indic = 0;
+        *(uint32_t *)compressed = 0;
         compressed_pos = sizeof(uint32_t);
         indic_pos = &compressed[0];
 …
                                 /* Classical meta-data */
                                 metadata = (uint16_t)(((best_offset - 1) << 3) | (best_len - 3));
                                 dest[metadata_size / sizeof(uint16_t)] = metadata;
+                                SSVAL(dest, metadata_size / sizeof(uint16_t), metadata);
                                 metadata_size += sizeof(uint16_t);
                         } else {
                                 metadata = (uint16_t)(((best_offset - 1) << 3) | 7);
                                 dest[metadata_size / sizeof(uint16_t)] = metadata;
+                                SSVAL(dest, metadata_size / sizeof(uint16_t), metadata);
                                 metadata_size = sizeof(uint16_t);
 …
+                                        }
                                         /* Additionnal best_len */
+                                        /* Additional best_len */
                                         compressed[compressed_pos + metadata_size] = (best_len - (3 + 7 + 15)) & 0xFF;
                                         metadata_size += sizeof(uint8_t);
 …
+                                        }
                                         /* Additionnal best_len */
+                                        /* Additional best_len */
                                         compressed[compressed_pos + metadata_size] = 255;
 …
                 if ((indic_bit - 1) % 32 > (indic_bit % 32)) {
                         *(uint32_t *)indic_pos = indic;
+                        SIVAL(indic_pos, 0, indic);
                         indic = 0;
                         indic_pos = &compressed[compressed_pos];
 …
                 compressed_pos++;
                 if (((indic_bit - 1) % 32) > (indic_bit % 32)){
                         *(uint32_t *)indic_pos = indic;
+                        SIVAL(indic_pos, 0, indic);
                         indic = 0;
                         indic_pos = &compressed[compressed_pos];
 …
                         indic |= 0 << (32 - ((indic_bit % 32) + 1));
+                *(uint32_t *)indic_pos = indic;
+                *(uint32_t *)&compressed[compressed_pos] = 0;
+                SIVAL(indic_pos, 0, indic);
                 compressed_pos += sizeof(uint32_t);
+        }

vendor/current/lib/compression/testsuite.c

-              r414
+              r740
 #include "includes.h"
 #include "torture/torture.h"
+#include "../compression/mszip.h"
+#include "talloc.h"
+#include "mszip.h"
+#include "lzxpress.h"
+/*
+  test lzxpress
+ */
+static bool test_lzxpress(struct torture_context *test)
+{
+        TALLOC_CTX *tmp_ctx = talloc_new(test);
+        uint8_t *data;
+        const char *fixed_data = "this is a test. and this is a test too";
+        const uint8_t fixed_out[] = { 0x00, 0x20, 0x00, 0x04, 0x74, 0x68, 0x69, 0x73,
+x20, 0x10, 0x00, 0x61, 0x20, 0x74, 0x65, 0x73,
+x74, 0x2E, 0x20, 0x61, 0x6E, 0x64, 0x20, 0x9F,
+x00, 0x04, 0x20, 0x74, 0x6F, 0x6F, 0x00, 0x00,
+x00, 0x00 };
+        ssize_t c_size;
+        uint8_t *out, *out2;
+        data = talloc_size(tmp_ctx, 1023);
+        out  = talloc_size(tmp_ctx, 2048);
+        memset(out, 0x42, talloc_get_size(out));
+        torture_comment(test, "lzxpress fixed compression\n");
+        c_size = lzxpress_compress((const uint8_t *)fixed_data,
+                                   strlen(fixed_data),
+                                   out,
+                                   talloc_get_size(out));
+        torture_assert_int_equal(test, c_size, sizeof(fixed_out), "fixed lzxpress_compress size");
+        torture_assert_mem_equal(test, out, fixed_out, c_size, "fixed lzxpress_compress data");
+        torture_comment(test, "lzxpress fixed decompression\n");
+        out2  = talloc_size(tmp_ctx, strlen(fixed_data));
+        c_size = lzxpress_decompress(out,
+                                     sizeof(fixed_out),
+                                     out2,
+                                     talloc_get_size(out2));
+        torture_assert_int_equal(test, c_size, strlen(fixed_data), "fixed lzxpress_decompress size");
+        torture_assert_mem_equal(test, out2, fixed_data, c_size, "fixed lzxpress_decompress data");
+        return true;
+}
 struct torture_suite *torture_local_compression(TALLOC_CTX *mem_ctx)
+{
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "COMPRESSION");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "compression");
+        torture_suite_add_simple_test(suite, "lzxpress", test_lzxpress);
         return suite;

vendor/current/lib/crypto/aes.c

-              r414
+              r740
+    }
+}
+void aes_cfb8_encrypt(const uint8_t *in, uint8_t *out,
+                      size_t length, const AES_KEY *key,
+                      uint8_t *iv, int forward)
+{
+        size_t i;
+        for (i=0; i < length; i++) {
+                uint8_t tiv[AES_BLOCK_SIZE*2];
+                memcpy(tiv, iv, AES_BLOCK_SIZE);
+                AES_encrypt(iv, iv, key);
+                if (!forward) {
+                        tiv[AES_BLOCK_SIZE] = in[i];
+                }
+                out[i] = in[i] ^ iv[0];
+                if (forward) {
+                        tiv[AES_BLOCK_SIZE] = out[i];
+                }
+                memcpy(iv, tiv+1, AES_BLOCK_SIZE);
+        }
+}

vendor/current/lib/crypto/aes.h

-              r414
+              r740
                      unsigned char *, int);
+void aes_cfb8_encrypt(const uint8_t *in, uint8_t *out,
+                      size_t length, const AES_KEY *key,
+                      uint8_t *iv, int forward);
 #ifdef  __cplusplus
+}

vendor/current/lib/crypto/arcfour.c

r414	r740
20	20	*/
21	21
22		#include "~~includes~~.h"
	22	#include "replace.h"
23	23	#include "../lib/crypto/arcfour.h"
24	24

vendor/current/lib/crypto/arcfour.h

r414	r740
1	1	#ifndef ARCFOUR_HEADER_H
2	2	#define ARCFOUR_HEADER_H
	3
	4	#include "../lib/util/data_blob.h"
3	5
4	6	struct arcfour_state {

vendor/current/lib/crypto/crc32.c

r414	r740
41	41	*/
42	42
43		#include "~~includes~~.h"
	43	#include "replace.h"
44	44	#include "../lib/crypto/crc32.h"
45	45

vendor/current/lib/crypto/hmacmd5.c

r414	r740
23	23	*/
24	24
25		#include "~~includes~~.h"
	25	#include "replace.h"
26	26	#include "../lib/crypto/hmacmd5.h"
27	27

vendor/current/lib/crypto/hmacmd5test.c

-              r414
+              r740
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+#include "includes.h"
+#include "replace.h"
+#include "../lib/util/util.h"
 #include "../lib/crypto/crypto.h"

vendor/current/lib/crypto/hmacsha256.c

r414	r740
27	27	*/
28	28
29		#include "~~includes~~.h"
	29	#include "replace.h"
30	30	#include "../lib/crypto/crypto.h"
31	31

vendor/current/lib/crypto/md4.c

r414	r740
18	18	*/
19	19
20		#include "~~includes~~.h"
	20	#include "replace.h"
21	21	#include "../lib/crypto/md4.h"
22	22

vendor/current/lib/crypto/md4test.c

-              r414
+              r740
 */
+#include "includes.h"
+#include "replace.h"
+#include "../lib/util/util.h"
 #include "../lib/crypto/crypto.h"
 …
  This uses the test values from rfc1320
 */
 bool torture_local_crypto_md4(struct torture_context *torture)
+bool torture_local_crypto_md4(struct torture_context *torture)
+{
         bool ret = true;

vendor/current/lib/crypto/md5.c

-              r414
+              r740
    abartlet@samba.org Jun 2001 */
 #include "includes.h"
+#include "replace.h"
 #include "md5.h"
 …
  * Note: this code is harmless on little-endian machines.
  */
 static void byteReverse(uint8_t *buf, uint_t longs)
+static void byteReverse(uint8_t *buf, unsigned int longs)
+{
     uint32_t t;
     do {
         t = (uint32_t) ((uint_t) buf[3] << 8 | buf[2]) << 16 |
             ((uint_t) buf[1] << 8 | buf[0]);
+        t = (uint32_t) ((unsigned int) buf[3] << 8 | buf[2]) << 16 |
+            ((unsigned int) buf[1] << 8 | buf[0]);
         *(uint32_t *) buf = t;
         buf += 4;
 …
 _PUBLIC_ void MD5Final(uint8_t digest[16], struct MD5Context *ctx)
+{
     uint_t count;
+    unsigned int count;
     uint8_t *p;
 …
     byteReverse((uint8_t *) ctx->buf, 4);
     memmove(digest, ctx->buf, 16);
     memset(ctx, 0, sizeof(ctx));        /* In case it's sensitive */
+    memset(ctx, 0, sizeof(*ctx));       /* In case it's sensitive */
+}

vendor/current/lib/crypto/md5test.c

-              r414
+              r740
 */
+#include "includes.h"
+#include "replace.h"
+#include "../lib/util/util.h"
 #include "../lib/crypto/crypto.h"

vendor/current/lib/crypto/sha256.c

r414	r740
39	39	*/
40	40
41		#include "~~includes~~.h"
	41	#include "replace.h"
42	42	#include "sha256.h"
43	43

vendor/current/lib/nss_wrapper/nss_wrapper.c

-              r414
+              r740
 #ifdef _SAMBA_BUILD_
+/* defining this gives us the posix getpwnam_r() calls on solaris
+   Thanks to heimdal for this */
+#define _POSIX_PTHREAD_SEMANTICS
 #define NSS_WRAPPER_NOT_REPLACE
 …
 };
 /* protoypes for files backend */
+/* prototypes for files backend */
 …
 static void nwrap_files_endgrent(struct nwrap_backend *b);
 /* protoypes for module backend */
+/* prototypes for module backend */
 static struct passwd *nwrap_module_getpwent(struct nwrap_backend *b);
 …
                               struct nwrap_backend **backends)
+{
+        struct nwrap_backend *b;
         *backends = (struct nwrap_backend *)realloc(*backends,
                 sizeof(struct nwrap_backend) * ((*num_backends) + 1));
 …
+        }
+        (*backends)[*num_backends].name = name;
+        (*backends)[*num_backends].ops = ops;
+        (*backends)[*num_backends].so_path = so_path;
+        (*backends)[*num_backends].so_handle = nwrap_load_module(so_path);
+        (*backends)[*num_backends].fns = nwrap_load_module_fns(&((*backends)[*num_backends]));
+        b = &((*backends)[*num_backends]);
+        b->name = name;
+        b->ops = ops;
+        b->so_path = so_path;
+        if (so_path != NULL) {
+                b->so_handle = nwrap_load_module(so_path);
+                b->fns = nwrap_load_module_fns(b);
+                if (b->fns == NULL) {
+                        return false;
+                }
+        } else {
+                b->so_handle = NULL;
+                b->fns = NULL;
+        }
         (*num_backends)++;
 …
         gid_t *groups_tmp;
         int count = 1;
         const char *name_of_group = NULL;
+        const char *name_of_group = "";
         if (!nwrap_enabled()) {

vendor/current/lib/nss_wrapper/nss_wrapper.pl

-              r414
+              r740
 my $opt_name = undef;
 my $opt_member = undef;
+my $opt_gid = 65534;# nogroup gid
 my $passwdfn = undef;
 …
 my $actionfn = undef;
 sub passwd_add($$$$);
 sub passwd_delete($$$$);
 sub group_add($$$$);
 sub group_delete($$$$);
 sub member_add($$$$);
 sub member_delete($$$$);
+sub passwd_add($$$$$);
+sub passwd_delete($$$$$);
+sub group_add($$$$$);
+sub group_delete($$$$$);
+sub member_add($$$$$);
+sub member_delete($$$$$);
 sub check_path($$);
 …
         'type=s'        => \$opt_type,
         'name=s'        => \$opt_name,
+        'member=s'      => \$opt_member
+        'member=s'      => \$opt_member,
+        'gid=i'         => \$opt_gid
 );
 …
         --member <member>       The name of the member.
+        --gid <gid>             Primary Group ID for new users.
 ";
         exit($ret);
 …
+}
 exit $actionfn->($opt_fullpath_passwd, $opt_member, $opt_fullpath_group, $opt_name);
+exit $actionfn->($opt_fullpath_passwd, $opt_member, $opt_fullpath_group, $opt_name, $opt_gid);
 sub check_path($$)
 …
+}
 sub passwd_add($$$$)
+{
         my ($path, $dummy, $dummy2, $name) = @_;
+sub passwd_add($$$$$)
+{
+        my ($path, $dummy, $dummy2, $name, $gid) = @_;
         #print "passwd_add: '$name' in '$path'\n";
 …
         my $uid = passwd_get_free_uid($passwd);
-        my $gid = 65534;# nogroup gid
         my $pwent = $name.":x:".$uid.":".$gid.":".$name." gecos:/nodir:/bin/false";
 …
+}
 sub passwd_delete($$$$)
+{
         my ($path, $dummy, $dummy2, $name) = @_;
+sub passwd_delete($$$$$)
+{
+        my ($path, $dummy, $dummy2, $name, $dummy3) = @_;
         #print "passwd_delete: '$name' in '$path'\n";
 …
+}
 sub group_add($$$$)
+{
         my ($dummy, $dummy2, $path, $name) = @_;
+sub group_add($$$$$)
+{
+        my ($dummy, $dummy2, $path, $name, $dummy3) = @_;
         #print "group_add: '$name' in '$path'\n";
 …
+}
 sub group_delete($$$$)
+{
         my ($dummy, $dummy2, $path, $name) = @_;
+sub group_delete($$$$$)
+{
+        my ($dummy, $dummy2, $path, $name, $dummy3) = @_;
         #print "group_delete: '$name' in '$path'\n";
 …
+}
 sub member_add($$$$)
+{
         my ($passwd_path, $username, $group_path, $groupname) = @_;
+sub member_add($$$$$)
+{
+        my ($passwd_path, $username, $group_path, $groupname, $dummy) = @_;
         #print "member_add: adding '$username' in '$passwd_path' to '$groupname' in '$group_path'\n";
 …
+}
 sub member_delete($$$$)
+{
         my ($passwd_path, $username, $group_path, $groupname) = @_;
+sub member_delete($$$$$)
+{
+        my ($passwd_path, $username, $group_path, $groupname, $dummy) = @_;
         #print "member_delete: removing '$username' in '$passwd_path' from '$groupname' in '$group_path'\n";

vendor/current/lib/nss_wrapper/testsuite.c

-              r414
+              r740
    local testing of the nss wrapper
    Copyright (C) Guenther Deschner 2009
+   Copyright (C) Guenther Deschner 2009-2010
    This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
+#ifndef NSS_WRAPPER
+#define NSS_WRAPPER
+#endif
 #include "torture/torture.h"
 #include "lib/replace/system/passwd.h"
-#include "lib/nss_wrapper/nss_wrapper.h"
 static bool copy_passwd(struct torture_context *tctx,
 …
                (unsigned long)grp->gr_gid);
         if (!grp->gr_mem[0]) {
+        if ((grp->gr_mem == NULL) || !grp->gr_mem[0]) {
                 printf("\n");
                 return;
 …
         if (!old_pwd || !old_group) {
+                torture_comment(tctx, "ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
                 torture_skip(tctx, "nothing to test\n");
-                return true;
+        }
 …
         if (!old_pwd || !old_group) {
+                torture_comment(tctx, "ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
                 torture_skip(tctx, "nothing to test\n");
-                return true;
+        }
 …
         if (!old_pwd || !old_group) {
+                torture_comment(tctx, "ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
                 torture_skip(tctx, "nothing to test\n");
-                return true;
+        }
 …
         if (!old_pwd || !old_group) {
+                torture_comment(tctx, "ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
                 torture_skip(tctx, "nothing to test\n");
-                return true;
+        }
 …
+}
+static bool test_nwrap_passwd_duplicates(struct torture_context *tctx)
+{
+        int i, d;
+        struct passwd *pwd;
+        size_t num_pwd;
+        int duplicates = 0;
+        torture_assert(tctx, test_nwrap_enum_passwd(tctx, &pwd, &num_pwd),
+            "failed to enumerate passwd");
+        for (i=0; i < num_pwd; i++) {
+                const char *current_name = pwd[i].pw_name;
+                for (d=0; d < num_pwd; d++) {
+                        const char *dup_name = pwd[d].pw_name;
+                        if (d == i) {
+                                continue;
+                        }
+                        if (!strequal(current_name, dup_name)) {
+                                continue;
+                        }
+                        torture_warning(tctx, "found duplicate names:");
+                        print_passwd(&pwd[d]);
+                        print_passwd(&pwd[i]);
+                        duplicates++;
+                }
+        }
+        if (duplicates) {
+                torture_fail(tctx, talloc_asprintf(tctx, "found %d duplicate names", duplicates));
+        }
+        return true;
+}
+static bool test_nwrap_group_duplicates(struct torture_context *tctx)
+{
+        int i, d;
+        struct group *grp;
+        size_t num_grp;
+        int duplicates = 0;
+        torture_assert(tctx, test_nwrap_enum_group(tctx, &grp, &num_grp),
+                "failed to enumerate group");
+        for (i=0; i < num_grp; i++) {
+                const char *current_name = grp[i].gr_name;
+                for (d=0; d < num_grp; d++) {
+                        const char *dup_name = grp[d].gr_name;
+                        if (d == i) {
+                                continue;
+                        }
+                        if (!strequal(current_name, dup_name)) {
+                                continue;
+                        }
+                        torture_warning(tctx, "found duplicate names:");
+                        print_group(&grp[d]);
+                        print_group(&grp[i]);
+                        duplicates++;
+                }
+        }
+        if (duplicates) {
+                torture_fail(tctx, talloc_asprintf(tctx, "found %d duplicate names", duplicates));
+        }
+        return true;
+}
+static bool test_nwrap_duplicates(struct torture_context *tctx)
+{
+        const char *old_pwd = getenv("NSS_WRAPPER_PASSWD");
+        const char *old_group = getenv("NSS_WRAPPER_GROUP");
+        if (!old_pwd || !old_group) {
+                torture_comment(tctx, "ENV NSS_WRAPPER_PASSWD or NSS_WRAPPER_GROUP not set\n");
+                torture_skip(tctx, "nothing to test\n");
+        }
+        torture_assert(tctx, test_nwrap_passwd_duplicates(tctx),
+                        "failed to test users");
+        torture_assert(tctx, test_nwrap_group_duplicates(tctx),
+                        "failed to test groups");
+        return true;
+}
 struct torture_suite *torture_local_nss_wrapper(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "NSS-WRAPPER");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "nss-wrapper");
         torture_suite_add_simple_test(suite, "enumeration", test_nwrap_enumeration);
 …
         torture_suite_add_simple_test(suite, "reentrant enumeration crosschecks", test_nwrap_reentrant_enumeration_crosschecks);
         torture_suite_add_simple_test(suite, "membership", test_nwrap_membership);
+        torture_suite_add_simple_test(suite, "duplicates", test_nwrap_duplicates);
         return suite;

vendor/current/lib/popt/popt.h

-              r414
+              r740
  * Print detailed description of options.
  * @param con           context
  * @param fp            ouput file handle
+ * @param fp            output file handle
  * @param flags         (unused)
  */
 …
  * Print terse description of options.
  * @param con           context
  * @param fp            ouput file handle
+ * @param fp            output file handle
  * @param flags         (unused)
  */

vendor/current/lib/replace/README

-              r414
+              r740
 telldir
 seekdir
+clock_gettime
 closedir
 dlopen
 …
 bool
 socklen_t
-uint_t
 uint{8,16,32,64}_t
 int{8,16,32,64}_t

vendor/current/lib/replace/autoconf-2.60.m4

-              r414
+              r740
 m4_ifndef([AC_USE_SYSTEM_EXTENSIONS],[
 AC_DEFUN([AC_USE_SYSTEM_EXTENSIONS],
+[
+  AC_BEFORE([$0], [AC_COMPILE_IFELSE])
+  AC_BEFORE([$0], [AC_RUN_IFELSE])
+  AC_REQUIRE([AC_GNU_SOURCE])
+  AC_REQUIRE([AC_AIX])
+  AC_REQUIRE([AC_MINIX])
+[AC_BEFORE([$0], [AC_COMPILE_IFELSE])dnl
+AC_BEFORE([$0], [AC_RUN_IFELSE])dnl
+  AC_CHECK_HEADER([minix/config.h], [MINIX=yes], [MINIX=])
+  if test "$MINIX" = yes; then
+    AC_DEFINE([_POSIX_SOURCE], [1],
+      [Define to 1 if you need to in order for `stat' and other
+       things to work.])
+    AC_DEFINE([_POSIX_1_SOURCE], [2],
+      [Define to 2 if the system does not provide POSIX.1 features
+       except with this defined.])
+    AC_DEFINE([_MINIX], [1],
+      [Define to 1 if on MINIX.])
+  fi
   AH_VERBATIM([__EXTENSIONS__],
+[/* Enable extensions on Solaris.  */
+[/* Enable extensions on AIX 3, Interix.  */
+#ifndef _ALL_SOURCE
+# undef _ALL_SOURCE
+#endif
+/* Enable GNU extensions on systems that have them.  */
+#ifndef _GNU_SOURCE
+# undef _GNU_SOURCE
+#endif
+/* Enable threading extensions on Solaris.  */
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# undef _POSIX_PTHREAD_SEMANTICS
+#endif
+/* Enable extensions on HP NonStop.  */
+#ifndef _TANDEM_SOURCE
+# undef _TANDEM_SOURCE
+#endif
+/* Enable general extensions on Solaris.  */
 #ifndef __EXTENSIONS__
 # undef __EXTENSIONS__
 #endif
+#ifndef _POSIX_PTHREAD_SEMANTICS
+# undef _POSIX_PTHREAD_SEMANTICS
+#endif])
+])
   AC_CACHE_CHECK([whether it is safe to define __EXTENSIONS__],
     [ac_cv_safe_to_define___extensions__],
     [AC_COMPILE_IFELSE(
        [AC_LANG_PROGRAM([
+       [AC_LANG_PROGRAM([[
 #         define __EXTENSIONS__ 1
           AC_INCLUDES_DEFAULT])],
+          ]AC_INCLUDES_DEFAULT])],
        [ac_cv_safe_to_define___extensions__=yes],
        [ac_cv_safe_to_define___extensions__=no])])
   test $ac_cv_safe_to_define___extensions__ = yes &&
     AC_DEFINE([__EXTENSIONS__])
+  AC_DEFINE([_ALL_SOURCE])
+  AC_DEFINE([_GNU_SOURCE])
   AC_DEFINE([_POSIX_PTHREAD_SEMANTICS])
+])
+])
+  AC_DEFINE([_TANDEM_SOURCE])
+])# AC_USE_SYSTEM_EXTENSIONS
+])

vendor/current/lib/replace/crypt.c

-              r414
+              r740
 #ifndef long32
 #define long32 int32
+#define long32 int32_t
 #endif
 #ifndef long64
 #define long64 int64
+#define long64 int64_t
 #endif
 …
      */
     clearmem(ktab, sizeof ktab);
     StrnCpy(ktab, key, 8);
+    strncpy(ktab, key, 8);
     ufc_mk_keytab(ktab);

vendor/current/lib/replace/getifaddrs.c

r414	r740
283	283
284	284	while (i > 0) {
285		u~~int_~~t inc;
	285	unsigned int inc;
286	286
287	287	inc = ifr->ifr_addr.sa_len;

vendor/current/lib/replace/getpass.c

-              r414
+              r740
 #endif
-#ifndef SIGNAL_CAST
-#define SIGNAL_CAST (RETSIGTYPE (*)(int))
-#endif
 #ifdef SYSV_TERMIO
 …
 #endif /* SYSV_TERMIO */
 static void catch_signal(int signum,void (*handler)(int ))
+static void catch_signal(int signum, void (*handler)(int ))
+{
 #ifdef HAVE_SIGACTION
 …
 ****************************************************************/
 static void gotintr_sig(void)
+static void gotintr_sig(int signum)
+{
         gotintr = 1;
 …
         /* Catch problematic signals */
         catch_signal(SIGINT, SIGNAL_CAST gotintr_sig);
+        catch_signal(SIGINT, gotintr_sig);
         /* Try to write to and read from the terminal if we can.
 …
         /* Catch problematic signals */
         catch_signal(SIGINT, SIGNAL_CAST SIG_DFL);
+        catch_signal(SIGINT, SIG_DFL);
         if (gotintr) {
                 printf("Interupted by signal.\n");
+                printf("Interrupted by signal.\n");
                 fflush(stdout);
                 exit(1);

vendor/current/lib/replace/libreplace.m4

-              r414
+              r740
 LIBREPLACEOBJ="${LIBREPLACEOBJ} $libreplacedir/snprintf.o"
-AC_TYPE_SIGNAL
 AC_TYPE_UID_T
 AC_TYPE_MODE_T
 …
+)
+AC_CHECK_HEADERS(linux/types.h)
 AC_CACHE_CHECK([for working mmap],libreplace_cv_HAVE_MMAP,[
 AC_TRY_RUN([#include "$libreplacedir/test/shared_mmap.c"],
 …
 AC_CHECK_HEADERS(unix.h)
 AC_CHECK_FUNCS(seteuid setresuid setegid setresgid chroot bzero strerror)
+AC_CHECK_FUNCS(seteuid setresuid setegid setresgid chroot bzero strerror strerror_r)
 AC_CHECK_FUNCS(vsyslog setlinebuf mktime ftruncate chsize rename)
 AC_CHECK_FUNCS(waitpid wait4 strlcpy strlcat initgroups memmove strdup)
 AC_CHECK_FUNCS(pread pwrite strndup strcasestr strtok_r mkdtemp dup2)
+AC_CHECK_FUNCS(pread pwrite strndup strcasestr strtok_r mkdtemp dup2 dprintf vdprintf)
 AC_CHECK_FUNCS(isatty chown lchown link readlink symlink realpath)
+AC_CHECK_FUNCS(fdatasync,,[
+        # if we didn't find it, look in librt (Solaris hides it there...)
+        AC_CHECK_LIB(rt, fdatasync,
+                [libreplace_cv_HAVE_FDATASYNC_IN_LIBRT=yes
+                AC_DEFINE(HAVE_FDATASYNC, 1, Define to 1 if there is support for fdatasync)])
+])
+AC_HAVE_DECL(fdatasync, [#include <unistd.h>])
+AC_CHECK_FUNCS(clock_gettime,libreplace_cv_have_clock_gettime=yes,[
+        AC_CHECK_LIB(rt, clock_gettime,
+                [libreplace_cv_HAVE_CLOCK_GETTIME_IN_LIBRT=yes
+                libreplace_cv_have_clock_gettime=yes
+                AC_DEFINE(HAVE_CLOCK_GETTIME, 1, Define to 1 if there is support for clock_gettime)])
+])
+AC_CHECK_FUNCS(get_current_dir_name)
 AC_HAVE_DECL(setresuid, [#include <unistd.h>])
 AC_HAVE_DECL(setresgid, [#include <unistd.h>])
 …
 AC_CHECK_FUNCS(strtoull __strtoull strtouq strtoll __strtoll strtoq)
+AC_CHECK_FUNCS(memmem)
 # this test disabled as we don't actually need __VA_ARGS__ yet
 AC_TRY_CPP([
 …
 m4_include(crypt.m4)
+if test x$libreplace_cv_have_clock_gettime = xyes ; then
+        SMB_CHECK_CLOCK_ID(CLOCK_MONOTONIC)
+        SMB_CHECK_CLOCK_ID(CLOCK_PROCESS_CPUTIME_ID)
+        SMB_CHECK_CLOCK_ID(CLOCK_REALTIME)
+fi
+AC_CACHE_CHECK([for struct timespec type],libreplace_cv_struct_timespec, [
+    AC_TRY_COMPILE([
+#include <sys/types.h>
+#if STDC_HEADERS
+#include <stdlib.h>
+#include <stddef.h>
+#endif
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+],[struct timespec ts;],
+        libreplace_cv_struct_timespec=yes,libreplace_cv_struct_timespec=no)])
+if test x"$libreplace_cv_struct_timespec" = x"yes"; then
+   AC_DEFINE(HAVE_STRUCT_TIMESPEC,1,[Whether we have struct timespec])
+fi
 AC_CHECK_FUNCS([printf memset memcpy],,[AC_MSG_ERROR([Required function not found])])
 …
 m4_include(libreplace_macros.m4)
+dnl SMB_CHECK_CLOCK_ID(clockid)
+dnl Test whether the specified clock_gettime clock ID is available. If it
+dnl is, we define HAVE_clockid
+AC_DEFUN([SMB_CHECK_CLOCK_ID],
+[
+    AC_MSG_CHECKING(for $1)
+    AC_TRY_LINK([
+#if TIME_WITH_SYS_TIME
+# include <sys/time.h>
+# include <time.h>
+#else
+# if HAVE_SYS_TIME_H
+#  include <sys/time.h>
+# else
+#  include <time.h>
+# endif
+#endif
+    ],
+    [
+clockid_t clk = $1;
+    ],
+    [
+        AC_MSG_RESULT(yes)
+        AC_DEFINE(HAVE_$1, 1,
+            [Whether the clock_gettime clock ID $1 is available])
+    ],
+    [
+        AC_MSG_RESULT(no)
+    ])
+])
 m4_ifndef([AC_USE_SYSTEM_EXTENSIONS],[m4_include(autoconf-2.60.m4)])

vendor/current/lib/replace/libreplace_cc.m4

r414	r740
116	116	AC_CHECK_SIZEOF(long long)
117	117
118		~~AC_CHECK_TYPE(uint_t, unsigned int)~~
119	118	AC_CHECK_TYPE(int8_t, char)
120	119	AC_CHECK_TYPE(uint8_t, unsigned char)

vendor/current/lib/replace/libreplace_macros.m4

-              r414
+              r740
+                }
         ])],[
                 AS_TR_SH([ac_cv_c_prototype_$1])=yes
+                eval AS_TR_SH([ac_cv_c_prototype_$1])=yes
         ],[
                 AS_TR_SH([ac_cv_c_prototype_$1])=no
+                eval AS_TR_SH([ac_cv_c_prototype_$1])=no
         ])
+)

vendor/current/lib/replace/libreplace_network.m4

-              r478
+              r740
 fi
 dnl The following test is roughl taken from the cvs sources.
+dnl The following test is roughly taken from the cvs sources.
 dnl
 dnl If we can't find connect, try looking in -lsocket, -lnsl, and -linet.
 …
 ],
 libreplace_cv_HAVE_GETADDRINFO=yes,libreplace_cv_HAVE_GETADDRINFO=no)])
+if test x"$libreplace_cv_HAVE_GETADDRINFO" = x"yes"; then
+        # getaddrinfo is broken on some AIX systems
+        # see bug 5910, use our replacements if we detect
+        # a broken system.
+        AC_TRY_RUN([
+                #include <stddef.h>
+                #include <sys/types.h>
+                #include <sys/socket.h>
+                #include <netdb.h>
+                int main(int argc, const char *argv[])
+                {
+                        struct addrinfo hints = {0,};
+                        struct addrinfo *ppres;
+                        const char hostname1[] = "0.0.0.0";
+                        const char hostname2[] = "127.0.0.1";
+                        const char hostname3[] = "::";
+                        hints.ai_socktype = SOCK_STREAM;
+                        hints.ai_family = AF_UNSPEC;
+                        hints.ai_flags =
+                                AI_NUMERICHOST|AI_PASSIVE|AI_ADDRCONFIG;
+                        /* Test for broken flag combination on AIX. */
+                        if (getaddrinfo(hostname1, NULL, &hints, &ppres) == EAI_BADFLAGS) {
+                                /* This fails on an IPv6-only box, but not with
+                                   the EAI_BADFLAGS error. */
+                                return 1;
+                        }
+                        if (getaddrinfo(hostname2, NULL, &hints, &ppres) == 0) {
+                                /* IPv4 lookup works - good enough. */
+                                return 0;
+                        }
+                        /* Uh-oh, no IPv4. Are we IPv6-only ? */
+                        return getaddrinfo(hostname3, NULL, &hints, &ppres) != 0 ? 1 : 0;
+                }],
+                libreplace_cv_HAVE_GETADDRINFO=yes,
+                libreplace_cv_HAVE_GETADDRINFO=no)
+fi
 if test x"$libreplace_cv_HAVE_GETADDRINFO" = x"yes"; then
         AC_DEFINE(HAVE_GETADDRINFO,1,[Whether the system has getaddrinfo])

vendor/current/lib/replace/replace.c

-              r414
+              r740
    Copyright (C) Andrew Tridgell 1992-1998
    Copyright (C) Jelmer Vernooij 2005-2008
+   Copyright (C) Matthieu Patou  2010
      ** NOTE! The following LGPL license applies to the replace
 …
+{
         /* have a reasonable go at emulating it. Hope that
            the system mktemp() isn't completly hopeless */
+           the system mktemp() isn't completely hopeless */
         char *p = mktemp(template);
         if (!p)
 …
 #endif
 #ifndef HAVE_STRTOLL
 long long int rep_strtoll(const char *str, char **endptr, int base)
 …
 #endif
+}
+#endif
+#else
+#ifdef HAVE_BSD_STRTOLL
+#ifdef HAVE_STRTOQ
+long long int rep_strtoll(const char *str, char **endptr, int base)
+{
+        long long int nb = strtoq(str, endptr, base);
+        /* In linux EINVAL is only returned if base is not ok */
+        if (errno == EINVAL) {
+                if (base == 0 || (base >1 && base <37)) {
+                        /* Base was ok so it's because we were not
+                         * able to make the convertion.
+                         * Let's reset errno.
+                         */
+                        errno = 0;
+                }
+        }
+        return nb;
+}
+#else
+#error "You need the strtoq function"
+#endif /* HAVE_STRTOQ */
+#endif /* HAVE_BSD_STRTOLL */
+#endif /* HAVE_STRTOLL */
 …
 #endif
+}
+#endif
+#else
+#ifdef HAVE_BSD_STRTOLL
+#ifdef HAVE_STRTOUQ
+unsigned long long int rep_strtoull(const char *str, char **endptr, int base)
+{
+        unsigned long long int nb = strtouq(str, endptr, base);
+        /* In linux EINVAL is only returned if base is not ok */
+        if (errno == EINVAL) {
+                if (base == 0 || (base >1 && base <37)) {
+                        /* Base was ok so it's because we were not
+                         * able to make the convertion.
+                         * Let's reset errno.
+                         */
+                        errno = 0;
+                }
+        }
+        return nb;
+}
+#else
+#error "You need the strtouq function"
+#endif /* HAVE_STRTOUQ */
+#endif /* HAVE_BSD_STRTOLL */
+#endif /* HAVE_STRTOULL */
 #ifndef HAVE_SETENV
 …
+}
 #endif
+#ifndef HAVE_MEMMEM
+void *rep_memmem(const void *haystack, size_t haystacklen,
+                 const void *needle, size_t needlelen)
+{
+        if (needlelen == 0) {
+                return discard_const(haystack);
+        }
+        while (haystacklen >= needlelen) {
+                char *p = (char *)memchr(haystack, *(const char *)needle,
+                                         haystacklen-(needlelen-1));
+                if (!p) return NULL;
+                if (memcmp(p, needle, needlelen) == 0) {
+                        return p;
+                }
+                haystack = p+1;
+                haystacklen -= (p - (const char *)haystack) + 1;
+        }
+        return NULL;
+}
+#endif
+#ifndef HAVE_VDPRINTF
+int rep_vdprintf(int fd, const char *format, va_list ap)
+{
+        char *s = NULL;
+        int ret;
+        vasprintf(&s, format, ap);
+        if (s == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        ret = write(fd, s, strlen(s));
+        free(s);
+        return ret;
+}
+#endif
+#ifndef HAVE_DPRINTF
+int rep_dprintf(int fd, const char *format, ...)
+{
+        int ret;
+        va_list ap;
+        va_start(ap, format);
+        ret = vdprintf(fd, format, ap);
+        va_end(ap);
+        return ret;
+}
+#endif
+#ifndef HAVE_GET_CURRENT_DIR_NAME
+char *rep_get_current_dir_name(void)
+{
+        char buf[PATH_MAX+1];
+        char *p;
+        p = getcwd(buf, sizeof(buf));
+        if (p == NULL) {
+                return NULL;
+        }
+        return strdup(p);
+}
+#endif
+#if !defined(HAVE_STRERROR_R) || !defined(STRERROR_R_PROTO_COMPATIBLE)
+int rep_strerror_r(int errnum, char *buf, size_t buflen)
+{
+        char *s = strerror(errnum);
+        if (strlen(s)+1 > buflen) {
+                errno = ERANGE;
+                return -1;
+        }
+        strncpy(buf, s, buflen);
+        return 0;
+}
+#endif
+#ifndef HAVE_CLOCK_GETTIME
+int rep_clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+        struct timeval tval;
+        switch (clk_id) {
+                case 0: /* CLOCK_REALTIME :*/
+#ifdef HAVE_GETTIMEOFDAY_TZ
+                        gettimeofday(&tval,NULL);
+#else
+                        gettimeofday(&tval);
+#endif
+                        tp->tv_sec = tval.tv_sec;
+                        tp->tv_nsec = tval.tv_usec * 1000;
+                        break;
+                default:
+                        errno = EINVAL;
+                        return -1;
+        }
+        return 0;
+}
+#endif

vendor/current/lib/replace/replace.h

-              r414
+              r740
 # define PRIi8          "i"
 #endif
 #ifndef PRIi8
+#ifndef PRIi16
 # define PRIi16         "i"
 #endif
 #ifndef PRIi8
+#ifndef PRIi32
 # define PRIi32         "i"
 #endif
 #ifndef PRIi8
+#ifndef PRIi64
 # define PRIi64         __PRI64_PREFIX "i"
 #endif
 …
 #endif
+#ifdef HAVE_LINUX_TYPES_H
+/*
+ * This is needed as some broken header files require this to be included early
+ */
+#include <linux/types.h>
+#endif
 #ifndef HAVE_STRERROR
 extern char *sys_errlist[];
 …
 #define memmove rep_memmove
 void *rep_memmove(void *dest,const void *src,int size);
+#endif
+#ifndef HAVE_MEMMEM
+#define memmem rep_memmem
+void *rep_memmem(const void *haystack, size_t haystacklen,
+                 const void *needle, size_t needlelen);
 #endif
 …
 #endif
 #ifndef HAVE_STRTOLL
 #define strtoll rep_strtoll
 long long int rep_strtoll(const char *str, char **endptr, int base);
+#else
+#ifdef HAVE_BSD_STRTOLL
+#define strtoll rep_strtoll
+long long int rep_strtoll(const char *str, char **endptr, int base);
+#endif
 #endif
 …
 #define strtoull rep_strtoull
 unsigned long long int rep_strtoull(const char *str, char **endptr, int base);
+#else
+#ifdef HAVE_BSD_STRTOLL /* yes, it's not HAVE_BSD_STRTOULL */
+#define strtoull rep_strtoull
+unsigned long long int rep_strtoull(const char *str, char **endptr, int base);
+#endif
 #endif
 …
 #define socketpair rep_socketpair
 /* prototype is in system/network.h */
+#endif
+#ifndef HAVE_VDPRINTF
+#define vdprintf rep_vdprintf
+int rep_vdprintf(int fd, const char *format, va_list ap);
+#endif
+#ifndef HAVE_DPRINTF
+#define dprintf rep_dprintf
+int rep_dprintf(int fd, const char *format, ...);
 #endif
 …
 #define freeifaddrs rep_freeifaddrs
 /* prototype is in "system/network.h" */
+#endif
+#ifndef HAVE_GET_CURRENT_DIR_NAME
+#define get_current_dir_name rep_get_current_dir_name
+char *rep_get_current_dir_name(void);
+#endif
+#if !defined(HAVE_STRERROR_R) || !defined(STRERROR_R_PROTO_COMPATIBLE)
+#undef strerror_r
+#define strerror_r rep_strerror_r
+int rep_strerror_r(int errnum, char *buf, size_t buflen);
+#endif
+#if !defined(HAVE_CLOCK_GETTIME)
+#define clock_gettime rep_clock_gettime
 #endif
 …
 #endif
+#ifndef HAVE_FDATASYNC
+#define fdatasync(fd) fsync(fd)
+#elif !defined(HAVE_DECL_FDATASYNC)
+int fdatasync(int );
+#endif
+/* these are used to mark symbols as local to a shared lib, or
+ * publicly available via the shared lib API */
+#ifndef _PUBLIC_
+#ifdef HAVE_VISIBILITY_ATTR
+#define _PUBLIC_ __attribute__((visibility("default")))
+#else
+#define _PUBLIC_
+#endif
+#endif
+#ifndef _PRIVATE_
+#ifdef HAVE_VISIBILITY_ATTR
+#  define _PRIVATE_ __attribute__((visibility("hidden")))
+#else
+#  define _PRIVATE_
+#endif
+#endif
+#ifndef HAVE_POLL
+#define poll rep_poll
+/* prototype is in "system/network.h" */
+#endif
 #endif /* _LIBREPLACE_REPLACE_H */

vendor/current/lib/replace/system/config.m4

-              r618
+              r740
 AC_CHECK_HEADERS(sys/select.h)
+# poll
+AC_CHECK_HEADERS(poll.h)
+AC_CHECK_FUNCS(poll,[],[LIBREPLACEOBJ="${LIBREPLACEOBJ} $libreplacedir/poll.o"])
 # time
 AC_CHECK_HEADERS(sys/time.h utime.h)
 AC_HEADER_TIME
 AC_CHECK_FUNCS(utime utimes)
+AC_CACHE_CHECK([if gettimeofday takes TZ argument],libreplace_cv_HAVE_GETTIMEOFDAY_TZ,[
+AC_TRY_RUN([
+#include <sys/time.h>
+#include <unistd.h>
+main() { struct timeval tv; exit(gettimeofday(&tv, NULL));}],
+           libreplace_cv_HAVE_GETTIMEOFDAY_TZ=yes,libreplace_cv_HAVE_GETTIMEOFDAY_TZ=no,libreplace_cv_HAVE_GETTIMEOFDAY_TZ=yes)])
+if test x"$libreplace_cv_HAVE_GETTIMEOFDAY_TZ" = x"yes"; then
+    AC_DEFINE(HAVE_GETTIMEOFDAY_TZ,1,[Whether gettimeofday() is available])
+fi
 # wait

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

-              r478
+              r740
 #define ss_family sin6_family
 #define HAVE_SS_FAMILY 1
 #else
+#else /*HAVE_STRUCT_SOCKADDR_IN6*/
 #define sockaddr_storage sockaddr_in
 #define ss_family sin_family
 #define HAVE_SS_FAMILY 1
 #endif
 #endif
+#endif /*HAVE_STRUCT_SOCKADDR_IN6*/
+#endif /*HAVE_STRUCT_SOCKADDR_STORAGE*/
 #ifndef HAVE_SS_FAMILY
 …
      */
 #   define IOV_MAX 512
-#  else
-#   error IOV_MAX and UIO_MAXIOV undefined
 #  endif
 # endif

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

-              r414
+              r740
 #ifdef NSS_WRAPPER
+#ifndef NSS_WRAPPER_DISABLE
 #ifndef NSS_WRAPPER_NOT_REPLACE
 #define NSS_WRAPPER_REPLACE
 #endif
+#endif /* NSS_WRAPPER_NOT_REPLACE */
 #include "../nss_wrapper/nss_wrapper.h"
+#endif
+#endif /* NSS_WRAPPER_DISABLE */
+#endif /* NSS_WRAPPER */
 #endif

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

-              r414
+              r740
 #ifdef HAVE_NEW_LIBREADLINE
+#  define RL_COMPLETION_CAST (rl_completion_func_t *)
+#ifdef HAVE_CPPFUNCTION
+#  define RL_COMPLETION_CAST (CPPFunction *)
+#elif HAVE_RL_COMPLETION_T
+#  define RL_COMPLETION_CAST (rl_completion_t *)
+#else
+#  define RL_COMPLETION_CAST
+#endif
 #else
 /* This type is missing from libreadline<4.0  (approximately) */

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

-              r414
+              r740
 #endif
+#ifdef HAVE_POLL
+#include <poll.h>
+#else
+/* Type used for the number of file descriptors.  */
+typedef unsigned long int nfds_t;
+/* Data structure describing a polling request.  */
+struct pollfd
+{
+        int fd;            /* File descriptor to poll.  */
+        short int events;  /* Types of events poller cares about.  */
+        short int revents; /* Types of events that actually occurred.  */
+};
+/* Event types that can be polled for.  These bits may be set in `events'
+   to indicate the interesting event types; they will appear in `revents'
+   to indicate the status of the file descriptor.  */
+#define POLLIN          0x001           /* There is data to read.  */
+#define POLLPRI         0x002           /* There is urgent data to read.  */
+#define POLLOUT         0x004           /* Writing now will not block.  */
+#define POLLRDNORM      0x040           /* Normal data may be read.  */
+#define POLLRDBAND      0x080           /* Priority data may be read.  */
+#define POLLWRNORM      0x100           /* Writing now will not block.  */
+#define POLLWRBAND      0x200           /* Priority data may be written.  */
+#define POLLERR         0x008           /* Error condition.  */
+#define POLLHUP         0x010           /* Hung up.  */
+#define POLLNVAL        0x020           /* Invalid polling request.  */
+/* define is in "replace.h" */
+int rep_poll(struct pollfd *fds, nfds_t nfds, int timeout);
 #endif
+#endif

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

-              r414
+              r740
 #endif
+#ifndef HAVE_STRUCT_TIMESPEC
+struct timespec {
+        time_t tv_sec;            /* Seconds.  */
+        long tv_nsec;           /* Nanoseconds.  */
+};
+#endif
 #ifndef HAVE_MKTIME
 /* define is in "replace.h" */
 …
 #endif
+#ifndef HAVE_CLOCK_GETTIME
+/* CLOCK_REALTIME is required by POSIX */
+#define CLOCK_REALTIME 0
+typedef int clockid_t;
+int rep_clock_gettime(clockid_t clk_id, struct timespec *tp);
 #endif
+/* make sure we have a best effort CUSTOM_CLOCK_MONOTONIC we can rely on */
+#if defined(CLOCK_MONOTONIC)
+#define CUSTOM_CLOCK_MONOTONIC CLOCK_MONOTONIC
+#elif defined(CLOCK_HIGHRES)
+#define CUSTOM_CLOCK_MONOTONIC CLOCK_HIGHRES
+#else
+#define CUSTOM_CLOCK_MONOTONIC CLOCK_REALTIME
+#endif
+#endif

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

-              r618
+              r740
 #endif
-#ifndef SIGNAL_CAST
-#define SIGNAL_CAST (RETSIGTYPE (*)(int))
-#endif
 #ifdef HAVE_SETJMP_H
 #include <setjmp.h>

vendor/current/lib/replace/test/os2_delete.c

-              r414
+              r740
                 char fname[40];
                 int fd;
                 sprintf(fname, TESTDIR "/test%u.txt", i);
+                snprintf(fname, sizeof(fname), TESTDIR "/test%u.txt", i);
                 fd = open(fname, O_CREAT|O_RDWR, 0600);
                 if (fd < 0) {
 …
         for (j=0; j<MIN(i, DELETE_SIZE); j++) {
                 char fname[40];
                 sprintf(fname, TESTDIR "/%s", names[j]);
+                snprintf(fname, sizeof(fname), TESTDIR "/%s", names[j]);
                 unlink(fname) == 0 || FAILED("unlink");
+        }

vendor/current/lib/replace/test/testsuite.c

-              r414
+              r740
 bool
 socklen_t
-uint_t
 uint{8,16,32,64}_t
 int{8,16,32,64}_t
 …
         printf("test: FUNCTION\n");
         if (strcmp(__FUNCTION__, "test_FUNCTION") != 0) {
                 printf("failure: FAILURE [\nFAILURE invalid\n]\n");
+                printf("failure: FUNCTION [\nFUNCTION invalid\n]\n");
                 return false;
+        }
 …
         return true;
+}
+static int test_memmem(void)
+{
+        char *s;
+        printf("test: memmem\n");
+        s = (char *)memmem("foo", 3, "fo", 2);
+        if (strcmp(s, "foo") != 0) {
+                printf(__location__ ": Failed memmem\n");
+                return false;
+        }
+        s = (char *)memmem("foo", 3, "", 0);
+        /* it is allowable for this to return NULL (as happens on
+           FreeBSD) */
+        if (s && strcmp(s, "foo") != 0) {
+                printf(__location__ ": Failed memmem\n");
+                return false;
+        }
+        s = (char *)memmem("foo", 4, "o", 1);
+        if (strcmp(s, "oo") != 0) {
+                printf(__location__ ": Failed memmem\n");
+                return false;
+        }
+        s = (char *)memmem("foobarfodx", 11, "fod", 3);
+        if (strcmp(s, "fodx") != 0) {
+                printf(__location__ ": Failed memmem\n");
+                return false;
+        }
+        printf("success: memmem\n");
+        return true;
+}
 struct torture_context;
 …
         ret &= test_utime();
         ret &= test_utimes();
+        ret &= test_memmem();
         return ret;

vendor/current/lib/smbconf/smbconf.c

-              r414
+              r740
  **********************************************************************/
 static WERROR smbconf_global_check(struct smbconf_ctx *ctx)
+static sbcErr smbconf_global_check(struct smbconf_ctx *ctx)
+{
         if (!smbconf_share_exists(ctx, GLOBAL_NAME)) {
                 return smbconf_create_share(ctx, GLOBAL_NAME);
+        }
+        return WERR_OK;
+        return SBC_ERR_OK;
+}
 …
+ *
  **********************************************************************/
+const char *sbcErrorString(sbcErr error)
+{
+        switch (error) {
+                case SBC_ERR_OK:
+                        return "SBC_ERR_OK";
+                case SBC_ERR_NOT_IMPLEMENTED:
+                        return "SBC_ERR_NOT_IMPLEMENTED";
+                case SBC_ERR_NOT_SUPPORTED:
+                        return "SBC_ERR_NOT_SUPPORTED";
+                case SBC_ERR_UNKNOWN_FAILURE:
+                        return "SBC_ERR_UNKNOWN_FAILURE";
+                case SBC_ERR_NOMEM:
+                        return "SBC_ERR_NOMEM";
+                case SBC_ERR_INVALID_PARAM:
+                        return "SBC_ERR_INVALID_PARAM";
+                case SBC_ERR_BADFILE:
+                        return "SBC_ERR_BADFILE";
+                case SBC_ERR_NO_SUCH_SERVICE:
+                        return "SBC_ERR_NO_SUCH_SERVICE";
+                case SBC_ERR_IO_FAILURE:
+                        return "SBC_ERR_IO_FAILURE";
+                case SBC_ERR_CAN_NOT_COMPLETE:
+                        return "SBC_ERR_CAN_NOT_COMPLETE";
+                case SBC_ERR_NO_MORE_ITEMS:
+                        return "SBC_ERR_NO_MORE_ITEMS";
+                case SBC_ERR_FILE_EXISTS:
+                        return "SBC_ERR_FILE_EXISTS";
+                case SBC_ERR_ACCESS_DENIED:
+                        return "SBC_ERR_ACCESS_DENIED";
+        }
+        return "unknown sbcErr value";
+}
 /**
 …
  * Drop the whole configuration (restarting empty).
  */
 WERROR smbconf_drop(struct smbconf_ctx *ctx)
+sbcErr smbconf_drop(struct smbconf_ctx *ctx)
+{
         return ctx->ops->drop(ctx);
 …
  *  param_values : list of lists of parameter values for each share
  */
 WERROR smbconf_get_config(struct smbconf_ctx *ctx,
+sbcErr smbconf_get_config(struct smbconf_ctx *ctx,
                           TALLOC_CTX *mem_ctx,
                           uint32_t *num_shares,
                           struct smbconf_service ***services)
+{
         WERROR werr = WERR_OK;
+        sbcErr err;
         TALLOC_CTX *tmp_ctx = NULL;
         uint32_t tmp_num_shares;
 …
         if ((num_shares == NULL) || (services == NULL)) {
                 werr = WERR_INVALID_PARAM;
+                err = SBC_ERR_INVALID_PARAM;
                 goto done;
+        }
 …
         tmp_ctx = talloc_stackframe();
         werr = smbconf_get_share_names(ctx, tmp_ctx, &tmp_num_shares,
                                        &tmp_share_names);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_get_share_names(ctx, tmp_ctx, &tmp_num_shares,
+                                      &tmp_share_names);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto done;
+        }
 …
         tmp_services = talloc_array(tmp_ctx, struct smbconf_service *,
                                     tmp_num_shares);
         if (tmp_services == NULL) {
                 werr = WERR_NOMEM;
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
         for (count = 0; count < tmp_num_shares; count++) {
                 werr = smbconf_get_share(ctx, tmp_services,
                                          tmp_share_names[count],
                                          &tmp_services[count]);
                 if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_get_share(ctx, tmp_services,
+                                        tmp_share_names[count],
+                                        &tmp_services[count]);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
+        }
         werr = WERR_OK;
+        err = SBC_ERR_OK;
         *num_shares = tmp_num_shares;
 …
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
  * get the list of share names defined in the configuration.
  */
 WERROR smbconf_get_share_names(struct smbconf_ctx *ctx,
+sbcErr smbconf_get_share_names(struct smbconf_ctx *ctx,
                                TALLOC_CTX *mem_ctx,
                                uint32_t *num_shares,
 …
  * Add a service if it does not already exist.
  */
 WERROR smbconf_create_share(struct smbconf_ctx *ctx,
+sbcErr smbconf_create_share(struct smbconf_ctx *ctx,
                             const char *servicename)
+{
         if ((servicename != NULL) && smbconf_share_exists(ctx, servicename)) {
                 return WERR_FILE_EXISTS;
+                return SBC_ERR_FILE_EXISTS;
+        }
 …
  * get a definition of a share (service) from configuration.
  */
 WERROR smbconf_get_share(struct smbconf_ctx *ctx,
+sbcErr smbconf_get_share(struct smbconf_ctx *ctx,
                          TALLOC_CTX *mem_ctx,
                          const char *servicename,
 …
  * delete a service from configuration
  */
 WERROR smbconf_delete_share(struct smbconf_ctx *ctx, const char *servicename)
+sbcErr smbconf_delete_share(struct smbconf_ctx *ctx, const char *servicename)
+{
         if (!smbconf_share_exists(ctx, servicename)) {
                 return WERR_NO_SUCH_SERVICE;
+                return SBC_ERR_NO_SUCH_SERVICE;
+        }
 …
  * set a configuration parameter to the value provided.
  */
 WERROR smbconf_set_parameter(struct smbconf_ctx *ctx,
+sbcErr smbconf_set_parameter(struct smbconf_ctx *ctx,
                              const char *service,
                              const char *param,
 …
  * This also creates [global] when it does not exist.
  */
 WERROR smbconf_set_global_parameter(struct smbconf_ctx *ctx,
+sbcErr smbconf_set_global_parameter(struct smbconf_ctx *ctx,
                                     const char *param, const char *val)
+{
+        WERROR werr;
+        werr = smbconf_global_check(ctx);
+        if (W_ERROR_IS_OK(werr)) {
+                werr = smbconf_set_parameter(ctx, GLOBAL_NAME, param, val);
+        }
+        return werr;
+        sbcErr err;
+        err = smbconf_global_check(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
+        err = smbconf_set_parameter(ctx, GLOBAL_NAME, param, val);
+        return err;
+}
 …
  * get the value of a configuration parameter as a string
  */
 WERROR smbconf_get_parameter(struct smbconf_ctx *ctx,
+sbcErr smbconf_get_parameter(struct smbconf_ctx *ctx,
                              TALLOC_CTX *mem_ctx,
                              const char *service,
 …
+{
         if (valstr == NULL) {
                 return WERR_INVALID_PARAM;
+                return SBC_ERR_INVALID_PARAM;
+        }
 …
  * Create [global] if it does not exist.
  */
 WERROR smbconf_get_global_parameter(struct smbconf_ctx *ctx,
+sbcErr smbconf_get_global_parameter(struct smbconf_ctx *ctx,
                                     TALLOC_CTX *mem_ctx,
                                     const char *param,
                                     char **valstr)
+{
+        WERROR werr;
+        werr = smbconf_global_check(ctx);
+        if (W_ERROR_IS_OK(werr)) {
+                werr = smbconf_get_parameter(ctx, mem_ctx, GLOBAL_NAME, param,
+                                             valstr);
+        }
+        return werr;
+        sbcErr err;
+        err = smbconf_global_check(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
+        err = smbconf_get_parameter(ctx, mem_ctx, GLOBAL_NAME, param,
+                                    valstr);
+        return err;
+}
 …
  * delete a parameter from configuration
  */
 WERROR smbconf_delete_parameter(struct smbconf_ctx *ctx,
+sbcErr smbconf_delete_parameter(struct smbconf_ctx *ctx,
                                 const char *service, const char *param)
+{
 …
  * Create [global] if it does not exist.
  */
 WERROR smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
+sbcErr smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
                                        const char *param)
+{
+        WERROR werr;
+        werr = smbconf_global_check(ctx);
+        if (W_ERROR_IS_OK(werr)) {
+                werr = smbconf_delete_parameter(ctx, GLOBAL_NAME, param);
+        }
+        return werr;
+}
+WERROR smbconf_get_includes(struct smbconf_ctx *ctx,
+        sbcErr err;
+        err = smbconf_global_check(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
+        err = smbconf_delete_parameter(ctx, GLOBAL_NAME, param);
+        return err;
+}
+sbcErr smbconf_get_includes(struct smbconf_ctx *ctx,
                             TALLOC_CTX *mem_ctx,
                             const char *service,
 …
+}
 WERROR smbconf_get_global_includes(struct smbconf_ctx *ctx,
+sbcErr smbconf_get_global_includes(struct smbconf_ctx *ctx,
                                    TALLOC_CTX *mem_ctx,
                                    uint32_t *num_includes, char ***includes)
+{
+        WERROR werr;
+        werr = smbconf_global_check(ctx);
+        if (W_ERROR_IS_OK(werr)) {
+                werr = smbconf_get_includes(ctx, mem_ctx, GLOBAL_NAME,
+                                            num_includes, includes);
+        }
+        return werr;
+}
+WERROR smbconf_set_includes(struct smbconf_ctx *ctx,
+        sbcErr err;
+        err = smbconf_global_check(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
+        err = smbconf_get_includes(ctx, mem_ctx, GLOBAL_NAME,
+                                    num_includes, includes);
+        return err;
+}
+sbcErr smbconf_set_includes(struct smbconf_ctx *ctx,
                             const char *service,
                             uint32_t num_includes, const char **includes)
 …
+}
 WERROR smbconf_set_global_includes(struct smbconf_ctx *ctx,
+sbcErr smbconf_set_global_includes(struct smbconf_ctx *ctx,
                                    uint32_t num_includes,
                                    const char **includes)
+{
+        WERROR werr;
+        werr = smbconf_global_check(ctx);
+        if (W_ERROR_IS_OK(werr)) {
+                werr = smbconf_set_includes(ctx, GLOBAL_NAME,
+                                            num_includes, includes);
+        }
+        return werr;
+}
+WERROR smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service)
+        sbcErr err;
+        err = smbconf_global_check(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
+        err = smbconf_set_includes(ctx, GLOBAL_NAME,
+                                   num_includes, includes);
+        return err;
+}
+sbcErr smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service)
+{
         return ctx->ops->delete_includes(ctx, service);
+}
+WERROR smbconf_delete_global_includes(struct smbconf_ctx *ctx)
+{
+        WERROR werr;
+        werr = smbconf_global_check(ctx);
+        if (W_ERROR_IS_OK(werr)) {
+                werr = smbconf_delete_includes(ctx, GLOBAL_NAME);
+        }
+        return werr;
+}
+WERROR smbconf_transaction_start(struct smbconf_ctx *ctx)
+sbcErr smbconf_delete_global_includes(struct smbconf_ctx *ctx)
+{
+        sbcErr err;
+        err = smbconf_global_check(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
+        err = smbconf_delete_includes(ctx, GLOBAL_NAME);
+        return err;
+}
+sbcErr smbconf_transaction_start(struct smbconf_ctx *ctx)
+{
         return ctx->ops->transaction_start(ctx);
+}
 WERROR smbconf_transaction_commit(struct smbconf_ctx *ctx)
+sbcErr smbconf_transaction_commit(struct smbconf_ctx *ctx)
+{
         return ctx->ops->transaction_commit(ctx);
+}
 WERROR smbconf_transaction_cancel(struct smbconf_ctx *ctx)
+sbcErr smbconf_transaction_cancel(struct smbconf_ctx *ctx)
+{
         return ctx->ops->transaction_cancel(ctx);

vendor/current/lib/smbconf/smbconf.h

-              r414
+              r740
 #define __LIBSMBCONF_H__
+/**
+ * @defgroup libsmbconf The smbconf API
+ *
+ * libsmbconf is a library to read or, based on the backend, modify the Samba
+ * configuration.
+ *
+ * @{
+ */
+/**
+ * @brief Status codes returned from smbconf functions
+ */
+enum _sbcErrType {
+        SBC_ERR_OK = 0,          /**< Successful completion **/
+        SBC_ERR_NOT_IMPLEMENTED, /**< Function not implemented **/
+        SBC_ERR_NOT_SUPPORTED,   /**< Function not supported **/
+        SBC_ERR_UNKNOWN_FAILURE, /**< General failure **/
+        SBC_ERR_NOMEM,           /**< Memory allocation error **/
+        SBC_ERR_INVALID_PARAM,   /**< An Invalid parameter was supplied **/
+        SBC_ERR_BADFILE,         /**< A bad file was supplied **/
+        SBC_ERR_NO_SUCH_SERVICE, /**< There is no such service provided **/
+        SBC_ERR_IO_FAILURE,      /**< There was an IO error **/
+        SBC_ERR_CAN_NOT_COMPLETE,/**< Can not complete action **/
+        SBC_ERR_NO_MORE_ITEMS,   /**< No more items left **/
+        SBC_ERR_FILE_EXISTS,     /**< File already exists **/
+        SBC_ERR_ACCESS_DENIED,   /**< Access has been denied **/
+};
+typedef enum _sbcErrType sbcErr;
+#define SBC_ERROR_IS_OK(x) ((x) == SBC_ERR_OK)
+#define SBC_ERROR_EQUAL(x,y) ((x) == (y))
 struct smbconf_ctx;
 …
 };
+/** Information about a service */
 struct smbconf_service {
         char *name;
         uint32_t num_params;
         char **param_names;
         char **param_values;
+        char *name;          /**< The name of the share */
+        uint32_t num_params; /**< List of length num_shares of parameter counts for each share */
+        char **param_names;  /**< List of lists of parameter names for each share */
+        char **param_values; /**< List of lists of parameter values for each share */
 };
 /*
+ * the smbconf API functions
+ * The smbconf API functions
+ */
+/**
+ * @brief Translate an error value into a string
+ *
+ * @param error
+ *
+ * @return a pointer to a static string
+ **/
+const char *sbcErrorString(sbcErr error);
+/**
+ * @brief Check if the backend requires messaging to be set up.
+ *
+ * Tell whether the backend requires messaging to be set up
+ * for the backend to work correctly.
+ *
+ * @param[in] ctx       The smbconf context to check.
+ *
+ * @return              True if needed, false if not.
  */
 bool smbconf_backend_requires_messaging(struct smbconf_ctx *ctx);
+/**
+ * @brief Tell whether the source is writeable.
+ *
+ * @param[in] ctx       The smbconf context to check.
+ *
+ * @return              True if it is writeable, false if not.
+ */
 bool smbconf_is_writeable(struct smbconf_ctx *ctx);
+/**
+ * @brief Close the configuration.
+ *
+ * @param[in] ctx       The smbconf context to close.
+ */
 void smbconf_shutdown(struct smbconf_ctx *ctx);
+/**
+ * @brief Detect changes in the configuration.
+ *
+ * Get the change sequence number of the given service/parameter. Service and
+ * parameter strings may be NULL.
+ *
+ * The given change sequence number (csn) struct is filled with the current
+ * csn. smbconf_changed() can also be used for initial retrieval of the csn.
+ *
+ * @param[in] ctx       The smbconf context to check for changes.
+ *
+ * @param[inout] csn    The smbconf csn to be filled.
+ *
+ * @param[in] service   The service name to check or NULL.
+ *
+ * @param[in] param     The param to check or NULL.
+ *
+ * @return              True if it has been changed, false if not.
+ */
 bool smbconf_changed(struct smbconf_ctx *ctx, struct smbconf_csn *csn,
                      const char *service, const char *param);
+WERROR smbconf_drop(struct smbconf_ctx *ctx);
+WERROR smbconf_get_config(struct smbconf_ctx *ctx,
+/**
+ * @brief Drop the whole configuration (restarting empty).
+ *
+ * @param[in] ctx       The smbconf context to drop the config.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_drop(struct smbconf_ctx *ctx);
+/**
+ * @brief Get the whole configuration as lists of strings with counts.
+ *
+ * @param[in] ctx       The smbconf context to get the lists from.
+ *
+ * @param[in] mem_ctx   The memory context to use.
+ *
+ * @param[in] num_shares A pointer to store the number of shares.
+ *
+ * @param[out] services  A pointer to store the services.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ *
+ * @see smbconf_service
+ */
+sbcErr smbconf_get_config(struct smbconf_ctx *ctx,
                           TALLOC_CTX *mem_ctx,
                           uint32_t *num_shares,
                           struct smbconf_service ***services);
+WERROR smbconf_get_share_names(struct smbconf_ctx *ctx,
+/**
+ * @brief Get the list of share names defined in the configuration.
+ *
+ * @param[in] ctx       The smbconf context to use.
+ *
+ * @param[in] mem_ctx   The memory context to use.
+ *
+ * @param[in] num_shares A pointer to store the number of shares.
+ *
+ * @param[in] share_names A pointer to store the share names.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_get_share_names(struct smbconf_ctx *ctx,
                                TALLOC_CTX *mem_ctx,
                                uint32_t *num_shares,
                                char ***share_names);
+/**
+ * @brief Check if a share/service of a given name exists.
+ *
+ * @param[in] ctx       The smbconf context to use.
+ *
+ * @param[in] servicename The service name to check if it exists.
+ *
+ * @return              True if it exists, false if not.
+ */
 bool smbconf_share_exists(struct smbconf_ctx *ctx, const char *servicename);
+WERROR smbconf_create_share(struct smbconf_ctx *ctx, const char *servicename);
+WERROR smbconf_get_share(struct smbconf_ctx *ctx,
+/**
+ * @brief Add a service if it does not already exist.
+ *
+ * @param[in] ctx       The smbconf context to use.
+ *
+ * @param[in] servicename The name of the service to add.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_create_share(struct smbconf_ctx *ctx, const char *servicename);
+/**
+ * @brief Get a definition of a share (service) from configuration.
+ *
+ * @param[in] ctx       The smbconf context to use.
+ *
+ * @param[in] mem_ctx   A memory context to allocate the result.
+ *
+ * @param[in] servicename The service name to get the information from.
+ *
+ * @param[out] service  A pointer to store the service information about the
+ *                      share.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ *
+ * @see smbconf_service
+ */
+sbcErr smbconf_get_share(struct smbconf_ctx *ctx,
                          TALLOC_CTX *mem_ctx,
                          const char *servicename,
                          struct smbconf_service **service);
+WERROR smbconf_delete_share(struct smbconf_ctx *ctx,
+/**
+ * @brief Delete a service from configuration.
+ *
+ * @param[in] ctx       The smbconf context to use.
+ *
+ * @param[in] servicename The service name to delete.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_delete_share(struct smbconf_ctx *ctx,
                             const char *servicename);
+WERROR smbconf_set_parameter(struct smbconf_ctx *ctx,
+/**
+ * @brief Set a configuration parameter to the value provided.
+ *
+ * @param[in] ctx       The smbconf context to use.
+ *
+ * @param[in] service   The service name to set the parameter.
+ *
+ * @param[in] param     The name of the parameter to set.
+ *
+ * @param[in] valstr    The value to set.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_set_parameter(struct smbconf_ctx *ctx,
                              const char *service,
                              const char *param,
                              const char *valstr);
+WERROR smbconf_set_global_parameter(struct smbconf_ctx *ctx,
+/**
+ * @brief Set a global configuration parameter to the value provided.
+ *
+ * This adds a paramet in the [global] service. It also creates [global] if it
+ * does't exist.
+ *
+ * @param[in] ctx       The smbconf context to use.
+ *
+ * @param[in] param     The name of the parameter to set.
+ *
+ * @param[in] val       The value to set.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_set_global_parameter(struct smbconf_ctx *ctx,
                                     const char *param, const char *val);
+WERROR smbconf_get_parameter(struct smbconf_ctx *ctx,
+/**
+ * @brief Get the value of a configuration parameter as a string.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in]  mem_ctx  The memory context to allocate the string on.
+ *
+ * @param[in]  service  The name of the service where to find the parameter.
+ *
+ * @param[in]  param    The parameter to get.
+ *
+ * @param[out] valstr   A pointer to store the value as a string.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_get_parameter(struct smbconf_ctx *ctx,
                              TALLOC_CTX *mem_ctx,
                              const char *service,
                              const char *param,
                              char **valstr);
+WERROR smbconf_get_global_parameter(struct smbconf_ctx *ctx,
+/**
+ * @brief Get the value of a global configuration parameter as a string.
+ *
+ * It also creates [global] if it does't exist.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in]  mem_ctx  The memory context to allocate the string on.
+ *
+ * @param[in]  param    The parameter to get.
+ *
+ * @param[out] valstr   A pointer to store the value as a string.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_get_global_parameter(struct smbconf_ctx *ctx,
                                     TALLOC_CTX *mem_ctx,
                                     const char *param,
                                     char **valstr);
+WERROR smbconf_delete_parameter(struct smbconf_ctx *ctx,
+/**
+ * @brief Delete a parameter from the configuration.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in] service   The service where the parameter can be found.
+ *
+ * @param[in] param     The name of the parameter to delete.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_delete_parameter(struct smbconf_ctx *ctx,
                                 const char *service, const char *param);
+WERROR smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
+/**
+ * @brief Delete a global parameter from the configuration.
+ *
+ * It also creates [global] if it does't exist.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in] param     The name of the parameter to delete.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
                                        const char *param);
+WERROR smbconf_get_includes(struct smbconf_ctx *ctx,
+/**
+ * @brief Get the list of names of included files.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in]  mem_ctx  The memory context to allocate the names.
+ *
+ * @param[in]  service  The service name to get the include files.
+ *
+ * @param[out] num_includes A pointer to store the number of included files.
+ *
+ * @param[out] includes A pointer to store the paths of the included files.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_get_includes(struct smbconf_ctx *ctx,
                             TALLOC_CTX *mem_ctx,
                             const char *service,
                             uint32_t *num_includes, char ***includes);
+WERROR smbconf_get_global_includes(struct smbconf_ctx *ctx,
+/**
+ * @brief Get the list of globally included files.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in]  mem_ctx  The memory context to allocate the names.
+ *
+ * @param[out] num_includes A pointer to store the number of included files.
+ *
+ * @param[out] includes A pointer to store the paths of the included files.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_get_global_includes(struct smbconf_ctx *ctx,
                                    TALLOC_CTX *mem_ctx,
                                    uint32_t *num_includes, char ***includes);
+WERROR smbconf_set_includes(struct smbconf_ctx *ctx,
+/**
+ * @brief Set a list of config files to include on the given service.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in]  service  The service to add includes.
+ *
+ * @param[in]  num_includes The number of includes to set.
+ *
+ * @param[in]  includes A list of paths to include.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_set_includes(struct smbconf_ctx *ctx,
                             const char *service,
                             uint32_t num_includes, const char **includes);
+WERROR smbconf_set_global_includes(struct smbconf_ctx *ctx,
+/**
+ * @brief Set a list of config files to include globally.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in]  num_includes The number of includes to set.
+ *
+ * @param[in]  includes A list of paths to include.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_set_global_includes(struct smbconf_ctx *ctx,
                                    uint32_t num_includes,
                                    const char **includes);
+WERROR smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service);
+WERROR smbconf_delete_global_includes(struct smbconf_ctx *ctx);
+WERROR smbconf_transaction_start(struct smbconf_ctx *ctx);
+WERROR smbconf_transaction_commit(struct smbconf_ctx *ctx);
+WERROR smbconf_transaction_cancel(struct smbconf_ctx *ctx);
+/**
+ * @brief Delete include parameter on the given service.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @param[in]  service  The name of the service to delete the includes from.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service);
+/**
+ * @brief Delete include parameter from the global service.
+ *
+ * @param[in]  ctx      The smbconf context to use.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_delete_global_includes(struct smbconf_ctx *ctx);
+/**
+ * @brief Start a transaction on the configuration backend.
+ *
+ * This is to speed up writes to the registry based backend.
+ *
+ * @param[in] ctx       The smbconf context to start the transaction.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ */
+sbcErr smbconf_transaction_start(struct smbconf_ctx *ctx);
+/**
+ * @brief Commit a transaction on the configuration backend.
+ *
+ * This is to speed up writes to the registry based backend.
+ *
+ * @param[in] ctx       The smbconf context to commit the transaction.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ *
+ * @see smbconf_transaction_start()
+ */
+sbcErr smbconf_transaction_commit(struct smbconf_ctx *ctx);
+/**
+ * @brief Cancel a transaction on the configuration backend.
+ *
+ * @param[in] ctx       The smbconf context to cancel the transaction.
+ *
+ * @return              SBC_ERR_OK on success, a corresponding sbcErr if an
+ *                      error occured.
+ *
+ * @see smbconf_transaction_start()
+ */
+sbcErr smbconf_transaction_cancel(struct smbconf_ctx *ctx);
+/* @} ******************************************************************/
 #endif /*  _LIBSMBCONF_H_  */

vendor/current/lib/smbconf/smbconf_private.h

-              r414
+              r740
 struct smbconf_ops {
         WERROR (*init)(struct smbconf_ctx *ctx, const char *path);
+        sbcErr (*init)(struct smbconf_ctx *ctx, const char *path);
         int (*shutdown)(struct smbconf_ctx *ctx);
         bool (*requires_messaging)(struct smbconf_ctx *ctx);
         bool (*is_writeable)(struct smbconf_ctx *ctx);
         WERROR (*open_conf)(struct smbconf_ctx *ctx);
+        sbcErr (*open_conf)(struct smbconf_ctx *ctx);
         int (*close_conf)(struct smbconf_ctx *ctx);
         void (*get_csn)(struct smbconf_ctx *ctx, struct smbconf_csn *csn,
                         const char *service, const char *param);
         WERROR (*drop)(struct smbconf_ctx *ctx);
         WERROR (*get_share_names)(struct smbconf_ctx *ctx,
+        sbcErr (*drop)(struct smbconf_ctx *ctx);
+        sbcErr (*get_share_names)(struct smbconf_ctx *ctx,
                                   TALLOC_CTX *mem_ctx,
                                   uint32_t *num_shares,
                                   char ***share_names);
         bool (*share_exists)(struct smbconf_ctx *ctx, const char *service);
         WERROR (*create_share)(struct smbconf_ctx *ctx, const char *service);
         WERROR (*get_share)(struct smbconf_ctx *ctx,
+        sbcErr (*create_share)(struct smbconf_ctx *ctx, const char *service);
+        sbcErr (*get_share)(struct smbconf_ctx *ctx,
                             TALLOC_CTX *mem_ctx,
                             const char *servicename,
                             struct smbconf_service **service);
         WERROR (*delete_share)(struct smbconf_ctx *ctx,
+        sbcErr (*delete_share)(struct smbconf_ctx *ctx,
                                     const char *servicename);
         WERROR (*set_parameter)(struct smbconf_ctx *ctx,
+        sbcErr (*set_parameter)(struct smbconf_ctx *ctx,
                                 const char *service,
                                 const char *param,
                                 const char *valstr);
         WERROR (*get_parameter)(struct smbconf_ctx *ctx,
+        sbcErr (*get_parameter)(struct smbconf_ctx *ctx,
                                 TALLOC_CTX *mem_ctx,
                                 const char *service,
                                 const char *param,
                                 char **valstr);
         WERROR (*delete_parameter)(struct smbconf_ctx *ctx,
+        sbcErr (*delete_parameter)(struct smbconf_ctx *ctx,
                                    const char *service, const char *param);
         WERROR (*get_includes)(struct smbconf_ctx *ctx,
+        sbcErr (*get_includes)(struct smbconf_ctx *ctx,
                                TALLOC_CTX *mem_ctx,
                                const char *service,
                                uint32_t *num_includes, char ***includes);
         WERROR (*set_includes)(struct smbconf_ctx *ctx,
+        sbcErr (*set_includes)(struct smbconf_ctx *ctx,
                                const char *service,
                                uint32_t num_includes, const char **includes);
         WERROR (*delete_includes)(struct smbconf_ctx *ctx,
+        sbcErr (*delete_includes)(struct smbconf_ctx *ctx,
                                   const char *service);
         WERROR (*transaction_start)(struct smbconf_ctx *ctx);
         WERROR (*transaction_commit)(struct smbconf_ctx *ctx);
         WERROR (*transaction_cancel)(struct smbconf_ctx *ctx);
+        sbcErr (*transaction_start)(struct smbconf_ctx *ctx);
+        sbcErr (*transaction_commit)(struct smbconf_ctx *ctx);
+        sbcErr (*transaction_cancel)(struct smbconf_ctx *ctx);
 };
 …
 };
 WERROR smbconf_init_internal(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
+sbcErr smbconf_init_internal(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
                              const char *path, struct smbconf_ops *ops);
 WERROR smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
+sbcErr smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
                                    char ***array,
                                    uint32_t count,

vendor/current/lib/smbconf/smbconf_txt.c

-              r414
+              r740
 #include "includes.h"
 #include "smbconf_private.h"
+#include "lib/smbconf/smbconf_txt.h"
 struct txt_cache {
 …
 static bool smbconf_txt_do_section(const char *section, void *private_data)
+{
         WERROR werr;
+        sbcErr err;
         uint32_t idx;
         struct txt_private_data *tpd = (struct txt_private_data *)private_data;
 …
+        }
         werr = smbconf_add_string_to_array(cache, &(cache->share_names),
                                            cache->num_shares, section);
         if (!W_ERROR_IS_OK(werr)) {
+        err = smbconf_add_string_to_array(cache, &(cache->share_names),
+                                          cache->num_shares, section);
+        if (!SBC_ERROR_IS_OK(err)) {
                 return false;
+        }
 …
                                      void *private_data)
+{
         WERROR werr;
+        sbcErr err;
         char **param_names, **param_values;
         uint32_t num_params;
 …
                 return true;
+        }
         werr = smbconf_add_string_to_array(cache,
+        err = smbconf_add_string_to_array(cache,
                                 &(cache->param_names[cache->current_share]),
                                 num_params, param_name);
         if (!W_ERROR_IS_OK(werr)) {
+        if (!SBC_ERROR_IS_OK(err)) {
                 return false;
+        }
         werr = smbconf_add_string_to_array(cache,
+        err = smbconf_add_string_to_array(cache,
                                 &(cache->param_values[cache->current_share]),
                                 num_params, param_value);
         cache->num_params[cache->current_share]++;
         return W_ERROR_IS_OK(werr);
+        return SBC_ERROR_IS_OK(err);
+}
 …
+}
 static WERROR smbconf_txt_init_cache(struct smbconf_ctx *ctx)
+static sbcErr smbconf_txt_init_cache(struct smbconf_ctx *ctx)
+{
         if (pd(ctx)->cache != NULL) {
 …
         if (pd(ctx)->cache == NULL) {
                 return WERR_NOMEM;
+        }
         return WERR_OK;
+}
 static WERROR smbconf_txt_load_file(struct smbconf_ctx *ctx)
+{
         WERROR werr;
+                return SBC_ERR_NOMEM;
+        }
+        return SBC_ERR_OK;
+}
+static sbcErr smbconf_txt_load_file(struct smbconf_ctx *ctx)
+{
+        sbcErr err;
         uint64_t new_csn;
         if (!file_exist(ctx->path)) {
                 return WERR_BADFILE;
+                return SBC_ERR_BADFILE;
+        }
         new_csn = (uint64_t)file_modtime(ctx->path);
         if (new_csn == pd(ctx)->csn) {
                 return WERR_OK;
+        }
         werr = smbconf_txt_init_cache(ctx);
         if (!W_ERROR_IS_OK(werr)) {
                 return werr;
+                return SBC_ERR_OK;
+        }
+        err = smbconf_txt_init_cache(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
 …
                         smbconf_txt_do_parameter, pd(ctx)))
+        {
                 return WERR_CAN_NOT_COMPLETE;
+                return SBC_ERR_CAN_NOT_COMPLETE;
+        }
         pd(ctx)->csn = new_csn;
         return WERR_OK;
+        return SBC_ERR_OK;
+}
 …
  * initialize the text based smbconf backend
  */
 static WERROR smbconf_txt_init(struct smbconf_ctx *ctx, const char *path)
+static sbcErr smbconf_txt_init(struct smbconf_ctx *ctx, const char *path)
+{
         if (path == NULL) {
                 return WERR_BADFILE;
+                return SBC_ERR_BADFILE;
+        }
         ctx->path = talloc_strdup(ctx, path);
         if (ctx->path == NULL) {
                 return WERR_NOMEM;
+                return SBC_ERR_NOMEM;
+        }
         ctx->data = talloc_zero(ctx, struct txt_private_data);
         if (ctx->data == NULL) {
                 return WERR_NOMEM;
+                return SBC_ERR_NOMEM;
+        }
         pd(ctx)->verbatim = true;
         return WERR_OK;
+        return SBC_ERR_OK;
+}
 …
+}
 static WERROR smbconf_txt_open(struct smbconf_ctx *ctx)
+static sbcErr smbconf_txt_open(struct smbconf_ctx *ctx)
+{
         return smbconf_txt_load_file(ctx);
 …
  * Drop the whole configuration (restarting empty)
  */
 static WERROR smbconf_txt_drop(struct smbconf_ctx *ctx)
+{
         return WERR_NOT_SUPPORTED;
+static sbcErr smbconf_txt_drop(struct smbconf_ctx *ctx)
+{
+        return SBC_ERR_NOT_SUPPORTED;
+}
 …
  * get the list of share names defined in the configuration.
  */
 static WERROR smbconf_txt_get_share_names(struct smbconf_ctx *ctx,
+static sbcErr smbconf_txt_get_share_names(struct smbconf_ctx *ctx,
                                           TALLOC_CTX *mem_ctx,
                                           uint32_t *num_shares,
 …
         uint32_t added_count = 0;
         TALLOC_CTX *tmp_ctx = NULL;
         WERROR werr = WERR_OK;
+        sbcErr err = SBC_ERR_OK;
         char **tmp_share_names = NULL;
         if ((num_shares == NULL) || (share_names == NULL)) {
+                werr = WERR_INVALID_PARAM;
+                goto done;
+        }
+        werr = smbconf_txt_load_file(ctx);
+        if (!W_ERROR_IS_OK(werr)) {
+                return werr;
+                return SBC_ERR_INVALID_PARAM;
+        }
+        err = smbconf_txt_load_file(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
 …
         if (smbconf_share_exists(ctx, NULL)) {
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
 , NULL);
                 if (!W_ERROR_IS_OK(werr)) {
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
+, NULL);
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
         if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
                                                    added_count, GLOBAL_NAME);
                 if (!W_ERROR_IS_OK(werr)) {
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
+                }
                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
+                err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
                                         added_count,
                                         pd(ctx)->cache->share_names[count]);
                 if (!W_ERROR_IS_OK(werr)) {
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
                                      const char *servicename)
+{
         WERROR werr;
         werr = smbconf_txt_load_file(ctx);
         if (!W_ERROR_IS_OK(werr)) {
+        sbcErr err;
+        err = smbconf_txt_load_file(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
                 return false;
+        }
 …
  * Add a service if it does not already exist
  */
 static WERROR smbconf_txt_create_share(struct smbconf_ctx *ctx,
+static sbcErr smbconf_txt_create_share(struct smbconf_ctx *ctx,
                                        const char *servicename)
+{
         return WERR_NOT_SUPPORTED;
+        return SBC_ERR_NOT_SUPPORTED;
+}
 …
  * get a definition of a share (service) from configuration.
  */
 static WERROR smbconf_txt_get_share(struct smbconf_ctx *ctx,
+static sbcErr smbconf_txt_get_share(struct smbconf_ctx *ctx,
                                     TALLOC_CTX *mem_ctx,
                                     const char *servicename,
                                     struct smbconf_service **service)
+{
         WERROR werr;
+        sbcErr err;
         uint32_t sidx, count;
         bool found;
 …
         struct smbconf_service *tmp_service = NULL;
         werr = smbconf_txt_load_file(ctx);
         if (!W_ERROR_IS_OK(werr)) {
                 return werr;
+        err = smbconf_txt_load_file(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
 …
                                       &sidx);
         if (!found) {
                 return WERR_NO_SUCH_SERVICE;
+                return SBC_ERR_NO_SUCH_SERVICE;
+        }
 …
         tmp_service = talloc_zero(tmp_ctx, struct smbconf_service);
         if (tmp_service == NULL) {
                 werr = WERR_NOMEM;
+                err = SBC_ERR_NOMEM;
                 goto done;
+        }
 …
                 tmp_service->name = talloc_strdup(tmp_service, servicename);
                 if (tmp_service->name == NULL) {
                         werr = WERR_NOMEM;
+                        err = SBC_ERR_NOMEM;
                         goto done;
+                }
 …
         for (count = 0; count < pd(ctx)->cache->num_params[sidx]; count++) {
                 werr = smbconf_add_string_to_array(tmp_service,
+                err = smbconf_add_string_to_array(tmp_service,
                                 &(tmp_service->param_names),
                                 count,
                                 pd(ctx)->cache->param_names[sidx][count]);
                 if (!W_ERROR_IS_OK(werr)) {
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
                 werr = smbconf_add_string_to_array(tmp_service,
+                err = smbconf_add_string_to_array(tmp_service,
                                 &(tmp_service->param_values),
                                 count,
                                 pd(ctx)->cache->param_values[sidx][count]);
                 if (!W_ERROR_IS_OK(werr)) {
+                if (!SBC_ERROR_IS_OK(err)) {
                         goto done;
+                }
 …
         tmp_service->num_params = count;
+        if (count > 0) {
+                *service = talloc_move(mem_ctx, &tmp_service);
+        } else {
+                *service = NULL;
+        }
+        *service = talloc_move(mem_ctx, &tmp_service);
 done:
         talloc_free(tmp_ctx);
         return werr;
+        return err;
+}
 …
  * delete a service from configuration
  */
 static WERROR smbconf_txt_delete_share(struct smbconf_ctx *ctx,
+static sbcErr smbconf_txt_delete_share(struct smbconf_ctx *ctx,
                                        const char *servicename)
+{
         return WERR_NOT_SUPPORTED;
+        return SBC_ERR_NOT_SUPPORTED;
+}
 …
  * set a configuration parameter to the value provided.
  */
 static WERROR smbconf_txt_set_parameter(struct smbconf_ctx *ctx,
+static sbcErr smbconf_txt_set_parameter(struct smbconf_ctx *ctx,
                                         const char *service,
                                         const char *param,
                                         const char *valstr)
+{
         return WERR_NOT_SUPPORTED;
+        return SBC_ERR_NOT_SUPPORTED;
+}
 …
  * get the value of a configuration parameter as a string
  */
 static WERROR smbconf_txt_get_parameter(struct smbconf_ctx *ctx,
+static sbcErr smbconf_txt_get_parameter(struct smbconf_ctx *ctx,
                                         TALLOC_CTX *mem_ctx,
                                         const char *service,
 …
                                         char **valstr)
+{
         WERROR werr;
+        sbcErr err;
         bool found;
         uint32_t share_index, param_index;
         werr = smbconf_txt_load_file(ctx);
         if (!W_ERROR_IS_OK(werr)) {
                 return werr;
+        err = smbconf_txt_load_file(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
 …
                                       &share_index);
         if (!found) {
                 return WERR_NO_SUCH_SERVICE;
+                return SBC_ERR_NO_SUCH_SERVICE;
+        }
 …
                                 &param_index);
         if (!found) {
                 return WERR_INVALID_PARAM;
+                return SBC_ERR_INVALID_PARAM;
+        }
 …
         if (*valstr == NULL) {
                 return WERR_NOMEM;
+        }
         return WERR_OK;
+                return SBC_ERR_NOMEM;
+        }
+        return SBC_ERR_OK;
+}
 …
  * delete a parameter from configuration
  */
 static WERROR smbconf_txt_delete_parameter(struct smbconf_ctx *ctx,
+static sbcErr smbconf_txt_delete_parameter(struct smbconf_ctx *ctx,
                                            const char *service,
                                            const char *param)
+{
         return WERR_NOT_SUPPORTED;
+}
 static WERROR smbconf_txt_get_includes(struct smbconf_ctx *ctx,
+        return SBC_ERR_NOT_SUPPORTED;
+}
+static sbcErr smbconf_txt_get_includes(struct smbconf_ctx *ctx,
                                        TALLOC_CTX *mem_ctx,
                                        const char *service,
 …
                                        char ***includes)
+{
         WERROR werr;
+        sbcErr err;
         bool found;
         uint32_t sidx, count;
 …
         char **tmp_includes = NULL;
         werr = smbconf_txt_load_file(ctx);
         if (!W_ERROR_IS_OK(werr)) {
                 return werr;
+        err = smbconf_txt_load_file(ctx);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }
 …
                                       &sidx);
         if (!found) {
                 return WERR_NO_SUCH_SERVICE;
+                return SBC_ERR_NO_SUCH_SERVICE;
+        }
 …
                              "include"))
+                {
                         werr = smbconf_add_string_to_array(tmp_ctx,
+                        err = smbconf_add_string_to_array(tmp_ctx,
                                 &tmp_includes,
                                 tmp_num_includes,
                                 pd(ctx)->cache->param_values[sidx][count]);
                         if (!W_ERROR_IS_OK(werr)) {
+                        if (!SBC_ERROR_IS_OK(err)) {
                                 goto done;
+                        }
 …
                 *includes = talloc_move(mem_ctx, &tmp_includes);
                 if (*includes == NULL) {
                         werr = WERR_NOMEM;
+                        err = SBC_ERR_NOMEM;
                         goto done;
+                }
 …
+        }
         werr = WERR_OK;
+        err = SBC_ERR_OK;
 done:
         talloc_free(tmp_ctx);
         return werr;
+}
 static WERROR smbconf_txt_set_includes(struct smbconf_ctx *ctx,
+        return err;
+}
+static sbcErr smbconf_txt_set_includes(struct smbconf_ctx *ctx,
                                        const char *service,
                                        uint32_t num_includes,
                                        const char **includes)
+{
         return WERR_NOT_SUPPORTED;
+}
 static WERROR smbconf_txt_delete_includes(struct smbconf_ctx *ctx,
+        return SBC_ERR_NOT_SUPPORTED;
+}
+static sbcErr smbconf_txt_delete_includes(struct smbconf_ctx *ctx,
                                           const char *service)
+{
         return WERR_NOT_SUPPORTED;
+}
 static WERROR smbconf_txt_transaction_start(struct smbconf_ctx *ctx)
+{
         return WERR_OK;
+}
 static WERROR smbconf_txt_transaction_commit(struct smbconf_ctx *ctx)
+{
         return WERR_OK;
+}
 static WERROR smbconf_txt_transaction_cancel(struct smbconf_ctx *ctx)
+{
         return WERR_OK;
+        return SBC_ERR_NOT_SUPPORTED;
+}
+static sbcErr smbconf_txt_transaction_start(struct smbconf_ctx *ctx)
+{
+        return SBC_ERR_OK;
+}
+static sbcErr smbconf_txt_transaction_commit(struct smbconf_ctx *ctx)
+{
+        return SBC_ERR_OK;
+}
+static sbcErr smbconf_txt_transaction_cancel(struct smbconf_ctx *ctx)
+{
+        return SBC_ERR_OK;
+}
 …
  * the only function that is exported from this module
  */
 WERROR smbconf_init_txt(TALLOC_CTX *mem_ctx,
+sbcErr smbconf_init_txt(TALLOC_CTX *mem_ctx,
                         struct smbconf_ctx **conf_ctx,
                         const char *path)
+{
         WERROR werr;
         werr = smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_txt);
         if (!W_ERROR_IS_OK(werr)) {
                 return werr;
+        sbcErr err;
+        err = smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_txt);
+        if (!SBC_ERROR_IS_OK(err)) {
+                return err;
+        }

vendor/current/lib/smbconf/smbconf_txt.h

r414	r740
27	27	*/
28	28
29		~~WERROR~~ smbconf_init_txt(TALLOC_CTX *mem_ctx,
	29	sbcErr smbconf_init_txt(TALLOC_CTX *mem_ctx,
30	30	struct smbconf_ctx **conf_ctx,
31	31	const char *path);

vendor/current/lib/smbconf/smbconf_util.c

-              r414
+              r740
  * should be called.
  */
 WERROR smbconf_init_internal(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
+sbcErr smbconf_init_internal(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
                              const char *path, struct smbconf_ops *ops)
+{
         WERROR werr = WERR_OK;
+        sbcErr err = SBC_ERR_OK;
         struct smbconf_ctx *ctx;
         if (conf_ctx == NULL) {
                 return WERR_INVALID_PARAM;
+                return SBC_ERR_INVALID_PARAM;
+        }
         ctx = talloc_zero(mem_ctx, struct smbconf_ctx);
         if (ctx == NULL) {
                 return WERR_NOMEM;
+                return SBC_ERR_NOMEM;
+        }
         ctx->ops = ops;
         werr = ctx->ops->init(ctx, path);
         if (!W_ERROR_IS_OK(werr)) {
+        err = ctx->ops->init(ctx, path);
+        if (!SBC_ERROR_IS_OK(err)) {
                 goto fail;
+        }
 …
         *conf_ctx = ctx;
         return werr;
+        return err;
 fail:
         talloc_free(ctx);
         return werr;
+        return err;
+}
 …
  * add a string to a talloced array of strings.
  */
 WERROR smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
+sbcErr smbconf_add_string_to_array(TALLOC_CTX *mem_ctx,
                                    char ***array,
                                    uint32_t count,
 …
         if (array == NULL) {
                 return WERR_INVALID_PARAM;
+                return SBC_ERR_INVALID_PARAM;
+        }
         new_array = talloc_realloc(mem_ctx, *array, char *, count + 1);
         if (new_array == NULL) {
                 return WERR_NOMEM;
+                return SBC_ERR_NOMEM;
+        }
 …
                 if (new_array[count] == NULL) {
                         talloc_free(new_array);
                         return WERR_NOMEM;
+                        return SBC_ERR_NOMEM;
+                }
+        }
 …
         *array = new_array;
         return WERR_OK;
+        return SBC_ERR_OK;
+}

vendor/current/lib/socket_wrapper/socket_wrapper.c

-              r414
+              r740
         case SOCKET_TYPE_CHAR_TCP:
         case SOCKET_TYPE_CHAR_UDP: {
                 struct sockaddr_in *in2 = (struct sockaddr_in *)in;
+                struct sockaddr_in *in2 = (struct sockaddr_in *)(void *)in;
                 if ((*len) < sizeof(*in2)) {
                     errno = EINVAL;
 …
         case SOCKET_TYPE_CHAR_TCP_V6:
         case SOCKET_TYPE_CHAR_UDP_V6: {
                 struct sockaddr_in6 *in2 = (struct sockaddr_in6 *)in;
+                struct sockaddr_in6 *in2 = (struct sockaddr_in6 *)(void *)in;
                 if ((*len) < sizeof(*in2)) {
                         errno = EINVAL;
 …
         case AF_INET: {
                 const struct sockaddr_in *in =
                     (const struct sockaddr_in *)inaddr;
+                    (const struct sockaddr_in *)(const void *)inaddr;
                 unsigned int addr = ntohl(in->sin_addr.s_addr);
                 char u_type = '\0';
 …
         case AF_INET6: {
                 const struct sockaddr_in6 *in =
                     (const struct sockaddr_in6 *)inaddr;
                 struct in6_addr cmp;
+                    (const struct sockaddr_in6 *)(const void *)inaddr;
+                struct in6_addr cmp1, cmp2;
                 switch (si->type) {
 …
                 prt = ntohs(in->sin6_port);
+                cmp = in->sin6_addr;
+                cmp.s6_addr[15] = 0;
+                if (IN6_ARE_ADDR_EQUAL(swrap_ipv6(), &cmp)) {
+                cmp1 = *swrap_ipv6();
+                cmp2 = in->sin6_addr;
+                cmp2.s6_addr[15] = 0;
+                if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
                         iface = in->sin6_addr.s6_addr[15];
                 } else {
 …
         case AF_INET: {
                 const struct sockaddr_in *in =
                     (const struct sockaddr_in *)inaddr;
+                    (const struct sockaddr_in *)(const void *)inaddr;
                 unsigned int addr = ntohl(in->sin_addr.s_addr);
                 char u_type = '\0';
 …
         case AF_INET6: {
                 const struct sockaddr_in6 *in =
                     (const struct sockaddr_in6 *)inaddr;
                 struct in6_addr cmp;
+                    (const struct sockaddr_in6 *)(const void *)inaddr;
+                struct in6_addr cmp1, cmp2;
                 switch (si->type) {
 …
                 prt = ntohs(in->sin6_port);
+                cmp = in->sin6_addr;
+                cmp.s6_addr[15] = 0;
+                cmp1 = *swrap_ipv6();
+                cmp2 = in->sin6_addr;
+                cmp2.s6_addr[15] = 0;
                 if (IN6_IS_ADDR_UNSPECIFIED(&in->sin6_addr)) {
                         iface = socket_wrapper_default_iface();
                 } else if (IN6_ARE_ADDR_EQUAL(swrap_ipv6(), &cmp)) {
+                } else if (IN6_ARE_ADDR_EQUAL(&cmp1, &cmp2)) {
                         iface = in->sin6_addr.s6_addr[15];
                 } else {
 …
                                   struct sockaddr_un *out_addr, int alloc_sock, int *bcast)
+{
+        struct sockaddr *out = (struct sockaddr *)(void *)out_addr;
         if (!out_addr)
                 return 0;
+        out_addr->sun_family = AF_UNIX;
+        out->sa_family = AF_UNIX;
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        out->sa_len = sizeof(*out_addr);
+#endif
         switch (in_addr->sa_family) {
 …
                 break;
+        }
         errno = EAFNOSUPPORT;
         return -1;
 …
                                     socklen_t *out_addrlen)
+{
+        int ret;
         if (out_addr == NULL || out_addrlen == NULL)
                 return 0;
 …
                         return -1;
+                }
+                return convert_un_in(in_addr, out_addr, out_addrlen);
+                ret = convert_un_in(in_addr, out_addr, out_addrlen);
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+                out_addr->sa_len = *out_addrlen;
+#endif
+                return ret;
         default:
                 break;
 …
                 ip->v6.flow_label_high  = 0x00;
                 ip->v6.flow_label_low   = 0x0000;
                 ip->v6.payload_length   = htons(wire_len - icmp_truncate_len);//TODO
+                ip->v6.payload_length   = htons(wire_len - icmp_truncate_len); /* TODO */
                 ip->v6.next_header      = protocol;
                 memcpy(ip->v6.src_addr, src_in6->sin6_addr.s6_addr, 16);
 …
                         ip->v6.flow_label_high  = 0x00;
                         ip->v6.flow_label_low   = 0x0000;
                         ip->v6.payload_length   = htons(wire_len - icmp_truncate_len);//TODO
+                        ip->v6.payload_length   = htons(wire_len - icmp_truncate_len); /* TODO */
                         ip->v6.next_header      = protocol;
                         memcpy(ip->v6.src_addr, dest_in6->sin6_addr.s6_addr, 16);
 …
         memset(&un_my_addr, 0, sizeof(un_my_addr));
         ret = real_accept(s, (struct sockaddr *)&un_addr, &un_addrlen);
+        ret = real_accept(s, (struct sockaddr *)(void *)&un_addr, &un_addrlen);
         if (ret == -1) {
                 free(my_addr);
 …
         if (addr != NULL && addrlen != NULL) {
+            *addrlen = len;
+            if (*addrlen >= len)
+                memcpy(addr, my_addr, len);
+            *addrlen = 0;
+        }
+        ret = real_getsockname(fd, (struct sockaddr *)&un_my_addr, &un_my_addrlen);
+                size_t copy_len = MIN(*addrlen, len);
+                if (copy_len > 0) {
+                        memcpy(addr, my_addr, copy_len);
+                }
+                *addrlen = len;
+        }
+        ret = real_getsockname(fd, (struct sockaddr *)(void *)&un_my_addr,
+                               &un_my_addrlen);
         if (ret == -1) {
                 free(child_si);
 …
                          type, socket_wrapper_default_iface(), port);
                 if (stat(un_addr.sun_path, &st) == 0) continue;
+                ret = real_bind(si->fd, (struct sockaddr *)&un_addr, sizeof(un_addr));
+                ret = real_bind(si->fd, (struct sockaddr *)(void *)&un_addr,
+                                sizeof(un_addr));
                 if (ret == -1) return ret;
 …
         struct sockaddr_un un_addr;
         struct socket_info *si = find_socket_info(s);
+        int bcast = 0;
         if (!si) {
 …
+        }
+        ret = sockaddr_convert_to_un(si, (const struct sockaddr *)serv_addr, addrlen, &un_addr, 0, NULL);
+        ret = sockaddr_convert_to_un(si, serv_addr,
+                                     addrlen, &un_addr, 0, &bcast);
         if (ret == -1) return -1;
+        if (bcast) {
+                errno = ENETUNREACH;
+                return -1;
+        }
         if (si->type == SOCK_DGRAM) {
 …
                 swrap_dump_packet(si, serv_addr, SWRAP_CONNECT_SEND, NULL, 0);
                 ret = real_connect(s, (struct sockaddr *)&un_addr,
+                ret = real_connect(s, (struct sockaddr *)(void *)&un_addr,
                                    sizeof(struct sockaddr_un));
+        }
 …
         si->myname = sockaddr_dup(myaddr, addrlen);
         ret = sockaddr_convert_to_un(si, (const struct sockaddr *)myaddr, addrlen, &un_addr, 1, &si->bcast);
+        ret = sockaddr_convert_to_un(si, myaddr, addrlen, &un_addr, 1, &si->bcast);
         if (ret == -1) return -1;
         unlink(un_addr.sun_path);
         ret = real_bind(s, (struct sockaddr *)&un_addr,
+        ret = real_bind(s, (struct sockaddr *)(void *)&un_addr,
                         sizeof(struct sockaddr_un));
 …
                 return -1;
+        }
+}
-_PUBLIC_ ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
+{
-        struct sockaddr_un un_addr;
-        socklen_t un_addrlen = sizeof(un_addr);
-        int ret;
-        struct socket_info *si = find_socket_info(s);
-        struct sockaddr_storage ss;
-        socklen_t ss_len = sizeof(ss);
-        if (!si) {
-                return real_recvfrom(s, buf, len, flags, from, fromlen);
+        }
-        if (!from) {
-                from = (struct sockaddr *)&ss;
-                fromlen = &ss_len;
+        }
-        if (si->type == SOCK_STREAM) {
-                /* cut down to 1500 byte packets for stream sockets,
-                 * which makes it easier to format PCAP capture files
-                 * (as the caller will simply continue from here) */
-                len = MIN(len, 1500);
+        }
-        /* irix 6.4 forgets to null terminate the sun_path string :-( */
-        memset(&un_addr, 0, sizeof(un_addr));
-        ret = real_recvfrom(s, buf, len, flags, (struct sockaddr *)&un_addr, &un_addrlen);
-        if (ret == -1)
-                return ret;
-        if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
-                                     si->family, from, fromlen) == -1) {
-                return -1;
+        }
-        swrap_dump_packet(si, from, SWRAP_RECVFROM, buf, ret);
-        return ret;
+}
-_PUBLIC_ ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
+{
-        struct sockaddr_un un_addr;
-        int ret;
-        struct socket_info *si = find_socket_info(s);
-        int bcast = 0;
-        if (!si) {
-                return real_sendto(s, buf, len, flags, to, tolen);
+        }
-        if (si->connected) {
-                if (to) {
-                        errno = EISCONN;
-                        return -1;
+                }
-                to = si->peername;
-                tolen = si->peername_len;
+        }
-        switch (si->type) {
-        case SOCK_STREAM:
-                /* cut down to 1500 byte packets for stream sockets,
-                 * which makes it easier to format PCAP capture files
-                 * (as the caller will simply continue from here) */
-                len = MIN(len, 1500);
-                ret = real_send(s, buf, len, flags);
-                break;
-        case SOCK_DGRAM:
-                if (si->bound == 0) {
-                        ret = swrap_auto_bind(si, si->family);
-                        if (ret == -1) return -1;
+                }
-                ret = sockaddr_convert_to_un(si, to, tolen, &un_addr, 0, &bcast);
-                if (ret == -1) return -1;
-                if (bcast) {
-                        struct stat st;
-                        unsigned int iface;
-                        unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
-                        char type;
-                        type = SOCKET_TYPE_CHAR_UDP;
-                        for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
-                                snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
-                                         socket_wrapper_dir(), type, iface, prt);
-                                if (stat(un_addr.sun_path, &st) != 0) continue;
-                                /* ignore the any errors in broadcast sends */
-                                real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
+                        }
-                        swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
-                        return len;
+                }
-                if (si->defer_connect) {
-                        ret = real_connect(s, (struct sockaddr *)&un_addr,
-                                           sizeof(un_addr));
-                        /* to give better errors */
-                        if (ret == -1 && errno == ENOENT) {
-                                errno = EHOSTUNREACH;
+                        }
-                        if (ret == -1) {
-                                return ret;
+                        }
-                        si->defer_connect = 0;
+                }
-                ret = real_sendto(s, buf, len, flags, (struct sockaddr *)&un_addr, sizeof(un_addr));
-                break;
-        default:
-                ret = -1;
-                errno = EHOSTUNREACH;
-                break;
+        }
-        /* to give better errors */
-        if (ret == -1 && errno == ENOENT) {
-                errno = EHOSTUNREACH;
+        }
-        if (ret == -1) {
-                swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
-                swrap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
-        } else {
-                swrap_dump_packet(si, to, SWRAP_SENDTO, buf, ret);
+        }
-        return ret;
+}
 …
+}
+static ssize_t swrap_sendmsg_before(struct socket_info *si,
+                                    struct msghdr *msg,
+                                    struct iovec *tmp_iov,
+                                    struct sockaddr_un *tmp_un,
+                                    const struct sockaddr_un **to_un,
+                                    const struct sockaddr **to,
+                                    int *bcast)
+{
+        size_t i, len = 0;
+        ssize_t ret;
+        if (to_un) {
+                *to_un = NULL;
+        }
+        if (to) {
+                *to = NULL;
+        }
+        if (bcast) {
+                *bcast = 0;
+        }
+        switch (si->type) {
+        case SOCK_STREAM:
+                if (!si->connected) {
+                        errno = ENOTCONN;
+                        return -1;
+                }
+                if (msg->msg_iovlen == 0) {
+                        break;
+                }
+                /*
+                 * cut down to 1500 byte packets for stream sockets,
+                 * which makes it easier to format PCAP capture files
+                 * (as the caller will simply continue from here)
+                 */
+                for (i=0; i < msg->msg_iovlen; i++) {
+                        size_t nlen;
+                        nlen = len + msg->msg_iov[i].iov_len;
+                        if (nlen > 1500) {
+                                break;
+                        }
+                }
+                msg->msg_iovlen = i;
+                if (msg->msg_iovlen == 0) {
+                        *tmp_iov = msg->msg_iov[0];
+                        tmp_iov->iov_len = MIN(tmp_iov->iov_len, 1500);
+                        msg->msg_iov = tmp_iov;
+                        msg->msg_iovlen = 1;
+                }
+                break;
+        case SOCK_DGRAM:
+                if (si->connected) {
+                        if (msg->msg_name) {
+                                errno = EISCONN;
+                                return -1;
+                        }
+                } else {
+                        const struct sockaddr *msg_name;
+                        msg_name = (const struct sockaddr *)msg->msg_name;
+                        if (msg_name == NULL) {
+                                errno = ENOTCONN;
+                                return -1;
+                        }
+                        ret = sockaddr_convert_to_un(si, msg_name, msg->msg_namelen,
+                                                     tmp_un, 0, bcast);
+                        if (ret == -1) return -1;
+                        if (to_un) {
+                                *to_un = tmp_un;
+                        }
+                        if (to) {
+                                *to = msg_name;
+                        }
+                        msg->msg_name = tmp_un;
+                        msg->msg_namelen = sizeof(*tmp_un);
+                }
+                if (si->bound == 0) {
+                        ret = swrap_auto_bind(si, si->family);
+                        if (ret == -1) return -1;
+                }
+                if (!si->defer_connect) {
+                        break;
+                }
+                ret = sockaddr_convert_to_un(si, si->peername, si->peername_len,
+                                             tmp_un, 0, NULL);
+                if (ret == -1) return -1;
+                ret = real_connect(si->fd, (struct sockaddr *)(void *)tmp_un,
+                                   sizeof(*tmp_un));
+                /* to give better errors */
+                if (ret == -1 && errno == ENOENT) {
+                        errno = EHOSTUNREACH;
+                }
+                if (ret == -1) {
+                        return ret;
+                }
+                si->defer_connect = 0;
+                break;
+        default:
+                errno = EHOSTUNREACH;
+                return -1;
+        }
+        return 0;
+}
+static void swrap_sendmsg_after(struct socket_info *si,
+                                struct msghdr *msg,
+                                const struct sockaddr *to,
+                                ssize_t ret)
+{
+        int saved_errno = errno;
+        size_t i, len = 0;
+        uint8_t *buf;
+        off_t ofs = 0;
+        size_t avail = 0;
+        size_t remain;
+        /* to give better errors */
+        if (ret == -1 && saved_errno == ENOENT) {
+                saved_errno = EHOSTUNREACH;
+        }
+        for (i=0; i < msg->msg_iovlen; i++) {
+                avail += msg->msg_iov[i].iov_len;
+        }
+        if (ret == -1) {
+                remain = MIN(80, avail);
+        } else {
+                remain = ret;
+        }
+        /* we capture it as one single packet */
+        buf = (uint8_t *)malloc(remain);
+        if (!buf) {
+                /* we just not capture the packet */
+                errno = saved_errno;
+                return;
+        }
+        for (i=0; i < msg->msg_iovlen; i++) {
+                size_t this_time = MIN(remain, msg->msg_iov[i].iov_len);
+                memcpy(buf + ofs,
+                       msg->msg_iov[i].iov_base,
+                       this_time);
+                ofs += this_time;
+                remain -= this_time;
+        }
+        len = ofs;
+        switch (si->type) {
+        case SOCK_STREAM:
+                if (ret == -1) {
+                        swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
+                        swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
+                } else {
+                        swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
+                }
+                break;
+        case SOCK_DGRAM:
+                if (si->connected) {
+                        to = si->peername;
+                }
+                if (ret == -1) {
+                        swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
+                        swrap_dump_packet(si, to, SWRAP_SENDTO_UNREACH, buf, len);
+                } else {
+                        swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
+                }
+                break;
+        }
+        free(buf);
+        errno = saved_errno;
+}
+_PUBLIC_ ssize_t swrap_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
+{
+        struct sockaddr_un un_addr;
+        socklen_t un_addrlen = sizeof(un_addr);
+        int ret;
+        struct socket_info *si = find_socket_info(s);
+        struct sockaddr_storage ss;
+        socklen_t ss_len = sizeof(ss);
+        if (!si) {
+                return real_recvfrom(s, buf, len, flags, from, fromlen);
+        }
+        if (!from) {
+                from = (struct sockaddr *)(void *)&ss;
+                fromlen = &ss_len;
+        }
+        if (si->type == SOCK_STREAM) {
+                /* cut down to 1500 byte packets for stream sockets,
+                 * which makes it easier to format PCAP capture files
+                 * (as the caller will simply continue from here) */
+                len = MIN(len, 1500);
+        }
+        /* irix 6.4 forgets to null terminate the sun_path string :-( */
+        memset(&un_addr, 0, sizeof(un_addr));
+        ret = real_recvfrom(s, buf, len, flags,
+                            (struct sockaddr *)(void *)&un_addr, &un_addrlen);
+        if (ret == -1)
+                return ret;
+        if (sockaddr_convert_from_un(si, &un_addr, un_addrlen,
+                                     si->family, from, fromlen) == -1) {
+                return -1;
+        }
+        swrap_dump_packet(si, from, SWRAP_RECVFROM, buf, ret);
+        return ret;
+}
+_PUBLIC_ ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen)
+{
+        struct msghdr msg;
+        struct iovec tmp;
+        struct sockaddr_un un_addr;
+        const struct sockaddr_un *to_un = NULL;
+        ssize_t ret;
+        struct socket_info *si = find_socket_info(s);
+        int bcast = 0;
+        if (!si) {
+                return real_sendto(s, buf, len, flags, to, tolen);
+        }
+        tmp.iov_base = discard_const_p(char, buf);
+        tmp.iov_len = len;
+        ZERO_STRUCT(msg);
+        msg.msg_name = discard_const_p(struct sockaddr, to); /* optional address */
+        msg.msg_namelen = tolen;       /* size of address */
+        msg.msg_iov = &tmp;            /* scatter/gather array */
+        msg.msg_iovlen = 1;            /* # elements in msg_iov */
+#if 0 /* not available on solaris */
+        msg.msg_control = NULL;        /* ancillary data, see below */
+        msg.msg_controllen = 0;        /* ancillary data buffer len */
+        msg.msg_flags = 0;             /* flags on received message */
+#endif
+        ret = swrap_sendmsg_before(si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
+        if (ret == -1) return -1;
+        buf = msg.msg_iov[0].iov_base;
+        len = msg.msg_iov[0].iov_len;
+        if (bcast) {
+                struct stat st;
+                unsigned int iface;
+                unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
+                char type;
+                type = SOCKET_TYPE_CHAR_UDP;
+                for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
+                        snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
+                                 socket_wrapper_dir(), type, iface, prt);
+                        if (stat(un_addr.sun_path, &st) != 0) continue;
+                        /* ignore the any errors in broadcast sends */
+                        real_sendto(s, buf, len, flags,
+                                    (struct sockaddr *)(void *)&un_addr,
+                                    sizeof(un_addr));
+                }
+                swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
+                return len;
+        }
+        ret = real_sendto(s, buf, len, flags, msg.msg_name, msg.msg_namelen);
+        swrap_sendmsg_after(si, &msg, to, ret);
+        return ret;
+}
 _PUBLIC_ ssize_t swrap_recv(int s, void *buf, size_t len, int flags)
+{
 …
 _PUBLIC_ ssize_t swrap_send(int s, const void *buf, size_t len, int flags)
+{
+        int ret;
+        struct msghdr msg;
+        struct iovec tmp;
+        struct sockaddr_un un_addr;
+        ssize_t ret;
         struct socket_info *si = find_socket_info(s);
 …
+        }
+        if (si->type == SOCK_STREAM) {
+                /* cut down to 1500 byte packets for stream sockets,
+                 * which makes it easier to format PCAP capture files
+                 * (as the caller will simply continue from here) */
+                len = MIN(len, 1500);
+        }
+        if (si->defer_connect) {
+                struct sockaddr_un un_addr;
+                int bcast = 0;
+                if (si->bound == 0) {
+                        ret = swrap_auto_bind(si, si->family);
+                        if (ret == -1) return -1;
+                }
+                ret = sockaddr_convert_to_un(si, si->peername, si->peername_len,
+                                             &un_addr, 0, &bcast);
+                if (ret == -1) return -1;
+                ret = real_connect(s, (struct sockaddr *)&un_addr,
+                                   sizeof(un_addr));
+                /* to give better errors */
+                if (ret == -1 && errno == ENOENT) {
+                        errno = EHOSTUNREACH;
+                }
+                if (ret == -1) {
+                        return ret;
+                }
+                si->defer_connect = 0;
+        }
+        tmp.iov_base = discard_const_p(char, buf);
+        tmp.iov_len = len;
+        ZERO_STRUCT(msg);
+        msg.msg_name = NULL;           /* optional address */
+        msg.msg_namelen = 0;           /* size of address */
+        msg.msg_iov = &tmp;            /* scatter/gather array */
+        msg.msg_iovlen = 1;            /* # elements in msg_iov */
+#if 0 /* not available on solaris */
+        msg.msg_control = NULL;        /* ancillary data, see below */
+        msg.msg_controllen = 0;        /* ancillary data buffer len */
+        msg.msg_flags = 0;             /* flags on received message */
+#endif
+        ret = swrap_sendmsg_before(si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
+        if (ret == -1) return -1;
+        buf = msg.msg_iov[0].iov_base;
+        len = msg.msg_iov[0].iov_len;
         ret = real_send(s, buf, len, flags);
+        if (ret == -1) {
+                swrap_dump_packet(si, NULL, SWRAP_SEND, buf, len);
+                swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
+        } else {
+                swrap_dump_packet(si, NULL, SWRAP_SEND, buf, ret);
+        }
+        swrap_sendmsg_after(si, &msg, NULL, ret);
         return ret;
+}
 _PUBLIC_ ssize_t swrap_sendmsg(int s, const struct msghdr *msg, int flags)
+{
         int ret;
         uint8_t *buf;
         off_t ofs = 0;
         size_t i;
         size_t remain;
+_PUBLIC_ ssize_t swrap_sendmsg(int s, const struct msghdr *omsg, int flags)
+{
+        struct msghdr msg;
+        struct iovec tmp;
+        struct sockaddr_un un_addr;
+        const struct sockaddr_un *to_un = NULL;
+        const struct sockaddr *to = NULL;
+        ssize_t ret;
         struct socket_info *si = find_socket_info(s);
+        int bcast = 0;
         if (!si) {
+                return real_sendmsg(s, msg, flags);
+        }
+        if (si->defer_connect) {
+                struct sockaddr_un un_addr;
+                int bcast = 0;
+                if (si->bound == 0) {
+                        ret = swrap_auto_bind(si, si->family);
+                        if (ret == -1) return -1;
+                }
+                ret = sockaddr_convert_to_un(si, si->peername, si->peername_len,
+                                             &un_addr, 0, &bcast);
+                if (ret == -1) return -1;
+                ret = real_connect(s, (struct sockaddr *)&un_addr,
+                                   sizeof(un_addr));
+                /* to give better errors */
+                if (ret == -1 && errno == ENOENT) {
+                        errno = EHOSTUNREACH;
+                }
+                if (ret == -1) {
+                        return ret;
+                }
+                si->defer_connect = 0;
+        }
+        ret = real_sendmsg(s, msg, flags);
+        remain = ret;
+        /* we capture it as one single packet */
+        buf = (uint8_t *)malloc(ret);
+        if (!buf) {
+                /* we just not capture the packet */
+                errno = 0;
+                return ret;
+        }
+        for (i=0; i < msg->msg_iovlen; i++) {
+                size_t this_time = MIN(remain, msg->msg_iov[i].iov_len);
+                memcpy(buf + ofs,
+                       msg->msg_iov[i].iov_base,
+                       this_time);
+                ofs += this_time;
+                remain -= this_time;
+        }
+        swrap_dump_packet(si, NULL, SWRAP_SEND, buf, ret);
+        free(buf);
+        if (ret == -1) {
+                swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
+        }
+                return real_sendmsg(s, omsg, flags);
+        }
+        tmp.iov_base = NULL;
+        tmp.iov_len = 0;
+        msg = *omsg;
+#if 0
+        msg.msg_name = omsg->msg_name;             /* optional address */
+        msg.msg_namelen = omsg->msg_namelen;       /* size of address */
+        msg.msg_iov = omsg->msg_iov;               /* scatter/gather array */
+        msg.msg_iovlen = omsg->msg_iovlen;         /* # elements in msg_iov */
+        /* the following is not available on solaris */
+        msg.msg_control = omsg->msg_control;       /* ancillary data, see below */
+        msg.msg_controllen = omsg->msg_controllen; /* ancillary data buffer len */
+        msg.msg_flags = omsg->msg_flags;           /* flags on received message */
+#endif
+        ret = swrap_sendmsg_before(si, &msg, &tmp, &un_addr, &to_un, &to, &bcast);
+        if (ret == -1) return -1;
+        if (bcast) {
+                struct stat st;
+                unsigned int iface;
+                unsigned int prt = ntohs(((const struct sockaddr_in *)to)->sin_port);
+                char type;
+                size_t i, len = 0;
+                uint8_t *buf;
+                off_t ofs = 0;
+                size_t avail = 0;
+                size_t remain;
+                for (i=0; i < msg.msg_iovlen; i++) {
+                        avail += msg.msg_iov[i].iov_len;
+                }
+                len = avail;
+                remain = avail;
+                /* we capture it as one single packet */
+                buf = (uint8_t *)malloc(remain);
+                if (!buf) {
+                        return -1;
+                }
+                for (i=0; i < msg.msg_iovlen; i++) {
+                        size_t this_time = MIN(remain, msg.msg_iov[i].iov_len);
+                        memcpy(buf + ofs,
+                               msg.msg_iov[i].iov_base,
+                               this_time);
+                        ofs += this_time;
+                        remain -= this_time;
+                }
+                type = SOCKET_TYPE_CHAR_UDP;
+                for(iface=0; iface <= MAX_WRAPPED_INTERFACES; iface++) {
+                        snprintf(un_addr.sun_path, sizeof(un_addr.sun_path), "%s/"SOCKET_FORMAT,
+                                 socket_wrapper_dir(), type, iface, prt);
+                        if (stat(un_addr.sun_path, &st) != 0) continue;
+                        msg.msg_name = &un_addr;           /* optional address */
+                        msg.msg_namelen = sizeof(un_addr); /* size of address */
+                        /* ignore the any errors in broadcast sends */
+                        real_sendmsg(s, &msg, flags);
+                }
+                swrap_dump_packet(si, to, SWRAP_SENDTO, buf, len);
+                free(buf);
+                return len;
+        }
+        ret = real_sendmsg(s, &msg, flags);
+        swrap_sendmsg_after(si, &msg, to, ret);
         return ret;
 …
         if (!si) {
                 return real_readv(s, vector, count);
+        }
+        if (!si->connected) {
+                errno = ENOTCONN;
+                return -1;
+        }
 …
                  * (as the caller will simply continue from here) */
                 size_t i, len = 0;
                 for (i=0; i < count; i++) {
                         size_t nlen;
 …
 int swrap_writev(int s, const struct iovec *vector, size_t count)
+{
+        int ret;
+        struct msghdr msg;
+        struct iovec tmp;
+        struct sockaddr_un un_addr;
+        ssize_t ret;
         struct socket_info *si = find_socket_info(s);
-        struct iovec v;
         if (!si) {
 …
+        }
+        if (si->type == SOCK_STREAM && count > 0) {
+                /* cut down to 1500 byte packets for stream sockets,
+                 * which makes it easier to format PCAP capture files
+                 * (as the caller will simply continue from here) */
+                size_t i, len = 0;
+                for (i=0; i < count; i++) {
+                        size_t nlen;
+                        nlen = len + vector[i].iov_len;
+                        if (nlen > 1500) {
+                                break;
+                        }
+                }
+                count = i;
+                if (count == 0) {
+                        v = vector[0];
+                        v.iov_len = MIN(v.iov_len, 1500);
+                        vector = &v;
+                        count = 1;
+                }
+        }
+        ret = real_writev(s, vector, count);
+        if (ret == -1) {
+                swrap_dump_packet(si, NULL, SWRAP_SEND_RST, NULL, 0);
+        } else {
+                uint8_t *buf;
+                off_t ofs = 0;
+                size_t i;
+                size_t remain = ret;
+                /* we capture it as one single packet */
+                buf = (uint8_t *)malloc(ret);
+                if (!buf) {
+                        /* we just not capture the packet */
+                        errno = 0;
+                        return ret;
+                }
+                for (i=0; i < count; i++) {
+                        size_t this_time = MIN(remain, vector[i].iov_len);
+                        memcpy(buf + ofs,
+                               vector[i].iov_base,
+                               this_time);
+                        ofs += this_time;
+                        remain -= this_time;
+                }
+                swrap_dump_packet(si, NULL, SWRAP_SEND, buf, ret);
+                free(buf);
+        }
+        tmp.iov_base = NULL;
+        tmp.iov_len = 0;
+        ZERO_STRUCT(msg);
+        msg.msg_name = NULL;           /* optional address */
+        msg.msg_namelen = 0;           /* size of address */
+        msg.msg_iov = discard_const_p(struct iovec, vector); /* scatter/gather array */
+        msg.msg_iovlen = count;        /* # elements in msg_iov */
+#if 0 /* not available on solaris */
+        msg.msg_control = NULL;        /* ancillary data, see below */
+        msg.msg_controllen = 0;        /* ancillary data buffer len */
+        msg.msg_flags = 0;             /* flags on received message */
+#endif
+        ret = swrap_sendmsg_before(si, &msg, &tmp, &un_addr, NULL, NULL, NULL);
+        if (ret == -1) return -1;
+        ret = real_writev(s, msg.msg_iov, msg.msg_iovlen);
+        swrap_sendmsg_after(si, &msg, NULL, ret);
         return ret;

vendor/current/lib/socket_wrapper/socket_wrapper.h

-              r414
+              r740
 ssize_t swrap_sendto(int s, const void *buf, size_t len, int flags, const struct sockaddr *to, socklen_t tolen);
 ssize_t swrap_sendmsg(int s, const struct msghdr *msg, int flags);
+ssize_t swrap_recvmsg(int s, struct msghdr *msg, int flags);
 int swrap_ioctl(int s, int req, void *ptr);
 ssize_t swrap_recv(int s, void *buf, size_t len, int flags);
 …
 #define sendmsg(s,msg,flags)            swrap_sendmsg(s,msg,flags)
+#ifdef recvmsg
+#undef recvmsg
+#endif
+#define recvmsg(s,msg,flags)            swrap_recvmsg(s,msg,flags)
 #ifdef ioctl
 #undef ioctl

vendor/current/lib/socket_wrapper/testsuite.c

r414	r740
96	96	{
97	97	struct torture_suite *suite = torture_suite_create(mem_ctx,
98		"~~SOCKET-WRAPPER~~");
	98	"socket-wrapper");
99	99
100	100	torture_suite_add_simple_test(suite, "socket_wrapper_dir", test_socket_wrapper_dir);

vendor/current/lib/subunit/python/subunit/init.py

-              r414
+              r740
+#
 #  subunit: extensions to python unittest to get test results from subprocesses.
+#  subunit: extensions to Python unittest to get test results from subprocesses.
 #  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
-#  Copyright (C) 2007  Jelmer Vernooij <jelmer@samba.org>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 3 of the License, or
+#  (at your option) any later version.
+#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
+#  license at the users choice. A copy of both licenses are available in the
+#  project source as Apache-2.0 and BSD. You may not use this file except in
+#  compliance with one of these two licences.
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+#  license you chose for the specific language governing permissions and
+#  limitations under that license.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+"""Subunit - a streaming test protocol
+Overview
+++++++++
+The ``subunit`` Python package provides a number of ``unittest`` extensions
+which can be used to cause tests to output Subunit, to parse Subunit streams
+into test activity, perform seamless test isolation within a regular test
+case and variously sort, filter and report on test runs.
+Key Classes
+-----------
+The ``subunit.TestProtocolClient`` class is a ``unittest.TestResult``
+extension which will translate a test run into a Subunit stream.
+The ``subunit.ProtocolTestCase`` class is an adapter between the Subunit wire
+protocol and the ``unittest.TestCase`` object protocol. It is used to translate
+a stream into a test run, which regular ``unittest.TestResult`` objects can
+process and report/inspect.
+Subunit has support for non-blocking usage too, for use with asyncore or
+Twisted. See the ``TestProtocolServer`` parser class for more details.
+Subunit includes extensions to the Python ``TestResult`` protocol. These are
+all done in a compatible manner: ``TestResult`` objects that do not implement
+the extension methods will not cause errors to be raised, instead the extension
+will either lose fidelity (for instance, folding expected failures to success
+in Python versions < 2.7 or 3.1), or discard the extended data (for extra
+details, tags, timestamping and progress markers).
+The test outcome methods ``addSuccess``, ``addError``, ``addExpectedFailure``,
+``addFailure``, ``addSkip`` take an optional keyword parameter ``details``
+which can be used instead of the usual python unittest parameter.
+When used the value of details should be a dict from ``string`` to
+``testtools.content.Content`` objects. This is a draft API being worked on with
+the Python Testing In Python mail list, with the goal of permitting a common
+way to provide additional data beyond a traceback, such as captured data from
+disk, logging messages etc. The reference for this API is in testtools (0.9.0
+and newer).
+The ``tags(new_tags, gone_tags)`` method is called (if present) to add or
+remove tags in the test run that is currently executing. If called when no
+test is in progress (that is, if called outside of the ``startTest``,
+``stopTest`` pair), the the tags apply to all sebsequent tests. If called
+when a test is in progress, then the tags only apply to that test.
+The ``time(a_datetime)`` method is called (if present) when a ``time:``
+directive is encountered in a Subunit stream. This is used to tell a TestResult
+about the time that events in the stream occured at, to allow reconstructing
+test timing from a stream.
+The ``progress(offset, whence)`` method controls progress data for a stream.
+The offset parameter is an int, and whence is one of subunit.PROGRESS_CUR,
+subunit.PROGRESS_SET, PROGRESS_PUSH, PROGRESS_POP. Push and pop operations
+ignore the offset parameter.
+Python test support
+-------------------
+``subunit.run`` is a convenience wrapper to run a Python test suite via
+the command line, reporting via Subunit::
+  $ python -m subunit.run mylib.tests.test_suite
+The ``IsolatedTestSuite`` class is a TestSuite that forks before running its
+tests, allowing isolation between the test runner and some tests.
+Similarly, ``IsolatedTestCase`` is a base class which can be subclassed to get
+tests that will fork() before that individual test is run.
+`ExecTestCase`` is a convenience wrapper for running an external
+program to get a Subunit stream and then report that back to an arbitrary
+result object::
+ class AggregateTests(subunit.ExecTestCase):
+     def test_script_one(self):
+         './bin/script_one'
+     def test_script_two(self):
+         './bin/script_two'
+ # Normally your normal test loading would take of this automatically,
+ # It is only spelt out in detail here for clarity.
+ suite = unittest.TestSuite([AggregateTests("test_script_one"),
+     AggregateTests("test_script_two")])
+ # Create any TestResult class you like.
+ result = unittest._TextTestResult(sys.stdout)
+ # And run your suite as normal, Subunit will exec each external script as
+ # needed and report to your result object.
+ suite.run(result)
+Utility modules
+---------------
+* subunit.chunked contains HTTP chunked encoding/decoding logic.
+* subunit.test_results contains TestResult helper classes.
+"""
+import datetime
 import os
+import re
 from StringIO import StringIO
+import subprocess
 import sys
 import unittest
+import iso8601
+from testtools import content, content_type, ExtendedToOriginalDecorator
+try:
+    from testtools.testresult.real import _StringException
+    RemoteException = _StringException
+    _remote_exception_str = '_StringException' # For testing.
+except ImportError:
+    raise ImportError ("testtools.testresult.real does not contain "
+        "_StringException, check your version.")
+from testtools import testresult
+import chunked, details, test_results
+PROGRESS_SET = 0
+PROGRESS_CUR = 1
+PROGRESS_PUSH = 2
+PROGRESS_POP = 3
 def test_suite():
 …
+def tags_to_new_gone(tags):
+    """Split a list of tags into a new_set and a gone_set."""
+    new_tags = set()
+    gone_tags = set()
+    for tag in tags:
+        if tag[0] == '-':
+            gone_tags.add(tag[1:])
+        else:
+            new_tags.add(tag)
+    return new_tags, gone_tags
+class DiscardStream(object):
+    """A filelike object which discards what is written to it."""
+    def write(self, bytes):
+        pass
+class _ParserState(object):
+    """State for the subunit parser."""
+    def __init__(self, parser):
+        self.parser = parser
+    def addError(self, offset, line):
+        """An 'error:' directive has been read."""
+        self.parser.stdOutLineReceived(line)
+    def addExpectedFail(self, offset, line):
+        """An 'xfail:' directive has been read."""
+        self.parser.stdOutLineReceived(line)
+    def addFailure(self, offset, line):
+        """A 'failure:' directive has been read."""
+        self.parser.stdOutLineReceived(line)
+    def addSkip(self, offset, line):
+        """A 'skip:' directive has been read."""
+        self.parser.stdOutLineReceived(line)
+    def addSuccess(self, offset, line):
+        """A 'success:' directive has been read."""
+        self.parser.stdOutLineReceived(line)
+    def lineReceived(self, line):
+        """a line has been received."""
+        parts = line.split(None, 1)
+        if len(parts) == 2 and line.startswith(parts[0]):
+            cmd, rest = parts
+            offset = len(cmd) + 1
+            cmd = cmd.rstrip(':')
+            if cmd in ('test', 'testing'):
+                self.startTest(offset, line)
+            elif cmd == 'error':
+                self.addError(offset, line)
+            elif cmd == 'failure':
+                self.addFailure(offset, line)
+            elif cmd == 'progress':
+                self.parser._handleProgress(offset, line)
+            elif cmd == 'skip':
+                self.addSkip(offset, line)
+            elif cmd in ('success', 'successful'):
+                self.addSuccess(offset, line)
+            elif cmd in ('tags',):
+                self.parser._handleTags(offset, line)
+                self.parser.subunitLineReceived(line)
+            elif cmd in ('time',):
+                self.parser._handleTime(offset, line)
+                self.parser.subunitLineReceived(line)
+            elif cmd == 'xfail':
+                self.addExpectedFail(offset, line)
+            else:
+                self.parser.stdOutLineReceived(line)
+        else:
+            self.parser.stdOutLineReceived(line)
+    def lostConnection(self):
+        """Connection lost."""
+        self.parser._lostConnectionInTest(u'unknown state of ')
+    def startTest(self, offset, line):
+        """A test start command received."""
+        self.parser.stdOutLineReceived(line)
+class _InTest(_ParserState):
+    """State for the subunit parser after reading a test: directive."""
+    def _outcome(self, offset, line, no_details, details_state):
+        """An outcome directive has been read.
+        :param no_details: Callable to call when no details are presented.
+        :param details_state: The state to switch to for details
+            processing of this outcome.
+        """
+        if self.parser.current_test_description == line[offset:-1]:
+            self.parser._state = self.parser._outside_test
+            self.parser.current_test_description = None
+            no_details()
+            self.parser.client.stopTest(self.parser._current_test)
+            self.parser._current_test = None
+            self.parser.subunitLineReceived(line)
+        elif self.parser.current_test_description + " [" == line[offset:-1]:
+            self.parser._state = details_state
+            details_state.set_simple()
+            self.parser.subunitLineReceived(line)
+        elif self.parser.current_test_description + " [ multipart" == \
+            line[offset:-1]:
+            self.parser._state = details_state
+            details_state.set_multipart()
+            self.parser.subunitLineReceived(line)
+        else:
+            self.parser.stdOutLineReceived(line)
+    def _error(self):
+        self.parser.client.addError(self.parser._current_test,
+            details={})
+    def addError(self, offset, line):
+        """An 'error:' directive has been read."""
+        self._outcome(offset, line, self._error,
+            self.parser._reading_error_details)
+    def _xfail(self):
+        self.parser.client.addExpectedFailure(self.parser._current_test,
+            details={})
+    def addExpectedFail(self, offset, line):
+        """An 'xfail:' directive has been read."""
+        self._outcome(offset, line, self._xfail,
+            self.parser._reading_xfail_details)
+    def _failure(self):
+        self.parser.client.addFailure(self.parser._current_test, details={})
+    def addFailure(self, offset, line):
+        """A 'failure:' directive has been read."""
+        self._outcome(offset, line, self._failure,
+            self.parser._reading_failure_details)
+    def _skip(self):
+        self.parser.client.addSkip(self.parser._current_test, details={})
+    def addSkip(self, offset, line):
+        """A 'skip:' directive has been read."""
+        self._outcome(offset, line, self._skip,
+            self.parser._reading_skip_details)
+    def _succeed(self):
+        self.parser.client.addSuccess(self.parser._current_test, details={})
+    def addSuccess(self, offset, line):
+        """A 'success:' directive has been read."""
+        self._outcome(offset, line, self._succeed,
+            self.parser._reading_success_details)
+    def lostConnection(self):
+        """Connection lost."""
+        self.parser._lostConnectionInTest(u'')
+class _OutSideTest(_ParserState):
+    """State for the subunit parser outside of a test context."""
+    def lostConnection(self):
+        """Connection lost."""
+    def startTest(self, offset, line):
+        """A test start command received."""
+        self.parser._state = self.parser._in_test
+        self.parser._current_test = RemotedTestCase(line[offset:-1])
+        self.parser.current_test_description = line[offset:-1]
+        self.parser.client.startTest(self.parser._current_test)
+        self.parser.subunitLineReceived(line)
+class _ReadingDetails(_ParserState):
+    """Common logic for readin state details."""
+    def endDetails(self):
+        """The end of a details section has been reached."""
+        self.parser._state = self.parser._outside_test
+        self.parser.current_test_description = None
+        self._report_outcome()
+        self.parser.client.stopTest(self.parser._current_test)
+    def lineReceived(self, line):
+        """a line has been received."""
+        self.details_parser.lineReceived(line)
+        self.parser.subunitLineReceived(line)
+    def lostConnection(self):
+        """Connection lost."""
+        self.parser._lostConnectionInTest(u'%s report of ' %
+            self._outcome_label())
+    def _outcome_label(self):
+        """The label to describe this outcome."""
+        raise NotImplementedError(self._outcome_label)
+    def set_simple(self):
+        """Start a simple details parser."""
+        self.details_parser = details.SimpleDetailsParser(self)
+    def set_multipart(self):
+        """Start a multipart details parser."""
+        self.details_parser = details.MultipartDetailsParser(self)
+class _ReadingFailureDetails(_ReadingDetails):
+    """State for the subunit parser when reading failure details."""
+    def _report_outcome(self):
+        self.parser.client.addFailure(self.parser._current_test,
+            details=self.details_parser.get_details())
+    def _outcome_label(self):
+        return "failure"
+class _ReadingErrorDetails(_ReadingDetails):
+    """State for the subunit parser when reading error details."""
+    def _report_outcome(self):
+        self.parser.client.addError(self.parser._current_test,
+            details=self.details_parser.get_details())
+    def _outcome_label(self):
+        return "error"
+class _ReadingExpectedFailureDetails(_ReadingDetails):
+    """State for the subunit parser when reading xfail details."""
+    def _report_outcome(self):
+        self.parser.client.addExpectedFailure(self.parser._current_test,
+            details=self.details_parser.get_details())
+    def _outcome_label(self):
+        return "xfail"
+class _ReadingSkipDetails(_ReadingDetails):
+    """State for the subunit parser when reading skip details."""
+    def _report_outcome(self):
+        self.parser.client.addSkip(self.parser._current_test,
+            details=self.details_parser.get_details("skip"))
+    def _outcome_label(self):
+        return "skip"
+class _ReadingSuccessDetails(_ReadingDetails):
+    """State for the subunit parser when reading success details."""
+    def _report_outcome(self):
+        self.parser.client.addSuccess(self.parser._current_test,
+            details=self.details_parser.get_details("success"))
+    def _outcome_label(self):
+        return "success"
 class TestProtocolServer(object):
     """A class for receiving results from a TestProtocol client."""
     OUTSIDE_TEST = 0
     TEST_STARTED = 1
+    READING_FAILURE = 2
     READING_ERROR = 3
+    def __init__(self, client, stream=sys.stdout):
         """Create a TestProtocol server instance.
         client should be an object that provides
          - startTest
          - addSuccess
          - addFailure
          - addError
          - stopTest
         methods, i.e. a TestResult.
+    """A parser for subunit.
+    :ivar tags: The current tags associated with the protocol stream.
+    """
+    def __init__(self, client, stream=None, forward_stream=None):
+        """Create a TestProtocolServer instance.
+        :param client: An object meeting the unittest.TestResult protocol.
+        :param stream: The stream that lines received which are not part of the
+            subunit protocol should be written to. This allows custom handling
+            of mixed protocols. By default, sys.stdout will be used for
+            convenience.
+        :param forward_stream: A stream to forward subunit lines to. This
+            allows a filter to forward the entire stream while still parsing
+            and acting on it. By default forward_stream is set to
+            DiscardStream() and no forwarding happens.
         """
+        self.state = TestProtocolServer.OUTSIDE_TEST
+        self.client = client
+        self.client = ExtendedToOriginalDecorator(client)
+        if stream is None:
+            stream = sys.stdout
         self._stream = stream
+    def _addError(self, offset, line):
+        if (self.state == TestProtocolServer.TEST_STARTED and
+            self.current_test_description == line[offset:-1]):
+            self.state = TestProtocolServer.OUTSIDE_TEST
+            self.current_test_description = None
+            self.client.addError(self._current_test, RemoteError(""))
+            self.client.stopTest(self._current_test)
+            self._current_test = None
+        elif (self.state == TestProtocolServer.TEST_STARTED and
+            self.current_test_description + " [" == line[offset:-1]):
+            self.state = TestProtocolServer.READING_ERROR
+            self._message = ""
+        self._forward_stream = forward_stream or DiscardStream()
+        # state objects we can switch too
+        self._in_test = _InTest(self)
+        self._outside_test = _OutSideTest(self)
+        self._reading_error_details = _ReadingErrorDetails(self)
+        self._reading_failure_details = _ReadingFailureDetails(self)
+        self._reading_skip_details = _ReadingSkipDetails(self)
+        self._reading_success_details = _ReadingSuccessDetails(self)
+        self._reading_xfail_details = _ReadingExpectedFailureDetails(self)
+        # start with outside test.
+        self._state = self._outside_test
+    def _handleProgress(self, offset, line):
+        """Process a progress directive."""
+        line = line[offset:].strip()
+        if line[0] in '+-':
+            whence = PROGRESS_CUR
+            delta = int(line)
+        elif line == "push":
+            whence = PROGRESS_PUSH
+            delta = None
+        elif line == "pop":
+            whence = PROGRESS_POP
+            delta = None
         else:
+            self.stdOutLineReceived(line)
+    def _addFailure(self, offset, line):
+        if (self.state == TestProtocolServer.TEST_STARTED and
+            self.current_test_description == line[offset:-1]):
+            self.state = TestProtocolServer.OUTSIDE_TEST
+            self.current_test_description = None
+            self.client.addFailure(self._current_test, RemoteError())
+            self.client.stopTest(self._current_test)
+        elif (self.state == TestProtocolServer.TEST_STARTED and
+            self.current_test_description + " [" == line[offset:-1]):
+            self.state = TestProtocolServer.READING_FAILURE
+            self._message = ""
+        else:
+            self.stdOutLineReceived(line)
+    def _addSuccess(self, offset, line):
+        if (self.state == TestProtocolServer.TEST_STARTED and
+            self.current_test_description == line[offset:-1]):
+            self.client.addSuccess(self._current_test)
+            self.client.stopTest(self._current_test)
+            self.current_test_description = None
+            self._current_test = None
+            self.state = TestProtocolServer.OUTSIDE_TEST
+        else:
+            self.stdOutLineReceived(line)
+    def _appendMessage(self, line):
+        if line[0:2] == " ]":
+            # quoted ] start
+            self._message += line[1:]
+        else:
+            self._message += line
+    def endQuote(self, line):
+        if self.state == TestProtocolServer.READING_FAILURE:
+            self.state = TestProtocolServer.OUTSIDE_TEST
+            self.current_test_description = None
+            self.client.addFailure(self._current_test,
+                                   RemoteError(self._message))
+            self.client.stopTest(self._current_test)
+        elif self.state == TestProtocolServer.READING_ERROR:
+            self.state = TestProtocolServer.OUTSIDE_TEST
+            self.current_test_description = None
+            self.client.addError(self._current_test,
+                                 RemoteError(self._message))
+            self.client.stopTest(self._current_test)
+        else:
+            self.stdOutLineReceived(line)
+            whence = PROGRESS_SET
+            delta = int(line)
+        self.client.progress(delta, whence)
+    def _handleTags(self, offset, line):
+        """Process a tags command."""
+        tags = line[offset:].split()
+        new_tags, gone_tags = tags_to_new_gone(tags)
+        self.client.tags(new_tags, gone_tags)
+    def _handleTime(self, offset, line):
+        # Accept it, but do not do anything with it yet.
+        try:
+            event_time = iso8601.parse_date(line[offset:-1])
+        except TypeError, e:
+            raise TypeError("Failed to parse %r, got %r" % (line, e))
+        self.client.time(event_time)
     def lineReceived(self, line):
         """Call the appropriate local method for the received line."""
+        if line == "]\n":
+            self.endQuote(line)
+        elif (self.state == TestProtocolServer.READING_FAILURE or
+              self.state == TestProtocolServer.READING_ERROR):
+            self._appendMessage(line)
+        else:
+            parts = line.split(None, 1)
+            if len(parts) == 2:
+                cmd, rest = parts
+                offset = len(cmd) + 1
+                cmd = cmd.strip(':')
+                if cmd in ('test', 'testing'):
+                    self._startTest(offset, line)
+                elif cmd == 'error':
+                    self._addError(offset, line)
+                elif cmd == 'failure':
+                    self._addFailure(offset, line)
+                elif cmd in ('success', 'successful'):
+                    self._addSuccess(offset, line)
+                else:
+                    self.stdOutLineReceived(line)
+            else:
+                self.stdOutLineReceived(line)
+        self._state.lineReceived(line)
+    def _lostConnectionInTest(self, state_string):
+        error_string = u"lost connection during %stest '%s'" % (
+            state_string, self.current_test_description)
+        self.client.addError(self._current_test, RemoteError(error_string))
+        self.client.stopTest(self._current_test)
     def lostConnection(self):
         """The input connection has finished."""
+        if self.state == TestProtocolServer.TEST_STARTED:
+            self.client.addError(self._current_test,
+                                 RemoteError("lost connection during test '%s'"
+                                             % self.current_test_description))
+            self.client.stopTest(self._current_test)
+        elif self.state == TestProtocolServer.READING_ERROR:
+            self.client.addError(self._current_test,
+                                 RemoteError("lost connection during "
+                                             "error report of test "
+                                             "'%s'" %
+                                             self.current_test_description))
+            self.client.stopTest(self._current_test)
+        elif self.state == TestProtocolServer.READING_FAILURE:
+            self.client.addError(self._current_test,
+                                 RemoteError("lost connection during "
+                                             "failure report of test "
+                                             "'%s'" %
+                                             self.current_test_description))
+            self.client.stopTest(self._current_test)
+        self._state.lostConnection()
     def readFrom(self, pipe):
+        """Blocking convenience API to parse an entire stream.
+        :param pipe: A file-like object supporting readlines().
+        :return: None.
+        """
         for line in pipe.readlines():
             self.lineReceived(line)
 …
     def _startTest(self, offset, line):
         """Internal call to change state machine. Override startTest()."""
+        if self.state == TestProtocolServer.OUTSIDE_TEST:
+            self.state = TestProtocolServer.TEST_STARTED
+            self._current_test = RemotedTestCase(line[offset:-1])
+            self.current_test_description = line[offset:-1]
+            self.client.startTest(self._current_test)
+        else:
+            self.stdOutLineReceived(line)
+        self._state.startTest(offset, line)
+    def subunitLineReceived(self, line):
+        self._forward_stream.write(line)
     def stdOutLineReceived(self, line):
 …
+class RemoteException(Exception):
+    """An exception that occured remotely to python."""
+    def __eq__(self, other):
+        try:
+            return self.args == other.args
+        except AttributeError:
+            return False
+class TestProtocolClient(unittest.TestResult):
+    """A class that looks like a TestResult and informs a TestProtocolServer."""
+class TestProtocolClient(testresult.TestResult):
+    """A TestResult which generates a subunit stream for a test run.
+    # Get a TestSuite or TestCase to run
+    suite = make_suite()
+    # Create a stream (any object with a 'write' method)
+    stream = file('tests.log', 'wb')
+    # Create a subunit result object which will output to the stream
+    result = subunit.TestProtocolClient(stream)
+    # Optionally, to get timing data for performance analysis, wrap the
+    # serialiser with a timing decorator
+    result = subunit.test_results.AutoTimingTestResultDecorator(result)
+    # Run the test suite reporting to the subunit result object
+    suite.run(result)
+    # Close the stream.
+    stream.close()
+    """
     def __init__(self, stream):
         super(TestProtocolClient, self).__init__()
+        testresult.TestResult.__init__(self)
         self._stream = stream
+    def addError(self, test, error):
+        """Report an error in test test."""
+        self._stream.write("error: %s [\n" % (test.shortDescription() or str(test)))
+        for line in self._exc_info_to_string(error, test).splitlines():
+            self._stream.write("%s\n" % line)
+        _make_stream_binary(stream)
+    def addError(self, test, error=None, details=None):
+        """Report an error in test test.
+        Only one of error and details should be provided: conceptually there
+        are two separate methods:
+            addError(self, test, error)
+            addError(self, test, details)
+        :param error: Standard unittest positional argument form - an
+            exc_info tuple.
+        :param details: New Testing-in-python drafted API; a dict from string
+            to subunit.Content objects.
+        """
+        self._addOutcome("error", test, error=error, details=details)
+    def addExpectedFailure(self, test, error=None, details=None):
+        """Report an expected failure in test test.
+        Only one of error and details should be provided: conceptually there
+        are two separate methods:
+            addError(self, test, error)
+            addError(self, test, details)
+        :param error: Standard unittest positional argument form - an
+            exc_info tuple.
+        :param details: New Testing-in-python drafted API; a dict from string
+            to subunit.Content objects.
+        """
+        self._addOutcome("xfail", test, error=error, details=details)
+    def addFailure(self, test, error=None, details=None):
+        """Report a failure in test test.
+        Only one of error and details should be provided: conceptually there
+        are two separate methods:
+            addFailure(self, test, error)
+            addFailure(self, test, details)
+        :param error: Standard unittest positional argument form - an
+            exc_info tuple.
+        :param details: New Testing-in-python drafted API; a dict from string
+            to subunit.Content objects.
+        """
+        self._addOutcome("failure", test, error=error, details=details)
+    def _addOutcome(self, outcome, test, error=None, details=None):
+        """Report a failure in test test.
+        Only one of error and details should be provided: conceptually there
+        are two separate methods:
+            addOutcome(self, test, error)
+            addOutcome(self, test, details)
+        :param outcome: A string describing the outcome - used as the
+            event name in the subunit stream.
+        :param error: Standard unittest positional argument form - an
+            exc_info tuple.
+        :param details: New Testing-in-python drafted API; a dict from string
+            to subunit.Content objects.
+        """
+        self._stream.write("%s: %s" % (outcome, test.id()))
+        if error is None and details is None:
+            raise ValueError
+        if error is not None:
+            self._stream.write(" [\n")
+            # XXX: this needs to be made much stricter, along the lines of
+            # Martin[gz]'s work in testtools. Perhaps subunit can use that?
+            for line in self._exc_info_to_unicode(error, test).splitlines():
+                self._stream.write(("%s\n" % line).encode('utf8'))
+        else:
+            self._write_details(details)
         self._stream.write("]\n")
+        super(TestProtocolClient, self).addError(test, error)
     def addFailure(self, test, error):
         """Report a failure in test test."""
         self._stream.write("failure: %s [\n" % (test.shortDescription() or str(test)))
         for line in self._exc_info_to_string(error, test).splitlines():
             self._stream.write("%s\n" % line)
         self._stream.write("]\n")
         super(TestProtocolClient, self).addFailure(test, error)
     def addSuccess(self, test):
+    def addSkip(self, test, reason=None, details=None):
+        """Report a skipped test."""
+        if reason is None:
+            self._addOutcome("skip", test, error=None, details=details)
+        else:
+            self._stream.write("skip: %s [\n" % test.id())
+            self._stream.write("%s\n" % reason)
+            self._stream.write("]\n")
+    def addSuccess(self, test, details=None):
         """Report a success in a test."""
+        self._stream.write("successful: %s\n" % (test.shortDescription() or str(test)))
+        super(TestProtocolClient, self).addSuccess(test)
+        self._stream.write("successful: %s" % test.id())
+        if not details:
+            self._stream.write("\n")
+        else:
+            self._write_details(details)
+            self._stream.write("]\n")
+    addUnexpectedSuccess = addSuccess
     def startTest(self, test):
         """Mark a test as starting its test run."""
-        self._stream.write("test: %s\n" % (test.shortDescription() or str(test)))
         super(TestProtocolClient, self).startTest(test)
+def RemoteError(description=""):
+    if description == "":
+        description = "\n"
+    return (RemoteException, RemoteException(description), None)
+        self._stream.write("test: %s\n" % test.id())
+        self._stream.flush()
+    def stopTest(self, test):
+        super(TestProtocolClient, self).stopTest(test)
+        self._stream.flush()
+    def progress(self, offset, whence):
+        """Provide indication about the progress/length of the test run.
+        :param offset: Information about the number of tests remaining. If
+            whence is PROGRESS_CUR, then offset increases/decreases the
+            remaining test count. If whence is PROGRESS_SET, then offset
+            specifies exactly the remaining test count.
+        :param whence: One of PROGRESS_CUR, PROGRESS_SET, PROGRESS_PUSH,
+            PROGRESS_POP.
+        """
+        if whence == PROGRESS_CUR and offset > -1:
+            prefix = "+"
+        elif whence == PROGRESS_PUSH:
+            prefix = ""
+            offset = "push"
+        elif whence == PROGRESS_POP:
+            prefix = ""
+            offset = "pop"
+        else:
+            prefix = ""
+        self._stream.write("progress: %s%s\n" % (prefix, offset))
+    def time(self, a_datetime):
+        """Inform the client of the time.
+        ":param datetime: A datetime.datetime object.
+        """
+        time = a_datetime.astimezone(iso8601.Utc())
+        self._stream.write("time: %04d-%02d-%02d %02d:%02d:%02d.%06dZ\n" % (
+            time.year, time.month, time.day, time.hour, time.minute,
+            time.second, time.microsecond))
+    def _write_details(self, details):
+        """Output details to the stream.
+        :param details: An extended details dict for a test outcome.
+        """
+        self._stream.write(" [ multipart\n")
+        for name, content in sorted(details.iteritems()):
+            self._stream.write("Content-Type: %s/%s" %
+                (content.content_type.type, content.content_type.subtype))
+            parameters = content.content_type.parameters
+            if parameters:
+                self._stream.write(";")
+                param_strs = []
+                for param, value in parameters.iteritems():
+                    param_strs.append("%s=%s" % (param, value))
+                self._stream.write(",".join(param_strs))
+            self._stream.write("\n%s\n" % name)
+            encoder = chunked.Encoder(self._stream)
+            map(encoder.write, content.iter_bytes())
+            encoder.close()
+    def done(self):
+        """Obey the testtools result.done() interface."""
+def RemoteError(description=u""):
+    return (_StringException, _StringException(description), None)
 class RemotedTestCase(unittest.TestCase):
+    """A class to represent test cases run in child processes."""
+    """A class to represent test cases run in child processes.
+    Instances of this class are used to provide the Python test API a TestCase
+    that can be printed to the screen, introspected for metadata and so on.
+    However, as they are a simply a memoisation of a test that was actually
+    run in the past by a separate process, they cannot perform any interactive
+    actions.
+    """
     def __eq__ (self, other):
 …
     def id(self):
         return "%s.%s" % (self._strclass(), self.__description)
+        return "%s" % (self.__description,)
     def __str__(self):
 …
         if result is None: result = self.defaultTestResult()
         result.startTest(self)
         result.addError(self, RemoteError("Cannot run RemotedTestCases.\n"))
+        result.addError(self, RemoteError(u"Cannot run RemotedTestCases.\n"))
         result.stopTest(self)
 …
     def debug(self):
         """Run the test without collecting errors in a TestResult"""
         self._run(unittest.TestResult())
+        self._run(testresult.TestResult())
     def _run(self, result):
         protocol = TestProtocolServer(result)
+        output = os.popen(self.script, mode='r')
+        protocol.readFrom(output)
+        output = subprocess.Popen(self.script, shell=True,
+            stdout=subprocess.PIPE).communicate()[0]
+        protocol.readFrom(StringIO(output))
 class IsolatedTestCase(unittest.TestCase):
+    """A TestCase which runs its tests in a forked process."""
+    """A TestCase which executes in a forked process.
+    Each test gets its own process, which has a performance overhead but will
+    provide excellent isolation from global state (such as django configs,
+    zope utilities and so on).
+    """
     def run(self, result=None):
 …
 class IsolatedTestSuite(unittest.TestSuite):
+    """A TestCase which runs its tests in a forked process."""
+    """A TestSuite which runs its tests in a forked process.
+    This decorator that will fork() before running the tests and report the
+    results from the child process using a Subunit stream.  This is useful for
+    handling tests that mutate global state, or are testing C extensions that
+    could crash the VM.
+    """
     def run(self, result=None):
         if result is None: result = unittest.TestResult()
+        if result is None: result = testresult.TestResult()
         run_isolated(unittest.TestSuite, self, result)
 …
+class SubunitTestRunner(object):
+    def __init__(self, stream=sys.stdout):
+        self.stream = stream
+    def run(self, test):
+        "Run the given test case or test suite."
+        result = TestProtocolClient(self.stream)
+        test(result)
+        return result
+def TAP2SubUnit(tap, subunit):
+    """Filter a TAP pipe into a subunit pipe.
+    :param tap: A tap pipe/stream/file object.
+    :param subunit: A pipe/stream/file object to write subunit results to.
+    :return: The exit code to exit with.
+    """
+    BEFORE_PLAN = 0
+    AFTER_PLAN = 1
+    SKIP_STREAM = 2
+    client = TestProtocolClient(subunit)
+    state = BEFORE_PLAN
+    plan_start = 1
+    plan_stop = 0
+    def _skipped_test(subunit, plan_start):
+        # Some tests were skipped.
+        subunit.write('test test %d\n' % plan_start)
+        subunit.write('error test %d [\n' % plan_start)
+        subunit.write('test missing from TAP output\n')
+        subunit.write(']\n')
+        return plan_start + 1
+    # Test data for the next test to emit
+    test_name = None
+    log = []
+    result = None
+    def _emit_test():
+        "write out a test"
+        if test_name is None:
+            return
+        subunit.write("test %s\n" % test_name)
+        if not log:
+            subunit.write("%s %s\n" % (result, test_name))
+        else:
+            subunit.write("%s %s [\n" % (result, test_name))
+        if log:
+            for line in log:
+                subunit.write("%s\n" % line)
+            subunit.write("]\n")
+        del log[:]
+    for line in tap:
+        if state == BEFORE_PLAN:
+            match = re.match("(\d+)\.\.(\d+)\s*(?:\#\s+(.*))?\n", line)
+            if match:
+                state = AFTER_PLAN
+                _, plan_stop, comment = match.groups()
+                plan_stop = int(plan_stop)
+                if plan_start > plan_stop and plan_stop == 0:
+                    # skipped file
+                    state = SKIP_STREAM
+                    subunit.write("test file skip\n")
+                    subunit.write("skip file skip [\n")
+                    subunit.write("%s\n" % comment)
+                    subunit.write("]\n")
+                continue
+        # not a plan line, or have seen one before
+        match = re.match("(ok|not ok)(?:\s+(\d+)?)?(?:\s+([^#]*[^#\s]+)\s*)?(?:\s+#\s+(TODO|SKIP|skip|todo)(?:\s+(.*))?)?\n", line)
+        if match:
+            # new test, emit current one.
+            _emit_test()
+            status, number, description, directive, directive_comment = match.groups()
+            if status == 'ok':
+                result = 'success'
+            else:
+                result = "failure"
+            if description is None:
+                description = ''
+            else:
+                description = ' ' + description
+            if directive is not None:
+                if directive.upper() == 'TODO':
+                    result = 'xfail'
+                elif directive.upper() == 'SKIP':
+                    result = 'skip'
+                if directive_comment is not None:
+                    log.append(directive_comment)
+            if number is not None:
+                number = int(number)
+                while plan_start < number:
+                    plan_start = _skipped_test(subunit, plan_start)
+            test_name = "test %d%s" % (plan_start, description)
+            plan_start += 1
+            continue
+        match = re.match("Bail out\!(?:\s*(.*))?\n", line)
+        if match:
+            reason, = match.groups()
+            if reason is None:
+                extra = ''
+            else:
+                extra = ' %s' % reason
+            _emit_test()
+            test_name = "Bail out!%s" % extra
+            result = "error"
+            state = SKIP_STREAM
+            continue
+        match = re.match("\#.*\n", line)
+        if match:
+            log.append(line[:-1])
+            continue
+        subunit.write(line)
+    _emit_test()
+    while plan_start <= plan_stop:
+        # record missed tests
+        plan_start = _skipped_test(subunit, plan_start)
+    return 0
+def tag_stream(original, filtered, tags):
+    """Alter tags on a stream.
+    :param original: The input stream.
+    :param filtered: The output stream.
+    :param tags: The tags to apply. As in a normal stream - a list of 'TAG' or
+        '-TAG' commands.
+        A 'TAG' command will add the tag to the output stream,
+        and override any existing '-TAG' command in that stream.
+        Specifically:
+         * A global 'tags: TAG' will be added to the start of the stream.
+         * Any tags commands with -TAG will have the -TAG removed.
+        A '-TAG' command will remove the TAG command from the stream.
+        Specifically:
+         * A 'tags: -TAG' command will be added to the start of the stream.
+         * Any 'tags: TAG' command will have 'TAG' removed from it.
+        Additionally, any redundant tagging commands (adding a tag globally
+        present, or removing a tag globally removed) are stripped as a
+        by-product of the filtering.
+    :return: 0
+    """
+    new_tags, gone_tags = tags_to_new_gone(tags)
+    def write_tags(new_tags, gone_tags):
+        if new_tags or gone_tags:
+            filtered.write("tags: " + ' '.join(new_tags))
+            if gone_tags:
+                for tag in gone_tags:
+                    filtered.write("-" + tag)
+            filtered.write("\n")
+    write_tags(new_tags, gone_tags)
+    # TODO: use the protocol parser and thus don't mangle test comments.
+    for line in original:
+        if line.startswith("tags:"):
+            line_tags = line[5:].split()
+            line_new, line_gone = tags_to_new_gone(line_tags)
+            line_new = line_new - gone_tags
+            line_gone = line_gone - new_tags
+            write_tags(line_new, line_gone)
+        else:
+            filtered.write(line)
+    return 0
+class ProtocolTestCase(object):
+    """Subunit wire protocol to unittest.TestCase adapter.
+    ProtocolTestCase honours the core of ``unittest.TestCase`` protocol -
+    calling a ProtocolTestCase or invoking the run() method will make a 'test
+    run' happen. The 'test run' will simply be a replay of the test activity
+    that has been encoded into the stream. The ``unittest.TestCase`` ``debug``
+    and ``countTestCases`` methods are not supported because there isn't a
+    sensible mapping for those methods.
+    # Get a stream (any object with a readline() method), in this case the
+    # stream output by the example from ``subunit.TestProtocolClient``.
+    stream = file('tests.log', 'rb')
+    # Create a parser which will read from the stream and emit
+    # activity to a unittest.TestResult when run() is called.
+    suite = subunit.ProtocolTestCase(stream)
+    # Create a result object to accept the contents of that stream.
+    result = unittest._TextTestResult(sys.stdout)
+    # 'run' the tests - process the stream and feed its contents to result.
+    suite.run(result)
+    stream.close()
+    :seealso: TestProtocolServer (the subunit wire protocol parser).
+    """
+    def __init__(self, stream, passthrough=None, forward=False):
+        """Create a ProtocolTestCase reading from stream.
+        :param stream: A filelike object which a subunit stream can be read
+            from.
+        :param passthrough: A stream pass non subunit input on to. If not
+            supplied, the TestProtocolServer default is used.
+        :param forward: A stream to pass subunit input on to. If not supplied
+            subunit input is not forwarded.
+        """
+        self._stream = stream
+        _make_stream_binary(stream)
+        self._passthrough = passthrough
+        self._forward = forward
+        _make_stream_binary(forward)
+    def __call__(self, result=None):
+        return self.run(result)
+    def run(self, result=None):
+        if result is None:
+            result = self.defaultTestResult()
+        protocol = TestProtocolServer(result, self._passthrough, self._forward)
+        line = self._stream.readline()
+        while line:
+            protocol.lineReceived(line)
+            line = self._stream.readline()
+        protocol.lostConnection()
+class TestResultStats(testresult.TestResult):
+    """A pyunit TestResult interface implementation for making statistics.
+    :ivar total_tests: The total tests seen.
+    :ivar passed_tests: The tests that passed.
+    :ivar failed_tests: The tests that failed.
+    :ivar seen_tags: The tags seen across all tests.
+    """
+    def __init__(self, stream):
+        """Create a TestResultStats which outputs to stream."""
+        testresult.TestResult.__init__(self)
+        self._stream = stream
+        self.failed_tests = 0
+        self.skipped_tests = 0
+        self.seen_tags = set()
+    @property
+    def total_tests(self):
+        return self.testsRun
+    def addError(self, test, err, details=None):
+        self.failed_tests += 1
+    def addFailure(self, test, err, details=None):
+        self.failed_tests += 1
+    def addSkip(self, test, reason, details=None):
+        self.skipped_tests += 1
+    def formatStats(self):
+        self._stream.write("Total tests:   %5d\n" % self.total_tests)
+        self._stream.write("Passed tests:  %5d\n" % self.passed_tests)
+        self._stream.write("Failed tests:  %5d\n" % self.failed_tests)
+        self._stream.write("Skipped tests: %5d\n" % self.skipped_tests)
+        tags = sorted(self.seen_tags)
+        self._stream.write("Seen tags: %s\n" % (", ".join(tags)))
+    @property
+    def passed_tests(self):
+        return self.total_tests - self.failed_tests - self.skipped_tests
+    def tags(self, new_tags, gone_tags):
+        """Accumulate the seen tags."""
+        self.seen_tags.update(new_tags)
+    def wasSuccessful(self):
+        """Tells whether or not this result was a success"""
+        return self.failed_tests == 0
+def get_default_formatter():
+    """Obtain the default formatter to write to.
+    :return: A file-like object.
+    """
+    formatter = os.getenv("SUBUNIT_FORMATTER")
+    if formatter:
+        return os.popen(formatter, "w")
+    else:
+        return sys.stdout
+def _make_stream_binary(stream):
+    """Ensure that a stream will be binary safe. See _make_binary_on_windows."""
+    if getattr(stream, 'fileno', None) is not None:
+        _make_binary_on_windows(stream.fileno())
+def _make_binary_on_windows(fileno):
+    """Win32 mangles \r\n to \n and that breaks streams. See bug lp:505078."""
+    if sys.platform == "win32":
+        import msvcrt
+        msvcrt.setmode(fileno, os.O_BINARY)

vendor/current/lib/subunit/python/subunit/tests/init.py

-              r414
+              r740
 #  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
+#  license at the users choice. A copy of both licenses are available in the
+#  project source as Apache-2.0 and BSD. You may not use this file except in
+#  compliance with one of these two licences.
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+#  license you chose for the specific language governing permissions and
+#  limitations under that license.
+#
+from subunit.tests import TestUtil, test_test_protocol
+from subunit.tests import (
+    TestUtil,
+    test_chunked,
+    test_details,
+    test_progress_model,
+    test_subunit_filter,
+    test_subunit_stats,
+    test_subunit_tags,
+    test_tap2subunit,
+    test_test_protocol,
+    test_test_results,
+    )
 def test_suite():
     result = TestUtil.TestSuite()
+    result.addTest(test_chunked.test_suite())
+    result.addTest(test_details.test_suite())
+    result.addTest(test_progress_model.test_suite())
+    result.addTest(test_test_results.test_suite())
     result.addTest(test_test_protocol.test_suite())
+    result.addTest(test_tap2subunit.test_suite())
+    result.addTest(test_subunit_filter.test_suite())
+    result.addTest(test_subunit_tags.test_suite())
+    result.addTest(test_subunit_stats.test_suite())
     return result

vendor/current/lib/subunit/python/subunit/tests/sample-script.py

-              r414
+              r740
 #!/usr/bin/env python
 import sys
+if len(sys.argv) == 2:
+    # subunit.tests.test_test_protocol.TestExecTestCase.test_sample_method_args
+    # uses this code path to be sure that the arguments were passed to
+    # sample-script.py
+    print "test fail"
+    print "error fail"
+    sys.exit(0)
 print "test old mcdonald"
 print "success old mcdonald"

vendor/current/lib/subunit/python/subunit/tests/test_test_protocol.py

-              r414
+              r740
+#
 #  subunit: extensions to python unittest to get test results from subprocesses.
+#  subunit: extensions to Python unittest to get test results from subprocesses.
 #  Copyright (C) 2005  Robert Collins <robertc@robertcollins.net>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#  Licensed under either the Apache License, Version 2.0 or the BSD 3-clause
+#  license at the users choice. A copy of both licenses are available in the
+#  project source as Apache-2.0 and BSD. You may not use this file except in
+#  compliance with one of these two licences.
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under these licenses is distributed on an "AS IS" BASIS, WITHOUT
+#  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+#  license you chose for the specific language governing permissions and
+#  limitations under that license.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+import datetime
 import unittest
 from StringIO import StringIO
 import os
+import sys
+from testtools.content import Content, TracebackContent
+from testtools.content_type import ContentType
+from testtools.tests.helpers import (
+    Python26TestResult,
+    Python27TestResult,
+    ExtendedTestResult,
+    )
 import subunit
+import sys
+try:
+    class MockTestProtocolServerClient(object):
+        """A mock protocol server client to test callbacks."""
+        def __init__(self):
+            self.end_calls = []
+            self.error_calls = []
+            self.failure_calls = []
+            self.start_calls = []
+            self.success_calls = []
+            super(MockTestProtocolServerClient, self).__init__()
+        def addError(self, test, error):
+            self.error_calls.append((test, error))
+        def addFailure(self, test, error):
+            self.failure_calls.append((test, error))
+        def addSuccess(self, test):
+            self.success_calls.append(test)
+        def stopTest(self, test):
+            self.end_calls.append(test)
+        def startTest(self, test):
+            self.start_calls.append(test)
+except AttributeError:
+    MockTestProtocolServer = None
+class TestMockTestProtocolServer(unittest.TestCase):
+    def test_start_test(self):
+        protocol = MockTestProtocolServerClient()
+        protocol.startTest(subunit.RemotedTestCase("test old mcdonald"))
+        self.assertEqual(protocol.start_calls,
+                         [subunit.RemotedTestCase("test old mcdonald")])
+        self.assertEqual(protocol.end_calls, [])
+        self.assertEqual(protocol.error_calls, [])
+        self.assertEqual(protocol.failure_calls, [])
+        self.assertEqual(protocol.success_calls, [])
+    def test_add_error(self):
+        protocol = MockTestProtocolServerClient()
+        protocol.addError(subunit.RemotedTestCase("old mcdonald"),
+                          subunit.RemoteError("omg it works"))
+        self.assertEqual(protocol.start_calls, [])
+        self.assertEqual(protocol.end_calls, [])
+        self.assertEqual(protocol.error_calls, [(
+                            subunit.RemotedTestCase("old mcdonald"),
+                            subunit.RemoteError("omg it works"))])
+        self.assertEqual(protocol.failure_calls, [])
+        self.assertEqual(protocol.success_calls, [])
+    def test_add_failure(self):
+        protocol = MockTestProtocolServerClient()
+        protocol.addFailure(subunit.RemotedTestCase("old mcdonald"),
+                            subunit.RemoteError("omg it works"))
+        self.assertEqual(protocol.start_calls, [])
+        self.assertEqual(protocol.end_calls, [])
+        self.assertEqual(protocol.error_calls, [])
+        self.assertEqual(protocol.failure_calls, [
+                            (subunit.RemotedTestCase("old mcdonald"),
+                             subunit.RemoteError("omg it works"))])
+        self.assertEqual(protocol.success_calls, [])
+    def test_add_success(self):
+        protocol = MockTestProtocolServerClient()
+        protocol.addSuccess(subunit.RemotedTestCase("test old mcdonald"))
+        self.assertEqual(protocol.start_calls, [])
+        self.assertEqual(protocol.end_calls, [])
+        self.assertEqual(protocol.error_calls, [])
+        self.assertEqual(protocol.failure_calls, [])
+        self.assertEqual(protocol.success_calls,
+                         [subunit.RemotedTestCase("test old mcdonald")])
+    def test_end_test(self):
+        protocol = MockTestProtocolServerClient()
+        protocol.stopTest(subunit.RemotedTestCase("test old mcdonald"))
+        self.assertEqual(protocol.end_calls,
+                         [subunit.RemotedTestCase("test old mcdonald")])
+        self.assertEqual(protocol.error_calls, [])
+        self.assertEqual(protocol.failure_calls, [])
+        self.assertEqual(protocol.success_calls, [])
+        self.assertEqual(protocol.start_calls, [])
+from subunit import _remote_exception_str
+import subunit.iso8601 as iso8601
 …
     def test_imports(self):
+        from subunit import DiscardStream
         from subunit import TestProtocolServer
         from subunit import RemotedTestCase
 …
         from subunit import IsolatedTestCase
         from subunit import TestProtocolClient
+        from subunit import ProtocolTestCase
+class TestDiscardStream(unittest.TestCase):
+    def test_write(self):
+        subunit.DiscardStream().write("content")
+class TestProtocolServerForward(unittest.TestCase):
+    def test_story(self):
+        client = unittest.TestResult()
+        out = StringIO()
+        protocol = subunit.TestProtocolServer(client, forward_stream=out)
+        pipe = StringIO("test old mcdonald\n"
+                        "success old mcdonald\n")
+        protocol.readFrom(pipe)
+        mcdonald = subunit.RemotedTestCase("old mcdonald")
+        self.assertEqual(client.testsRun, 1)
+        self.assertEqual(pipe.getvalue(), out.getvalue())
+    def test_not_command(self):
+        client = unittest.TestResult()
+        out = StringIO()
+        protocol = subunit.TestProtocolServer(client,
+            stream=subunit.DiscardStream(), forward_stream=out)
+        pipe = StringIO("success old mcdonald\n")
+        protocol.readFrom(pipe)
+        self.assertEqual(client.testsRun, 0)
+        self.assertEqual("", out.getvalue())
 class TestTestProtocolServerPipe(unittest.TestCase):
 …
         an_error = subunit.RemotedTestCase("an error")
         self.assertEqual(client.errors,
                          [(an_error, 'RemoteException: \n\n')])
+                         [(an_error, _remote_exception_str + '\n')])
         self.assertEqual(
             client.failures,
+            [(bing, "RemoteException: foo.c:53:ERROR invalid state\n\n")])
+            [(bing, _remote_exception_str + ": Text attachment: traceback\n"
+                "------------\nfoo.c:53:ERROR invalid state\n"
+                "------------\n\n")])
         self.assertEqual(client.testsRun, 3)
+    def test_non_test_characters_forwarded_immediately(self):
+        pass
 class TestTestProtocolServerStartTest(unittest.TestCase):
     def setUp(self):
         self.client = MockTestProtocolServerClient()
+        self.client = Python26TestResult()
         self.protocol = subunit.TestProtocolServer(self.client)
     def test_start_test(self):
         self.protocol.lineReceived("test old mcdonald\n")
         self.assertEqual(self.client.start_calls,
                          [subunit.RemotedTestCase("old mcdonald")])
+        self.assertEqual(self.client._events,
+            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
     def test_start_testing(self):
         self.protocol.lineReceived("testing old mcdonald\n")
         self.assertEqual(self.client.start_calls,
                          [subunit.RemotedTestCase("old mcdonald")])
+        self.assertEqual(self.client._events,
+            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
     def test_start_test_colon(self):
         self.protocol.lineReceived("test: old mcdonald\n")
+        self.assertEqual(self.client.start_calls,
+                         [subunit.RemotedTestCase("old mcdonald")])
+        self.assertEqual(self.client._events,
+            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
+    def test_indented_test_colon_ignored(self):
+        self.protocol.lineReceived(" test: old mcdonald\n")
+        self.assertEqual([], self.client._events)
     def test_start_testing_colon(self):
         self.protocol.lineReceived("testing: old mcdonald\n")
         self.assertEqual(self.client.start_calls,
                          [subunit.RemotedTestCase("old mcdonald")])
+        self.assertEqual(self.client._events,
+            [('startTest', subunit.RemotedTestCase("old mcdonald"))])
 …
     def setUp(self):
-        from StringIO import StringIO
         self.stdout = StringIO()
         self.test = subunit.RemotedTestCase("old mcdonald")
         self.client = MockTestProtocolServerClient()
+        self.client = ExtendedTestResult()
         self.protocol = subunit.TestProtocolServer(self.client, self.stdout)
 …
     def test_keywords_before_test(self):
         self.keywords_before_test()
+        self.assertEqual(self.client.start_calls, [])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls, [])
+        self.assertEqual(self.client.success_calls, [])
+        self.assertEqual(self.client._events, [])
     def test_keywords_after_error(self):
 …
         self.protocol.lineReceived("error old mcdonald\n")
         self.keywords_before_test()
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls,
+                         [(self.test, subunit.RemoteError(""))])
+        self.assertEqual(self.client.failure_calls, [])
+        self.assertEqual(self.client.success_calls, [])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addError', self.test, {}),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_keywords_after_failure(self):
 …
         self.protocol.lineReceived("failure old mcdonald\n")
         self.keywords_before_test()
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls,
+                         [(self.test, subunit.RemoteError())])
+        self.assertEqual(self.client.success_calls, [])
+        self.assertEqual(self.client._events, [
+            ('startTest', self.test),
+            ('addFailure', self.test, {}),
+            ('stopTest', self.test),
+            ])
     def test_keywords_after_success(self):
 …
         self.protocol.lineReceived("success old mcdonald\n")
         self.keywords_before_test()
         self.assertEqual(self.client.start_calls, [self.test])
         self.assertEqual(self.client.end_calls, [self.test])
         self.assertEqual(self.client.error_calls, [])
         self.assertEqual(self.client.failure_calls, [])
         self.assertEqual(self.client.success_calls, [self.test])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addSuccess', self.test),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_keywords_after_test(self):
 …
                                                  "successful: a\n"
                                                  "]\n")
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.failure_calls,
+                         [(self.test, subunit.RemoteError())])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.success_calls, [])
+        self.assertEqual(self.client._events, [
+            ('startTest', self.test),
+            ('addFailure', self.test, {}),
+            ('stopTest', self.test),
+            ])
     def test_keywords_during_failure(self):
+        # A smoke test to make sure that the details parsers have control
+        # appropriately.
         self.protocol.lineReceived("test old mcdonald\n")
         self.protocol.lineReceived("failure: old mcdonald [\n")
 …
         self.protocol.lineReceived("]\n")
         self.assertEqual(self.stdout.getvalue(), "")
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.failure_calls,
+                         [(self.test, subunit.RemoteError("test old mcdonald\n"
+                                                  "failure a\n"
+                                                  "failure: a\n"
+                                                  "error a\n"
+                                                  "error: a\n"
+                                                  "success a\n"
+                                                  "success: a\n"
+                                                  "successful a\n"
+                                                  "successful: a\n"
+                                                  "]\n"))])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.success_calls, [])
+        details = {}
+        details['traceback'] = Content(ContentType("text", "x-traceback",
+            {'charset': 'utf8'}),
+            lambda:[
+            "test old mcdonald\n"
+            "failure a\n"
+            "failure: a\n"
+            "error a\n"
+            "error: a\n"
+            "success a\n"
+            "success: a\n"
+            "successful a\n"
+            "successful: a\n"
+            "]\n"])
+        self.assertEqual(self.client._events, [
+            ('startTest', self.test),
+            ('addFailure', self.test, details),
+            ('stopTest', self.test),
+            ])
     def test_stdout_passthrough(self):
 …
     def setUp(self):
         self.client = MockTestProtocolServerClient()
+        self.client = Python26TestResult()
         self.protocol = subunit.TestProtocolServer(self.client)
         self.test = subunit.RemotedTestCase("old mcdonald")
 …
     def test_lost_connection_no_input(self):
         self.protocol.lostConnection()
+        self.assertEqual(self.client.start_calls, [])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls, [])
+        self.assertEqual(self.client.success_calls, [])
+        self.assertEqual([], self.client._events)
     def test_lost_connection_after_start(self):
         self.protocol.lineReceived("test old mcdonald\n")
         self.protocol.lostConnection()
         self.assertEqual(self.client.start_calls, [self.test])
         self.assertEqual(self.client.end_calls, [self.test])
         self.assertEqual(self.client.error_calls, [
             (self.test, subunit.RemoteError("lost connection during "
                                             "test 'old mcdonald'"))])
         self.assertEqual(self.client.failure_calls, [])
         self.assertEqual(self.client.success_calls, [])
+        failure = subunit.RemoteError(
+            u"lost connection during test 'old mcdonald'")
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addError', self.test, failure),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_lost_connected_after_error(self):
 …
         self.protocol.lineReceived("error old mcdonald\n")
         self.protocol.lostConnection()
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.failure_calls, [])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [
+            (self.test, subunit.RemoteError(""))])
+        self.assertEqual(self.client.success_calls, [])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addError', self.test, subunit.RemoteError(u"")),
+            ('stopTest', self.test),
+            ], self.client._events)
+    def do_connection_lost(self, outcome, opening):
+        self.protocol.lineReceived("test old mcdonald\n")
+        self.protocol.lineReceived("%s old mcdonald %s" % (outcome, opening))
+        self.protocol.lostConnection()
+        failure = subunit.RemoteError(
+            u"lost connection during %s report of test 'old mcdonald'" %
+            outcome)
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addError', self.test, failure),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_lost_connection_during_error(self):
+        self.protocol.lineReceived("test old mcdonald\n")
+        self.protocol.lineReceived("error old mcdonald [\n")
+        self.protocol.lostConnection()
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [
+            (self.test, subunit.RemoteError("lost connection during error "
+                                            "report of test 'old mcdonald'"))])
+        self.assertEqual(self.client.failure_calls, [])
+        self.assertEqual(self.client.success_calls, [])
+        self.do_connection_lost("error", "[\n")
+    def test_lost_connection_during_error_details(self):
+        self.do_connection_lost("error", "[ multipart\n")
     def test_lost_connected_after_failure(self):
 …
         self.protocol.lineReceived("failure old mcdonald\n")
         self.protocol.lostConnection()
+        test = subunit.RemotedTestCase("old mcdonald")
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls,
+                         [(self.test, subunit.RemoteError())])
+        self.assertEqual(self.client.success_calls, [])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addFailure', self.test, subunit.RemoteError(u"")),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_lost_connection_during_failure(self):
+        self.protocol.lineReceived("test old mcdonald\n")
+        self.protocol.lineReceived("failure old mcdonald [\n")
+        self.protocol.lostConnection()
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls,
+                         [(self.test,
+                           subunit.RemoteError("lost connection during "
+                                               "failure report"
+                                               " of test 'old mcdonald'"))])
+        self.assertEqual(self.client.failure_calls, [])
+        self.assertEqual(self.client.success_calls, [])
+        self.do_connection_lost("failure", "[\n")
+    def test_lost_connection_during_failure_details(self):
+        self.do_connection_lost("failure", "[ multipart\n")
     def test_lost_connection_after_success(self):
 …
         self.protocol.lineReceived("success old mcdonald\n")
         self.protocol.lostConnection()
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls, [])
+        self.assertEqual(self.client.success_calls, [self.test])
+class TestTestProtocolServerAddError(unittest.TestCase):
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addSuccess', self.test),
+            ('stopTest', self.test),
+            ], self.client._events)
+    def test_lost_connection_during_success(self):
+        self.do_connection_lost("success", "[\n")
+    def test_lost_connection_during_success_details(self):
+        self.do_connection_lost("success", "[ multipart\n")
+    def test_lost_connection_during_skip(self):
+        self.do_connection_lost("skip", "[\n")
+    def test_lost_connection_during_skip_details(self):
+        self.do_connection_lost("skip", "[ multipart\n")
+    def test_lost_connection_during_xfail(self):
+        self.do_connection_lost("xfail", "[\n")
+    def test_lost_connection_during_xfail_details(self):
+        self.do_connection_lost("xfail", "[ multipart\n")
+class TestInTestMultipart(unittest.TestCase):
     def setUp(self):
         self.client = MockTestProtocolServerClient()
+        self.client = ExtendedTestResult()
         self.protocol = subunit.TestProtocolServer(self.client)
         self.protocol.lineReceived("test mcdonalds farm\n")
         self.test = subunit.RemotedTestCase("mcdonalds farm")
+    def test__outcome_sets_details_parser(self):
+        self.protocol._reading_success_details.details_parser = None
+        self.protocol._state._outcome(0, "mcdonalds farm [ multipart\n",
+            None, self.protocol._reading_success_details)
+        parser = self.protocol._reading_success_details.details_parser
+        self.assertNotEqual(None, parser)
+        self.assertTrue(isinstance(parser,
+            subunit.details.MultipartDetailsParser))
+class TestTestProtocolServerAddError(unittest.TestCase):
+    def setUp(self):
+        self.client = ExtendedTestResult()
+        self.protocol = subunit.TestProtocolServer(self.client)
+        self.protocol.lineReceived("test mcdonalds farm\n")
+        self.test = subunit.RemotedTestCase("mcdonalds farm")
     def simple_error_keyword(self, keyword):
         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [
+            (self.test, subunit.RemoteError(""))])
+        self.assertEqual(self.client.failure_calls, [])
+        details = {}
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addError', self.test, details),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_simple_error(self):
 …
         self.protocol.lineReceived("error mcdonalds farm [\n")
         self.protocol.lineReceived("]\n")
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [
+            (self.test, subunit.RemoteError(""))])
+        self.assertEqual(self.client.failure_calls, [])
+        details = {}
+        details['traceback'] = Content(ContentType("text", "x-traceback",
+            {'charset': 'utf8'}), lambda:[""])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addError', self.test, details),
+            ('stopTest', self.test),
+            ], self.client._events)
     def error_quoted_bracket(self, keyword):
 …
         self.protocol.lineReceived(" ]\n")
         self.protocol.lineReceived("]\n")
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [
+            (self.test, subunit.RemoteError("]\n"))])
+        self.assertEqual(self.client.failure_calls, [])
+        details = {}
+        details['traceback'] = Content(ContentType("text", "x-traceback",
+            {'charset': 'utf8'}), lambda:["]\n"])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addError', self.test, details),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_error_quoted_bracket(self):
 …
     def setUp(self):
         self.client = MockTestProtocolServerClient()
+        self.client = ExtendedTestResult()
         self.protocol = subunit.TestProtocolServer(self.client)
         self.protocol.lineReceived("test mcdonalds farm\n")
         self.test = subunit.RemotedTestCase("mcdonalds farm")
+    def assertFailure(self, details):
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addFailure', self.test, details),
+            ('stopTest', self.test),
+            ], self.client._events)
     def simple_failure_keyword(self, keyword):
         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls,
+                         [(self.test, subunit.RemoteError())])
+        details = {}
+        self.assertFailure(details)
     def test_simple_failure(self):
 …
         self.protocol.lineReceived("failure mcdonalds farm [\n")
         self.protocol.lineReceived("]\n")
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls,
+                         [(self.test, subunit.RemoteError())])
+        details = {}
+        details['traceback'] = Content(ContentType("text", "x-traceback",
+            {'charset': 'utf8'}), lambda:[""])
+        self.assertFailure(details)
     def failure_quoted_bracket(self, keyword):
 …
         self.protocol.lineReceived(" ]\n")
         self.protocol.lineReceived("]\n")
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.failure_calls,
+                         [(self.test, subunit.RemoteError("]\n"))])
+        details = {}
+        details['traceback'] = Content(ContentType("text", "x-traceback",
+            {'charset': 'utf8'}), lambda:["]\n"])
+        self.assertFailure(details)
     def test_failure_quoted_bracket(self):
 …
+class TestTestProtocolServerAddxFail(unittest.TestCase):
+    """Tests for the xfail keyword.
+    In Python this can thunk through to Success due to stdlib limitations (see
+    README).
+    """
+    def capture_expected_failure(self, test, err):
+        self._events.append((test, err))
+    def setup_python26(self):
+        """Setup a test object ready to be xfailed and thunk to success."""
+        self.client = Python26TestResult()
+        self.setup_protocol()
+    def setup_python27(self):
+        """Setup a test object ready to be xfailed."""
+        self.client = Python27TestResult()
+        self.setup_protocol()
+    def setup_python_ex(self):
+        """Setup a test object ready to be xfailed with details."""
+        self.client = ExtendedTestResult()
+        self.setup_protocol()
+    def setup_protocol(self):
+        """Setup the protocol based on self.client."""
+        self.protocol = subunit.TestProtocolServer(self.client)
+        self.protocol.lineReceived("test mcdonalds farm\n")
+        self.test = self.client._events[-1][-1]
+    def simple_xfail_keyword(self, keyword, as_success):
+        self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+        self.check_success_or_xfail(as_success)
+    def check_success_or_xfail(self, as_success, error_message=None):
+        if as_success:
+            self.assertEqual([
+                ('startTest', self.test),
+                ('addSuccess', self.test),
+                ('stopTest', self.test),
+                ], self.client._events)
+        else:
+            details = {}
+            if error_message is not None:
+                details['traceback'] = Content(
+                    ContentType("text", "x-traceback", {'charset': 'utf8'}),
+                    lambda:[error_message])
+            if isinstance(self.client, ExtendedTestResult):
+                value = details
+            else:
+                if error_message is not None:
+                    value = subunit.RemoteError(u'Text attachment: traceback\n'
+                        '------------\n' + error_message + '------------\n')
+                else:
+                    value = subunit.RemoteError()
+            self.assertEqual([
+                ('startTest', self.test),
+                ('addExpectedFailure', self.test, value),
+                ('stopTest', self.test),
+                ], self.client._events)
+    def test_simple_xfail(self):
+        self.setup_python26()
+        self.simple_xfail_keyword("xfail", True)
+        self.setup_python27()
+        self.simple_xfail_keyword("xfail",  False)
+        self.setup_python_ex()
+        self.simple_xfail_keyword("xfail",  False)
+    def test_simple_xfail_colon(self):
+        self.setup_python26()
+        self.simple_xfail_keyword("xfail:", True)
+        self.setup_python27()
+        self.simple_xfail_keyword("xfail:", False)
+        self.setup_python_ex()
+        self.simple_xfail_keyword("xfail:", False)
+    def test_xfail_empty_message(self):
+        self.setup_python26()
+        self.empty_message(True)
+        self.setup_python27()
+        self.empty_message(False)
+        self.setup_python_ex()
+        self.empty_message(False, error_message="")
+    def empty_message(self, as_success, error_message="\n"):
+        self.protocol.lineReceived("xfail mcdonalds farm [\n")
+        self.protocol.lineReceived("]\n")
+        self.check_success_or_xfail(as_success, error_message)
+    def xfail_quoted_bracket(self, keyword, as_success):
+        # This tests it is accepted, but cannot test it is used today, because
+        # of not having a way to expose it in Python so far.
+        self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
+        self.protocol.lineReceived(" ]\n")
+        self.protocol.lineReceived("]\n")
+        self.check_success_or_xfail(as_success, "]\n")
+    def test_xfail_quoted_bracket(self):
+        self.setup_python26()
+        self.xfail_quoted_bracket("xfail", True)
+        self.setup_python27()
+        self.xfail_quoted_bracket("xfail", False)
+        self.setup_python_ex()
+        self.xfail_quoted_bracket("xfail", False)
+    def test_xfail_colon_quoted_bracket(self):
+        self.setup_python26()
+        self.xfail_quoted_bracket("xfail:", True)
+        self.setup_python27()
+        self.xfail_quoted_bracket("xfail:", False)
+        self.setup_python_ex()
+        self.xfail_quoted_bracket("xfail:", False)
+class TestTestProtocolServerAddSkip(unittest.TestCase):
+    """Tests for the skip keyword.
+    In Python this meets the testtools extended TestResult contract.
+    (See https://launchpad.net/testtools).
+    """
+    def setUp(self):
+        """Setup a test object ready to be skipped."""
+        self.client = ExtendedTestResult()
+        self.protocol = subunit.TestProtocolServer(self.client)
+        self.protocol.lineReceived("test mcdonalds farm\n")
+        self.test = self.client._events[-1][-1]
+    def assertSkip(self, reason):
+        details = {}
+        if reason is not None:
+            details['reason'] = Content(
+                ContentType("text", "plain"), lambda:[reason])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addSkip', self.test, details),
+            ('stopTest', self.test),
+            ], self.client._events)
+    def simple_skip_keyword(self, keyword):
+        self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+        self.assertSkip(None)
+    def test_simple_skip(self):
+        self.simple_skip_keyword("skip")
+    def test_simple_skip_colon(self):
+        self.simple_skip_keyword("skip:")
+    def test_skip_empty_message(self):
+        self.protocol.lineReceived("skip mcdonalds farm [\n")
+        self.protocol.lineReceived("]\n")
+        self.assertSkip("")
+    def skip_quoted_bracket(self, keyword):
+        # This tests it is accepted, but cannot test it is used today, because
+        # of not having a way to expose it in Python so far.
+        self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
+        self.protocol.lineReceived(" ]\n")
+        self.protocol.lineReceived("]\n")
+        self.assertSkip("]\n")
+    def test_skip_quoted_bracket(self):
+        self.skip_quoted_bracket("skip")
+    def test_skip_colon_quoted_bracket(self):
+        self.skip_quoted_bracket("skip:")
 class TestTestProtocolServerAddSuccess(unittest.TestCase):
     def setUp(self):
         self.client = MockTestProtocolServerClient()
+        self.client = ExtendedTestResult()
         self.protocol = subunit.TestProtocolServer(self.client)
         self.protocol.lineReceived("test mcdonalds farm\n")
 …
     def simple_success_keyword(self, keyword):
         self.protocol.lineReceived("%s mcdonalds farm\n" % keyword)
+        self.assertEqual(self.client.start_calls, [self.test])
+        self.assertEqual(self.client.end_calls, [self.test])
+        self.assertEqual(self.client.error_calls, [])
+        self.assertEqual(self.client.success_calls, [self.test])
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addSuccess', self.test),
+            ('stopTest', self.test),
+            ], self.client._events)
     def test_simple_success(self):
 …
     def test_simple_success_colon(self):
         self.simple_success_keyword("successful:")
+    def assertSuccess(self, details):
+        self.assertEqual([
+            ('startTest', self.test),
+            ('addSuccess', self.test, details),
+            ('stopTest', self.test),
+            ], self.client._events)
+    def test_success_empty_message(self):
+        self.protocol.lineReceived("success mcdonalds farm [\n")
+        self.protocol.lineReceived("]\n")
+        details = {}
+        details['message'] = Content(ContentType("text", "plain"),
+            lambda:[""])
+        self.assertSuccess(details)
+    def success_quoted_bracket(self, keyword):
+        # This tests it is accepted, but cannot test it is used today, because
+        # of not having a way to expose it in Python so far.
+        self.protocol.lineReceived("%s mcdonalds farm [\n" % keyword)
+        self.protocol.lineReceived(" ]\n")
+        self.protocol.lineReceived("]\n")
+        details = {}
+        details['message'] = Content(ContentType("text", "plain"),
+            lambda:["]\n"])
+        self.assertSuccess(details)
+    def test_success_quoted_bracket(self):
+        self.success_quoted_bracket("success")
+    def test_success_colon_quoted_bracket(self):
+        self.success_quoted_bracket("success:")
+class TestTestProtocolServerProgress(unittest.TestCase):
+    """Test receipt of progress: directives."""
+    def test_progress_accepted_stdlib(self):
+        self.result = Python26TestResult()
+        self.stream = StringIO()
+        self.protocol = subunit.TestProtocolServer(self.result,
+            stream=self.stream)
+        self.protocol.lineReceived("progress: 23")
+        self.protocol.lineReceived("progress: -2")
+        self.protocol.lineReceived("progress: +4")
+        self.assertEqual("", self.stream.getvalue())
+    def test_progress_accepted_extended(self):
+        # With a progress capable TestResult, progress events are emitted.
+        self.result = ExtendedTestResult()
+        self.stream = StringIO()
+        self.protocol = subunit.TestProtocolServer(self.result,
+            stream=self.stream)
+        self.protocol.lineReceived("progress: 23")
+        self.protocol.lineReceived("progress: push")
+        self.protocol.lineReceived("progress: -2")
+        self.protocol.lineReceived("progress: pop")
+        self.protocol.lineReceived("progress: +4")
+        self.assertEqual("", self.stream.getvalue())
+        self.assertEqual([
+            ('progress', 23, subunit.PROGRESS_SET),
+            ('progress', None, subunit.PROGRESS_PUSH),
+            ('progress', -2, subunit.PROGRESS_CUR),
+            ('progress', None, subunit.PROGRESS_POP),
+            ('progress', 4, subunit.PROGRESS_CUR),
+            ], self.result._events)
+class TestTestProtocolServerStreamTags(unittest.TestCase):
+    """Test managing tags on the protocol level."""
+    def setUp(self):
+        self.client = ExtendedTestResult()
+        self.protocol = subunit.TestProtocolServer(self.client)
+    def test_initial_tags(self):
+        self.protocol.lineReceived("tags: foo bar:baz  quux\n")
+        self.assertEqual([
+            ('tags', set(["foo", "bar:baz", "quux"]), set()),
+            ], self.client._events)
+    def test_minus_removes_tags(self):
+        self.protocol.lineReceived("tags: -bar quux\n")
+        self.assertEqual([
+            ('tags', set(["quux"]), set(["bar"])),
+            ], self.client._events)
+    def test_tags_do_not_get_set_on_test(self):
+        self.protocol.lineReceived("test mcdonalds farm\n")
+        test = self.client._events[0][-1]
+        self.assertEqual(None, getattr(test, 'tags', None))
+    def test_tags_do_not_get_set_on_global_tags(self):
+        self.protocol.lineReceived("tags: foo bar\n")
+        self.protocol.lineReceived("test mcdonalds farm\n")
+        test = self.client._events[-1][-1]
+        self.assertEqual(None, getattr(test, 'tags', None))
+    def test_tags_get_set_on_test_tags(self):
+        self.protocol.lineReceived("test mcdonalds farm\n")
+        test = self.client._events[-1][-1]
+        self.protocol.lineReceived("tags: foo bar\n")
+        self.protocol.lineReceived("success mcdonalds farm\n")
+        self.assertEqual(None, getattr(test, 'tags', None))
+class TestTestProtocolServerStreamTime(unittest.TestCase):
+    """Test managing time information at the protocol level."""
+    def test_time_accepted_stdlib(self):
+        self.result = Python26TestResult()
+        self.stream = StringIO()
+        self.protocol = subunit.TestProtocolServer(self.result,
+            stream=self.stream)
+        self.protocol.lineReceived("time: 2001-12-12 12:59:59Z\n")
+        self.assertEqual("", self.stream.getvalue())
+    def test_time_accepted_extended(self):
+        self.result = ExtendedTestResult()
+        self.stream = StringIO()
+        self.protocol = subunit.TestProtocolServer(self.result,
+            stream=self.stream)
+        self.protocol.lineReceived("time: 2001-12-12 12:59:59Z\n")
+        self.assertEqual("", self.stream.getvalue())
+        self.assertEqual([
+            ('time', datetime.datetime(2001, 12, 12, 12, 59, 59, 0,
+            iso8601.Utc()))
+            ], self.result._events)
 …
         self.assertEqual("A test description",
                          test.shortDescription())
         self.assertEqual("subunit.RemotedTestCase.A test description",
+        self.assertEqual("A test description",
                          test.id())
         self.assertEqual("A test description (subunit.RemotedTestCase)", "%s" % test)
 …
         result = unittest.TestResult()
         test.run(result)
         self.assertEqual([(test, "RemoteException: "
+        self.assertEqual([(test, _remote_exception_str + ": "
                                  "Cannot run RemotedTestCases.\n\n")],
                          result.errors)
 …
     def test_eq(self):
         error = subunit.RemoteError("Something went wrong")
         another_error = subunit.RemoteError("Something went wrong")
         different_error = subunit.RemoteError("boo!")
+        error = subunit.RemoteError(u"Something went wrong")
+        another_error = subunit.RemoteError(u"Something went wrong")
+        different_error = subunit.RemoteError(u"boo!")
         self.assertEqual(error, another_error)
         self.assertNotEqual(error, different_error)
 …
     def test_empty_constructor(self):
         self.assertEqual(subunit.RemoteError(), subunit.RemoteError(""))
+        self.assertEqual(subunit.RemoteError(), subunit.RemoteError(u""))
 …
             # that fails, errors and succeeds
+        def test_sample_method_args(self):
+            """sample-script.py foo"""
+            # sample that will run just one test.
     def test_construct(self):
 …
                          subunit.join_dir(__file__, 'sample-script.py'))
+    def test_args(self):
+        result = unittest.TestResult()
+        test = self.SampleExecTestCase("test_sample_method_args")
+        test.run(result)
+        self.assertEqual(1, result.testsRun)
     def test_run(self):
         runner = MockTestProtocolServerClient()
+        result = ExtendedTestResult()
         test = self.SampleExecTestCase("test_sample_method")
         test.run(runner)
+        test.run(result)
         mcdonald = subunit.RemotedTestCase("old mcdonald")
         bing = subunit.RemotedTestCase("bing crosby")
+        bing_details = {}
+        bing_details['traceback'] = Content(ContentType("text", "x-traceback",
+            {'charset': 'utf8'}), lambda:["foo.c:53:ERROR invalid state\n"])
         an_error = subunit.RemotedTestCase("an error")
+        self.assertEqual(runner.error_calls,
+                         [(an_error, subunit.RemoteError())])
+        self.assertEqual(runner.failure_calls,
+                         [(bing,
+                           subunit.RemoteError(
+                            "foo.c:53:ERROR invalid state\n"))])
+        self.assertEqual(runner.start_calls, [mcdonald, bing, an_error])
+        self.assertEqual(runner.end_calls, [mcdonald, bing, an_error])
+        error_details = {}
+        self.assertEqual([
+            ('startTest', mcdonald),
+            ('addSuccess', mcdonald),
+            ('stopTest', mcdonald),
+            ('startTest', bing),
+            ('addFailure', bing, bing_details),
+            ('stopTest', bing),
+            ('startTest', an_error),
+            ('addError', an_error, error_details),
+            ('stopTest', an_error),
+            ], result._events)
     def test_debug(self):
 …
         self.protocol = subunit.TestProtocolClient(self.io)
         self.test = TestTestProtocolClient("test_start_test")
+        self.sample_details = {'something':Content(
+            ContentType('text', 'plain'), lambda:['serialised\nform'])}
+        self.sample_tb_details = dict(self.sample_details)
+        self.sample_tb_details['traceback'] = TracebackContent(
+            subunit.RemoteError(u"boo qux"), self.test)
     def test_start_test(self):
 …
     def test_stop_test(self):
         """Test stopTest on a TestProtocolClient."""
+        # stopTest doesn't output anything.
         self.protocol.stopTest(self.test)
         self.assertEqual(self.io.getvalue(), "")
 …
             self.io.getvalue(), "successful: %s\n" % self.test.id())
+    def test_add_success_details(self):
+        """Test addSuccess on a TestProtocolClient with details."""
+        self.protocol.addSuccess(self.test, details=self.sample_details)
+        self.assertEqual(
+            self.io.getvalue(), "successful: %s [ multipart\n"
+                "Content-Type: text/plain\n"
+                "something\n"
+                "F\r\nserialised\nform0\r\n]\n" % self.test.id())
     def test_add_failure(self):
         """Test addFailure on a TestProtocolClient."""
+        self.protocol.addFailure(self.test, subunit.RemoteError("boo"))
+        self.protocol.addFailure(
+            self.test, subunit.RemoteError(u"boo qux"))
         self.assertEqual(
             self.io.getvalue(),
+            'failure: %s [\nRemoteException: boo\n]\n' % self.test.id())
+            ('failure: %s [\n' + _remote_exception_str + ': boo qux\n]\n')
+            % self.test.id())
+    def test_add_failure_details(self):
+        """Test addFailure on a TestProtocolClient with details."""
+        self.protocol.addFailure(
+            self.test, details=self.sample_tb_details)
+        self.assertEqual(
+            self.io.getvalue(),
+            ("failure: %s [ multipart\n"
+            "Content-Type: text/plain\n"
+            "something\n"
+            "F\r\nserialised\nform0\r\n"
+            "Content-Type: text/x-traceback;charset=utf8,language=python\n"
+            "traceback\n"
+            "1A\r\n" + _remote_exception_str + ": boo qux\n0\r\n"
+            "]\n") % self.test.id())
     def test_add_error(self):
         """Test stopTest on a TestProtocolClient."""
+        self.protocol.addError(self.test, subunit.RemoteError("phwoar"))
+        self.protocol.addError(
+            self.test, subunit.RemoteError(u"phwoar crikey"))
         self.assertEqual(
             self.io.getvalue(),
+            'error: %s [\n'
+            "RemoteException: phwoar\n"
+            ('error: %s [\n' +
+            _remote_exception_str + ": phwoar crikey\n"
+            "]\n") % self.test.id())
+    def test_add_error_details(self):
+        """Test stopTest on a TestProtocolClient with details."""
+        self.protocol.addError(
+            self.test, details=self.sample_tb_details)
+        self.assertEqual(
+            self.io.getvalue(),
+            ("error: %s [ multipart\n"
+            "Content-Type: text/plain\n"
+            "something\n"
+            "F\r\nserialised\nform0\r\n"
+            "Content-Type: text/x-traceback;charset=utf8,language=python\n"
+            "traceback\n"
+            "1A\r\n" + _remote_exception_str + ": boo qux\n0\r\n"
+            "]\n") % self.test.id())
+    def test_add_expected_failure(self):
+        """Test addExpectedFailure on a TestProtocolClient."""
+        self.protocol.addExpectedFailure(
+            self.test, subunit.RemoteError(u"phwoar crikey"))
+        self.assertEqual(
+            self.io.getvalue(),
+            ('xfail: %s [\n' +
+            _remote_exception_str + ": phwoar crikey\n"
+            "]\n") % self.test.id())
+    def test_add_expected_failure_details(self):
+        """Test addExpectedFailure on a TestProtocolClient with details."""
+        self.protocol.addExpectedFailure(
+            self.test, details=self.sample_tb_details)
+        self.assertEqual(
+            self.io.getvalue(),
+            ("xfail: %s [ multipart\n"
+            "Content-Type: text/plain\n"
+            "something\n"
+            "F\r\nserialised\nform0\r\n"
+            "Content-Type: text/x-traceback;charset=utf8,language=python\n"
+            "traceback\n"
+            "1A\r\n"+ _remote_exception_str + ": boo qux\n0\r\n"
+            "]\n") % self.test.id())
+    def test_add_skip(self):
+        """Test addSkip on a TestProtocolClient."""
+        self.protocol.addSkip(
+            self.test, "Has it really?")
+        self.assertEqual(
+            self.io.getvalue(),
+            'skip: %s [\nHas it really?\n]\n' % self.test.id())
+    def test_add_skip_details(self):
+        """Test addSkip on a TestProtocolClient with details."""
+        details = {'reason':Content(
+            ContentType('text', 'plain'), lambda:['Has it really?'])}
+        self.protocol.addSkip(
+            self.test, details=details)
+        self.assertEqual(
+            self.io.getvalue(),
+            "skip: %s [ multipart\n"
+            "Content-Type: text/plain\n"
+            "reason\n"
+            "E\r\nHas it really?0\r\n"
             "]\n" % self.test.id())
+    def test_progress_set(self):
+        self.protocol.progress(23, subunit.PROGRESS_SET)
+        self.assertEqual(self.io.getvalue(), 'progress: 23\n')
+    def test_progress_neg_cur(self):
+        self.protocol.progress(-23, subunit.PROGRESS_CUR)
+        self.assertEqual(self.io.getvalue(), 'progress: -23\n')
+    def test_progress_pos_cur(self):
+        self.protocol.progress(23, subunit.PROGRESS_CUR)
+        self.assertEqual(self.io.getvalue(), 'progress: +23\n')
+    def test_progress_pop(self):
+        self.protocol.progress(1234, subunit.PROGRESS_POP)
+        self.assertEqual(self.io.getvalue(), 'progress: pop\n')
+    def test_progress_push(self):
+        self.protocol.progress(1234, subunit.PROGRESS_PUSH)
+        self.assertEqual(self.io.getvalue(), 'progress: push\n')
+    def test_time(self):
+        # Calling time() outputs a time signal immediately.
+        self.protocol.time(
+            datetime.datetime(2009,10,11,12,13,14,15, iso8601.Utc()))
+        self.assertEqual(
+            "time: 2009-10-11 12:13:14.000015Z\n",
+            self.io.getvalue())
+    def test_add_unexpected_success(self):
+        """Test addUnexpectedSuccess on a TestProtocolClient."""
+        self.protocol.addUnexpectedSuccess(self.test)
+        self.assertEqual(
+            self.io.getvalue(), "successful: %s\n" % self.test.id())
+    def test_add_unexpected_success_details(self):
+        """Test addUnexpectedSuccess on a TestProtocolClient with details."""
+        self.protocol.addUnexpectedSuccess(self.test, details=self.sample_details)
+        self.assertEqual(
+            self.io.getvalue(), "successful: %s [ multipart\n"
+                "Content-Type: text/plain\n"
+                "something\n"
+                "F\r\nserialised\nform0\r\n]\n" % self.test.id())

vendor/current/lib/talloc/pytalloc.c

-              r414
+              r740
 /*
    Unix SMB/CIFS implementation.
    Python/Talloc glue
    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   Python Talloc Module
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2010
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "replace.h"
+#include <Python.h>
 #include <talloc.h>
 #include <pytalloc.h>
+/**
+ * Simple dealloc for talloc-wrapping PyObjects
  */
 void py_talloc_dealloc(PyObject* self)
+void inittalloc(void);
+/* print a talloc tree report for a talloc python object */
+static PyObject *py_talloc_report_full(PyObject *self, PyObject *args)
+{
+        py_talloc_Object *obj = (py_talloc_Object *)self;
+        talloc_free(obj->talloc_ctx);
+        obj->talloc_ctx = NULL;
+        self->ob_type->tp_free(self);
+        PyObject *py_obj = Py_None;
+        PyTypeObject *type;
+        if (!PyArg_ParseTuple(args, "|O", &py_obj))
+                return NULL;
+        if (py_obj == Py_None) {
+                talloc_report_full(NULL, stdout);
+        } else {
+                type = (PyTypeObject*)PyObject_Type(py_obj);
+                talloc_report_full(py_talloc_get_mem_ctx(py_obj), stdout);
+        }
+        return Py_None;
+}
+/**
+ * Import an existing talloc pointer into a Python object.
+ */
+PyObject *py_talloc_steal_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx,
+                                                   void *ptr)
+/* enable null tracking */
+static PyObject *py_talloc_enable_null_tracking(PyObject *self)
+{
+        py_talloc_Object *ret = (py_talloc_Object *)py_type->tp_alloc(py_type, 0);
+        ret->talloc_ctx = talloc_new(NULL);
+        if (ret->talloc_ctx == NULL) {
+                return NULL;
+        }
+        if (talloc_steal(ret->talloc_ctx, mem_ctx) == NULL) {
+                return NULL;
+        }
+        ret->ptr = ptr;
+        return (PyObject *)ret;
+        talloc_enable_null_tracking();
+        return Py_None;
+}
+/* return the number of talloc blocks */
+static PyObject *py_talloc_total_blocks(PyObject *self, PyObject *args)
+{
+        PyObject *py_obj = Py_None;
+        PyTypeObject *type;
+        if (!PyArg_ParseTuple(args, "|O", &py_obj))
+                return NULL;
+        if (py_obj == Py_None) {
+                return PyLong_FromLong(talloc_total_blocks(NULL));
+        }
+        type = (PyTypeObject*)PyObject_Type(py_obj);
+        return PyLong_FromLong(talloc_total_blocks(py_talloc_get_mem_ctx(py_obj)));
+}
+static PyMethodDef talloc_methods[] = {
+        { "report_full", (PyCFunction)py_talloc_report_full, METH_VARARGS,
+                "show a talloc tree for an object"},
+        { "enable_null_tracking", (PyCFunction)py_talloc_enable_null_tracking, METH_NOARGS,
+                "enable tracking of the NULL object"},
+        { "total_blocks", (PyCFunction)py_talloc_total_blocks, METH_VARARGS,
+                "return talloc block count"},
+        { NULL }
+};
 /**
+ * Import an existing talloc pointer into a Python object, leaving the
+ * original parent, and creating a reference to the object in the python
+ * object
+ * Default (but only slightly more useful than the default) implementation of Repr().
  */
+PyObject *py_talloc_reference_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx, void *ptr)
+{
+        py_talloc_Object *ret = (py_talloc_Object *)py_type->tp_alloc(py_type, 0);
+        ret->talloc_ctx = talloc_new(NULL);
+        if (ret->talloc_ctx == NULL) {
+                return NULL;
+        }
+        if (talloc_reference(ret->talloc_ctx, mem_ctx) == NULL) {
+                return NULL;
+        }
+        ret->ptr = ptr;
+        return (PyObject *)ret;
+}
+/**
+ * Default (but slightly more useful than the default) implementation of Repr().
+ */
+PyObject *py_talloc_default_repr(PyObject *obj)
+static PyObject *py_talloc_default_repr(PyObject *obj)
+{
         py_talloc_Object *talloc_obj = (py_talloc_Object *)obj;
 …
+}
+static void py_cobject_talloc_free(void *ptr)
+/**
+ * Simple dealloc for talloc-wrapping PyObjects
+ */
+static void py_talloc_dealloc(PyObject* self)
+{
+        talloc_free(ptr);
+        py_talloc_Object *obj = (py_talloc_Object *)self;
+        assert(talloc_unlink(NULL, obj->talloc_ctx) != -1);
+        obj->talloc_ctx = NULL;
+        self->ob_type->tp_free(self);
+}
+PyObject *PyCObject_FromTallocPtr(void *ptr)
+/**
+ * Default (but only slightly more useful than the default) implementation of cmp.
+ */
+static int py_talloc_default_cmp(PyObject *_obj1, PyObject *_obj2)
+{
+        return PyCObject_FromVoidPtr(ptr, py_cobject_talloc_free);
+        py_talloc_Object *obj1 = (py_talloc_Object *)_obj1,
+                                         *obj2 = (py_talloc_Object *)_obj2;
+        if (obj1->ob_type != obj2->ob_type)
+                return (obj1->ob_type - obj2->ob_type);
+        return ((char *)py_talloc_get_ptr(obj1) - (char *)py_talloc_get_ptr(obj2));
+}
+static PyTypeObject TallocObject_Type = {
+        .tp_name = "talloc.Object",
+        .tp_doc = "Python wrapper for a talloc-maintained object.",
+        .tp_basicsize = sizeof(py_talloc_Object),
+        .tp_dealloc = (destructor)py_talloc_dealloc,
+        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+        .tp_repr = py_talloc_default_repr,
+        .tp_compare = py_talloc_default_cmp,
+};
+void inittalloc(void)
+{
+        PyObject *m;
+        if (PyType_Ready(&TallocObject_Type) < 0)
+                return;
+        m = Py_InitModule3("talloc", talloc_methods,
+                                           "Python wrapping of talloc-maintained objects.");
+        if (m == NULL)
+                return;
+        Py_INCREF(&TallocObject_Type);
+        PyModule_AddObject(m, "Object", (PyObject *)&TallocObject_Type);
+}

vendor/current/lib/talloc/pytalloc.h

-              r414
+              r740
 } py_talloc_Object;
+/* Deallocate a py_talloc_Object */
 void py_talloc_dealloc(PyObject* self);
+PyTypeObject *PyTalloc_GetObjectType(void);
+int PyTalloc_Check(PyObject *);
 /* Retrieve the pointer for a py_talloc_object. Like talloc_get_type()
 …
 PyObject *py_talloc_steal_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx, void *ptr);
+PyObject *py_talloc_steal(PyTypeObject *py_type, void *ptr);
 PyObject *py_talloc_reference_ex(PyTypeObject *py_type, TALLOC_CTX *mem_ctx, void *ptr);
-#define py_talloc_steal(py_type, talloc_ptr) py_talloc_steal_ex(py_type, talloc_ptr, talloc_ptr)
 #define py_talloc_reference(py_type, talloc_ptr) py_talloc_reference_ex(py_type, talloc_ptr, talloc_ptr)
-/* Sane default implementation of reprfunc. */
-PyObject *py_talloc_default_repr(PyObject *py_obj);
 #define py_talloc_new(type, typeobj) py_talloc_steal(typeobj, talloc_zero(NULL, type))
 …
 PyObject *PyCObject_FromTallocPtr(void *);
+PyObject *PyString_FromString_check_null(const char *ptr);
 #endif /* _PY_TALLOC_H_ */

vendor/current/lib/talloc/script/mksigs.pl

-              r414
+              r740
 my $in_comment = 0;
+my $in_doxygen = 0;
 my $extern_C_block = 0;
 …
                         next;
+                }
+        }
+        # find end of DOXYGEN section
+        if ($in_doxygen) {
+                if ($LINE =~ /^#\s*else(?:\s+.*)?$/) {
+                        $in_doxygen = 0;
+                }
+                next;
+        }
 …
                 $LINE .= " " . $LINE2;
+        }
+        # remove DOXYGEN sections
+        if ($LINE =~ /^#\s*ifdef\s+DOXYGEN(?:\s+.*)?$/) {
+                $in_doxygen = 1;
+                next;
+        }
         # remove all preprocessor directives

vendor/current/lib/talloc/script/mksyms.awk

r414	r740
9	9	BEGIN {
10	10	inheader=0;
	11	indoxygen=0;
11	12	}
12	13
…	…
21	22	next;
22	23	}
	24	if (indoxygen) {
	25	if (match($0,"^#[ \t]else[ \t].*$")) {
	26	indoxygen = 0;
	27	}
	28	next;
	29	}
23	30	}
24	31
25		/^static/ \|\| /^[ \t]*typedef/ \|\| !/^[a-zA-Z\_]/ {
	32	/^static/ \|\| /^[ \t]*typedef/ \|\| !/^[a-zA-Z\_\#]/ {
26	33	next;
27	34	}
…	…
34	41	}
35	42
	43	/^#[ \t]ifdef[ \t]DOXYGEN[ \t].$/ {
	44	indoxygen=1;
	45	next;
	46	}
	47
36	48	# look for function headers:
37	49	{
38	50	gotstart = 0;
39	51	if ($0 ~ /^[A-Za-z_][A-Za-z0-9_]+/) {
40		gotstart = 1;
	52	gotstart = 1;
41	53	}
42	54	if(!gotstart) {

vendor/current/lib/talloc/script/release-script.sh

-              r414
+              r740
 #!/bin/bash
+LNAME=talloc
+LINCLUDE=talloc.h
 if [ "$1" = "" ]; then
 …
 fi
 if [ ! -d "lib/talloc" ]; then
+if [ ! -d "lib/${LNAME}" ]; then
     echo "Run this script from the samba base directory."
     exit 1
 fi
-# Check exports and signatures are up to date
-pushd lib/talloc
-./script/abi_checks.sh talloc talloc.h
-abicheck=$?
-popd
-if [ ! "$abicheck" = "0" ]; then
-    echo "ERROR: ABI Checks produced warnings!"
-    exit 1
-fi
-git clean -f -x -d lib/talloc
-git clean -f -x -d lib/replace
 curbranch=`git branch |grep "^*" | tr -d "* "`
 …
 # Checkout the release tag
 git branch -f talloc-release-script-${strver} talloc-${strver}
+git branch -f ${LNAME}-release-script-${strver} ${LNAME}-${strver}
 if [ ! "$?" = "0" ];  then
     echo "Unable to checkout talloc-${strver} release"
+    echo "Unable to checkout ${LNAME}-${strver} release"
     exit 1
 fi
+git checkout talloc-release-script-${strver}
+function cleanquit {
+    #Clean up
+    git checkout $curbranch
+    git branch -d ${LNAME}-release-script-${strver}
+    exit $1
+}
+# NOTE: use cleanquit after this point
+git checkout ${LNAME}-release-script-${strver}
 # Test configure agrees with us
 confver=`grep "^AC_INIT" lib/talloc/configure.ac | tr -d "AC_INIT(talloc, " | tr -d ")"`
+confver=`grep "^AC_INIT" lib/${LNAME}/configure.ac | tr -d "AC_INIT(${LNAME}, " | tr -d ")"`
 if [ ! "$confver" = "$version" ]; then
     echo "Wrong version, requested release for ${version}, found ${confver}"
     exit 1
+    cleanquit 1
 fi
+# Check exports and signatures are up to date
+pushd lib/${LNAME}
+./script/abi_checks.sh ${LNAME} ${LINCLUDE}
+abicheck=$?
+popd
+if [ ! "$abicheck" = "0" ]; then
+    echo "ERROR: ABI Checks produced warnings!"
+    cleanquit 1
+fi
+git clean -f -x -d lib/${LNAME}
+git clean -f -x -d lib/replace
 # Now build tarball
 cp -a lib/talloc talloc-${version}
 cp -a lib/replace talloc-${version}/libreplace
 pushd talloc-${version}
+cp -a lib/${LNAME} ${LNAME}-${version}
+cp -a lib/replace ${LNAME}-${version}/libreplace
+pushd ${LNAME}-${version}
 ./autogen.sh
 popd
 tar cvzf talloc-${version}.tar.gz talloc-${version}
 rm -fr talloc-${version}
+tar cvzf ${LNAME}-${version}.tar.gz ${LNAME}-${version}
+rm -fr ${LNAME}-${version}
+#Clean up
+git checkout $curbranch
+git branch -d talloc-release-script-${strver}
+cleanquit 0

vendor/current/lib/talloc/talloc.3.xml

-              r414
+              r740
   </refnamediv>
   <refsynopsisdiv>
 <synopsis>#include &lt;talloc/talloc.h&gt;</synopsis>
+<synopsis>#include &lt;talloc.h&gt;</synopsis>
   </refsynopsisdiv>
   <refsect1><title>DESCRIPTION</title>
 …
         <para>
           This is a utility macro that creates a new memory context hanging
           off an exiting context, automatically naming it "talloc_new:
+          off an existing context, automatically naming it "talloc_new:
           __location__" where __location__ is the source line it is called
           from.  It is particularly useful for creating a new temporary
 …
         <programlisting>talloc_set_name_const(ptr, ptr)</programlisting>
     </refsect2>
     <refsect2><title>char *talloc_append_string(const void *<emphasis role="italic">t</emphasis>, char *<emphasis role="italic">orig</emphasis>, const char *<emphasis role="italic">append</emphasis>);</title>
         <para>
           The talloc_append_string() function appends the given formatted
           string to the given string.
+    <refsect2><title>char *talloc_vasprintf(const void *<emphasis role="italic">t</emphasis>, const char *<emphasis role="italic">fmt</emphasis>, va_list <emphasis role="italic">ap</emphasis>);</title>
+        <para>
+          The talloc_vasprintf() function is the talloc equivalent of the C
+          library function vasprintf(3).
         </para>
         <para>
 …
         <programlisting>talloc_set_name_const(ptr, ptr)</programlisting>
     </refsect2>
+    <refsect2><title>char *talloc_vasprintf(const void *<emphasis role="italic">t</emphasis>, const char *<emphasis role="italic">fmt</emphasis>, va_list <emphasis role="italic">ap</emphasis>);</title>
+        <para>
+          The talloc_vasprintf() function is the talloc equivalent of the C
+          library function vasprintf(3).
+    <refsect2><title>char *talloc_asprintf(const void *<emphasis role="italic">t</emphasis>, const char *<emphasis role="italic">fmt</emphasis>, ...);</title>
+        <para>
+          The talloc_asprintf() function is the talloc equivalent of the C
+          library function asprintf(3).
+        </para>
+        <para>
+          This function sets the name of the new pointer to the passed
+          string. This is equivalent to:
+        </para>
+        <programlisting>talloc_set_name_const(ptr, ptr)</programlisting>
+    </refsect2>
+    <refsect2><title>char *talloc_asprintf_append(char *s, const char *fmt, ...);</title>
+        <para>
+          The talloc_asprintf_append() function appends the given formatted
+          string to the given string.
         </para>
         <para>
 …
         <programlisting>talloc_set_name_const(ptr, ptr)</programlisting>
     </refsect2>
+    <refsect2><title>char *talloc_asprintf(const void *<emphasis role="italic">t</emphasis>, const char *<emphasis role="italic">fmt</emphasis>, ...);</title>
+        <para>
+          The talloc_asprintf() function is the talloc equivalent of the C
+          library function asprintf(3).
+        </para>
+        <para>
+          This function sets the name of the new pointer to the passed
+          string. This is equivalent to:
+        </para>
+        <programlisting>talloc_set_name_const(ptr, ptr)</programlisting>
+    </refsect2>
+    <refsect2><title>char *talloc_asprintf_append(char *s, const char *fmt, ...);</title>
+        <para>
+          The talloc_asprintf_append() function appends the given formatted
+          string to the given string.
+        </para>
+        <para>
+          This function sets the name of the new pointer to the new
+          string. This is equivalent to:
+        </para>
+        <programlisting>talloc_set_name_const(ptr, ptr)</programlisting>
+    </refsect2>
+    <refsect2><title>(type *)talloc_array(const void *ctx, type, uint_t count);</title>
+    <refsect2><title>(type *)talloc_array(const void *ctx, type, unsigned int count);</title>
         <para>
           The talloc_array() macro is equivalent to:
 …
         </para>
     </refsect2>
     <refsect2><title>void *talloc_array_size(const void *ctx, size_t size, uint_t count);</title>
+    <refsect2><title>void *talloc_array_size(const void *ctx, size_t size, unsigned int count);</title>
         <para>
           The talloc_array_size() function is useful when the type is not
 …
         </para>
     </refsect2>
     <refsect2><title>(typeof(ptr)) talloc_array_ptrtype(const void *ctx, ptr, uint_t count);</title>
+    <refsect2><title>(typeof(ptr)) talloc_array_ptrtype(const void *ctx, ptr, unsigned int count);</title>
         <para>
           The talloc_ptrtype() macro should be used when you have a pointer to an array

vendor/current/lib/talloc/talloc.c

-              r414
+              r740
 #endif
+/* Special macros that are no-ops except when run under Valgrind on
+ * x86.  They've moved a little bit from valgrind 1.0.4 to 1.9.4 */
+#ifdef HAVE_VALGRIND_MEMCHECK_H
+        /* memcheck.h includes valgrind.h */
+#include <valgrind/memcheck.h>
+#elif defined(HAVE_VALGRIND_H)
+#include <valgrind.h>
+#endif
 /* use this to force every realloc to change the pointer, to stress test
    code that might not cope */
 …
 static void *null_context;
 static void *autofree_context;
+/* used to enable fill of memory on free, which can be useful for
+ * catching use after free errors when valgrind is too slow
+ */
+static struct {
+        bool initialised;
+        bool enabled;
+        uint8_t fill_value;
+} talloc_fill;
+#define TALLOC_FILL_ENV "TALLOC_FREE_FILL"
+/*
+ * do not wipe the header, to allow the
+ * double-free logic to still work
+ */
+#define TC_INVALIDATE_FULL_FILL_CHUNK(_tc) do { \
+        if (unlikely(talloc_fill.enabled)) { \
+                size_t _flen = (_tc)->size; \
+                char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
+                memset(_fptr, talloc_fill.fill_value, _flen); \
+        } \
+} while (0)
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
+/* Mark the whole chunk as not accessable */
+#define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { \
+        size_t _flen = TC_HDR_SIZE + (_tc)->size; \
+        char *_fptr = (char *)(_tc); \
+        VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
+} while(0)
+#else
+#define TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc) do { } while (0)
+#endif
+#define TC_INVALIDATE_FULL_CHUNK(_tc) do { \
+        TC_INVALIDATE_FULL_FILL_CHUNK(_tc); \
+        TC_INVALIDATE_FULL_VALGRIND_CHUNK(_tc); \
+} while (0)
+#define TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
+        if (unlikely(talloc_fill.enabled)) { \
+                size_t _flen = (_tc)->size - (_new_size); \
+                char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
+                _fptr += (_new_size); \
+                memset(_fptr, talloc_fill.fill_value, _flen); \
+        } \
+} while (0)
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
+/* Mark the unused bytes not accessable */
+#define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
+        size_t _flen = (_tc)->size - (_new_size); \
+        char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
+        _fptr += (_new_size); \
+        VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
+} while (0)
+#else
+#define TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
+#endif
+#define TC_INVALIDATE_SHRINK_CHUNK(_tc, _new_size) do { \
+        TC_INVALIDATE_SHRINK_FILL_CHUNK(_tc, _new_size); \
+        TC_INVALIDATE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
+} while (0)
+#define TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size) do { \
+        if (unlikely(talloc_fill.enabled)) { \
+                size_t _flen = (_tc)->size - (_new_size); \
+                char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
+                _fptr += (_new_size); \
+                memset(_fptr, talloc_fill.fill_value, _flen); \
+        } \
+} while (0)
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
+/* Mark the unused bytes as undefined */
+#define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { \
+        size_t _flen = (_tc)->size - (_new_size); \
+        char *_fptr = (char *)TC_PTR_FROM_CHUNK(_tc); \
+        _fptr += (_new_size); \
+        VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
+} while (0)
+#else
+#define TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
+#endif
+#define TC_UNDEFINE_SHRINK_CHUNK(_tc, _new_size) do { \
+        TC_UNDEFINE_SHRINK_FILL_CHUNK(_tc, _new_size); \
+        TC_UNDEFINE_SHRINK_VALGRIND_CHUNK(_tc, _new_size); \
+} while (0)
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
+/* Mark the new bytes as undefined */
+#define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { \
+        size_t _old_used = TC_HDR_SIZE + (_tc)->size; \
+        size_t _new_used = TC_HDR_SIZE + (_new_size); \
+        size_t _flen = _new_used - _old_used; \
+        char *_fptr = _old_used + (char *)(_tc); \
+        VALGRIND_MAKE_MEM_UNDEFINED(_fptr, _flen); \
+} while (0)
+#else
+#define TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size) do { } while (0)
+#endif
+#define TC_UNDEFINE_GROW_CHUNK(_tc, _new_size) do { \
+        TC_UNDEFINE_GROW_VALGRIND_CHUNK(_tc, _new_size); \
+} while (0)
 struct talloc_reference_handle {
 …
 /* 16 byte alignment seems to keep everyone happy */
+#define TC_HDR_SIZE ((sizeof(struct talloc_chunk)+15)&~15)
+#define TC_ALIGN16(s) (((s)+15)&~15)
+#define TC_HDR_SIZE TC_ALIGN16(sizeof(struct talloc_chunk))
 #define TC_PTR_FROM_CHUNK(tc) ((void *)(TC_HDR_SIZE + (char*)tc))
 int talloc_version_major(void)
+_PUBLIC_ int talloc_version_major(void)
+{
         return TALLOC_VERSION_MAJOR;
+}
 int talloc_version_minor(void)
+_PUBLIC_ int talloc_version_minor(void)
+{
         return TALLOC_VERSION_MINOR;
 …
 static void (*talloc_log_fn)(const char *message);
 void talloc_set_log_fn(void (*log_fn)(const char *message))
+_PUBLIC_ void talloc_set_log_fn(void (*log_fn)(const char *message))
+{
         talloc_log_fn = log_fn;
 …
+}
 void talloc_set_log_stderr(void)
+_PUBLIC_ void talloc_set_log_stderr(void)
+{
         talloc_set_log_fn(talloc_log_stderr);
 …
 static void (*talloc_abort_fn)(const char *reason);
 void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
+_PUBLIC_ void talloc_set_abort_fn(void (*abort_fn)(const char *reason))
+{
         talloc_abort_fn = abort_fn;
 …
+}
 static void talloc_abort_double_free(void)
+{
         talloc_abort("Bad talloc magic value - double free");
+static void talloc_abort_access_after_free(void)
+{
+        talloc_abort("Bad talloc magic value - access after free");
+}
 …
                 if (tc->flags & TALLOC_FLAG_FREE) {
                         talloc_log("talloc: double free error - first free may be at %s\n", tc->name);
                         talloc_abort_double_free();
+                        talloc_log("talloc: access after free error - first free may be at %s\n", tc->name);
+                        talloc_abort_access_after_free();
                         return NULL;
                 } else {
 …
+}
 void *talloc_parent(const void *ptr)
+_PUBLIC_ void *talloc_parent(const void *ptr)
+{
         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 …
   find parents name
 */
 const char *talloc_parent_name(const void *ptr)
+_PUBLIC_ const char *talloc_parent_name(const void *ptr)
+{
         struct talloc_chunk *tc = talloc_parent_chunk(ptr);
 …
 #define TALLOC_POOL_HDR_SIZE 16
+#define TC_POOL_SPACE_LEFT(_pool_tc) \
+        PTR_DIFF(TC_HDR_SIZE + (_pool_tc)->size + (char *)(_pool_tc), \
+                 (_pool_tc)->pool)
+#define TC_POOL_FIRST_CHUNK(_pool_tc) \
+        ((void *)(TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE + (char *)(_pool_tc)))
+#define TC_POOLMEM_CHUNK_SIZE(_tc) \
+        TC_ALIGN16(TC_HDR_SIZE + (_tc)->size)
+#define TC_POOLMEM_NEXT_CHUNK(_tc) \
+        ((void *)(TC_POOLMEM_CHUNK_SIZE(tc) + (char*)(_tc)))
+/* Mark the whole remaining pool as not accessable */
+#define TC_INVALIDATE_FILL_POOL(_pool_tc) do { \
+        if (unlikely(talloc_fill.enabled)) { \
+                size_t _flen = TC_POOL_SPACE_LEFT(_pool_tc); \
+                char *_fptr = (char *)(_pool_tc)->pool; \
+                memset(_fptr, talloc_fill.fill_value, _flen); \
+        } \
+} while(0)
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
+/* Mark the whole remaining pool as not accessable */
+#define TC_INVALIDATE_VALGRIND_POOL(_pool_tc) do { \
+        size_t _flen = TC_POOL_SPACE_LEFT(_pool_tc); \
+        char *_fptr = (char *)(_pool_tc)->pool; \
+        VALGRIND_MAKE_MEM_NOACCESS(_fptr, _flen); \
+} while(0)
+#else
+#define TC_INVALIDATE_VALGRIND_POOL(_pool_tc) do { } while (0)
+#endif
+#define TC_INVALIDATE_POOL(_pool_tc) do { \
+        TC_INVALIDATE_FILL_POOL(_pool_tc); \
+        TC_INVALIDATE_VALGRIND_POOL(_pool_tc); \
+} while (0)
 static unsigned int *talloc_pool_objectcount(struct talloc_chunk *tc)
+{
         return (unsigned int *)((char *)tc + sizeof(struct talloc_chunk));
+        return (unsigned int *)((char *)tc + TC_HDR_SIZE);
+}
 …
+        }
+        space_left = ((char *)pool_ctx + TC_HDR_SIZE + pool_ctx->size)
+                - ((char *)pool_ctx->pool);
+        space_left = TC_POOL_SPACE_LEFT(pool_ctx);
         /*
          * Align size to 16 bytes
          */
         chunk_size = ((size + 15) & ~15);
+        chunk_size = TC_ALIGN16(size);
         if (space_left < chunk_size) {
 …
  */
 void *talloc_pool(const void *context, size_t size)
+_PUBLIC_ void *talloc_pool(const void *context, size_t size)
+{
         void *result = __talloc(context, size + TALLOC_POOL_HDR_SIZE);
 …
         tc->flags |= TALLOC_FLAG_POOL;
         tc->pool = (char *)result + TALLOC_POOL_HDR_SIZE;
+        tc->pool = TC_POOL_FIRST_CHUNK(tc);
         *talloc_pool_objectcount(tc) = 1;
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
+        VALGRIND_MAKE_MEM_NOACCESS(tc->pool, size);
+#endif
+        TC_INVALIDATE_POOL(tc);
         return result;
 …
   be continued to be used
 */
 void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
+_PUBLIC_ void _talloc_set_destructor(const void *ptr, int (*destructor)(void *))
+{
         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 …
   increase the reference count on a piece of memory.
 */
 int talloc_increase_ref_count(const void *ptr)
+_PUBLIC_ int talloc_increase_ref_count(const void *ptr)
+{
         if (unlikely(!talloc_reference(null_context, ptr))) {
 …
   and in either order
 */
 void *_talloc_reference_loc(const void *context, const void *ptr, const char *location)
+_PUBLIC_ void *_talloc_reference_loc(const void *context, const void *ptr, const char *location)
+{
         struct talloc_chunk *tc;
 …
 static void *_talloc_steal_internal(const void *new_ctx, const void *ptr);
+static inline void _talloc_free_poolmem(struct talloc_chunk *tc,
+                                        const char *location)
+{
+        struct talloc_chunk *pool;
+        void *next_tc;
+        unsigned int *pool_object_count;
+        pool = (struct talloc_chunk *)tc->pool;
+        next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
+        tc->flags |= TALLOC_FLAG_FREE;
+        /* we mark the freed memory with where we called the free
+         * from. This means on a double free error we can report where
+         * the first free came from
+         */
+        tc->name = location;
+        TC_INVALIDATE_FULL_CHUNK(tc);
+        pool_object_count = talloc_pool_objectcount(pool);
+        if (unlikely(*pool_object_count == 0)) {
+                talloc_abort("Pool object count zero!");
+                return;
+        }
+        *pool_object_count -= 1;
+        if (unlikely(*pool_object_count == 1 && !(pool->flags & TALLOC_FLAG_FREE))) {
+                /*
+                 * if there is just one object left in the pool
+                 * and pool->flags does not have TALLOC_FLAG_FREE,
+                 * it means this is the pool itself and
+                 * the rest is available for new objects
+                 * again.
+                 */
+                pool->pool = TC_POOL_FIRST_CHUNK(pool);
+                TC_INVALIDATE_POOL(pool);
+        } else if (unlikely(*pool_object_count == 0)) {
+                /*
+                 * we mark the freed memory with where we called the free
+                 * from. This means on a double free error we can report where
+                 * the first free came from
+                 */
+                pool->name = location;
+                TC_INVALIDATE_FULL_CHUNK(pool);
+                free(pool);
+        } else if (pool->pool == next_tc) {
+                /*
+                 * if pool->pool still points to end of
+                 * 'tc' (which is stored in the 'next_tc' variable),
+                 * we can reclaim the memory of 'tc'.
+                 */
+                pool->pool = tc;
+        }
+}
+static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
+                                                  void *ptr,
+                                                  const char *location);
 /*
    internal talloc_free call
 …
+        }
+        /* possibly initialised the talloc fill value */
+        if (unlikely(!talloc_fill.initialised)) {
+                const char *fill = getenv(TALLOC_FILL_ENV);
+                if (fill != NULL) {
+                        talloc_fill.enabled = true;
+                        talloc_fill.fill_value = strtoul(fill, NULL, 0);
+                }
+                talloc_fill.initialised = true;
+        }
         tc = talloc_chunk_from_ptr(ptr);
         if (unlikely(tc->refs)) {
                 int is_child;
                 /* check this is a reference from a child or grantchild
                  * back to it's parent or grantparent
+                /* check if this is a reference from a child or
+                 * grandchild back to it's parent or grandparent
+                 *
                  * in that case we need to remove the reference and
 …
         tc->flags |= TALLOC_FLAG_LOOP;
+        while (tc->child) {
+                /* we need to work out who will own an abandoned child
+                   if it cannot be freed. In priority order, the first
+                   choice is owner of any remaining reference to this
+                   pointer, the second choice is our parent, and the
+                   final choice is the null context. */
+                void *child = TC_PTR_FROM_CHUNK(tc->child);
+                const void *new_parent = null_context;
+                if (unlikely(tc->child->refs)) {
+                        struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
+                        if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+                }
+                if (unlikely(_talloc_free_internal(child, location) == -1)) {
+                        if (new_parent == null_context) {
+                                struct talloc_chunk *p = talloc_parent_chunk(ptr);
+                                if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+                        }
+                        _talloc_steal_internal(new_parent, child);
+                }
+        }
+        _talloc_free_children_internal(tc, ptr, location);
         tc->flags |= TALLOC_FLAG_FREE;
 …
         tc->name = location;
+        if (tc->flags & (TALLOC_FLAG_POOL|TALLOC_FLAG_POOLMEM)) {
+                struct talloc_chunk *pool;
+        if (tc->flags & TALLOC_FLAG_POOL) {
                 unsigned int *pool_object_count;
+                pool = (tc->flags & TALLOC_FLAG_POOL)
+                        ? tc : (struct talloc_chunk *)tc->pool;
+                pool_object_count = talloc_pool_objectcount(pool);
+                if (*pool_object_count == 0) {
+                pool_object_count = talloc_pool_objectcount(tc);
+                if (unlikely(*pool_object_count == 0)) {
                         talloc_abort("Pool object count zero!");
                         return 0;
 …
                 *pool_object_count -= 1;
+                if (*pool_object_count == 0) {
+                        free(pool);
+                }
+        }
+        else {
+                if (unlikely(*pool_object_count == 0)) {
+                        TC_INVALIDATE_FULL_CHUNK(tc);
+                        free(tc);
+                }
+        } else if (tc->flags & TALLOC_FLAG_POOLMEM) {
+                _talloc_free_poolmem(tc, location);
+        } else {
+                TC_INVALIDATE_FULL_CHUNK(tc);
                 free(tc);
+        }
 …
    passing NULL as ptr will always return NULL with no side effects.
 */
 void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
+_PUBLIC_ void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location)
+{
         struct talloc_chunk *tc;
 …
+                }
+        }
+#if 0
+        /* this test is probably too expensive to have on in the
+           normal build, but it useful for debugging */
+        if (talloc_is_parent(new_ctx, ptr)) {
+                talloc_log("WARNING: stealing into talloc child at %s\n", location);
+        }
+#endif
         return _talloc_steal_internal(new_ctx, ptr);
 …
    The old parent can be either a reference or a parent
 */
 void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
+_PUBLIC_ void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr)
+{
         struct talloc_chunk *tc;
 …
   controlled varient of talloc_free()
 */
 int talloc_unlink(const void *context, void *ptr)
+_PUBLIC_ int talloc_unlink(const void *context, void *ptr)
+{
         struct talloc_chunk *tc_p, *new_p;
 …
   add a name to an existing pointer
 */
 const char *talloc_set_name(const void *ptr, const char *fmt, ...)
+_PUBLIC_ const char *talloc_set_name(const void *ptr, const char *fmt, ...)
+{
         const char *name;
 …
   to name the pointer.
 */
 void *talloc_named(const void *context, size_t size, const char *fmt, ...)
+_PUBLIC_ void *talloc_named(const void *context, size_t size, const char *fmt, ...)
+{
         va_list ap;
 …
   return the name of a talloc ptr, or "UNNAMED"
 */
 const char *talloc_get_name(const void *ptr)
+_PUBLIC_ const char *talloc_get_name(const void *ptr)
+{
         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 …
   otherwise return NULL
 */
 void *talloc_check_name(const void *ptr, const char *name)
+_PUBLIC_ void *talloc_check_name(const void *ptr, const char *name)
+{
         const char *pname;
 …
+}
 void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
+_PUBLIC_ void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location)
+{
         const char *pname;
 …
   this is for compatibility with older versions of talloc
 */
 void *talloc_init(const char *fmt, ...)
+_PUBLIC_ void *talloc_init(const char *fmt, ...)
+{
         va_list ap;
 …
         const char *name;
-        /*
-         * samba3 expects talloc_report_depth_cb(NULL, ...)
-         * reports all talloc'ed memory, so we need to enable
-         * null_tracking
-         */
-        talloc_enable_null_tracking();
         ptr = __talloc(NULL, 0);
         if (unlikely(ptr == NULL)) return NULL;
 …
+}
+/*
+  this is a replacement for the Samba3 talloc_destroy_pool functionality. It
+  should probably not be used in new code. It's in here to keep the talloc
+  code consistent across Samba 3 and 4.
+*/
+void talloc_free_children(void *ptr)
+{
+        struct talloc_chunk *tc;
+        if (unlikely(ptr == NULL)) {
+                return;
+        }
+        tc = talloc_chunk_from_ptr(ptr);
+static inline void _talloc_free_children_internal(struct talloc_chunk *tc,
+                                                  void *ptr,
+                                                  const char *location)
+{
         while (tc->child) {
                 /* we need to work out who will own an abandoned child
 …
                 void *child = TC_PTR_FROM_CHUNK(tc->child);
                 const void *new_parent = null_context;
+                struct talloc_chunk *old_parent = NULL;
                 if (unlikely(tc->child->refs)) {
                         struct talloc_chunk *p = talloc_parent_chunk(tc->child->refs);
                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+                }
+                if (unlikely(talloc_free(child) == -1)) {
+                /* finding the parent here is potentially quite
+                   expensive, but the alternative, which is to change
+                   talloc to always have a valid tc->parent pointer,
+                   makes realloc more expensive where there are a
+                   large number of children.
+                   The reason we need the parent pointer here is that
+                   if _talloc_free_internal() fails due to references
+                   or a failing destructor we need to re-parent, but
+                   the free call can invalidate the prev pointer.
+                */
+                if (new_parent == null_context && (tc->child->refs || tc->child->destructor)) {
+                        old_parent = talloc_parent_chunk(ptr);
+                }
+                if (unlikely(_talloc_free_internal(child, location) == -1)) {
                         if (new_parent == null_context) {
                                 struct talloc_chunk *p = talloc_parent_chunk(ptr);
+                                struct talloc_chunk *p = old_parent;
                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
+                        }
 …
+                }
+        }
+        if ((tc->flags & TALLOC_FLAG_POOL)
+            && (*talloc_pool_objectcount(tc) == 1)) {
+                tc->pool = ((char *)tc + TC_HDR_SIZE + TALLOC_POOL_HDR_SIZE);
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_NOACCESS)
+                VALGRIND_MAKE_MEM_NOACCESS(
+                        tc->pool, tc->size - TALLOC_POOL_HDR_SIZE);
+#endif
+        }
+}
+/*
+  this is a replacement for the Samba3 talloc_destroy_pool functionality. It
+  should probably not be used in new code. It's in here to keep the talloc
+  code consistent across Samba 3 and 4.
+*/
+_PUBLIC_ void talloc_free_children(void *ptr)
+{
+        struct talloc_chunk *tc;
+        if (unlikely(ptr == NULL)) {
+                return;
+        }
+        tc = talloc_chunk_from_ptr(ptr);
+        _talloc_free_children_internal(tc, ptr, __location__);
+}
 …
    Allocate a bit of memory as a child of an existing pointer
 */
 void *_talloc(const void *context, size_t size)
+_PUBLIC_ void *_talloc(const void *context, size_t size)
+{
         return __talloc(context, size);
 …
   externally callable talloc_set_name_const()
 */
 void talloc_set_name_const(const void *ptr, const char *name)
+_PUBLIC_ void talloc_set_name_const(const void *ptr, const char *name)
+{
         _talloc_set_name_const(ptr, name);
 …
   to name the pointer.
 */
 void *talloc_named_const(const void *context, size_t size, const char *name)
+_PUBLIC_ void *talloc_named_const(const void *context, size_t size, const char *name)
+{
         return _talloc_named_const(context, size, name);
 …
    any) returns non-zero
 */
 int _talloc_free(void *ptr, const char *location)
+_PUBLIC_ int _talloc_free(void *ptr, const char *location)
+{
         struct talloc_chunk *tc;
 …
                 struct talloc_reference_handle *h;
+                if (talloc_parent(ptr) == null_context && tc->refs->next == NULL) {
+                        /* in this case we do know which parent should
+                           get this pointer, as there is really only
+                           one parent */
+                        return talloc_unlink(null_context, ptr);
+                }
                 talloc_log("ERROR: talloc_free with references at %s\n",
                            location);
 …
   ptr is NULL
 */
 void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
+_PUBLIC_ void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name)
+{
         struct talloc_chunk *tc;
         void *new_ptr;
         bool malloced = false;
+        struct talloc_chunk *pool_tc = NULL;
         /* size zero is equivalent to free() */
 …
+        }
+        /* don't let anybody try to realloc a talloc_pool */
+        if (unlikely(tc->flags & TALLOC_FLAG_POOLMEM)) {
+                pool_tc = (struct talloc_chunk *)tc->pool;
+        }
+#if (ALWAYS_REALLOC == 0)
         /* don't shrink if we have less than 1k to gain */
+        if ((size < tc->size) && ((tc->size - size) < 1024)) {
+                tc->size = size;
+        if (size < tc->size) {
+                if (pool_tc) {
+                        void *next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
+                        TC_INVALIDATE_SHRINK_CHUNK(tc, size);
+                        tc->size = size;
+                        if (next_tc == pool_tc->pool) {
+                                pool_tc->pool = TC_POOLMEM_NEXT_CHUNK(tc);
+                        }
+                        return ptr;
+                } else if ((tc->size - size) < 1024) {
+                        /*
+                         * if we call TC_INVALIDATE_SHRINK_CHUNK() here
+                         * we would need to call TC_UNDEFINE_GROW_CHUNK()
+                         * after each realloc call, which slows down
+                         * testing a lot :-(.
+                         *
+                         * That is why we only mark memory as undefined here.
+                         */
+                        TC_UNDEFINE_SHRINK_CHUNK(tc, size);
+                        /* do not shrink if we have less than 1k to gain */
+                        tc->size = size;
+                        return ptr;
+                }
+        } else if (tc->size == size) {
+                /*
+                 * do not change the pointer if it is exactly
+                 * the same size.
+                 */
                 return ptr;
+        }
+#endif
         /* by resetting magic we catch users of the old memory */
 …
 #if ALWAYS_REALLOC
+        new_ptr = malloc(size + TC_HDR_SIZE);
+        if (new_ptr) {
+                memcpy(new_ptr, tc, MIN(tc->size, size) + TC_HDR_SIZE);
+                free(tc);
+        }
+#else
+        if (tc->flags & TALLOC_FLAG_POOLMEM) {
+        if (pool_tc) {
                 new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
+                *talloc_pool_objectcount((struct talloc_chunk *)
+                                         (tc->pool)) -= 1;
+                *talloc_pool_objectcount(pool_tc) -= 1;
                 if (new_ptr == NULL) {
 …
                 if (new_ptr) {
                         memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
+                        TC_INVALIDATE_FULL_CHUNK(tc);
+                }
+        } else {
+                new_ptr = malloc(size + TC_HDR_SIZE);
+                if (new_ptr) {
+                        memcpy(new_ptr, tc, MIN(tc->size, size) + TC_HDR_SIZE);
+                        free(tc);
+                }
+        }
+#else
+        if (pool_tc) {
+                void *next_tc = TC_POOLMEM_NEXT_CHUNK(tc);
+                size_t old_chunk_size = TC_POOLMEM_CHUNK_SIZE(tc);
+                size_t new_chunk_size = TC_ALIGN16(TC_HDR_SIZE + size);
+                size_t space_needed;
+                size_t space_left;
+                unsigned int chunk_count = *talloc_pool_objectcount(pool_tc);
+                if (!(pool_tc->flags & TALLOC_FLAG_FREE)) {
+                        chunk_count -= 1;
+                }
+                if (chunk_count == 1) {
+                        /*
+                         * optimize for the case where 'tc' is the only
+                         * chunk in the pool.
+                         */
+                        space_needed = new_chunk_size;
+                        space_left = pool_tc->size - TALLOC_POOL_HDR_SIZE;
+                        if (space_left >= space_needed) {
+                                size_t old_used = TC_HDR_SIZE + tc->size;
+                                size_t new_used = TC_HDR_SIZE + size;
+                                pool_tc->pool = TC_POOL_FIRST_CHUNK(pool_tc);
+#if defined(DEVELOPER) && defined(VALGRIND_MAKE_MEM_UNDEFINED)
+                                /*
+                                 * we need to prepare the memmove into
+                                 * the unaccessable area.
+                                 */
+                                {
+                                        size_t diff = PTR_DIFF(tc, pool_tc->pool);
+                                        size_t flen = MIN(diff, old_used);
+                                        char *fptr = (char *)pool_tc->pool;
+                                        VALGRIND_MAKE_MEM_UNDEFINED(fptr, flen);
+                                }
+#endif
+                                memmove(pool_tc->pool, tc, old_used);
+                                new_ptr = pool_tc->pool;
+                                tc = (struct talloc_chunk *)new_ptr;
+                                TC_UNDEFINE_GROW_CHUNK(tc, size);
+                                /*
+                                 * first we do not align the pool pointer
+                                 * because we want to invalidate the padding
+                                 * too.
+                                 */
+                                pool_tc->pool = new_used + (char *)new_ptr;
+                                TC_INVALIDATE_POOL(pool_tc);
+                                /* now the aligned pointer */
+                                pool_tc->pool = new_chunk_size + (char *)new_ptr;
+                                goto got_new_ptr;
+                        }
+                        next_tc = NULL;
+                }
+                if (new_chunk_size == old_chunk_size) {
+                        TC_UNDEFINE_GROW_CHUNK(tc, size);
+                        tc->flags &= ~TALLOC_FLAG_FREE;
+                        tc->size = size;
+                        return ptr;
+                }
+                if (next_tc == pool_tc->pool) {
+                        /*
+                         * optimize for the case where 'tc' is the last
+                         * chunk in the pool.
+                         */
+                        space_needed = new_chunk_size - old_chunk_size;
+                        space_left = TC_POOL_SPACE_LEFT(pool_tc);
+                        if (space_left >= space_needed) {
+                                TC_UNDEFINE_GROW_CHUNK(tc, size);
+                                tc->flags &= ~TALLOC_FLAG_FREE;
+                                tc->size = size;
+                                pool_tc->pool = TC_POOLMEM_NEXT_CHUNK(tc);
+                                return ptr;
+                        }
+                }
+                new_ptr = talloc_alloc_pool(tc, size + TC_HDR_SIZE);
+                if (new_ptr == NULL) {
+                        new_ptr = malloc(TC_HDR_SIZE+size);
+                        malloced = true;
+                }
+                if (new_ptr) {
+                        memcpy(new_ptr, tc, MIN(tc->size,size) + TC_HDR_SIZE);
+                        _talloc_free_poolmem(tc, __location__ "_talloc_realloc");
+                }
+        }
 …
                 new_ptr = realloc(tc, size + TC_HDR_SIZE);
+        }
+got_new_ptr:
 #endif
         if (unlikely(!new_ptr)) {
 …
   between two structures, and want the old pointer to be set to NULL
 */
 void *_talloc_move(const void *new_ctx, const void *_pptr)
+_PUBLIC_ void *_talloc_move(const void *new_ctx, const void *_pptr)
+{
         const void **pptr = discard_const_p(const void *,_pptr);
 …
   return the total size of a talloc pool (subtree)
 */
 size_t talloc_total_size(const void *ptr)
+_PUBLIC_ size_t talloc_total_size(const void *ptr)
+{
         size_t total = 0;
 …
   return the total number of blocks in a talloc pool (subtree)
 */
 size_t talloc_total_blocks(const void *ptr)
+_PUBLIC_ size_t talloc_total_blocks(const void *ptr)
+{
         size_t total = 0;
 …
   return the number of external references to a pointer
 */
 size_t talloc_reference_count(const void *ptr)
+_PUBLIC_ size_t talloc_reference_count(const void *ptr)
+{
         struct talloc_chunk *tc = talloc_chunk_from_ptr(ptr);
 …
   report on memory usage by all children of a pointer, giving a full tree view
 */
 void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+_PUBLIC_ void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
                             void (*callback)(const void *ptr,
                                              int depth, int max_depth,
 …
   report on memory usage by all children of a pointer, giving a full tree view
 */
 void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
+_PUBLIC_ void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f)
+{
         if (f) {
 …
   report on memory usage by all children of a pointer, giving a full tree view
 */
 void talloc_report_full(const void *ptr, FILE *f)
+_PUBLIC_ void talloc_report_full(const void *ptr, FILE *f)
+{
         talloc_report_depth_file(ptr, 0, -1, f);
 …
   report on memory usage by all children of a pointer
 */
 void talloc_report(const void *ptr, FILE *f)
+_PUBLIC_ void talloc_report(const void *ptr, FILE *f)
+{
         talloc_report_depth_file(ptr, 0, 1, f);
 …
   enable tracking of the NULL context
 */
 void talloc_enable_null_tracking(void)
+_PUBLIC_ void talloc_enable_null_tracking(void)
+{
         if (null_context == NULL) {
 …
   into the NULL context. This is needed for the talloc testsuite
 */
 void talloc_enable_null_tracking_no_autofree(void)
+_PUBLIC_ void talloc_enable_null_tracking_no_autofree(void)
+{
         if (null_context == NULL) {
 …
   disable tracking of the NULL context
 */
 void talloc_disable_null_tracking(void)
+_PUBLIC_ void talloc_disable_null_tracking(void)
+{
         if (null_context != NULL) {
 …
   enable leak reporting on exit
 */
 void talloc_enable_leak_report(void)
+_PUBLIC_ void talloc_enable_leak_report(void)
+{
         talloc_enable_null_tracking();
 …
   enable full leak reporting on exit
 */
 void talloc_enable_leak_report_full(void)
+_PUBLIC_ void talloc_enable_leak_report_full(void)
+{
         talloc_enable_null_tracking();
 …
    talloc and zero memory.
 */
 void *_talloc_zero(const void *ctx, size_t size, const char *name)
+_PUBLIC_ void *_talloc_zero(const void *ctx, size_t size, const char *name)
+{
         void *p = _talloc_named_const(ctx, size, name);
 …
   memdup with a talloc.
 */
 void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
+_PUBLIC_ void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name)
+{
         void *newp = _talloc_named_const(t, size, name);
 …
   strdup with a talloc
 */
 char *talloc_strdup(const void *t, const char *p)
+_PUBLIC_ char *talloc_strdup(const void *t, const char *p)
+{
         if (unlikely(!p)) return NULL;
 …
   strndup with a talloc
 */
 char *talloc_strndup(const void *t, const char *p, size_t n)
+_PUBLIC_ char *talloc_strndup(const void *t, const char *p, size_t n)
+{
         if (unlikely(!p)) return NULL;
 …
  * Appends at the end of the string.
  */
 char *talloc_strdup_append(char *s, const char *a)
+_PUBLIC_ char *talloc_strdup_append(char *s, const char *a)
+{
         if (unlikely(!s)) {
 …
  * not the end of the string.
  */
 char *talloc_strdup_append_buffer(char *s, const char *a)
+_PUBLIC_ char *talloc_strdup_append_buffer(char *s, const char *a)
+{
         size_t slen;
 …
  * Appends at the end of the string.
  */
 char *talloc_strndup_append(char *s, const char *a, size_t n)
+_PUBLIC_ char *talloc_strndup_append(char *s, const char *a, size_t n)
+{
         if (unlikely(!s)) {
 …
  * not the end of the string.
  */
 char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
+_PUBLIC_ char *talloc_strndup_append_buffer(char *s, const char *a, size_t n)
+{
         size_t slen;
 …
 #endif
 char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
+_PUBLIC_ char *talloc_vasprintf(const void *t, const char *fmt, va_list ap)
+{
         int len;
 …
   memory holding the result, inside a memory pool.
  */
 char *talloc_asprintf(const void *t, const char *fmt, ...)
+_PUBLIC_ char *talloc_asprintf(const void *t, const char *fmt, ...)
+{
         va_list ap;
 …
  * of the string.
  **/
 char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+_PUBLIC_ char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap)
+{
         if (unlikely(!s)) {
 …
  * end of the talloc'ed buffer, not the end of the string.
  **/
 char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
+_PUBLIC_ char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap)
+{
         size_t slen;
 …
   into a string buffer.
  */
 char *talloc_asprintf_append(char *s, const char *fmt, ...)
+_PUBLIC_ char *talloc_asprintf_append(char *s, const char *fmt, ...)
+{
         va_list ap;
 …
   into a buffer.
  */
 char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
+_PUBLIC_ char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...)
+{
         va_list ap;
 …
   alloc an array, checking for integer overflow in the array size
 */
 void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+_PUBLIC_ void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+{
         if (count >= MAX_TALLOC_SIZE/el_size) {
 …
   alloc an zero array, checking for integer overflow in the array size
 */
 void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+_PUBLIC_ void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name)
+{
         if (count >= MAX_TALLOC_SIZE/el_size) {
 …
   realloc an array, checking for integer overflow in the array size
 */
 void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
+_PUBLIC_ void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name)
+{
         if (count >= MAX_TALLOC_SIZE/el_size) {
 …
   all the basic capabilities of an allocation library, which is why this is useful)
 */
 void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
+_PUBLIC_ void *talloc_realloc_fn(const void *context, void *ptr, size_t size)
+{
         return _talloc_realloc(context, ptr, size, NULL);
 …
   this is useful for reducing the noise in leak reports
 */
 void *talloc_autofree_context(void)
+_PUBLIC_ void *talloc_autofree_context(void)
+{
         if (autofree_context == NULL) {
 …
+}
 size_t talloc_get_size(const void *context)
+_PUBLIC_ size_t talloc_get_size(const void *context)
+{
         struct talloc_chunk *tc;
 …
   find a parent of this context that has the given name, if any
 */
 void *talloc_find_parent_byname(const void *context, const char *name)
+_PUBLIC_ void *talloc_find_parent_byname(const void *context, const char *name)
+{
         struct talloc_chunk *tc;
 …
   show the parentage of a context
 */
 void talloc_show_parents(const void *context, FILE *file)
+_PUBLIC_ void talloc_show_parents(const void *context, FILE *file)
+{
         struct talloc_chunk *tc;
 …
   return 1 if ptr is a parent of context
 */
 int talloc_is_parent(const void *context, const void *ptr)
+static int _talloc_is_parent(const void *context, const void *ptr, int depth)
+{
         struct talloc_chunk *tc;
 …
         tc = talloc_chunk_from_ptr(context);
         while (tc) {
+        while (tc && depth > 0) {
                 if (TC_PTR_FROM_CHUNK(tc) == ptr) return 1;
                 while (tc && tc->prev) tc = tc->prev;
                 if (tc) {
                         tc = tc->parent;
+                        depth--;
+                }
+        }
         return 0;
+}
+/*
+  return 1 if ptr is a parent of context
+*/
+_PUBLIC_ int talloc_is_parent(const void *context, const void *ptr)
+{
+        return _talloc_is_parent(context, ptr, TALLOC_MAX_DEPTH);
+}

vendor/current/lib/talloc/talloc.h

-              r414
+              r740
 #include <stdarg.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * @defgroup talloc The talloc API
+ *
+ * talloc is a hierarchical, reference counted memory pool system with
+ * destructors. It is the core memory allocator used in Samba.
+ *
+ * @{
+ */
 #define TALLOC_VERSION_MAJOR 2
 #define TALLOC_VERSION_MINOR 0
 …
 int talloc_version_minor(void);
+/* this is only needed for compatibility with the old talloc */
+/**
+ * @brief Define a talloc parent type
+ *
+ * As talloc is a hierarchial memory allocator, every talloc chunk is a
+ * potential parent to other talloc chunks. So defining a separate type for a
+ * talloc chunk is not strictly necessary. TALLOC_CTX is defined nevertheless,
+ * as it provides an indicator for function arguments. You will frequently
+ * write code like
+ *
+ * @code
+ *      struct foo *foo_create(TALLOC_CTX *mem_ctx)
+ *      {
+ *              struct foo *result;
+ *              result = talloc(mem_ctx, struct foo);
+ *              if (result == NULL) return NULL;
+ *                      ... initialize foo ...
+ *              return result;
+ *      }
+ * @endcode
+ *
+ * In this type of allocating functions it is handy to have a general
+ * TALLOC_CTX type to indicate which parent to put allocated structures on.
+ */
 typedef void TALLOC_CTX;
 …
 #endif
+#ifdef DOXYGEN
+/**
+ * @brief Create a new talloc context.
+ *
+ * The talloc() macro is the core of the talloc library. It takes a memory
+ * context and a type, and returns a pointer to a new area of memory of the
+ * given type.
+ *
+ * The returned pointer is itself a talloc context, so you can use it as the
+ * context argument to more calls to talloc if you wish.
+ *
+ * The returned pointer is a "child" of the supplied context. This means that if
+ * you talloc_free() the context then the new child disappears as well.
+ * Alternatively you can free just the child.
+ *
+ * @param[in]  ctx      A talloc context to create a new reference on or NULL to
+ *                      create a new top level context.
+ *
+ * @param[in]  type     The type of memory to allocate.
+ *
+ * @return              A type casted talloc context or NULL on error.
+ *
+ * @code
+ *      unsigned int *a, *b;
+ *
+ *      a = talloc(NULL, unsigned int);
+ *      b = talloc(a, unsigned int);
+ * @endcode
+ *
+ * @see talloc_zero
+ * @see talloc_array
+ * @see talloc_steal
+ * @see talloc_free
+ */
+void *talloc(const void *ctx, #type);
+#else
+#define talloc(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
+void *_talloc(const void *context, size_t size);
+#endif
+/**
+ * @brief Create a new top level talloc context.
+ *
+ * This function creates a zero length named talloc context as a top level
+ * context. It is equivalent to:
+ *
+ * @code
+ *      talloc_named(NULL, 0, fmt, ...);
+ * @endcode
+ * @param[in]  fmt      Format string for the name.
+ *
+ * @param[in]  ...      Additional printf-style arguments.
+ *
+ * @return              The allocated memory chunk, NULL on error.
+ *
+ * @see talloc_named()
+ */
+void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
+#ifdef DOXYGEN
+/**
+ * @brief Free a chunk of talloc memory.
+ *
+ * The talloc_free() function frees a piece of talloc memory, and all its
+ * children. You can call talloc_free() on any pointer returned by
+ * talloc().
+ *
+ * The return value of talloc_free() indicates success or failure, with 0
+ * returned for success and -1 for failure. A possible failure condition
+ * is if the pointer had a destructor attached to it and the destructor
+ * returned -1. See talloc_set_destructor() for details on
+ * destructors. Likewise, if "ptr" is NULL, then the function will make
+ * no modifications and return -1.
+ *
+ * If this pointer has an additional parent when talloc_free() is called
+ * then the memory is not actually released, but instead the most
+ * recently established parent is destroyed. See talloc_reference() for
+ * details on establishing additional parents.
+ *
+ * For more control on which parent is removed, see talloc_unlink()
+ *
+ * talloc_free() operates recursively on its children.
+ *
+ * From the 2.0 version of talloc, as a special case, talloc_free() is
+ * refused on pointers that have more than one parent, as talloc would
+ * have no way of knowing which parent should be removed. To free a
+ * pointer that has more than one parent please use talloc_unlink().
+ *
+ * To help you find problems in your code caused by this behaviour, if
+ * you do try and free a pointer with more than one parent then the
+ * talloc logging function will be called to give output like this:
+ *
+ * @code
+ *   ERROR: talloc_free with references at some_dir/source/foo.c:123
+ *     reference at some_dir/source/other.c:325
+ *     reference at some_dir/source/third.c:121
+ * @endcode
+ *
+ * Please see the documentation for talloc_set_log_fn() and
+ * talloc_set_log_stderr() for more information on talloc logging
+ * functions.
+ *
+ * @param[in]  ptr      The chunk to be freed.
+ *
+ * @return              Returns 0 on success and -1 on error. A possible
+ *                      failure condition is if the pointer had a destructor
+ *                      attached to it and the destructor returned -1. Likewise,
+ *                      if "ptr" is NULL, then the function will make no
+ *                      modifications and returns -1.
+ *
+ * Example:
+ * @code
+ *      unsigned int *a, *b;
+ *      a = talloc(NULL, unsigned int);
+ *      b = talloc(a, unsigned int);
+ *
+ *      talloc_free(a); // Frees a and b
+ * @endcode
+ *
+ * @see talloc_set_destructor()
+ * @see talloc_unlink()
+ */
+int talloc_free(void *ptr);
+#else
+#define talloc_free(ctx) _talloc_free(ctx, __location__)
+int _talloc_free(void *ptr, const char *location);
+#endif
+/**
+ * @brief Free a talloc chunk's children.
+ *
+ * The function walks along the list of all children of a talloc context and
+ * talloc_free()s only the children, not the context itself.
+ *
+ * @param[in]  ptr      The chunk that you want to free the children of.
+ */
+void talloc_free_children(void *ptr);
+#ifdef DOXYGEN
+/**
+ * @brief Assign a destructor function to be called when a chunk is freed.
+ *
+ * The function talloc_set_destructor() sets the "destructor" for the pointer
+ * "ptr". A destructor is a function that is called when the memory used by a
+ * pointer is about to be released. The destructor receives the pointer as an
+ * argument, and should return 0 for success and -1 for failure.
+ *
+ * The destructor can do anything it wants to, including freeing other pieces
+ * of memory. A common use for destructors is to clean up operating system
+ * resources (such as open file descriptors) contained in the structure the
+ * destructor is placed on.
+ *
+ * You can only place one destructor on a pointer. If you need more than one
+ * destructor then you can create a zero-length child of the pointer and place
+ * an additional destructor on that.
+ *
+ * To remove a destructor call talloc_set_destructor() with NULL for the
+ * destructor.
+ *
+ * If your destructor attempts to talloc_free() the pointer that it is the
+ * destructor for then talloc_free() will return -1 and the free will be
+ * ignored. This would be a pointless operation anyway, as the destructor is
+ * only called when the memory is just about to go away.
+ *
+ * @param[in]  ptr      The talloc chunk to add a destructor to.
+ *
+ * @param[in]  destructor  The destructor function to be called. NULL to remove
+ *                         it.
+ *
+ * Example:
+ * @code
+ *      static int destroy_fd(int *fd) {
+ *              close(*fd);
+ *              return 0;
+ *      }
+ *
+ *      int *open_file(const char *filename) {
+ *              int *fd = talloc(NULL, int);
+ *              *fd = open(filename, O_RDONLY);
+ *              if (*fd < 0) {
+ *                      talloc_free(fd);
+ *                      return NULL;
+ *              }
+ *              // Whenever they free this, we close the file.
+ *              talloc_set_destructor(fd, destroy_fd);
+ *              return fd;
+ *      }
+ * @endcode
+ *
+ * @see talloc()
+ * @see talloc_free()
+ */
+void talloc_set_destructor(const void *ptr, int (*destructor)(void *));
+/**
+ * @brief Change a talloc chunk's parent.
+ *
+ * The talloc_steal() function changes the parent context of a talloc
+ * pointer. It is typically used when the context that the pointer is
+ * currently a child of is going to be freed and you wish to keep the
+ * memory for a longer time.
+ *
+ * To make the changed hierarchy less error-prone, you might consider to use
+ * talloc_move().
+ *
+ * If you try and call talloc_steal() on a pointer that has more than one
+ * parent then the result is ambiguous. Talloc will choose to remove the
+ * parent that is currently indicated by talloc_parent() and replace it with
+ * the chosen parent. You will also get a message like this via the talloc
+ * logging functions:
+ *
+ * @code
+ *   WARNING: talloc_steal with references at some_dir/source/foo.c:123
+ *     reference at some_dir/source/other.c:325
+ *     reference at some_dir/source/third.c:121
+ * @endcode
+ *
+ * To unambiguously change the parent of a pointer please see the function
+ * talloc_reparent(). See the talloc_set_log_fn() documentation for more
+ * information on talloc logging.
+ *
+ * @param[in]  new_ctx  The new parent context.
+ *
+ * @param[in]  ptr      The talloc chunk to move.
+ *
+ * @return              Returns the pointer that you pass it. It does not have
+ *                      any failure modes.
+ *
+ * @note It is possible to produce loops in the parent/child relationship
+ * if you are not careful with talloc_steal(). No guarantees are provided
+ * as to your sanity or the safety of your data if you do this.
+ */
+void *talloc_steal(const void *new_ctx, const void *ptr);
+#else /* DOXYGEN */
 /* try to make talloc_set_destructor() and talloc_steal() type safe,
    if we have a recent gcc */
 …
    stupidity in gcc 4.1.x */
 #define talloc_steal(ctx, ptr) ({ _TALLOC_TYPEOF(ptr) __talloc_steal_ret = (_TALLOC_TYPEOF(ptr))_talloc_steal_loc((ctx),(ptr), __location__); __talloc_steal_ret; })
 #else
+#else /* __GNUC__ >= 3 */
 #define talloc_set_destructor(ptr, function) \
         _talloc_set_destructor((ptr), (int (*)(void *))(function))
 #define _TALLOC_TYPEOF(ptr) void *
 #define talloc_steal(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_steal_loc((ctx),(ptr), __location__)
+#endif
+#define talloc_reference(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_reference_loc((ctx),(ptr), __location__)
+#endif /* __GNUC__ >= 3 */
+void _talloc_set_destructor(const void *ptr, int (*_destructor)(void *));
+void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location);
+#endif /* DOXYGEN */
+/**
+ * @brief Assign a name to a talloc chunk.
+ *
+ * Each talloc pointer has a "name". The name is used principally for
+ * debugging purposes, although it is also possible to set and get the name on
+ * a pointer in as a way of "marking" pointers in your code.
+ *
+ * The main use for names on pointer is for "talloc reports". See
+ * talloc_report() and talloc_report_full() for details. Also see
+ * talloc_enable_leak_report() and talloc_enable_leak_report_full().
+ *
+ * The talloc_set_name() function allocates memory as a child of the
+ * pointer. It is logically equivalent to:
+ *
+ * @code
+ *      talloc_set_name_const(ptr, talloc_asprintf(ptr, fmt, ...));
+ * @endcode
+ *
+ * @param[in]  ptr      The talloc chunk to assign a name to.
+ *
+ * @param[in]  fmt      Format string for the name.
+ *
+ * @param[in]  ...      Add printf-style additional arguments.
+ *
+ * @return              The assigned name, NULL on error.
+ *
+ * @note Multiple calls to talloc_set_name() will allocate more memory without
+ * releasing the name. All of the memory is released when the ptr is freed
+ * using talloc_free().
+ */
+const char *talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+#ifdef DOXYGEN
+/**
+ * @brief Change a talloc chunk's parent.
+ *
+ * This function has the same effect as talloc_steal(), and additionally sets
+ * the source pointer to NULL. You would use it like this:
+ *
+ * @code
+ *      struct foo *X = talloc(tmp_ctx, struct foo);
+ *      struct foo *Y;
+ *      Y = talloc_move(new_ctx, &X);
+ * @endcode
+ *
+ * @param[in]  new_ctx  The new parent context.
+ *
+ * @param[in]  ptr      Pointer to the talloc chunk to move.
+ *
+ * @return              The pointer of the talloc chunk it has been moved to,
+ *                      NULL on error.
+ */
+void *talloc_move(const void *new_ctx, const void *ptr);
+#else
 #define talloc_move(ctx, ptr) (_TALLOC_TYPEOF(*(ptr)))_talloc_move((ctx),(void *)(ptr))
+/* useful macros for creating type checked pointers */
+#define talloc(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
+void *_talloc_move(const void *new_ctx, const void *pptr);
+#endif
+/**
+ * @brief Assign a name to a talloc chunk.
+ *
+ * The function is just like talloc_set_name(), but it takes a string constant,
+ * and is much faster. It is extensively used by the "auto naming" macros, such
+ * as talloc_p().
+ *
+ * This function does not allocate any memory. It just copies the supplied
+ * pointer into the internal representation of the talloc ptr. This means you
+ * must not pass a name pointer to memory that will disappear before the ptr
+ * is freed with talloc_free().
+ *
+ * @param[in]  ptr      The talloc chunk to assign a name to.
+ *
+ * @param[in]  name     Format string for the name.
+ */
+void talloc_set_name_const(const void *ptr, const char *name);
+/**
+ * @brief Create a named talloc chunk.
+ *
+ * The talloc_named() function creates a named talloc pointer. It is
+ * equivalent to:
+ *
+ * @code
+ *      ptr = talloc_size(context, size);
+ *      talloc_set_name(ptr, fmt, ....);
+ * @endcode
+ *
+ * @param[in]  context  The talloc context to hang the result off.
+ *
+ * @param[in]  size     Number of char's that you want to allocate.
+ *
+ * @param[in]  fmt      Format string for the name.
+ *
+ * @param[in]  ...      Additional printf-style arguments.
+ *
+ * @return              The allocated memory chunk, NULL on error.
+ *
+ * @see talloc_set_name()
+ */
+void *talloc_named(const void *context, size_t size,
+                   const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
+/**
+ * @brief Basic routine to allocate a chunk of memory.
+ *
+ * This is equivalent to:
+ *
+ * @code
+ *      ptr = talloc_size(context, size);
+ *      talloc_set_name_const(ptr, name);
+ * @endcode
+ *
+ * @param[in]  context  The parent context.
+ *
+ * @param[in]  size     The number of char's that we want to allocate.
+ *
+ * @param[in]  name     The name the talloc block has.
+ *
+ * @return             The allocated memory chunk, NULL on error.
+ */
+void *talloc_named_const(const void *context, size_t size, const char *name);
+#ifdef DOXYGEN
+/**
+ * @brief Untyped allocation.
+ *
+ * The function should be used when you don't have a convenient type to pass to
+ * talloc(). Unlike talloc(), it is not type safe (as it returns a void *), so
+ * you are on your own for type checking.
+ *
+ * Best to use talloc() or talloc_array() instead.
+ *
+ * @param[in]  ctx     The talloc context to hang the result off.
+ *
+ * @param[in]  size    Number of char's that you want to allocate.
+ *
+ * @return             The allocated memory chunk, NULL on error.
+ *
+ * Example:
+ * @code
+ *      void *mem = talloc_size(NULL, 100);
+ * @endcode
+ */
+void *talloc_size(const void *ctx, size_t size);
+#else
 #define talloc_size(ctx, size) talloc_named_const(ctx, size, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Allocate into a typed pointer.
+ *
+ * The talloc_ptrtype() macro should be used when you have a pointer and want
+ * to allocate memory to point at with this pointer. When compiling with
+ * gcc >= 3 it is typesafe. Note this is a wrapper of talloc_size() and
+ * talloc_get_name() will return the current location in the source file and
+ * not the type.
+ *
+ * @param[in]  ctx      The talloc context to hang the result off.
+ *
+ * @param[in]  type     The pointer you want to assign the result to.
+ *
+ * @return              The properly casted allocated memory chunk, NULL on
+ *                      error.
+ *
+ * Example:
+ * @code
+ *       unsigned int *a = talloc_ptrtype(NULL, a);
+ * @endcode
+ */
+void *talloc_ptrtype(const void *ctx, #type);
+#else
 #define talloc_ptrtype(ctx, ptr) (_TALLOC_TYPEOF(ptr))talloc_size(ctx, sizeof(*(ptr)))
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Allocate a new 0-sized talloc chunk.
+ *
+ * This is a utility macro that creates a new memory context hanging off an
+ * existing context, automatically naming it "talloc_new: __location__" where
+ * __location__ is the source line it is called from. It is particularly
+ * useful for creating a new temporary working context.
+ *
+ * @param[in]  ctx      The talloc parent context.
+ *
+ * @return              A new talloc chunk, NULL on error.
+ */
+void *talloc_new(const void *ctx);
+#else
 #define talloc_new(ctx) talloc_named_const(ctx, 0, "talloc_new: " __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Allocate a 0-initizialized structure.
+ *
+ * The macro is equivalent to:
+ *
+ * @code
+ *      ptr = talloc(ctx, type);
+ *      if (ptr) memset(ptr, 0, sizeof(type));
+ * @endcode
+ *
+ * @param[in]  ctx      The talloc context to hang the result off.
+ *
+ * @param[in]  type     The type that we want to allocate.
+ *
+ * @return              Pointer to a piece of memory, properly cast to 'type *',
+ *                      NULL on error.
+ *
+ * Example:
+ * @code
+ *      unsigned int *a, *b;
+ *      a = talloc_zero(NULL, unsigned int);
+ *      b = talloc_zero(a, unsigned int);
+ * @endcode
+ *
+ * @see talloc()
+ * @see talloc_zero_size()
+ * @see talloc_zero_array()
+ */
+void *talloc_zero(const void *ctx, #type);
+/**
+ * @brief Allocate untyped, 0-initialized memory.
+ *
+ * @param[in]  ctx      The talloc context to hang the result off.
+ *
+ * @param[in]  size     Number of char's that you want to allocate.
+ *
+ * @return              The allocated memory chunk.
+ */
+void *talloc_zero_size(const void *ctx, size_t size);
+#else
 #define talloc_zero(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
 #define talloc_zero_size(ctx, size) _talloc_zero(ctx, size, __location__)
+#define talloc_zero_array(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
+#define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
+#define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
+#define talloc_array_ptrtype(ctx, ptr, count) (_TALLOC_TYPEOF(ptr))talloc_array_size(ctx, sizeof(*(ptr)), count)
+#define talloc_array_length(ctx) (talloc_get_size(ctx)/sizeof(*ctx))
+#define talloc_realloc(ctx, p, type, count) (type *)_talloc_realloc_array(ctx, p, sizeof(type), count, #type)
+#define talloc_realloc_size(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__)
+void *_talloc_zero(const void *ctx, size_t size, const char *name);
+#endif
+/**
+ * @brief Return the name of a talloc chunk.
+ *
+ * @param[in]  ptr      The talloc chunk.
+ *
+ * @return              The current name for the given talloc pointer.
+ *
+ * @see talloc_set_name()
+ */
+const char *talloc_get_name(const void *ptr);
+/**
+ * @brief Verify that a talloc chunk carries a specified name.
+ *
+ * This function checks if a pointer has the specified name. If it does
+ * then the pointer is returned.
+ *
+ * @param[in]  ptr       The talloc chunk to check.
+ *
+ * @param[in]  name      The name to check against.
+ *
+ * @return               The pointer if the name matches, NULL if it doesn't.
+ */
+void *talloc_check_name(const void *ptr, const char *name);
+/**
+ * @brief Get the parent chunk of a pointer.
+ *
+ * @param[in]  ptr      The talloc pointer to inspect.
+ *
+ * @return              The talloc parent of ptr, NULL on error.
+ */
+void *talloc_parent(const void *ptr);
+/**
+ * @brief Get a talloc chunk's parent name.
+ *
+ * @param[in]  ptr      The talloc pointer to inspect.
+ *
+ * @return              The name of ptr's parent chunk.
+ */
+const char *talloc_parent_name(const void *ptr);
+/**
+ * @brief Get the total size of a talloc chunk including its children.
+ *
+ * The function returns the total size in bytes used by this pointer and all
+ * child pointers. Mostly useful for debugging.
+ *
+ * Passing NULL is allowed, but it will only give a meaningful result if
+ * talloc_enable_leak_report() or talloc_enable_leak_report_full() has
+ * been called.
+ *
+ * @param[in]  ptr      The talloc chunk.
+ *
+ * @return              The total size.
+ */
+size_t talloc_total_size(const void *ptr);
+/**
+ * @brief Get the number of talloc chunks hanging off a chunk.
+ *
+ * The talloc_total_blocks() function returns the total memory block
+ * count used by this pointer and all child pointers. Mostly useful for
+ * debugging.
+ *
+ * Passing NULL is allowed, but it will only give a meaningful result if
+ * talloc_enable_leak_report() or talloc_enable_leak_report_full() has
+ * been called.
+ *
+ * @param[in]  ptr      The talloc chunk.
+ *
+ * @return              The total size.
+ */
+size_t talloc_total_blocks(const void *ptr);
+#ifdef DOXYGEN
+/**
+ * @brief Duplicate a memory area into a talloc chunk.
+ *
+ * The function is equivalent to:
+ *
+ * @code
+ *      ptr = talloc_size(ctx, size);
+ *      if (ptr) memcpy(ptr, p, size);
+ * @endcode
+ *
+ * @param[in]  t        The talloc context to hang the result off.
+ *
+ * @param[in]  p        The memory chunk you want to duplicate.
+ *
+ * @param[in]  size     Number of char's that you want copy.
+ *
+ * @return              The allocated memory chunk.
+ *
+ * @see talloc_size()
+ */
+void *talloc_memdup(const void *t, const void *p, size_t size);
+#else
 #define talloc_memdup(t, p, size) _talloc_memdup(t, p, size, __location__)
+void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name);
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Assign a type to a talloc chunk.
+ *
+ * This macro allows you to force the name of a pointer to be a particular type.
+ * This can be used in conjunction with talloc_get_type() to do type checking on
+ * void* pointers.
+ *
+ * It is equivalent to this:
+ *
+ * @code
+ *      talloc_set_name_const(ptr, #type)
+ * @endcode
+ *
+ * @param[in]  ptr      The talloc chunk to assign the type to.
+ *
+ * @param[in]  type     The type to assign.
+ */
+void talloc_set_type(const char *ptr, #type);
+/**
+ * @brief Get a typed pointer out of a talloc pointer.
+ *
+ * This macro allows you to do type checking on talloc pointers. It is
+ * particularly useful for void* private pointers. It is equivalent to
+ * this:
+ *
+ * @code
+ *      (type *)talloc_check_name(ptr, #type)
+ * @endcode
+ *
+ * @param[in]  ptr      The talloc pointer to check.
+ *
+ * @param[in]  type     The type to check against.
+ *
+ * @return              The properly casted pointer given by ptr, NULL on error.
+ */
+type *talloc_get_type(const void *ptr, #type);
+#else
 #define talloc_set_type(ptr, type) talloc_set_name_const(ptr, #type)
 #define talloc_get_type(ptr, type) (type *)talloc_check_name(ptr, #type)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Safely turn a void pointer into a typed pointer.
+ *
+ * This macro is used together with talloc(mem_ctx, struct foo). If you had to
+ * assing the talloc chunk pointer to some void pointer variable,
+ * talloc_get_type_abort() is the recommended way to get the convert the void
+ * pointer back to a typed pointer.
+ *
+ * @param[in]  ptr      The void pointer to convert.
+ *
+ * @param[in]  type     The type that this chunk contains
+ *
+ * @return              The same value as ptr, type-checked and properly cast.
+ */
+void *talloc_get_type_abort(const void *ptr, #type);
+#else
 #define talloc_get_type_abort(ptr, type) (type *)_talloc_get_type_abort(ptr, #type, __location__)
+void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location);
+#endif
+/**
+ * @brief Find a parent context by name.
+ *
+ * Find a parent memory context of the current context that has the given
+ * name. This can be very useful in complex programs where it may be
+ * difficult to pass all information down to the level you need, but you
+ * know the structure you want is a parent of another context.
+ *
+ * @param[in]  ctx      The talloc chunk to start from.
+ *
+ * @param[in]  name     The name of the parent we look for.
+ *
+ * @return              The memory context we are looking for, NULL if not
+ *                      found.
+ */
+void *talloc_find_parent_byname(const void *ctx, const char *name);
+#ifdef DOXYGEN
+/**
+ * @brief Find a parent context by type.
+ *
+ * Find a parent memory context of the current context that has the given
+ * name. This can be very useful in complex programs where it may be
+ * difficult to pass all information down to the level you need, but you
+ * know the structure you want is a parent of another context.
+ *
+ * Like talloc_find_parent_byname() but takes a type, making it typesafe.
+ *
+ * @param[in]  ptr      The talloc chunk to start from.
+ *
+ * @param[in]  type     The type of the parent to look for.
+ *
+ * @return              The memory context we are looking for, NULL if not
+ *                      found.
+ */
+void *talloc_find_parent_bytype(const void *ptr, #type);
+#else
 #define talloc_find_parent_bytype(ptr, type) (type *)talloc_find_parent_byname(ptr, #type)
+#define talloc_free(ctx) _talloc_free(ctx, __location__)
+#endif
+/**
+ * @brief Allocate a talloc pool.
+ *
+ * A talloc pool is a pure optimization for specific situations. In the
+ * release process for Samba 3.2 we found out that we had become considerably
+ * slower than Samba 3.0 was. Profiling showed that malloc(3) was a large CPU
+ * consumer in benchmarks. For Samba 3.2 we have internally converted many
+ * static buffers to dynamically allocated ones, so malloc(3) being beaten
+ * more was no surprise. But it made us slower.
+ *
+ * talloc_pool() is an optimization to call malloc(3) a lot less for the use
+ * pattern Samba has: The SMB protocol is mainly a request/response protocol
+ * where we have to allocate a certain amount of memory per request and free
+ * that after the SMB reply is sent to the client.
+ *
+ * talloc_pool() creates a talloc chunk that you can use as a talloc parent
+ * exactly as you would use any other ::TALLOC_CTX. The difference is that
+ * when you talloc a child of this pool, no malloc(3) is done. Instead, talloc
+ * just increments a pointer inside the talloc_pool. This also works
+ * recursively. If you use the child of the talloc pool as a parent for
+ * grand-children, their memory is also taken from the talloc pool.
+ *
+ * If you talloc_free() children of a talloc pool, the memory is not given
+ * back to the system. Instead, free(3) is only called if the talloc_pool()
+ * itself is released with talloc_free().
+ *
+ * The downside of a talloc pool is that if you talloc_move() a child of a
+ * talloc pool to a talloc parent outside the pool, the whole pool memory is
+ * not free(3)'ed until that moved chunk is also talloc_free()ed.
+ *
+ * @param[in]  context  The talloc context to hang the result off.
+ *
+ * @param[in]  size     Size of the talloc pool.
+ *
+ * @return              The allocated talloc pool, NULL on error.
+ */
+void *talloc_pool(const void *context, size_t size);
+/**
+ * @brief Free a talloc chunk and NULL out the pointer.
+ *
+ * TALLOC_FREE() frees a pointer and sets it to NULL. Use this if you want
+ * immediate feedback (i.e. crash) if you use a pointer after having free'ed
+ * it.
+ *
+ * @param[in]  ctx      The chunk to be freed.
+ */
+#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
+/* @} ******************************************************************/
+/**
+ * \defgroup talloc_ref The talloc reference function.
+ * @ingroup talloc
+ *
+ * This module contains the definitions around talloc references
+ *
+ * @{
+ */
+/**
+ * @brief Increase the reference count of a talloc chunk.
+ *
+ * The talloc_increase_ref_count(ptr) function is exactly equivalent to:
+ *
+ * @code
+ *      talloc_reference(NULL, ptr);
+ * @endcode
+ *
+ * You can use either syntax, depending on which you think is clearer in
+ * your code.
+ *
+ * @param[in]  ptr      The pointer to increase the reference count.
+ *
+ * @return              0 on success, -1 on error.
+ */
+int talloc_increase_ref_count(const void *ptr);
+/**
+ * @brief Get the number of references to a talloc chunk.
+ *
+ * @param[in]  ptr      The pointer to retrieve the reference count from.
+ *
+ * @return              The number of references.
+ */
+size_t talloc_reference_count(const void *ptr);
+#ifdef DOXYGEN
+/**
+ * @brief Create an additional talloc parent to a pointer.
+ *
+ * The talloc_reference() function makes "context" an additional parent of
+ * ptr. Each additional reference consumes around 48 bytes of memory on intel
+ * x86 platforms.
+ *
+ * If ptr is NULL, then the function is a no-op, and simply returns NULL.
+ *
+ * After creating a reference you can free it in one of the following ways:
+ *
+ * - you can talloc_free() any parent of the original pointer. That
+ *   will reduce the number of parents of this pointer by 1, and will
+ *   cause this pointer to be freed if it runs out of parents.
+ *
+ * - you can talloc_free() the pointer itself. That will destroy the
+ *   most recently established parent to the pointer and leave the
+ *   pointer as a child of its current parent.
+ *
+ * For more control on which parent to remove, see talloc_unlink()
+ * @param[in]  ctx      The additional parent.
+ *
+ * @param[in]  ptr      The pointer you want to create an additional parent for.
+ *
+ * @return              The original pointer 'ptr', NULL if talloc ran out of
+ *                      memory in creating the reference.
+ *
+ * Example:
+ * @code
+ *      unsigned int *a, *b, *c;
+ *      a = talloc(NULL, unsigned int);
+ *      b = talloc(NULL, unsigned int);
+ *      c = talloc(a, unsigned int);
+ *      // b also serves as a parent of c.
+ *      talloc_reference(b, c);
+ * @endcode
+ *
+ * @see talloc_unlink()
+ */
+void *talloc_reference(const void *ctx, const void *ptr);
+#else
+#define talloc_reference(ctx, ptr) (_TALLOC_TYPEOF(ptr))_talloc_reference_loc((ctx),(ptr), __location__)
+void *_talloc_reference_loc(const void *context, const void *ptr, const char *location);
+#endif
+/**
+ * @brief Remove a specific parent from a talloc chunk.
+ *
+ * The function removes a specific parent from ptr. The context passed must
+ * either be a context used in talloc_reference() with this pointer, or must be
+ * a direct parent of ptr.
+ *
+ * Usually you can just use talloc_free() instead of talloc_unlink(), but
+ * sometimes it is useful to have the additional control on which parent is
+ * removed.
+ *
+ * @param[in]  context  The talloc parent to remove.
+ *
+ * @param[in]  ptr      The talloc ptr you want to remove the parent from.
+ *
+ * @return              0 on success, -1 on error.
+ *
+ * @note If the parent has already been removed using talloc_free() then
+ * this function will fail and will return -1.  Likewise, if ptr is NULL,
+ * then the function will make no modifications and return -1.
+ *
+ * Example:
+ * @code
+ *      unsigned int *a, *b, *c;
+ *      a = talloc(NULL, unsigned int);
+ *      b = talloc(NULL, unsigned int);
+ *      c = talloc(a, unsigned int);
+ *      // b also serves as a parent of c.
+ *      talloc_reference(b, c);
+ *      talloc_unlink(b, c);
+ * @endcode
+ */
+int talloc_unlink(const void *context, void *ptr);
+/**
+ * @brief Provide a talloc context that is freed at program exit.
+ *
+ * This is a handy utility function that returns a talloc context
+ * which will be automatically freed on program exit. This can be used
+ * to reduce the noise in memory leak reports.
+ *
+ * Never use this in code that might be used in objects loaded with
+ * dlopen and unloaded with dlclose. talloc_autofree_context()
+ * internally uses atexit(3). Some platforms like modern Linux handles
+ * this fine, but for example FreeBSD does not deal well with dlopen()
+ * and atexit() used simultaneously: dlclose() does not clean up the
+ * list of atexit-handlers, so when the program exits the code that
+ * was registered from within talloc_autofree_context() is gone, the
+ * program crashes at exit.
+ *
+ * @return              A talloc context, NULL on error.
+ */
+void *talloc_autofree_context(void);
+/**
+ * @brief Get the size of a talloc chunk.
+ *
+ * This function lets you know the amount of memory alloced so far by
+ * this context. It does NOT account for subcontext memory.
+ * This can be used to calculate the size of an array.
+ *
+ * @param[in]  ctx      The talloc chunk.
+ *
+ * @return              The size of the talloc chunk.
+ */
+size_t talloc_get_size(const void *ctx);
+/**
+ * @brief Show the parentage of a context.
+ *
+ * @param[in]  context            The talloc context to look at.
+ *
+ * @param[in]  file               The output to use, a file, stdout or stderr.
+ */
+void talloc_show_parents(const void *context, FILE *file);
+/**
+ * @brief Check if a context is parent of a talloc chunk.
+ *
+ * This checks if context is referenced in the talloc hierarchy above ptr.
+ *
+ * @param[in]  context  The assumed talloc context.
+ *
+ * @param[in]  ptr      The talloc chunk to check.
+ *
+ * @return              Return 1 if this is the case, 0 if not.
+ */
+int talloc_is_parent(const void *context, const void *ptr);
+/**
+ * @brief Change the parent context of a talloc pointer.
+ *
+ * The function changes the parent context of a talloc pointer. It is typically
+ * used when the context that the pointer is currently a child of is going to be
+ * freed and you wish to keep the memory for a longer time.
+ *
+ * The difference between talloc_reparent() and talloc_steal() is that
+ * talloc_reparent() can specify which parent you wish to change. This is
+ * useful when a pointer has multiple parents via references.
+ *
+ * @param[in]  old_parent
+ * @param[in]  new_parent
+ * @param[in]  ptr
+ *
+ * @return              Return the pointer you passed. It does not have any
+ *                      failure modes.
+ */
+void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr);
+/* @} ******************************************************************/
+/**
+ * @defgroup talloc_array The talloc array functions
+ * @ingroup talloc
+ *
+ * Talloc contains some handy helpers for handling Arrays conveniently
+ *
+ * @{
+ */
+#ifdef DOXYGEN
+/**
+ * @brief Allocate an array.
+ *
+ * The macro is equivalent to:
+ *
+ * @code
+ *      (type *)talloc_size(ctx, sizeof(type) * count);
+ * @endcode
+ *
+ * except that it provides integer overflow protection for the multiply,
+ * returning NULL if the multiply overflows.
+ *
+ * @param[in]  ctx      The talloc context to hang the result off.
+ *
+ * @param[in]  type     The type that we want to allocate.
+ *
+ * @param[in]  count    The number of 'type' elements you want to allocate.
+ *
+ * @return              The allocated result, properly cast to 'type *', NULL on
+ *                      error.
+ *
+ * Example:
+ * @code
+ *      unsigned int *a, *b;
+ *      a = talloc_zero(NULL, unsigned int);
+ *      b = talloc_array(a, unsigned int, 100);
+ * @endcode
+ *
+ * @see talloc()
+ * @see talloc_zero_array()
+ */
+void *talloc_array(const void *ctx, #type, unsigned count);
+#else
+#define talloc_array(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
+void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name);
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Allocate an array.
+ *
+ * @param[in]  ctx      The talloc context to hang the result off.
+ *
+ * @param[in]  size     The size of an array element.
+ *
+ * @param[in]  count    The number of elements you want to allocate.
+ *
+ * @return              The allocated result, NULL on error.
+ */
+void *talloc_array_size(const void *ctx, size_t size, unsigned count);
+#else
+#define talloc_array_size(ctx, size, count) _talloc_array(ctx, size, count, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Allocate an array into a typed pointer.
+ *
+ * The macro should be used when you have a pointer to an array and want to
+ * allocate memory of an array to point at with this pointer. When compiling
+ * with gcc >= 3 it is typesafe. Note this is a wrapper of talloc_array_size()
+ * and talloc_get_name() will return the current location in the source file
+ * and not the type.
+ *
+ * @param[in]  ctx      The talloc context to hang the result off.
+ *
+ * @param[in]  ptr      The pointer you want to assign the result to.
+ *
+ * @param[in]  count    The number of elements you want to allocate.
+ *
+ * @return              The allocated memory chunk, properly casted. NULL on
+ *                      error.
+ */
+void *talloc_array_ptrtype(const void *ctx, const void *ptr, unsigned count);
+#else
+#define talloc_array_ptrtype(ctx, ptr, count) (_TALLOC_TYPEOF(ptr))talloc_array_size(ctx, sizeof(*(ptr)), count)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Get the number of elements in a talloc'ed array.
+ *
+ * A talloc chunk carries its own size, so for talloc'ed arrays it is not
+ * necessary to store the number of elements explicitly.
+ *
+ * @param[in]  ctx      The allocated array.
+ *
+ * @return              The number of elements in ctx.
+ */
+size_t talloc_array_length(const void *ctx);
+#else
+#define talloc_array_length(ctx) (talloc_get_size(ctx)/sizeof(*ctx))
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Allocate a zero-initialized array
+ *
+ * @param[in]  ctx      The talloc context to hang the result off.
+ *
+ * @param[in]  type     The type that we want to allocate.
+ *
+ * @param[in]  count    The number of "type" elements you want to allocate.
+ *
+ * @return              The allocated result casted to "type *", NULL on error.
+ *
+ * The talloc_zero_array() macro is equivalent to:
+ *
+ * @code
+ *     ptr = talloc_array(ctx, type, count);
+ *     if (ptr) memset(ptr, sizeof(type) * count);
+ * @endcode
+ */
+void *talloc_zero_array(const void *ctx, #type, unsigned count);
+#else
+#define talloc_zero_array(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
+void *_talloc_zero_array(const void *ctx,
+                         size_t el_size,
+                         unsigned count,
+                         const char *name);
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Change the size of a talloc array.
+ *
+ * The macro changes the size of a talloc pointer. The 'count' argument is the
+ * number of elements of type 'type' that you want the resulting pointer to
+ * hold.
+ *
+ * talloc_realloc() has the following equivalences:
+ *
+ * @code
+ *      talloc_realloc(ctx, NULL, type, 1) ==> talloc(ctx, type);
+ *      talloc_realloc(ctx, NULL, type, N) ==> talloc_array(ctx, type, N);
+ *      talloc_realloc(ctx, ptr, type, 0)  ==> talloc_free(ptr);
+ * @endcode
+ *
+ * The "context" argument is only used if "ptr" is NULL, otherwise it is
+ * ignored.
+ *
+ * @param[in]  ctx      The parent context used if ptr is NULL.
+ *
+ * @param[in]  ptr      The chunk to be resized.
+ *
+ * @param[in]  type     The type of the array element inside ptr.
+ *
+ * @param[in]  count    The intended number of array elements.
+ *
+ * @return              The new array, NULL on error. The call will fail either
+ *                      due to a lack of memory, or because the pointer has more
+ *                      than one parent (see talloc_reference()).
+ */
+void *talloc_realloc(const void *ctx, void *ptr, #type, size_t count);
+#else
+#define talloc_realloc(ctx, p, type, count) (type *)_talloc_realloc_array(ctx, p, sizeof(type), count, #type)
+void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name);
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Untyped realloc to change the size of a talloc array.
+ *
+ * The macro is useful when the type is not known so the typesafe
+ * talloc_realloc() cannot be used.
+ *
+ * @param[in]  ctx      The parent context used if 'ptr' is NULL.
+ *
+ * @param[in]  ptr      The chunk to be resized.
+ *
+ * @param[in]  size     The new chunk size.
+ *
+ * @return              The new array, NULL on error.
+ */
+void *talloc_realloc_size(const void *ctx, void *ptr, size_t size);
+#else
+#define talloc_realloc_size(ctx, ptr, size) _talloc_realloc(ctx, ptr, size, __location__)
+void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name);
+#endif
+/**
+ * @brief Provide a function version of talloc_realloc_size.
+ *
+ * This is a non-macro version of talloc_realloc(), which is useful as
+ * libraries sometimes want a ralloc function pointer. A realloc()
+ * implementation encapsulates the functionality of malloc(), free() and
+ * realloc() in one call, which is why it is useful to be able to pass around
+ * a single function pointer.
+ *
+ * @param[in]  context  The parent context used if ptr is NULL.
+ *
+ * @param[in]  ptr      The chunk to be resized.
+ *
+ * @param[in]  size     The new chunk size.
+ *
+ * @return              The new chunk, NULL on error.
+ */
+void *talloc_realloc_fn(const void *context, void *ptr, size_t size);
+/* @} ******************************************************************/
+/**
+ * @defgroup talloc_string The talloc string functions.
+ * @ingroup talloc
+ *
+ * talloc string allocation and manipulation functions.
+ * @{
+ */
+/**
+ * @brief Duplicate a string into a talloc chunk.
+ *
+ * This function is equivalent to:
+ *
+ * @code
+ *      ptr = talloc_size(ctx, strlen(p)+1);
+ *      if (ptr) memcpy(ptr, p, strlen(p)+1);
+ * @endcode
+ *
+ * This functions sets the name of the new pointer to the passed
+ * string. This is equivalent to:
+ *
+ * @code
+ *      talloc_set_name_const(ptr, ptr)
+ * @endcode
+ *
+ * @param[in]  t        The talloc context to hang the result off.
+ *
+ * @param[in]  p        The string you want to duplicate.
+ *
+ * @return              The duplicated string, NULL on error.
+ */
+char *talloc_strdup(const void *t, const char *p);
+/**
+ * @brief Append a string to given string and duplicate the result.
+ *
+ * @param[in]  s        The destination to append to.
+ *
+ * @param[in]  a        The string you want to append.
+ *
+ * @return              The duplicated string, NULL on error.
+ *
+ * @see talloc_strdup()
+ */
+char *talloc_strdup_append(char *s, const char *a);
+/**
+ * @brief Append a string to a given buffer and duplicate the result.
+ *
+ * @param[in]  s        The destination buffer to append to.
+ *
+ * @param[in]  a        The string you want to append.
+ *
+ * @return              The duplicated string, NULL on error.
+ *
+ * @see talloc_strdup()
+ */
+char *talloc_strdup_append_buffer(char *s, const char *a);
+/**
+ * @brief Duplicate a length-limited string into a talloc chunk.
+ *
+ * This function is the talloc equivalent of the C library function strndup(3).
+ *
+ * This functions sets the name of the new pointer to the passed string. This is
+ * equivalent to:
+ *
+ * @code
+ *      talloc_set_name_const(ptr, ptr)
+ * @endcode
+ *
+ * @param[in]  t        The talloc context to hang the result off.
+ *
+ * @param[in]  p        The string you want to duplicate.
+ *
+ * @param[in]  n        The maximum string length to duplicate.
+ *
+ * @return              The duplicated string, NULL on error.
+ */
+char *talloc_strndup(const void *t, const char *p, size_t n);
+/**
+ * @brief Append at most n characters of a string to given string and duplicate
+ *        the result.
+ *
+ * @param[in]  s        The destination string to append to.
+ *
+ * @param[in]  a        The source string you want to append.
+ *
+ * @param[in]  n        The number of characters you want to append from the
+ *                      string.
+ *
+ * @return              The duplicated string, NULL on error.
+ *
+ * @see talloc_strndup()
+ */
+char *talloc_strndup_append(char *s, const char *a, size_t n);
+/**
+ * @brief Append at most n characters of a string to given buffer and duplicate
+ *        the result.
+ *
+ * @param[in]  s        The destination buffer to append to.
+ *
+ * @param[in]  a        The source string you want to append.
+ *
+ * @param[in]  n        The number of characters you want to append from the
+ *                      string.
+ *
+ * @return              The duplicated string, NULL on error.
+ *
+ * @see talloc_strndup()
+ */
+char *talloc_strndup_append_buffer(char *s, const char *a, size_t n);
+/**
+ * @brief Format a string given a va_list.
+ *
+ * This function is the talloc equivalent of the C library function
+ * vasprintf(3).
+ *
+ * This functions sets the name of the new pointer to the new string. This is
+ * equivalent to:
+ *
+ * @code
+ *      talloc_set_name_const(ptr, ptr)
+ * @endcode
+ *
+ * @param[in]  t        The talloc context to hang the result off.
+ *
+ * @param[in]  fmt      The format string.
+ *
+ * @param[in]  ap       The parameters used to fill fmt.
+ *
+ * @return              The formatted string, NULL on error.
+ */
+char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+/**
+ * @brief Format a string given a va_list and append it to the given destination
+ *        string.
+ *
+ * @param[in]  s        The destination string to append to.
+ *
+ * @param[in]  fmt      The format string.
+ *
+ * @param[in]  ap       The parameters used to fill fmt.
+ *
+ * @return              The formatted string, NULL on error.
+ *
+ * @see talloc_vasprintf()
+ */
+char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+/**
+ * @brief Format a string given a va_list and append it to the given destination
+ *        buffer.
+ *
+ * @param[in]  s        The destination buffer to append to.
+ *
+ * @param[in]  fmt      The format string.
+ *
+ * @param[in]  ap       The parameters used to fill fmt.
+ *
+ * @return              The formatted string, NULL on error.
+ *
+ * @see talloc_vasprintf()
+ */
+char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+/**
+ * @brief Format a string.
+ *
+ * This function is the talloc equivalent of the C library function asprintf(3).
+ *
+ * This functions sets the name of the new pointer to the new string. This is
+ * equivalent to:
+ *
+ * @code
+ *      talloc_set_name_const(ptr, ptr)
+ * @endcode
+ *
+ * @param[in]  t        The talloc context to hang the result off.
+ *
+ * @param[in]  fmt      The format string.
+ *
+ * @param[in]  ...      The parameters used to fill fmt.
+ *
+ * @return              The formatted string, NULL on error.
+ */
+char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+/**
+ * @brief Append a formatted string to another string.
+ *
+ * This function appends the given formatted string to the given string. Use
+ * this varient when the string in the current talloc buffer may have been
+ * truncated in length.
+ *
+ * This functions sets the name of the new pointer to the new
+ * string. This is equivalent to:
+ *
+ * @code
+ *      talloc_set_name_const(ptr, ptr)
+ * @endcode
+ *
+ * @param[in]  s        The string to append to.
+ *
+ * @param[in]  fmt      The format string.
+ *
+ * @param[in]  ...      The parameters used to fill fmt.
+ *
+ * @return              The formatted string, NULL on error.
+ */
+char *talloc_asprintf_append(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+/**
+ * @brief Append a formatted string to another string.
+ *
+ * @param[in]  s        The string to append to
+ *
+ * @param[in]  fmt      The format string.
+ *
+ * @param[in]  ...      The parameters used to fill fmt.
+ *
+ * @return              The formatted string, NULL on error.
+ */
+char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+/* @} ******************************************************************/
+/**
+ * @defgroup talloc_debug The talloc debugging support functions
+ * @ingroup talloc
+ *
+ * To aid memory debugging, talloc contains routines to inspect the currently
+ * allocated memory hierarchy.
+ *
+ * @{
+ */
+/**
+ * @brief Walk a complete talloc hierarchy.
+ *
+ * This provides a more flexible reports than talloc_report(). It
+ * will recursively call the callback for the entire tree of memory
+ * referenced by the pointer. References in the tree are passed with
+ * is_ref = 1 and the pointer that is referenced.
+ *
+ * You can pass NULL for the pointer, in which case a report is
+ * printed for the top level memory context, but only if
+ * talloc_enable_leak_report() or talloc_enable_leak_report_full()
+ * has been called.
+ *
+ * The recursion is stopped when depth >= max_depth.
+ * max_depth = -1 means only stop at leaf nodes.
+ *
+ * @param[in]  ptr      The talloc chunk.
+ *
+ * @param[in]  depth    Internal parameter to control recursion. Call with 0.
+ *
+ * @param[in]  max_depth  Maximum recursion level.
+ *
+ * @param[in]  callback  Function to be called on every chunk.
+ *
+ * @param[in]  private_data  Private pointer passed to callback.
+ */
+void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+                            void (*callback)(const void *ptr,
+                                             int depth, int max_depth,
+                                             int is_ref,
+                                             void *private_data),
+                            void *private_data);
+/**
+ * @brief Print a talloc hierarchy.
+ *
+ * This provides a more flexible reports than talloc_report(). It
+ * will let you specify the depth and max_depth.
+ *
+ * @param[in]  ptr      The talloc chunk.
+ *
+ * @param[in]  depth    Internal parameter to control recursion. Call with 0.
+ *
+ * @param[in]  max_depth  Maximum recursion level.
+ *
+ * @param[in]  f        The file handle to print to.
+ */
+void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f);
+/**
+ * @brief Print a summary report of all memory used by ptr.
+ *
+ * This provides a more detailed report than talloc_report(). It will
+ * recursively print the ensire tree of memory referenced by the
+ * pointer. References in the tree are shown by giving the name of the
+ * pointer that is referenced.
+ *
+ * You can pass NULL for the pointer, in which case a report is printed
+ * for the top level memory context, but only if
+ * talloc_enable_leak_report() or talloc_enable_leak_report_full() has
+ * been called.
+ *
+ * @param[in]  ptr      The talloc chunk.
+ *
+ * @param[in]  f        The file handle to print to.
+ *
+ * Example:
+ * @code
+ *      unsigned int *a, *b;
+ *      a = talloc(NULL, unsigned int);
+ *      b = talloc(a, unsigned int);
+ *      fprintf(stderr, "Dumping memory tree for a:\n");
+ *      talloc_report_full(a, stderr);
+ * @endcode
+ *
+ * @see talloc_report()
+ */
+void talloc_report_full(const void *ptr, FILE *f);
+/**
+ * @brief Print a summary report of all memory used by ptr.
+ *
+ * This function prints a summary report of all memory used by ptr. One line of
+ * report is printed for each immediate child of ptr, showing the total memory
+ * and number of blocks used by that child.
+ *
+ * You can pass NULL for the pointer, in which case a report is printed
+ * for the top level memory context, but only if talloc_enable_leak_report()
+ * or talloc_enable_leak_report_full() has been called.
+ *
+ * @param[in]  ptr      The talloc chunk.
+ *
+ * @param[in]  f        The file handle to print to.
+ *
+ * Example:
+ * @code
+ *      unsigned int *a, *b;
+ *      a = talloc(NULL, unsigned int);
+ *      b = talloc(a, unsigned int);
+ *      fprintf(stderr, "Summary of memory tree for a:\n");
+ *      talloc_report(a, stderr);
+ * @endcode
+ *
+ * @see talloc_report_full()
+ */
+void talloc_report(const void *ptr, FILE *f);
+/**
+ * @brief Enable tracking the use of NULL memory contexts.
+ *
+ * This enables tracking of the NULL memory context without enabling leak
+ * reporting on exit. Useful for when you want to do your own leak
+ * reporting call via talloc_report_null_full();
+ */
+void talloc_enable_null_tracking(void);
+/**
+ * @brief Enable tracking the use of NULL memory contexts.
+ *
+ * This enables tracking of the NULL memory context without enabling leak
+ * reporting on exit. Useful for when you want to do your own leak
+ * reporting call via talloc_report_null_full();
+ */
+void talloc_enable_null_tracking_no_autofree(void);
+/**
+ * @brief Disable tracking of the NULL memory context.
+ *
+ * This disables tracking of the NULL memory context.
+ */
+void talloc_disable_null_tracking(void);
+/**
+ * @brief Enable leak report when a program exits.
+ *
+ * This enables calling of talloc_report(NULL, stderr) when the program
+ * exits. In Samba4 this is enabled by using the --leak-report command
+ * line option.
+ *
+ * For it to be useful, this function must be called before any other
+ * talloc function as it establishes a "null context" that acts as the
+ * top of the tree. If you don't call this function first then passing
+ * NULL to talloc_report() or talloc_report_full() won't give you the
+ * full tree printout.
+ *
+ * Here is a typical talloc report:
+ *
+ * @code
+ * talloc report on 'null_context' (total 267 bytes in 15 blocks)
+ *      libcli/auth/spnego_parse.c:55  contains     31 bytes in   2 blocks
+ *      libcli/auth/spnego_parse.c:55  contains     31 bytes in   2 blocks
+ *      iconv(UTF8,CP850)              contains     42 bytes in   2 blocks
+ *      libcli/auth/spnego_parse.c:55  contains     31 bytes in   2 blocks
+ *      iconv(CP850,UTF8)              contains     42 bytes in   2 blocks
+ *      iconv(UTF8,UTF-16LE)           contains     45 bytes in   2 blocks
+ *      iconv(UTF-16LE,UTF8)           contains     45 bytes in   2 blocks
+ * @endcode
+ */
+void talloc_enable_leak_report(void);
+/**
+ * @brief Enable full leak report when a program exits.
+ *
+ * This enables calling of talloc_report_full(NULL, stderr) when the
+ * program exits. In Samba4 this is enabled by using the
+ * --leak-report-full command line option.
+ *
+ * For it to be useful, this function must be called before any other
+ * talloc function as it establishes a "null context" that acts as the
+ * top of the tree. If you don't call this function first then passing
+ * NULL to talloc_report() or talloc_report_full() won't give you the
+ * full tree printout.
+ *
+ * Here is a typical full report:
+ *
+ * @code
+ * full talloc report on 'root' (total 18 bytes in 8 blocks)
+ *      p1                             contains     18 bytes in   7 blocks (ref 0)
+ *      r1                             contains     13 bytes in   2 blocks (ref 0)
+ *      reference to: p2
+ *      p2                             contains      1 bytes in   1 blocks (ref 1)
+ *      x3                             contains      1 bytes in   1 blocks (ref 0)
+ *      x2                             contains      1 bytes in   1 blocks (ref 0)
+ *      x1                             contains      1 bytes in   1 blocks (ref 0)
+ * @endcode
+ */
+void talloc_enable_leak_report_full(void);
+/* @} ******************************************************************/
+void talloc_set_abort_fn(void (*abort_fn)(const char *reason));
+void talloc_set_log_fn(void (*log_fn)(const char *message));
+void talloc_set_log_stderr(void);
 #if TALLOC_DEPRECATED
 …
 #endif
+#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
+/* The following definitions come from talloc.c  */
+void *_talloc(const void *context, size_t size);
+void *talloc_pool(const void *context, size_t size);
+void _talloc_set_destructor(const void *ptr, int (*_destructor)(void *));
+int talloc_increase_ref_count(const void *ptr);
+size_t talloc_reference_count(const void *ptr);
+void *_talloc_reference_loc(const void *context, const void *ptr, const char *location);
+int talloc_unlink(const void *context, void *ptr);
+const char *talloc_set_name(const void *ptr, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+void talloc_set_name_const(const void *ptr, const char *name);
+void *talloc_named(const void *context, size_t size,
+                   const char *fmt, ...) PRINTF_ATTRIBUTE(3,4);
+void *talloc_named_const(const void *context, size_t size, const char *name);
+const char *talloc_get_name(const void *ptr);
+void *talloc_check_name(const void *ptr, const char *name);
+void *_talloc_get_type_abort(const void *ptr, const char *name, const char *location);
+void *talloc_parent(const void *ptr);
+const char *talloc_parent_name(const void *ptr);
+void *talloc_init(const char *fmt, ...) PRINTF_ATTRIBUTE(1,2);
+int _talloc_free(void *ptr, const char *location);
+void talloc_free_children(void *ptr);
+void *_talloc_realloc(const void *context, void *ptr, size_t size, const char *name);
+void *_talloc_steal_loc(const void *new_ctx, const void *ptr, const char *location);
+void *talloc_reparent(const void *old_parent, const void *new_parent, const void *ptr);
+void *_talloc_move(const void *new_ctx, const void *pptr);
+size_t talloc_total_size(const void *ptr);
+size_t talloc_total_blocks(const void *ptr);
+void talloc_report_depth_cb(const void *ptr, int depth, int max_depth,
+                            void (*callback)(const void *ptr,
+                                             int depth, int max_depth,
+                                             int is_ref,
+                                             void *private_data),
+                            void *private_data);
+void talloc_report_depth_file(const void *ptr, int depth, int max_depth, FILE *f);
+void talloc_report_full(const void *ptr, FILE *f);
+void talloc_report(const void *ptr, FILE *f);
+void talloc_enable_null_tracking(void);
+void talloc_enable_null_tracking_no_autofree(void);
+void talloc_disable_null_tracking(void);
+void talloc_enable_leak_report(void);
+void talloc_enable_leak_report_full(void);
+void *_talloc_zero(const void *ctx, size_t size, const char *name);
+void *_talloc_memdup(const void *t, const void *p, size_t size, const char *name);
+void *_talloc_array(const void *ctx, size_t el_size, unsigned count, const char *name);
+void *_talloc_zero_array(const void *ctx, size_t el_size, unsigned count, const char *name);
+void *_talloc_realloc_array(const void *ctx, void *ptr, size_t el_size, unsigned count, const char *name);
+void *talloc_realloc_fn(const void *context, void *ptr, size_t size);
+void *talloc_autofree_context(void);
+size_t talloc_get_size(const void *ctx);
+void *talloc_find_parent_byname(const void *ctx, const char *name);
+void talloc_show_parents(const void *context, FILE *file);
+int talloc_is_parent(const void *context, const void *ptr);
+char *talloc_strdup(const void *t, const char *p);
+char *talloc_strdup_append(char *s, const char *a);
+char *talloc_strdup_append_buffer(char *s, const char *a);
+char *talloc_strndup(const void *t, const char *p, size_t n);
+char *talloc_strndup_append(char *s, const char *a, size_t n);
+char *talloc_strndup_append_buffer(char *s, const char *a, size_t n);
+char *talloc_vasprintf(const void *t, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+char *talloc_vasprintf_append(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+char *talloc_vasprintf_append_buffer(char *s, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(2,0);
+char *talloc_asprintf(const void *t, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+char *talloc_asprintf_append(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+char *talloc_asprintf_append_buffer(char *s, const char *fmt, ...) PRINTF_ATTRIBUTE(2,3);
+void talloc_set_abort_fn(void (*abort_fn)(const char *reason));
+void talloc_set_log_fn(void (*log_fn)(const char *message));
+void talloc_set_log_stderr(void);
+#endif
+#ifndef TALLOC_MAX_DEPTH
+#define TALLOC_MAX_DEPTH 10000
+#endif
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+#endif

vendor/current/lib/talloc/talloc.pc.in

r414	r740
7	7	Description: A hierarchical pool based memory system with destructors
8	8	Version: @TALLOC_VERSION@
9		Libs: -L${libdir} -ltalloc
	9	Libs: @LIB_RPATH@ -L${libdir} -ltalloc
10	10	Cflags: -I${includedir}
11	11	URL: http://talloc.samba.org/

vendor/current/lib/talloc/talloc_guide.txt

-              r414
+              r740
 synchronization.
+talloc and shared objects
+-------------------------
+talloc can be used in shared objects. Special care needs to be taken
+to never use talloc_autofree_context() in code that might be loaded
+with dlopen() and unloaded with dlclose(), as talloc_autofree_context()
+internally uses atexit(3). Some platforms like modern Linux handles
+this fine, but for example FreeBSD does not deal well with dlopen()
+and atexit() used simultaneously: dlclose() does not clean up the list
+of atexit-handlers, so when the program exits the code that was
+registered from within talloc_autofree_context() is gone, the program
+crashes at exit.
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 …
 The return value of talloc_free() indicates success or failure, with 0
+returned for success and -1 for failure. The only possible failure
+condition is if the pointer had a destructor attached to it and the
+destructor returned -1. See talloc_set_destructor() for details on
+destructors.
+returned for success and -1 for failure. A possible failure condition
+is if the pointer had a destructor attached to it and the destructor
+returned -1. See talloc_set_destructor() for details on
+destructors. Likewise, if "ptr" is NULL, then the function will make
+no modifications and returns -1.
 If this pointer has an additional parent when talloc_free() is called
 …
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 ((type *)talloc_array(const void *ctx, type, uint_t count);
+((type *)talloc_array(const void *ctx, type, unsigned int count);
 The talloc_array() macro is equivalent to::
 …
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 void *talloc_array_size(const void *ctx, size_t size, uint_t count);
+void *talloc_array_size(const void *ctx, size_t size, unsigned int count);
 The talloc_array_size() function is useful when the type is not
 …
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 (typeof(ptr)) talloc_array_ptrtype(const void *ctx, ptr, uint_t count);
+(typeof(ptr)) talloc_array_ptrtype(const void *ctx, ptr, unsigned int count);
 The talloc_ptrtype() macro should be used when you have a pointer to an array

vendor/current/lib/talloc/testsuite.c

-              r414
+              r740
 #include "replace.h"
 #include "system/time.h"
+#include "talloc.h"
+#include <talloc.h>
+#include "talloc_testsuite.h"
 static struct timeval timeval_current(void)
 …
 static unsigned int test_abort_count;
+#if 0
 static void test_abort_fn(const char *reason)
+{
 …
         talloc_set_abort_fn(test_abort_fn);
+}
+#endif
 static void test_abort_stop(void)
 …
         void *pool;
         void *p1, *p2, *p3, *p4;
+        void *p2_2;
         pool = talloc_pool(NULL, 1024);
         p1 = talloc_size(pool, 80);
+        memset(p1, 0x11, talloc_get_size(p1));
         p2 = talloc_size(pool, 20);
+        memset(p2, 0x11, talloc_get_size(p2));
         p3 = talloc_size(p1, 50);
+        memset(p3, 0x11, talloc_get_size(p3));
         p4 = talloc_size(p3, 1000);
+        memset(p4, 0x11, talloc_get_size(p4));
+#if 1 /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
+        p2_2 = talloc_realloc_size(pool, p2, 20+1);
+        torture_assert("pool realloc 20+1", p2_2 == p2, "failed: pointer changed");
+        memset(p2, 0x11, talloc_get_size(p2));
+        p2_2 = talloc_realloc_size(pool, p2, 20-1);
+        torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
+        memset(p2, 0x11, talloc_get_size(p2));
+        p2_2 = talloc_realloc_size(pool, p2, 20-1);
+        torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
+        memset(p2, 0x11, talloc_get_size(p2));
+        talloc_free(p3);
+        /* this should reclaim the memory of p4 and p3 */
+        p2_2 = talloc_realloc_size(pool, p2, 400);
+        torture_assert("pool realloc 400", p2_2 == p2, "failed: pointer changed");
+        memset(p2, 0x11, talloc_get_size(p2));
+        talloc_free(p1);
+        /* this should reclaim the memory of p1 */
+        p2_2 = talloc_realloc_size(pool, p2, 800);
+        torture_assert("pool realloc 800", p2_2 == p1, "failed: pointer not changed");
+        p2 = p2_2;
+        memset(p2, 0x11, talloc_get_size(p2));
+        /* this should do a malloc */
+        p2_2 = talloc_realloc_size(pool, p2, 1800);
+        torture_assert("pool realloc 1800", p2_2 != p2, "failed: pointer not changed");
+        p2 = p2_2;
+        memset(p2, 0x11, talloc_get_size(p2));
+        /* this should reclaim the memory from the pool */
+        p3 = talloc_size(pool, 80);
+        torture_assert("pool alloc 80", p3 == p1, "failed: pointer changed");
+        memset(p3, 0x11, talloc_get_size(p3));
+        talloc_free(p2);
+        talloc_free(p3);
+        p1 = talloc_size(pool, 80);
+        memset(p1, 0x11, talloc_get_size(p1));
+        p2 = talloc_size(pool, 20);
+        memset(p2, 0x11, talloc_get_size(p2));
+        talloc_free(p1);
+        p2_2 = talloc_realloc_size(pool, p2, 20-1);
+        torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
+        memset(p2, 0x11, talloc_get_size(p2));
+        p2_2 = talloc_realloc_size(pool, p2, 20-1);
+        torture_assert("pool realloc 20-1", p2_2 == p2, "failed: pointer changed");
+        memset(p2, 0x11, talloc_get_size(p2));
+        /* this should do a malloc */
+        p2_2 = talloc_realloc_size(pool, p2, 1800);
+        torture_assert("pool realloc 1800", p2_2 != p2, "failed: pointer not changed");
+        p2 = p2_2;
+        memset(p2, 0x11, talloc_get_size(p2));
+        /* this should reclaim the memory from the pool */
+        p3 = talloc_size(pool, 800);
+        torture_assert("pool alloc 800", p3 == p1, "failed: pointer changed");
+        memset(p3, 0x11, talloc_get_size(p3));
+#endif /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
         talloc_free(pool);
 …
         return true;
+}
+static bool test_pool_steal(void)
+{
+        void *root;
+        void *pool;
+        void *p1, *p2;
+        void *p1_2, *p2_2;
+        size_t hdr;
+        size_t ofs1, ofs2;
+        root = talloc_new(NULL);
+        pool = talloc_pool(root, 1024);
+        p1 = talloc_size(pool, 4 * 16);
+        torture_assert("pool allocate 4 * 16", p1 != NULL, "failed ");
+        memset(p1, 0x11, talloc_get_size(p1));
+        p2 = talloc_size(pool, 4 * 16);
+        torture_assert("pool allocate 4 * 16", p2 > p1, "failed: !(p2 > p1) ");
+        memset(p2, 0x11, talloc_get_size(p2));
+        ofs1 = PTR_DIFF(p2, p1);
+        hdr = ofs1 - talloc_get_size(p1);
+        talloc_steal(root, p1);
+        talloc_steal(root, p2);
+        talloc_free(pool);
+        p1_2 = p1;
+#if 1 /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
+        p1_2 = talloc_realloc_size(root, p1, 5 * 16);
+        torture_assert("pool realloc 5 * 16", p1_2 > p2, "failed: pointer not changed");
+        memset(p1_2, 0x11, talloc_get_size(p1_2));
+        ofs1 = PTR_DIFF(p1_2, p2);
+        ofs2 = talloc_get_size(p2) + hdr;
+        torture_assert("pool realloc ", ofs1 == ofs2, "failed: pointer offset unexpected");
+        p2_2 = talloc_realloc_size(root, p2, 3 * 16);
+        torture_assert("pool realloc 5 * 16", p2_2 == p2, "failed: pointer changed");
+        memset(p2_2, 0x11, talloc_get_size(p2_2));
+#endif /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
+        talloc_free(p1_2);
+        p2_2 = p2;
+#if 1 /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
+        /* now we should reclaim the full pool */
+        p2_2 = talloc_realloc_size(root, p2, 8 * 16);
+        torture_assert("pool realloc 8 * 16", p2_2 == p1, "failed: pointer not expected");
+        p2 = p2_2;
+        memset(p2_2, 0x11, talloc_get_size(p2_2));
+        /* now we malloc and free the full pool space */
+        p2_2 = talloc_realloc_size(root, p2, 2 * 1024);
+        torture_assert("pool realloc 2 * 1024", p2_2 != p1, "failed: pointer not expected");
+        memset(p2_2, 0x11, talloc_get_size(p2_2));
+#endif /* this relies on ALWAYS_REALLOC == 0 in talloc.c */
+        talloc_free(p2_2);
+        talloc_free(root);
+        return true;
+}
+static bool test_free_ref_null_context(void)
+{
+        void *p1, *p2, *p3;
+        int ret;
+        talloc_disable_null_tracking();
+        p1 = talloc_new(NULL);
+        p2 = talloc_new(NULL);
+        p3 = talloc_reference(p2, p1);
+        torture_assert("reference", p3 == p1, "failed: reference on null");
+        ret = talloc_free(p1);
+        torture_assert("ref free with null parent", ret == 0, "failed: free with null parent");
+        talloc_free(p2);
+        talloc_enable_null_tracking_no_autofree();
+        p1 = talloc_new(NULL);
+        p2 = talloc_new(NULL);
+        p3 = talloc_reference(p2, p1);
+        torture_assert("reference", p3 == p1, "failed: reference on null");
+        ret = talloc_free(p1);
+        torture_assert("ref free with null tracked parent", ret == 0, "failed: free with null parent");
+        talloc_free(p2);
+        return true;
+}
+static bool test_rusty(void)
+{
+        void *root;
+        const char *p1;
+        talloc_enable_null_tracking();
+        root = talloc_new(NULL);
+        p1 = talloc_strdup(root, "foo");
+        talloc_increase_ref_count(p1);
+        talloc_report_full(root, stdout);
+        talloc_free(root);
+        return true;
+}
 static void test_reset(void)
 …
+}
-struct torture_context;
 bool torture_local_talloc(struct torture_context *tctx)
+{
 …
         test_reset();
         ret &= test_pool();
+        test_reset();
+        ret &= test_pool_steal();
+        test_reset();
+        ret &= test_free_ref_null_context();
+        test_reset();
+        ret &= test_rusty();
         if (ret) {
 …
         test_reset();
+        talloc_disable_null_tracking();
         return ret;
+}

vendor/current/lib/talloc/testsuite_main.c

-              r414
+              r740
 #include "replace.h"
+struct torture_context;
+bool torture_local_talloc(struct torture_context *tctx);
+#include "talloc_testsuite.h"
 int main(void)

vendor/current/lib/tdb/common/check.c

-              r414
+              r740
+{
         struct tdb_header hdr;
+        if (tdb->methods->tdb_read(tdb, 0, &hdr, sizeof(hdr), DOCONV()) == -1)
+        uint32_t h1, h2;
+        if (tdb->methods->tdb_read(tdb, 0, &hdr, sizeof(hdr), 0) == -1)
                 return false;
         if (strcmp(hdr.magic_food, TDB_MAGIC_FOOD) != 0)
 …
                 goto corrupt;
+        if (hdr.rwlocks != 0)
+        if (hdr.rwlocks != 0 && hdr.rwlocks != TDB_HASH_RWLOCK_MAGIC)
+                goto corrupt;
+        tdb_header_hash(tdb, &h1, &h2);
+        if (hdr.magic1_hash && hdr.magic2_hash &&
+            (hdr.magic1_hash != h1 || hdr.magic2_hash != h2))
                 goto corrupt;
 …
+}
+int tdb_check(struct tdb_context *tdb,
+/* Slow, but should be very rare. */
+size_t tdb_dead_space(struct tdb_context *tdb, tdb_off_t off)
+{
+        size_t len;
+        for (len = 0; off + len < tdb->map_size; len++) {
+                char c;
+                if (tdb->methods->tdb_read(tdb, off, &c, 1, 0))
+                        return 0;
+                if (c != 0 && c != 0x42)
+                        break;
+        }
+        return len;
+}
+_PUBLIC_ int tdb_check(struct tdb_context *tdb,
               int (*check)(TDB_DATA key, TDB_DATA data, void *private_data),
               void *private_data)
 …
         struct tdb_record rec;
         bool found_recovery = false;
+        if (tdb_lockall(tdb) == -1)
+                return -1;
+        tdb_len_t dead;
+        bool locked;
+        /* Read-only databases use no locking at all: it's best-effort.
+         * We may have a write lock already, so skip that case too. */
+        if (tdb->read_only || tdb->allrecord_lock.count != 0) {
+                locked = false;
+        } else {
+                if (tdb_lockall_read(tdb) == -1)
+                        return -1;
+                locked = true;
+        }
         /* Make sure we know true size of the underlying file. */
 …
                                 goto free;
                         break;
+                /* If we crash after ftruncate, we can get zeroes or fill. */
+                case TDB_RECOVERY_INVALID_MAGIC:
+                case 0x42424242:
+                        if (recovery_start == off) {
+                                found_recovery = true;
+                                break;
+                        }
+                        dead = tdb_dead_space(tdb, off);
+                        if (dead < sizeof(rec))
+                                goto corrupt;
+                        TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                                 "Dead space at %d-%d (of %u)\n",
+                                 off, off + dead, tdb->map_size));
+                        rec.rec_len = dead - sizeof(rec);
+                        break;
                 case TDB_RECOVERY_MAGIC:
-                case 0: /* Used for invalid (or in-progress) recovery area. */
                         if (recovery_start != off) {
                                 TDB_LOG((tdb, TDB_DEBUG_ERROR,
 …
                         found_recovery = true;
                         break;
+                default:
+                default: ;
+                corrupt:
                         tdb->ecode = TDB_ERR_CORRUPT;
                         TDB_LOG((tdb, TDB_DEBUG_ERROR,
 …
         if (recovery_start != 0 && !found_recovery) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                         "Expected %s recovery area, got %s\n",
+                         recovery_start ? "a" : "no",
+                         found_recovery ? "one" : "none"));
+                         "Expected a recovery area at %u\n",
+                         recovery_start));
                 goto free;
+        }
         free(hashes);
+        tdb_unlockall(tdb);
+        if (locked) {
+                tdb_unlockall_read(tdb);
+        }
         return 0;
 …
         free(hashes);
 unlock:
+        tdb_unlockall(tdb);
+        if (locked) {
+                tdb_unlockall_read(tdb);
+        }
         return -1;
+}

vendor/current/lib/tdb/common/dump.c

-              r414
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
+}
 void tdb_dump_all(struct tdb_context *tdb)
+_PUBLIC_ void tdb_dump_all(struct tdb_context *tdb)
+{
         int i;
 …
+}
 int tdb_printfreelist(struct tdb_context *tdb)
+_PUBLIC_ int tdb_printfreelist(struct tdb_context *tdb)
+{
         int ret;

vendor/current/lib/tdb/common/error.c

-              r414
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 #include "tdb_private.h"
 enum TDB_ERROR tdb_error(struct tdb_context *tdb)
+_PUBLIC_ enum TDB_ERROR tdb_error(struct tdb_context *tdb)
+{
         return tdb->ecode;
 …
 /* Error string for the last tdb error */
 const char *tdb_errorstr(struct tdb_context *tdb)
+_PUBLIC_ const char *tdb_errorstr(struct tdb_context *tdb)
+{
         uint32_t i;

vendor/current/lib/tdb/common/freelist.c

-              r414
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 /* Add an element into the freelist. Merge adjacent records if
    neccessary. */
+   necessary. */
 int tdb_free(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
+{
 …
                 struct tdb_record l;
                 tdb_off_t leftsize;
                 /* Read in tailer and jump back to header */
                 if (tdb_ofs_read(tdb, left, &leftsize) == -1) {
 …
                         break;
+                }
                 /* this multiplier means we only extremely rarely
                    search more than 50 or so records. At 50 records we
 …
    return the size of the freelist - used to decide if we should repack
 */
 int tdb_freelist_size(struct tdb_context *tdb)
+_PUBLIC_ int tdb_freelist_size(struct tdb_context *tdb)
+{
         tdb_off_t ptr;

vendor/current/lib/tdb/common/freelistcheck.c

r414	r740
44	44	}
45	45
46		int tdb_validate_freelist(struct tdb_context tdb, int pnum_entries)
	46	_PUBLIC_ int tdb_validate_freelist(struct tdb_context tdb, int pnum_entries)
47	47	{
48	48	struct tdb_context *mem_tdb = NULL;

vendor/current/lib/tdb/common/io.c

-              r597
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
         tdb_oob,
         tdb_expand_file,
-        tdb_brlock
 };

vendor/current/lib/tdb/common/lock.c

-              r414
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 #include "tdb_private.h"
+#define TDB_MARK_LOCK 0x80000000
+void tdb_setalarm_sigptr(struct tdb_context *tdb, volatile sig_atomic_t *ptr)
+_PUBLIC_ void tdb_setalarm_sigptr(struct tdb_context *tdb, volatile sig_atomic_t *ptr)
+{
         tdb->interrupt_sig_ptr = ptr;
+}
+static int fcntl_lock(struct tdb_context *tdb,
+                      int rw, off_t off, off_t len, bool waitflag)
+{
+        struct flock fl;
+        fl.l_type = rw;
+        fl.l_whence = SEEK_SET;
+        fl.l_start = off;
+        fl.l_len = len;
+        fl.l_pid = 0;
+        if (waitflag)
+                return fcntl(tdb->fd, F_SETLKW, &fl);
+        else
+                return fcntl(tdb->fd, F_SETLK, &fl);
+}
+static int fcntl_unlock(struct tdb_context *tdb, int rw, off_t off, off_t len)
+{
+        struct flock fl;
+#if 0 /* Check they matched up locks and unlocks correctly. */
+        char line[80];
+        FILE *locks;
+        bool found = false;
+        locks = fopen("/proc/locks", "r");
+        while (fgets(line, 80, locks)) {
+                char *p;
+                int type, start, l;
+                /* eg. 1: FLOCK  ADVISORY  WRITE 2440 08:01:2180826 0 EOF */
+                p = strchr(line, ':') + 1;
+                if (strncmp(p, " POSIX  ADVISORY  ", strlen(" POSIX  ADVISORY  ")))
+                        continue;
+                p += strlen(" FLOCK  ADVISORY  ");
+                if (strncmp(p, "READ  ", strlen("READ  ")) == 0)
+                        type = F_RDLCK;
+                else if (strncmp(p, "WRITE ", strlen("WRITE ")) == 0)
+                        type = F_WRLCK;
+                else
+                        abort();
+                p += 6;
+                if (atoi(p) != getpid())
+                        continue;
+                p = strchr(strchr(p, ' ') + 1, ' ') + 1;
+                start = atoi(p);
+                p = strchr(p, ' ') + 1;
+                if (strncmp(p, "EOF", 3) == 0)
+                        l = 0;
+                else
+                        l = atoi(p) - start + 1;
+                if (off == start) {
+                        if (len != l) {
+                                fprintf(stderr, "Len %u should be %u: %s",
+                                        (int)len, l, line);
+                                abort();
+                        }
+                        if (type != rw) {
+                                fprintf(stderr, "Type %s wrong: %s",
+                                        rw == F_RDLCK ? "READ" : "WRITE", line);
+                                abort();
+                        }
+                        found = true;
+                        break;
+                }
+        }
+        if (!found) {
+                fprintf(stderr, "Unlock on %u@%u not found!\n",
+                        (int)off, (int)len);
+                abort();
+        }
+        fclose(locks);
+#endif
+        fl.l_type = F_UNLCK;
+        fl.l_whence = SEEK_SET;
+        fl.l_start = off;
+        fl.l_len = len;
+        fl.l_pid = 0;
+        return fcntl(tdb->fd, F_SETLKW, &fl);
+}
+/* list -1 is the alloc list, otherwise a hash chain. */
+static tdb_off_t lock_offset(int list)
+{
+        return FREELIST_TOP + 4*list;
+}
 …
    note that a len of zero means lock to end of file
 */
 int tdb_brlock(struct tdb_context *tdb, tdb_off_t offset,
                int rw_type, int lck_type, int probe, size_t len)
+{
+        struct flock fl;
+int tdb_brlock(struct tdb_context *tdb,
+               int rw_type, tdb_off_t offset, size_t len,
+               enum tdb_lock_flags flags)
+{
         int ret;
         if (tdb->flags & TDB_NOLOCK) {
+                return 0;
+        }
+        if (flags & TDB_LOCK_MARK_ONLY) {
                 return 0;
+        }
 …
+        }
-        fl.l_type = rw_type;
-        fl.l_whence = SEEK_SET;
-        fl.l_start = offset;
-        fl.l_len = len;
-        fl.l_pid = 0;
         do {
                 ret = fcntl(tdb->fd,lck_type,&fl);
+                ret = fcntl_lock(tdb, rw_type, offset, len,
+                                 flags & TDB_LOCK_WAIT);
                 /* Check for a sigalarm break. */
                 if (ret == -1 && errno == EINTR &&
 …
                  * EAGAIN is an expected return from non-blocking
                  * locks. */
                 if (!probe && lck_type != F_SETLK) {
                         TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d\n",
                                  tdb->fd, offset, rw_type, lck_type, (int)len));
+                if (!(flags & TDB_LOCK_PROBE) && errno != EAGAIN) {
+                        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d flags=%d len=%d\n",
+                                 tdb->fd, offset, rw_type, flags, (int)len));
+                }
                 return -1;
 …
+}
+int tdb_brunlock(struct tdb_context *tdb,
+                 int rw_type, tdb_off_t offset, size_t len)
+{
+        int ret;
+        if (tdb->flags & TDB_NOLOCK) {
+                return 0;
+        }
+        do {
+                ret = fcntl_unlock(tdb, rw_type, offset, len);
+        } while (ret == -1 && errno == EINTR);
+        if (ret == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brunlock failed (fd=%d) at offset %d rw_type=%d len=%d\n",
+                         tdb->fd, offset, rw_type, (int)len));
+        }
+        return ret;
+}
 /*
 …
   made. For those OSes we may loop for a while.
 */
 int tdb_brlock_upgrade(struct tdb_context *tdb, tdb_off_t offset, size_t len)
+int tdb_allrecord_upgrade(struct tdb_context *tdb)
+{
         int count = 1000;
+        if (tdb->allrecord_lock.count != 1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                         "tdb_allrecord_upgrade failed: count %u too high\n",
+                         tdb->allrecord_lock.count));
+                return -1;
+        }
+        if (tdb->allrecord_lock.off != 1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                         "tdb_allrecord_upgrade failed: already upgraded?\n"));
+                return -1;
+        }
         while (count--) {
                 struct timeval tv;
+                if (tdb_brlock(tdb, offset, F_WRLCK, F_SETLKW, 1, len) == 0) {
+                if (tdb_brlock(tdb, F_WRLCK, FREELIST_TOP, 0,
+                               TDB_LOCK_WAIT|TDB_LOCK_PROBE) == 0) {
+                        tdb->allrecord_lock.ltype = F_WRLCK;
+                        tdb->allrecord_lock.off = 0;
                         return 0;
+                }
 …
                 select(0, NULL, NULL, NULL, &tv);
+        }
         TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock_upgrade failed at offset %d\n", offset));
+        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_allrecord_upgrade failed\n"));
         return -1;
+}
+/* lock a list in the database. list -1 is the alloc list */
+static int _tdb_lock(struct tdb_context *tdb, int list, int ltype, int op)
+static struct tdb_lock_type *find_nestlock(struct tdb_context *tdb,
+                                           tdb_off_t offset)
+{
+        unsigned int i;
+        for (i=0; i<tdb->num_lockrecs; i++) {
+                if (tdb->lockrecs[i].off == offset) {
+                        return &tdb->lockrecs[i];
+                }
+        }
+        return NULL;
+}
+/* lock an offset in the database. */
+int tdb_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                  enum tdb_lock_flags flags)
+{
         struct tdb_lock_type *new_lck;
+        int i;
+        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
+        ltype &= ~TDB_MARK_LOCK;
+        /* a global lock allows us to avoid per chain locks */
+        if (tdb->global_lock.count &&
+            (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
+                return 0;
+        }
+        if (tdb->global_lock.count) {
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        if (list < -1 || list >= (int)tdb->header.hash_size) {
+                tdb->ecode = TDB_ERR_LOCK;
+                TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid list %d for ltype=%d\n",
+                           list, ltype));
+        if (offset >= lock_offset(tdb->header.hash_size)) {
+                tdb->ecode = TDB_ERR_LOCK;
+                TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid offset %u for ltype=%d\n",
+                         offset, ltype));
                 return -1;
+        }
 …
                 return 0;
+        for (i=0; i<tdb->num_lockrecs; i++) {
+                if (tdb->lockrecs[i].list == list) {
+                        if (tdb->lockrecs[i].count == 0) {
+                                /*
+                                 * Can't happen, see tdb_unlock(). It should
+                                 * be an assert.
+                                 */
+                                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock: "
+                                         "lck->count == 0 for list %d", list));
+                        }
+                        /*
+                         * Just increment the in-memory struct, posix locks
+                         * don't stack.
+                         */
+                        tdb->lockrecs[i].count++;
+                        return 0;
+                }
+        new_lck = find_nestlock(tdb, offset);
+        if (new_lck) {
+                /*
+                 * Just increment the in-memory struct, posix locks
+                 * don't stack.
+                 */
+                new_lck->count++;
+                return 0;
+        }
 …
         /* Since fcntl locks don't nest, we do a lock for the first one,
            and simply bump the count for future ones */
+        if (!mark_lock &&
+            tdb->methods->tdb_brlock(tdb,FREELIST_TOP+4*list, ltype, op,
+, 1)) {
+                return -1;
+        }
+        tdb->num_locks++;
+        tdb->lockrecs[tdb->num_lockrecs].list = list;
+        if (tdb_brlock(tdb, ltype, offset, 1, flags)) {
+                return -1;
+        }
+        tdb->lockrecs[tdb->num_lockrecs].off = offset;
         tdb->lockrecs[tdb->num_lockrecs].count = 1;
         tdb->lockrecs[tdb->num_lockrecs].ltype = ltype;
         tdb->num_lockrecs += 1;
+        tdb->num_lockrecs++;
         return 0;
+}
+static int tdb_lock_and_recover(struct tdb_context *tdb)
+{
+        int ret;
+        /* We need to match locking order in transaction commit. */
+        if (tdb_brlock(tdb, F_WRLCK, FREELIST_TOP, 0, TDB_LOCK_WAIT)) {
+                return -1;
+        }
+        if (tdb_brlock(tdb, F_WRLCK, OPEN_LOCK, 1, TDB_LOCK_WAIT)) {
+                tdb_brunlock(tdb, F_WRLCK, FREELIST_TOP, 0);
+                return -1;
+        }
+        ret = tdb_transaction_recover(tdb);
+        tdb_brunlock(tdb, F_WRLCK, OPEN_LOCK, 1);
+        tdb_brunlock(tdb, F_WRLCK, FREELIST_TOP, 0);
+        return ret;
+}
+static bool have_data_locks(const struct tdb_context *tdb)
+{
+        unsigned int i;
+        for (i = 0; i < tdb->num_lockrecs; i++) {
+                if (tdb->lockrecs[i].off >= lock_offset(-1))
+                        return true;
+        }
+        return false;
+}
+static int tdb_lock_list(struct tdb_context *tdb, int list, int ltype,
+                         enum tdb_lock_flags waitflag)
+{
+        int ret;
+        bool check = false;
+        /* a allrecord lock allows us to avoid per chain locks */
+        if (tdb->allrecord_lock.count &&
+            (ltype == tdb->allrecord_lock.ltype || ltype == F_RDLCK)) {
+                return 0;
+        }
+        if (tdb->allrecord_lock.count) {
+                tdb->ecode = TDB_ERR_LOCK;
+                ret = -1;
+        } else {
+                /* Only check when we grab first data lock. */
+                check = !have_data_locks(tdb);
+                ret = tdb_nest_lock(tdb, lock_offset(list), ltype, waitflag);
+                if (ret == 0 && check && tdb_needs_recovery(tdb)) {
+                        tdb_nest_unlock(tdb, lock_offset(list), ltype, false);
+                        if (tdb_lock_and_recover(tdb) == -1) {
+                                return -1;
+                        }
+                        return tdb_lock_list(tdb, list, ltype, waitflag);
+                }
+        }
+        return ret;
+}
 …
+{
         int ret;
+        ret = _tdb_lock(tdb, list, ltype, F_SETLKW);
+        ret = tdb_lock_list(tdb, list, ltype, TDB_LOCK_WAIT);
         if (ret) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock failed on list %d "
 …
 int tdb_lock_nonblock(struct tdb_context *tdb, int list, int ltype)
+{
+        return _tdb_lock(tdb, list, ltype, F_SETLK);
+}
+/* unlock the database: returns void because it's too late for errors. */
+        /* changed to return int it may be interesting to know there
+           has been an error  --simo */
+int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
+        return tdb_lock_list(tdb, list, ltype, TDB_LOCK_NOWAIT);
+}
+int tdb_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                    bool mark_lock)
+{
         int ret = -1;
+        int i;
+        struct tdb_lock_type *lck = NULL;
+        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
+        ltype &= ~TDB_MARK_LOCK;
+        /* a global lock allows us to avoid per chain locks */
+        if (tdb->global_lock.count &&
+            (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
+                return 0;
+        }
+        if (tdb->global_lock.count) {
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        struct tdb_lock_type *lck;
         if (tdb->flags & TDB_NOLOCK)
 …
         /* Sanity checks */
         if (list < -1 || list >= (int)tdb->header.hash_size) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
+        if (offset >= lock_offset(tdb->header.hash_size)) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: offset %u invalid (%d)\n", offset, tdb->header.hash_size));
                 return ret;
+        }
+        for (i=0; i<tdb->num_lockrecs; i++) {
+                if (tdb->lockrecs[i].list == list) {
+                        lck = &tdb->lockrecs[i];
+                        break;
+                }
+        }
+        lck = find_nestlock(tdb, offset);
         if ((lck == NULL) || (lck->count == 0)) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: count is 0\n"));
 …
                 ret = 0;
         } else {
+                ret = tdb->methods->tdb_brlock(tdb, FREELIST_TOP+4*list, F_UNLCK,
+                                               F_SETLKW, 0, 1);
+        }
+        tdb->num_locks--;
+                ret = tdb_brunlock(tdb, ltype, offset, 1);
+        }
         /*
 …
          * last array element.
          */
+        if (tdb->num_lockrecs > 1) {
+                *lck = tdb->lockrecs[tdb->num_lockrecs-1];
+        }
+        tdb->num_lockrecs -= 1;
+        *lck = tdb->lockrecs[--tdb->num_lockrecs];
         /*
 …
+}
+int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
+{
+        /* a global lock allows us to avoid per chain locks */
+        if (tdb->allrecord_lock.count &&
+            (ltype == tdb->allrecord_lock.ltype || ltype == F_RDLCK)) {
+                return 0;
+        }
+        if (tdb->allrecord_lock.count) {
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        return tdb_nest_unlock(tdb, lock_offset(list), ltype, false);
+}
 /*
   get the transaction lock
  */
+int tdb_transaction_lock(struct tdb_context *tdb, int ltype)
+{
+        if (tdb->global_lock.count) {
+                return 0;
+        }
+        if (tdb->transaction_lock_count > 0) {
+                tdb->transaction_lock_count++;
+                return 0;
+        }
+        if (tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, ltype,
+                                     F_SETLKW, 0, 1) == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_lock: failed to get transaction lock\n"));
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        tdb->transaction_lock_count++;
+        return 0;
+int tdb_transaction_lock(struct tdb_context *tdb, int ltype,
+                         enum tdb_lock_flags lockflags)
+{
+        return tdb_nest_lock(tdb, TRANSACTION_LOCK, ltype, lockflags);
+}
 …
   release the transaction lock
  */
+int tdb_transaction_unlock(struct tdb_context *tdb)
+{
+        int ret;
+        if (tdb->global_lock.count) {
+                return 0;
+        }
+        if (tdb->transaction_lock_count > 1) {
+                tdb->transaction_lock_count--;
+                return 0;
+        }
+        ret = tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, F_UNLCK, F_SETLKW, 0, 1);
+        if (ret == 0) {
+                tdb->transaction_lock_count = 0;
+        }
+        return ret;
+}
+/* lock/unlock entire database */
+static int _tdb_lockall(struct tdb_context *tdb, int ltype, int op)
+{
+        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
+        ltype &= ~TDB_MARK_LOCK;
+int tdb_transaction_unlock(struct tdb_context *tdb, int ltype)
+{
+        return tdb_nest_unlock(tdb, TRANSACTION_LOCK, ltype, false);
+}
+/* Returns 0 if all done, -1 if error, 1 if ok. */
+static int tdb_allrecord_check(struct tdb_context *tdb, int ltype,
+                               enum tdb_lock_flags flags, bool upgradable)
+{
         /* There are no locks on read-only dbs */
         if (tdb->read_only || tdb->traverse_read) {
 …
+        }
         if (tdb->global_lock.count && tdb->global_lock.ltype == ltype) {
                 tdb->global_lock.count++;
                 return 0;
+        }
         if (tdb->global_lock.count) {
+        if (tdb->allrecord_lock.count && tdb->allrecord_lock.ltype == ltype) {
+                tdb->allrecord_lock.count++;
+                return 0;
+        }
+        if (tdb->allrecord_lock.count) {
                 /* a global lock of a different type exists */
                 tdb->ecode = TDB_ERR_LOCK;
                 return -1;
+        }
         if (tdb->num_locks != 0) {
+        if (tdb_have_extra_locks(tdb)) {
                 /* can't combine global and chain locks */
                 tdb->ecode = TDB_ERR_LOCK;
 …
+        }
+        if (!mark_lock &&
+            tdb->methods->tdb_brlock(tdb, FREELIST_TOP, ltype, op,
+, 4*tdb->header.hash_size)) {
+                if (op == F_SETLKW) {
+                        TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lockall failed (%s)\n", strerror(errno)));
+                }
+                return -1;
+        }
+        tdb->global_lock.count = 1;
+        tdb->global_lock.ltype = ltype;
+        if (upgradable && ltype != F_RDLCK) {
+                /* tdb error: you can't upgrade a write lock! */
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        return 1;
+}
+/* We only need to lock individual bytes, but Linux merges consecutive locks
+ * so we lock in contiguous ranges. */
+static int tdb_chainlock_gradual(struct tdb_context *tdb,
+                                 int ltype, enum tdb_lock_flags flags,
+                                 size_t off, size_t len)
+{
+        int ret;
+        enum tdb_lock_flags nb_flags = (flags & ~TDB_LOCK_WAIT);
+        if (len <= 4) {
+                /* Single record.  Just do blocking lock. */
+                return tdb_brlock(tdb, ltype, off, len, flags);
+        }
+        /* First we try non-blocking. */
+        ret = tdb_brlock(tdb, ltype, off, len, nb_flags);
+        if (ret == 0) {
+                return 0;
+        }
+        /* Try locking first half, then second. */
+        ret = tdb_chainlock_gradual(tdb, ltype, flags, off, len / 2);
+        if (ret == -1)
+                return -1;
+        ret = tdb_chainlock_gradual(tdb, ltype, flags,
+                                    off + len / 2, len - len / 2);
+        if (ret == -1) {
+                tdb_brunlock(tdb, ltype, off, len / 2);
+                return -1;
+        }
         return 0;
+}
+/* lock/unlock entire database.  It can only be upgradable if you have some
+ * other way of guaranteeing exclusivity (ie. transaction write lock).
+ * We do the locking gradually to avoid being starved by smaller locks. */
+int tdb_allrecord_lock(struct tdb_context *tdb, int ltype,
+                       enum tdb_lock_flags flags, bool upgradable)
+{
+        switch (tdb_allrecord_check(tdb, ltype, flags, upgradable)) {
+        case -1:
+                return -1;
+        case 0:
+                return 0;
+        }
+        /* We cover two kinds of locks:
+         * 1) Normal chain locks.  Taken for almost all operations.
+         * 3) Individual records locks.  Taken after normal or free
+         *    chain locks.
+         *
+         * It is (1) which cause the starvation problem, so we're only
+         * gradual for that. */
+        if (tdb_chainlock_gradual(tdb, ltype, flags, FREELIST_TOP,
+                                  tdb->header.hash_size * 4) == -1) {
+                return -1;
+        }
+        /* Grab individual record locks. */
+        if (tdb_brlock(tdb, ltype, lock_offset(tdb->header.hash_size), 0,
+                       flags) == -1) {
+                tdb_brunlock(tdb, ltype, FREELIST_TOP,
+                             tdb->header.hash_size * 4);
+                return -1;
+        }
+        tdb->allrecord_lock.count = 1;
+        /* If it's upgradable, it's actually exclusive so we can treat
+         * it as a write lock. */
+        tdb->allrecord_lock.ltype = upgradable ? F_WRLCK : ltype;
+        tdb->allrecord_lock.off = upgradable;
+        if (tdb_needs_recovery(tdb)) {
+                bool mark = flags & TDB_LOCK_MARK_ONLY;
+                tdb_allrecord_unlock(tdb, ltype, mark);
+                if (mark) {
+                        tdb->ecode = TDB_ERR_LOCK;
+                        TDB_LOG((tdb, TDB_DEBUG_ERROR,
+                                 "tdb_lockall_mark cannot do recovery\n"));
+                        return -1;
+                }
+                if (tdb_lock_and_recover(tdb) == -1) {
+                        return -1;
+                }
+                return tdb_allrecord_lock(tdb, ltype, flags, upgradable);
+        }
+        return 0;
+}
 /* unlock entire db */
+static int _tdb_unlockall(struct tdb_context *tdb, int ltype)
+{
+        bool mark_lock = ((ltype & TDB_MARK_LOCK) == TDB_MARK_LOCK);
+        ltype &= ~TDB_MARK_LOCK;
+int tdb_allrecord_unlock(struct tdb_context *tdb, int ltype, bool mark_lock)
+{
         /* There are no locks on read-only dbs */
         if (tdb->read_only || tdb->traverse_read) {
 …
+        }
+        if (tdb->global_lock.ltype != ltype || tdb->global_lock.count == 0) {
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        if (tdb->global_lock.count > 1) {
+                tdb->global_lock.count--;
+                return 0;
+        }
+        if (!mark_lock &&
+            tdb->methods->tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW,
+, 4*tdb->header.hash_size)) {
+        if (tdb->allrecord_lock.count == 0) {
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        /* Upgradable locks are marked as write locks. */
+        if (tdb->allrecord_lock.ltype != ltype
+            && (!tdb->allrecord_lock.off || ltype != F_RDLCK)) {
+                tdb->ecode = TDB_ERR_LOCK;
+                return -1;
+        }
+        if (tdb->allrecord_lock.count > 1) {
+                tdb->allrecord_lock.count--;
+                return 0;
+        }
+        if (!mark_lock && tdb_brunlock(tdb, ltype, FREELIST_TOP, 0)) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlockall failed (%s)\n", strerror(errno)));
                 return -1;
+        }
         tdb->global_lock.count = 0;
         tdb->global_lock.ltype = 0;
+        tdb->allrecord_lock.count = 0;
+        tdb->allrecord_lock.ltype = 0;
         return 0;
 …
 /* lock entire database with write lock */
 int tdb_lockall(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_lockall");
         return _tdb_lockall(tdb, F_WRLCK, F_SETLKW);
+        return tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_WAIT, false);
+}
 /* lock entire database with write lock - mark only */
 int tdb_lockall_mark(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall_mark(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_lockall_mark");
         return _tdb_lockall(tdb, F_WRLCK | TDB_MARK_LOCK, F_SETLKW);
+        return tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_MARK_ONLY, false);
+}
 /* unlock entire database with write lock - unmark only */
 int tdb_lockall_unmark(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall_unmark(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_lockall_unmark");
         return _tdb_unlockall(tdb, F_WRLCK | TDB_MARK_LOCK);
+        return tdb_allrecord_unlock(tdb, F_WRLCK, true);
+}
 /* lock entire database with write lock - nonblocking varient */
 int tdb_lockall_nonblock(struct tdb_context *tdb)
+{
         int ret = _tdb_lockall(tdb, F_WRLCK, F_SETLK);
+_PUBLIC_ int tdb_lockall_nonblock(struct tdb_context *tdb)
+{
+        int ret = tdb_allrecord_lock(tdb, F_WRLCK, TDB_LOCK_NOWAIT, false);
         tdb_trace_ret(tdb, "tdb_lockall_nonblock", ret);
         return ret;
 …
 /* unlock entire database with write lock */
 int tdb_unlockall(struct tdb_context *tdb)
+_PUBLIC_ int tdb_unlockall(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_unlockall");
         return _tdb_unlockall(tdb, F_WRLCK);
+        return tdb_allrecord_unlock(tdb, F_WRLCK, false);
+}
 /* lock entire database with read lock */
 int tdb_lockall_read(struct tdb_context *tdb)
+_PUBLIC_ int tdb_lockall_read(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_lockall_read");
         return _tdb_lockall(tdb, F_RDLCK, F_SETLKW);
+        return tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, false);
+}
 /* lock entire database with read lock - nonblock varient */
 int tdb_lockall_read_nonblock(struct tdb_context *tdb)
+{
         int ret = _tdb_lockall(tdb, F_RDLCK, F_SETLK);
+_PUBLIC_ int tdb_lockall_read_nonblock(struct tdb_context *tdb)
+{
+        int ret = tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_NOWAIT, false);
         tdb_trace_ret(tdb, "tdb_lockall_read_nonblock", ret);
         return ret;
 …
 /* unlock entire database with read lock */
 int tdb_unlockall_read(struct tdb_context *tdb)
+_PUBLIC_ int tdb_unlockall_read(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_unlockall_read");
         return _tdb_unlockall(tdb, F_RDLCK);
+        return tdb_allrecord_unlock(tdb, F_RDLCK, false);
+}
 /* lock/unlock one hash chain. This is meant to be used to reduce
    contention - it cannot guarantee how many records will be locked */
 int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
+{
         int ret = tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
 …
    to reduce contention - it cannot guarantee how many records will be
    locked */
 int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock_nonblock(struct tdb_context *tdb, TDB_DATA key)
+{
         int ret = tdb_lock_nonblock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
 …
 /* mark a chain as locked without actually locking it. Warning! use with great caution! */
+int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key)
+{
+        int ret = tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK | TDB_MARK_LOCK);
+_PUBLIC_ int tdb_chainlock_mark(struct tdb_context *tdb, TDB_DATA key)
+{
+        int ret = tdb_nest_lock(tdb, lock_offset(BUCKET(tdb->hash_fn(&key))),
+                                F_WRLCK, TDB_LOCK_MARK_ONLY);
         tdb_trace_1rec(tdb, "tdb_chainlock_mark", key);
         return ret;
 …
 /* unmark a chain as locked without actually locking it. Warning! use with great caution! */
 int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock_unmark(struct tdb_context *tdb, TDB_DATA key)
+{
         tdb_trace_1rec(tdb, "tdb_chainlock_unmark", key);
+        return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK | TDB_MARK_LOCK);
+}
+int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
+        return tdb_nest_unlock(tdb, lock_offset(BUCKET(tdb->hash_fn(&key))),
+                               F_WRLCK, true);
+}
+_PUBLIC_ int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
+{
         tdb_trace_1rec(tdb, "tdb_chainunlock", key);
 …
+}
 int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
+{
         int ret;
 …
+}
 int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
+{
         tdb_trace_1rec(tdb, "tdb_chainunlock_read", key);
 …
+}
 /* record lock stops delete underneath */
 int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off)
+{
         if (tdb->global_lock.count) {
                 return 0;
+        }
         return off ? tdb->methods->tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0, 1) : 0;
+        if (tdb->allrecord_lock.count) {
+                return 0;
+        }
+        return off ? tdb_brlock(tdb, F_RDLCK, off, 1, TDB_LOCK_WAIT) : 0;
+}
 …
                 if (i->off == off)
                         return -1;
+        return tdb->methods->tdb_brlock(tdb, off, F_WRLCK, F_SETLK, 1, 1);
+}
+/*
+  Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
+  an error to fail to get the lock here.
+*/
+        if (tdb->allrecord_lock.count) {
+                if (tdb->allrecord_lock.ltype == F_WRLCK) {
+                        return 0;
+                }
+                return -1;
+        }
+        return tdb_brlock(tdb, F_WRLCK, off, 1, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE);
+}
 int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off)
+{
+        return tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLK, 0, 1);
+        if (tdb->allrecord_lock.count) {
+                return 0;
+        }
+        return tdb_brunlock(tdb, F_WRLCK, off, 1);
+}
 …
         uint32_t count = 0;
         if (tdb->global_lock.count) {
+        if (tdb->allrecord_lock.count) {
                 return 0;
+        }
 …
                 if (i->off == off)
                         count++;
+        return (count == 1 ? tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0, 1) : 0);
+}
+        return (count == 1 ? tdb_brunlock(tdb, F_RDLCK, off, 1) : 0);
+}
+bool tdb_have_extra_locks(struct tdb_context *tdb)
+{
+        unsigned int extra = tdb->num_lockrecs;
+        /* A transaction holds the lock for all records. */
+        if (!tdb->transaction && tdb->allrecord_lock.count) {
+                return true;
+        }
+        /* We always hold the active lock if CLEAR_IF_FIRST. */
+        if (find_nestlock(tdb, ACTIVE_LOCK)) {
+                extra--;
+        }
+        /* In a transaction, we expect to hold the transaction lock */
+        if (tdb->transaction && find_nestlock(tdb, TRANSACTION_LOCK)) {
+                extra--;
+        }
+        return extra;
+}
+/* The transaction code uses this to remove all locks. */
+void tdb_release_transaction_locks(struct tdb_context *tdb)
+{
+        unsigned int i, active = 0;
+        if (tdb->allrecord_lock.count != 0) {
+                tdb_brunlock(tdb, tdb->allrecord_lock.ltype, FREELIST_TOP, 0);
+                tdb->allrecord_lock.count = 0;
+        }
+        for (i=0;i<tdb->num_lockrecs;i++) {
+                struct tdb_lock_type *lck = &tdb->lockrecs[i];
+                /* Don't release the active lock!  Copy it to first entry. */
+                if (lck->off == ACTIVE_LOCK) {
+                        tdb->lockrecs[active++] = *lck;
+                } else {
+                        tdb_brunlock(tdb, lck->ltype, lck->off, 1);
+                }
+        }
+        tdb->num_lockrecs = active;
+        if (tdb->num_lockrecs == 0) {
+                SAFE_FREE(tdb->lockrecs);
+        }
+}

vendor/current/lib/tdb/common/open.c

-              r414
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 static struct tdb_context *tdbs = NULL;
+/* This is based on the hash algorithm from gdbm */
+static unsigned int default_tdb_hash(TDB_DATA *key)
+{
+        uint32_t value; /* Used to compute the hash value.  */
+        uint32_t   i;   /* Used to cycle through random values. */
+        /* Set the initial value from the key size. */
+        for (value = 0x238F13AF * key->dsize, i=0; i < key->dsize; i++)
+                value = (value + (key->dptr[i] << (i*5 % 24)));
+        return (1103515243 * value + 12345);
+}
+/* We use two hashes to double-check they're using the right hash function. */
+void tdb_header_hash(struct tdb_context *tdb,
+                     uint32_t *magic1_hash, uint32_t *magic2_hash)
+{
+        TDB_DATA hash_key;
+        uint32_t tdb_magic = TDB_MAGIC;
+        hash_key.dptr = discard_const_p(unsigned char, TDB_MAGIC_FOOD);
+        hash_key.dsize = sizeof(TDB_MAGIC_FOOD);
+        *magic1_hash = tdb->hash_fn(&hash_key);
+        hash_key.dptr = (unsigned char *)CONVERT(tdb_magic);
+        hash_key.dsize = sizeof(tdb_magic);
+        *magic2_hash = tdb->hash_fn(&hash_key);
+        /* Make sure at least one hash is non-zero! */
+        if (*magic1_hash == 0 && *magic2_hash == 0)
+                *magic1_hash = 1;
+}
 /* initialise a new database with a specified hash size */
 …
         size_t size;
         int ret = -1;
-        ssize_t written;
         /* We make it up in memory, then write it out if not internal */
 …
         newdb->version = TDB_VERSION;
         newdb->hash_size = hash_size;
+        tdb_header_hash(tdb, &newdb->magic1_hash, &newdb->magic2_hash);
+        /* Make sure older tdbs (which don't check the magic hash fields)
+         * will refuse to open this TDB. */
+        if (tdb->flags & TDB_INCOMPATIBLE_HASH)
+                newdb->rwlocks = TDB_HASH_RWLOCK_MAGIC;
         if (tdb->flags & TDB_INTERNAL) {
                 tdb->map_size = size;
 …
         memcpy(newdb->magic_food, TDB_MAGIC_FOOD, strlen(TDB_MAGIC_FOOD)+1);
         /* we still have "ret == -1" here */
+        written = write(tdb->fd, newdb, size);
+        if (written == size) {
+        if (tdb_write_all(tdb->fd, newdb, size))
                 ret = 0;
-        } else if (written != -1) {
-                /* call write once again, this usually should return -1 and
-                 * set errno appropriately */
-                size -= written;
-                written = write(tdb->fd, newdb+written, size);
-                if (written == size) {
-                ret = 0;
-                } else if (written >= 0) {
-                        /* a second incomplete write - we give up.
-                         * guessing the errno... */
-                        errno = ENOSPC;
+                }
+        }
   fail:
 …
+{
         struct tdb_context *i;
         for (i = tdbs; i; i = i->next) {
                 if (i->device == device && i->inode == ino) {
 …
    @param name may be NULL for internal databases. */
 struct tdb_context *tdb_open(const char *name, int hash_size, int tdb_flags,
+_PUBLIC_ struct tdb_context *tdb_open(const char *name, int hash_size, int tdb_flags,
                       int open_flags, mode_t mode)
+{
 …
+}
+struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
+static bool check_header_hash(struct tdb_context *tdb,
+                              bool default_hash, uint32_t *m1, uint32_t *m2)
+{
+        tdb_header_hash(tdb, m1, m2);
+        if (tdb->header.magic1_hash == *m1 &&
+            tdb->header.magic2_hash == *m2) {
+                return true;
+        }
+        /* If they explicitly set a hash, always respect it. */
+        if (!default_hash)
+                return false;
+        /* Otherwise, try the other inbuilt hash. */
+        if (tdb->hash_fn == tdb_old_hash)
+                tdb->hash_fn = tdb_jenkins_hash;
+        else
+                tdb->hash_fn = tdb_old_hash;
+        return check_header_hash(tdb, false, m1, m2);
+}
+_PUBLIC_ struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
                                 int open_flags, mode_t mode,
                                 const struct tdb_logging_context *log_ctx,
 …
         uint32_t vertest;
         unsigned v;
+        const char *hash_alg;
+        uint32_t magic1, magic2;
         if (!(tdb = (struct tdb_context *)calloc(1, sizeof *tdb))) {
 …
                 tdb->log.log_private = NULL;
+        }
+        tdb->hash_fn = hash_fn ? hash_fn : default_tdb_hash;
+        if (name == NULL && (tdb_flags & TDB_INTERNAL)) {
+                name = "__TDB_INTERNAL__";
+        }
+        if (name == NULL) {
+                tdb->name = discard_const_p(char, "__NULL__");
+                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_open_ex: called with name == NULL\n"));
+                tdb->name = NULL;
+                errno = EINVAL;
+                goto fail;
+        }
+        /* now make a copy of the name, as the caller memory might went away */
+        if (!(tdb->name = (char *)strdup(name))) {
+                /*
+                 * set the name as the given string, so that tdb_name() will
+                 * work in case of an error.
+                 */
+                tdb->name = discard_const_p(char, name);
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: can't strdup(%s)\n",
+                         name));
+                tdb->name = NULL;
+                errno = ENOMEM;
+                goto fail;
+        }
+        if (hash_fn) {
+                tdb->hash_fn = hash_fn;
+                hash_alg = "the user defined";
+        } else {
+                /* This controls what we use when creating a tdb. */
+                if (tdb->flags & TDB_INCOMPATIBLE_HASH) {
+                        tdb->hash_fn = tdb_jenkins_hash;
+                } else {
+                        tdb->hash_fn = tdb_old_hash;
+                }
+                hash_alg = "either default";
+        }
         /* cache the page size */
 …
                 goto fail;
+        }
         if (hash_size == 0)
                 hash_size = DEFAULT_HASH_SIZE;
 …
+        }
+        if (getenv("TDB_NO_FSYNC")) {
+                tdb->flags |= TDB_NOSYNC;
+        }
         /*
          * TDB_ALLOW_NESTING is the default behavior.
 …
         /* ensure there is only one process initialising at once */
         if (tdb->methods->tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to get global lock on %s: %s\n",
+        if (tdb_nest_lock(tdb, OPEN_LOCK, F_WRLCK, TDB_LOCK_WAIT) == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to get open lock on %s: %s\n",
                          name, strerror(errno)));
                 goto fail;      /* errno set by tdb_brlock */
 …
         if ((tdb_flags & TDB_CLEAR_IF_FIRST) &&
             (!tdb->read_only) &&
             (locked = (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_WRLCK, F_SETLK, 0, 1) == 0))) {
+            (locked = (tdb_nest_lock(tdb, ACTIVE_LOCK, F_WRLCK, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE) == 0))) {
                 open_flags |= O_CREAT;
                 if (ftruncate(tdb->fd, 0) == -1) {
 …
                 goto fail;
+        if (tdb->header.rwlocks != 0) {
+        if (tdb->header.rwlocks != 0 &&
+            tdb->header.rwlocks != TDB_HASH_RWLOCK_MAGIC) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: spinlocks no longer supported\n"));
+                goto fail;
+        }
+        if ((tdb->header.magic1_hash == 0) && (tdb->header.magic2_hash == 0)) {
+                /* older TDB without magic hash references */
+                tdb->hash_fn = tdb_old_hash;
+        } else if (!check_header_hash(tdb, !hash_fn, &magic1, &magic2)) {
+                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_open_ex: "
+                         "%s was not created with %s hash function we are using\n"
+                         "magic1_hash[0x%08X %s 0x%08X] "
+                         "magic2_hash[0x%08X %s 0x%08X]\n",
+                         name, hash_alg,
+                         tdb->header.magic1_hash,
+                         (tdb->header.magic1_hash == magic1) ? "==" : "!=",
+                         magic1,
+                         tdb->header.magic2_hash,
+                         (tdb->header.magic2_hash == magic2) ? "==" : "!=",
+                         magic2));
+                errno = EINVAL;
                 goto fail;
+        }
 …
+        }
-        if (!(tdb->name = (char *)strdup(name))) {
-                errno = ENOMEM;
-                goto fail;
+        }
         tdb->map_size = st.st_size;
         tdb->device = st.st_dev;
 …
         tdb_mmap(tdb);
         if (locked) {
                 if (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_UNLCK, F_SETLK, 0, 1) == -1) {
+                if (tdb_nest_unlock(tdb, ACTIVE_LOCK, F_WRLCK, false) == -1) {
                         TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: "
                                  "failed to take ACTIVE_LOCK on %s: %s\n",
+                                 "failed to release ACTIVE_LOCK on %s: %s\n",
                                  name, strerror(errno)));
                         goto fail;
 …
         if (tdb_flags & TDB_CLEAR_IF_FIRST) {
                 /* leave this lock in place to indicate it's in use */
                 if (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0, 1) == -1)
+                if (tdb_nest_lock(tdb, ACTIVE_LOCK, F_RDLCK, TDB_LOCK_WAIT) == -1) {
                         goto fail;
+                }
+        }
 …
         /* Internal (memory-only) databases skip all the code above to
          * do with disk files, and resume here by releasing their
+         * global lock and hooking into the active list. */
+        if (tdb->methods->tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1) == -1)
+                goto fail;
+         * open lock and hooking into the active list. */
+        if (tdb_nest_unlock(tdb, OPEN_LOCK, F_WRLCK, false) == -1) {
+                goto fail;
+        }
         tdb->next = tdbs;
         tdbs = tdb;
 …
                         tdb_munmap(tdb);
+        }
-        SAFE_FREE(tdb->name);
         if (tdb->fd != -1)
                 if (close(tdb->fd) != 0)
                         TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to close tdb->fd on error!\n"));
+        SAFE_FREE(tdb->lockrecs);
+        SAFE_FREE(tdb->name);
         SAFE_FREE(tdb);
         errno = save_errno;
 …
  */
 void tdb_set_max_dead(struct tdb_context *tdb, int max_dead)
+_PUBLIC_ void tdb_set_max_dead(struct tdb_context *tdb, int max_dead)
+{
         tdb->max_dead_records = max_dead;
 …
  * @returns -1 for error; 0 for success.
  **/
 int tdb_close(struct tdb_context *tdb)
+_PUBLIC_ int tdb_close(struct tdb_context *tdb)
+{
         struct tdb_context **i;
         int ret = 0;
+        if (tdb->transaction) {
+                tdb_transaction_cancel(tdb);
+        }
         tdb_trace(tdb, "tdb_close");
-        if (tdb->transaction) {
-                _tdb_transaction_cancel(tdb);
+        }
         if (tdb->map_ptr) {
 …
 /* register a loging function */
 void tdb_set_logging_function(struct tdb_context *tdb,
                               const struct tdb_logging_context *log_ctx)
+_PUBLIC_ void tdb_set_logging_function(struct tdb_context *tdb,
+                                       const struct tdb_logging_context *log_ctx)
+{
         tdb->log = *log_ctx;
+}
 void *tdb_get_logging_private(struct tdb_context *tdb)
+_PUBLIC_ void *tdb_get_logging_private(struct tdb_context *tdb)
+{
         return tdb->log.log_private;
 …
+        }
         if (tdb->num_locks != 0 || tdb->global_lock.count) {
+        if (tdb_have_extra_locks(tdb)) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_reopen: reopen not allowed with locks held\n"));
                 goto fail;
 …
 #endif /* fake pread or pwrite */
+        if (active_lock &&
+            (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0, 1) == -1)) {
+        /* We may still think we hold the active lock. */
+        tdb->num_lockrecs = 0;
+        SAFE_FREE(tdb->lockrecs);
+        if (active_lock && tdb_nest_lock(tdb, ACTIVE_LOCK, F_RDLCK, TDB_LOCK_WAIT) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: failed to obtain active lock\n"));
                 goto fail;
 …
 /* reopen a tdb - this can be used after a fork to ensure that we have an independent
    seek pointer from our parent and to re-establish locks */
 int tdb_reopen(struct tdb_context *tdb)
+_PUBLIC_ int tdb_reopen(struct tdb_context *tdb)
+{
         return tdb_reopen_internal(tdb, tdb->flags & TDB_CLEAR_IF_FIRST);
 …
 /* reopen all tdb's */
 int tdb_reopen_all(int parent_longlived)
+_PUBLIC_ int tdb_reopen_all(int parent_longlived)
+{
         struct tdb_context *tdb;

vendor/current/lib/tdb/common/tdb.c

-              r414
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 #include "tdb_private.h"
 TDB_DATA tdb_null;
+_PUBLIC_ TDB_DATA tdb_null;
 /*
 …
   the TDB_SEQNUM flag
 */
 void tdb_increment_seqnum_nonblock(struct tdb_context *tdb)
+_PUBLIC_ void tdb_increment_seqnum_nonblock(struct tdb_context *tdb)
+{
         tdb_off_t seqnum=0;
         if (!(tdb->flags & TDB_SEQNUM)) {
                 return;
 …
+        }
+        if (tdb_brlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, F_SETLKW, 1, 1) != 0) {
+        if (tdb_nest_lock(tdb, TDB_SEQNUM_OFS, F_WRLCK,
+                          TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
                 return;
+        }
 …
         tdb_increment_seqnum_nonblock(tdb);
         tdb_brlock(tdb, TDB_SEQNUM_OFS, F_UNLCK, F_SETLKW, 1, 1);
+        tdb_nest_unlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, false);
+}
 …
+{
         tdb_off_t rec_ptr;
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 …
+                }
+        }
         /* must be long enough key, data and tailer */
 …
                 return tdb_rec_write(tdb, rec_ptr, &rec);
+        }
         return 0;
+}
 …
+}
 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
+{
         TDB_DATA ret = _tdb_fetch(tdb, key);
 …
  * should be fast and should not block on other syscalls.
+ *
  * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
+ * DON'T CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
+ *
  * For mmapped tdb's that do not have a transaction open it points the parsing
 …
  * This is interesting for all readers of potentially large data structures in
  * the tdb records, ldb indexes being one example.
+ *
+ * Return -1 if the record was not found.
  */
 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
+_PUBLIC_ int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
                      int (*parser)(TDB_DATA key, TDB_DATA data,
                                    void *private_data),
 …
         if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
+                /* record not found */
                 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, -1);
                 tdb->ecode = TDB_ERR_NOEXIST;
                 return 0;
+                return -1;
+        }
         tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
 …
+{
         struct tdb_record rec;
         if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
                 return 0;
 …
+}
 int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
+{
         uint32_t hash = tdb->hash_fn(&key);
 …
         tdb_off_t rec_ptr;
         struct tdb_record rec;
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 …
                 return -1;
+        }
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 …
+}
 int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
+_PUBLIC_ int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
+{
         uint32_t hash = tdb->hash_fn(&key);
 …
+{
         tdb_off_t rec_ptr;
         /* read in the hash top */
         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 …
    return 0 on success, -1 on failure
 */
 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
+_PUBLIC_ int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
+{
         uint32_t hash;
 …
 /* Append to an entry. Create if not exist. */
 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
+_PUBLIC_ int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
+{
         uint32_t hash;
 …
         ret = _tdb_store(tdb, key, dbuf, 0, hash);
         tdb_trace_2rec_retrec(tdb, "tdb_append", key, new_dbuf, dbuf);
 failed:
         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
 …
   useful for external logging functions
 */
 const char *tdb_name(struct tdb_context *tdb)
+_PUBLIC_ const char *tdb_name(struct tdb_context *tdb)
+{
         return tdb->name;
 …
   of the fd
 */
 int tdb_fd(struct tdb_context *tdb)
+_PUBLIC_ int tdb_fd(struct tdb_context *tdb)
+{
         return tdb->fd;
 …
   useful for external tdb routines that wish to log tdb errors
 */
 tdb_log_func tdb_log_fn(struct tdb_context *tdb)
+_PUBLIC_ tdb_log_func tdb_log_fn(struct tdb_context *tdb)
+{
         return tdb->log.log_fn;
 …
   test of a possible tdb change.
 */
 int tdb_get_seqnum(struct tdb_context *tdb)
+_PUBLIC_ int tdb_get_seqnum(struct tdb_context *tdb)
+{
         tdb_off_t seqnum=0;
 …
+}
 int tdb_hash_size(struct tdb_context *tdb)
+_PUBLIC_ int tdb_hash_size(struct tdb_context *tdb)
+{
         return tdb->header.hash_size;
+}
 size_t tdb_map_size(struct tdb_context *tdb)
+_PUBLIC_ size_t tdb_map_size(struct tdb_context *tdb)
+{
         return tdb->map_size;
+}
 int tdb_get_flags(struct tdb_context *tdb)
+_PUBLIC_ int tdb_get_flags(struct tdb_context *tdb)
+{
         return tdb->flags;
+}
 void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
+_PUBLIC_ void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
+{
         if ((flags & TDB_ALLOW_NESTING) &&
 …
+}
 void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
+_PUBLIC_ void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
+{
         if ((flags & TDB_ALLOW_NESTING) &&
 …
   enable sequence number handling on an open tdb
 */
 void tdb_enable_seqnum(struct tdb_context *tdb)
+_PUBLIC_ void tdb_enable_seqnum(struct tdb_context *tdb)
+{
         tdb->flags |= TDB_SEQNUM;
 …
 /*
   wipe the entire database, deleting all records. This can be done
   very fast by using a global lock. The entire data portion of the
+  very fast by using a allrecord lock. The entire data portion of the
   file becomes a single entry in the freelist.
   This code carefully steps around the recovery area, leaving it alone
  */
 int tdb_wipe_all(struct tdb_context *tdb)
+_PUBLIC_ int tdb_wipe_all(struct tdb_context *tdb)
+{
         int i;
 …
   repack a tdb
  */
 int tdb_repack(struct tdb_context *tdb)
+_PUBLIC_ int tdb_repack(struct tdb_context *tdb)
+{
         struct tdb_context *tmp_db;
 …
+}
+/* Even on files, we can get partial writes due to signals. */
+bool tdb_write_all(int fd, const void *buf, size_t count)
+{
+        while (count) {
+                ssize_t ret;
+                ret = write(fd, buf, count);
+                if (ret < 0)
+                        return false;
+                buf = (const char *)buf + ret;
+                count -= ret;
+        }
+        return true;
+}
 #ifdef TDB_TRACE
 static void tdb_trace_write(struct tdb_context *tdb, const char *str)
+{
         if (write(tdb->tracefd, str, strlen(str)) != strlen(str)) {
+        if (!tdb_write_alltdb->tracefd, str, strlen(str)) {
                 close(tdb->tracefd);
                 tdb->tracefd = -1;

vendor/current/lib/tdb/common/tdb_private.h

-              r414
+              r740
    Copyright (C) Andrew Tridgell              2005
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 #define TDB_DEAD_MAGIC (0xFEE1DEAD)
 #define TDB_RECOVERY_MAGIC (0xf53bc0e7U)
+#define TDB_RECOVERY_INVALID_MAGIC (0x0)
+#define TDB_HASH_RWLOCK_MAGIC (0xbad1a51U)
 #define TDB_ALIGNMENT 4
 #define DEFAULT_HASH_SIZE 131
 …
 /* lock offsets */
 #define GLOBAL_LOCK      0
+#define OPEN_LOCK        0
 #define ACTIVE_LOCK      4
 #define TRANSACTION_LOCK 8
 …
         tdb_off_t recovery_start; /* offset of transaction recovery region */
         tdb_off_t sequence_number; /* used when TDB_SEQNUM is set */
+        tdb_off_t reserved[29];
+        uint32_t magic1_hash; /* hash of TDB_MAGIC_FOOD. */
+        uint32_t magic2_hash; /* hash of TDB_MAGIC. */
+        tdb_off_t reserved[27];
 };
 struct tdb_lock_type {
         int list;
+        uint32_t off;
         uint32_t count;
         uint32_t ltype;
 …
 };
+enum tdb_lock_flags {
+        /* WAIT == F_SETLKW, NOWAIT == F_SETLK */
+        TDB_LOCK_NOWAIT = 0,
+        TDB_LOCK_WAIT = 1,
+        /* If set, don't log an error on failure. */
+        TDB_LOCK_PROBE = 2,
+        /* If set, don't actually lock at all. */
+        TDB_LOCK_MARK_ONLY = 4,
+};
 struct tdb_methods {
 …
         int (*tdb_oob)(struct tdb_context *, tdb_off_t , int );
         int (*tdb_expand_file)(struct tdb_context *, tdb_off_t , tdb_off_t );
-        int (*tdb_brlock)(struct tdb_context *, tdb_off_t , int, int, int, size_t);
 };
 …
         int traverse_read; /* read-only traversal */
         int traverse_write; /* read-write traversal */
         struct tdb_lock_type global_lock;
+        struct tdb_lock_type allrecord_lock; /* .offset == upgradable */
         int num_lockrecs;
         struct tdb_lock_type *lockrecs; /* only real locks, all with count>0 */
 …
         unsigned int (*hash_fn)(TDB_DATA *key);
         int open_flags; /* flags used in the open - needed by reopen */
-        unsigned int num_locks; /* number of chain locks held */
         const struct tdb_methods *methods;
         struct tdb_transaction *transaction;
         int page_size;
         int max_dead_records;
-        int transaction_lock_count;
 #ifdef TDB_TRACE
         int tracefd;
 …
 int tdb_lock(struct tdb_context *tdb, int list, int ltype);
 int tdb_lock_nonblock(struct tdb_context *tdb, int list, int ltype);
+int tdb_nest_lock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                  enum tdb_lock_flags flags);
+int tdb_nest_unlock(struct tdb_context *tdb, uint32_t offset, int ltype,
+                    bool mark_lock);
 int tdb_unlock(struct tdb_context *tdb, int list, int ltype);
+int tdb_brlock(struct tdb_context *tdb, tdb_off_t offset, int rw_type, int lck_type, int probe, size_t len);
+int tdb_transaction_lock(struct tdb_context *tdb, int ltype);
+int tdb_transaction_unlock(struct tdb_context *tdb);
+int tdb_brlock_upgrade(struct tdb_context *tdb, tdb_off_t offset, size_t len);
+int tdb_brlock(struct tdb_context *tdb,
+               int rw_type, tdb_off_t offset, size_t len,
+               enum tdb_lock_flags flags);
+int tdb_brunlock(struct tdb_context *tdb,
+                 int rw_type, tdb_off_t offset, size_t len);
+bool tdb_have_extra_locks(struct tdb_context *tdb);
+void tdb_release_transaction_locks(struct tdb_context *tdb);
+int tdb_transaction_lock(struct tdb_context *tdb, int ltype,
+                         enum tdb_lock_flags lockflags);
+int tdb_transaction_unlock(struct tdb_context *tdb, int ltype);
+int tdb_recovery_area(struct tdb_context *tdb,
+                      const struct tdb_methods *methods,
+                      tdb_off_t *recovery_offset,
+                      struct tdb_record *rec);
+int tdb_allrecord_lock(struct tdb_context *tdb, int ltype,
+                       enum tdb_lock_flags flags, bool upgradable);
+int tdb_allrecord_unlock(struct tdb_context *tdb, int ltype, bool mark_lock);
+int tdb_allrecord_upgrade(struct tdb_context *tdb);
 int tdb_write_lock_record(struct tdb_context *tdb, tdb_off_t off);
 int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off);
 …
 int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off);
 int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off);
 int _tdb_transaction_cancel(struct tdb_context *tdb);
+bool tdb_needs_recovery(struct tdb_context *tdb);
 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec);
 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec);
 …
 int tdb_rec_free_read(struct tdb_context *tdb, tdb_off_t off,
                       struct tdb_record *rec);
+bool tdb_write_all(int fd, const void *buf, size_t count);
+int tdb_transaction_recover(struct tdb_context *tdb);
+void tdb_header_hash(struct tdb_context *tdb,
+                     uint32_t *magic1_hash, uint32_t *magic2_hash);
+unsigned int tdb_old_hash(TDB_DATA *key);
+size_t tdb_dead_space(struct tdb_context *tdb, tdb_off_t off);

vendor/current/lib/tdb/common/transaction.c

-              r414
+              r740
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
     existing transaction record. If the inner transaction is cancelled
     then a subsequent commit will fail
   - keep a mirrored copy of the tdb hash chain heads to allow for the
     fast hash heads scan on traverse, updating the mirrored copy in
 …
   - check for a valid recovery record on open of the tdb, while the
     global lock is held. Automatically recover from the transaction
+    open lock is held. Automatically recover from the transaction
     recovery area if needed, then continue with the open as
     usual. This allows for smooth crash recovery with no administrator
 …
         tdb_off_t magic_offset;
-        /* set when the GLOBAL_LOCK has been taken */
-        bool global_lock_taken;
         /* old file size before transaction */
         tdb_len_t old_map_size;
         /* we should re-pack on commit */
         bool need_repack;
+        /* did we expand in this transaction */
+        bool expanded;
 };
 …
+                }
+        }
         /* now copy it out of this block */
         memcpy(buf, tdb->transaction->blocks[blk] + (off % tdb->transaction->block_size), len);
 …
+                }
+        }
         /* overwrite part of an existing block */
         if (buf == NULL) {
 …
+        }
+        tdb->transaction->need_repack = true;
+        return 0;
+}
+/*
+  brlock during a transaction - ignore them
+*/
+static int transaction_brlock(struct tdb_context *tdb, tdb_off_t offset,
+                              int rw_type, int lck_type, int probe, size_t len)
+{
+        tdb->transaction->expanded = true;
         return 0;
+}
 …
         transaction_oob,
         transaction_expand_file,
-        transaction_brlock
 };
 …
   transaction is allowed to be pending per tdb_context
 */
+int tdb_transaction_start(struct tdb_context *tdb)
+static int _tdb_transaction_start(struct tdb_context *tdb,
+                                  enum tdb_lock_flags lockflags)
+{
         /* some sanity checks */
 …
+        }
         if (tdb->num_locks != 0 || tdb->global_lock.count) {
+        if (tdb_have_extra_locks(tdb)) {
                 /* the caller must not have any locks when starting a
                    transaction as otherwise we'll be screwed by lack
 …
            discussed with Volker, there are a number of ways we could
            make this async, which we will probably do in the future */
         if (tdb_transaction_lock(tdb, F_WRLCK) == -1) {
+        if (tdb_transaction_lock(tdb, F_WRLCK, lockflags) == -1) {
                 SAFE_FREE(tdb->transaction->blocks);
                 SAFE_FREE(tdb->transaction);
+                return -1;
+        }
+                if ((lockflags & TDB_LOCK_WAIT) == 0) {
+                        tdb->ecode = TDB_ERR_NOLOCK;
+                }
+                return -1;
+        }
         /* get a read lock from the freelist to the end of file. This
            is upgraded to a write lock during the commit */
         if (tdb_brlock(tdb, FREELIST_TOP, F_RDLCK, F_SETLKW, 0, 0) == -1) {
+        if (tdb_allrecord_lock(tdb, F_RDLCK, TDB_LOCK_WAIT, true) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: failed to get hash locks\n"));
+                tdb->ecode = TDB_ERR_LOCK;
+                goto fail;
+                goto fail_allrecord_lock;
+        }
 …
         tdb_trace(tdb, "tdb_transaction_start");
         return 0;
 fail:
+        tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 0);
+        tdb_transaction_unlock(tdb);
+        tdb_allrecord_unlock(tdb, F_RDLCK, false);
+fail_allrecord_lock:
+        tdb_transaction_unlock(tdb, F_WRLCK);
         SAFE_FREE(tdb->transaction->blocks);
         SAFE_FREE(tdb->transaction->hash_heads);
 …
+}
+_PUBLIC_ int tdb_transaction_start(struct tdb_context *tdb)
+{
+        return _tdb_transaction_start(tdb, TDB_LOCK_WAIT);
+}
+_PUBLIC_ int tdb_transaction_start_nonblock(struct tdb_context *tdb)
+{
+        return _tdb_transaction_start(tdb, TDB_LOCK_NOWAIT|TDB_LOCK_PROBE);
+}
 /*
 …
+        }
+#ifdef HAVE_FDATASYNC
+        if (fdatasync(tdb->fd) != 0) {
+#else
         if (fsync(tdb->fd) != 0) {
+#endif
                 tdb->ecode = TDB_ERR_IO;
                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction: fsync failed\n"));
 …
 int _tdb_transaction_cancel(struct tdb_context *tdb)
+static int _tdb_transaction_cancel(struct tdb_context *tdb)
+{
         int i, ret = 0;
 …
         if (tdb->transaction->magic_offset) {
                 const struct tdb_methods *methods = tdb->transaction->io_methods;
                 uint32_t zero = 0;
+                const uint32_t invalid = TDB_RECOVERY_INVALID_MAGIC;
                 /* remove the recovery marker */
                 if (methods->tdb_write(tdb, tdb->transaction->magic_offset, &zero, 4) == -1 ||
+                if (methods->tdb_write(tdb, tdb->transaction->magic_offset, &invalid, 4) == -1 ||
                 transaction_sync(tdb, tdb->transaction->magic_offset, 4) == -1) {
                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_cancel: failed to remove recovery magic\n"));
 …
+        }
+        if (tdb->transaction->global_lock_taken) {
+                tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1);
+                tdb->transaction->global_lock_taken = false;
+        }
+        /* remove any global lock created during the transaction */
+        if (tdb->global_lock.count != 0) {
+                tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 4*tdb->header.hash_size);
+                tdb->global_lock.count = 0;
+        }
+        /* remove any locks created during the transaction */
+        if (tdb->num_locks != 0) {
+                for (i=0;i<tdb->num_lockrecs;i++) {
+                        tdb_brlock(tdb,FREELIST_TOP+4*tdb->lockrecs[i].list,
+                                   F_UNLCK,F_SETLKW, 0, 1);
+                }
+                tdb->num_locks = 0;
+                tdb->num_lockrecs = 0;
+                SAFE_FREE(tdb->lockrecs);
+        }
+        /* This also removes the OPEN_LOCK, if we have it. */
+        tdb_release_transaction_locks(tdb);
         /* restore the normal io methods */
         tdb->methods = tdb->transaction->io_methods;
-        tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 0);
-        tdb_transaction_unlock(tdb);
         SAFE_FREE(tdb->transaction->hash_heads);
         SAFE_FREE(tdb->transaction);
         return ret;
+}
 …
   cancel the current transaction
 */
 int tdb_transaction_cancel(struct tdb_context *tdb)
+_PUBLIC_ int tdb_transaction_cancel(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_transaction_cancel");
 …
+}
+int tdb_recovery_area(struct tdb_context *tdb,
+                      const struct tdb_methods *methods,
+                      tdb_off_t *recovery_offset,
+                      struct tdb_record *rec)
+{
+        if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, recovery_offset) == -1) {
+                return -1;
+        }
+        if (*recovery_offset == 0) {
+                rec->rec_len = 0;
+                return 0;
+        }
+        if (methods->tdb_read(tdb, *recovery_offset, rec, sizeof(*rec),
+                              DOCONV()) == -1) {
+                return -1;
+        }
+        /* ignore invalid recovery regions: can happen in crash */
+        if (rec->magic != TDB_RECOVERY_MAGIC &&
+            rec->magic != TDB_RECOVERY_INVALID_MAGIC) {
+                *recovery_offset = 0;
+                rec->rec_len = 0;
+        }
+        return 0;
+}
 /*
   allocate the recovery area, or use an existing recovery area if it is
 …
         tdb_off_t recovery_head;
         if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
+        if (tdb_recovery_area(tdb, methods, &recovery_head, &rec) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to read recovery head\n"));
-                return -1;
+        }
-        rec.rec_len = 0;
-        if (recovery_head != 0 &&
-            methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
-                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_recovery_allocate: failed to read recovery record\n"));
                 return -1;
+        }
 …
         memset(rec, 0, sizeof(*rec));
         rec->magic    = 0;
+        rec->magic    = TDB_RECOVERY_INVALID_MAGIC;
         rec->data_len = recovery_size;
         rec->rec_len  = recovery_max_size;
         rec->key_len  = old_map_size;
         CONVERT(rec);
+        CONVERT(*rec);
         /* build the recovery data into a single blob to allow us to do a single
 …
                         length = tdb->transaction->last_block_size;
+                }
                 if (offset >= old_map_size) {
                         continue;
 …
         tailer = sizeof(*rec) + recovery_max_size;
         memcpy(p, &tailer, 4);
+        CONVERT(p);
+        if (DOCONV()) {
+                tdb_convert(p, 4);
+        }
         /* write the recovery data to the recovery area */
 …
         methods = tdb->transaction->io_methods;
         /* if there are any locks pending then the caller has not
            nested their locks properly, so fail the transaction */
         if (tdb->num_locks || tdb->global_lock.count) {
+        if (tdb_have_extra_locks(tdb)) {
                 tdb->ecode = TDB_ERR_LOCK;
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: locks pending on commit\n"));
 …
         /* upgrade the main transaction lock region to a write lock */
         if (tdb_brlock_upgrade(tdb, FREELIST_TOP, 0) == -1) {
+        if (tdb_allrecord_upgrade(tdb) == -1) {
                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to upgrade hash locks\n"));
-                tdb->ecode = TDB_ERR_LOCK;
                 _tdb_transaction_cancel(tdb);
                 return -1;
+        }
         /* get the global lock - this prevents new users attaching to the database
+        /* get the open lock - this prevents new users attaching to the database
            during the commit */
+        if (tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to get global lock\n"));
+                tdb->ecode = TDB_ERR_LOCK;
+        if (tdb_nest_lock(tdb, OPEN_LOCK, F_WRLCK, TDB_LOCK_WAIT) == -1) {
+                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_prepare_commit: failed to get open lock\n"));
                 _tdb_transaction_cancel(tdb);
                 return -1;
+        }
-        tdb->transaction->global_lock_taken = true;
         if (!(tdb->flags & TDB_NOSYNC)) {
 …
+        }
         /* Keep the global lock until the actual commit */
+        /* Keep the open lock until the actual commit */
         return 0;
 …
    prepare to commit the current transaction
 */
 int tdb_transaction_prepare_commit(struct tdb_context *tdb)
+{
+_PUBLIC_ int tdb_transaction_prepare_commit(struct tdb_context *tdb)
+{
         tdb_trace(tdb, "tdb_transaction_prepare_commit");
         return _tdb_transaction_prepare_commit(tdb);
+}
+/* A repack is worthwhile if the largest is less than half total free. */
+static bool repack_worthwhile(struct tdb_context *tdb)
+{
+        tdb_off_t ptr;
+        struct tdb_record rec;
+        tdb_len_t total = 0, largest = 0;
+        if (tdb_ofs_read(tdb, FREELIST_TOP, &ptr) == -1) {
+                return false;
+        }
+        while (ptr != 0 && tdb_rec_free_read(tdb, ptr, &rec) == 0) {
+                total += rec.rec_len;
+                if (rec.rec_len > largest) {
+                        largest = rec.rec_len;
+                }
+                ptr = rec.next;
+        }
+        return total > largest * 2;
+}
 /*
   commit the current transaction
 */
 int tdb_transaction_commit(struct tdb_context *tdb)
+{
+_PUBLIC_ int tdb_transaction_commit(struct tdb_context *tdb)
+{
         const struct tdb_methods *methods;
         int i;
         bool need_repack;
+        bool need_repack = false;
         if (tdb->transaction == NULL) {
 …
                 if (methods->tdb_write(tdb, offset, tdb->transaction->blocks[i], length) == -1) {
                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: write failed during commit\n"));
                         /* we've overwritten part of the data and
                            possibly expanded the file, so we need to
 …
                 SAFE_FREE(tdb->transaction->blocks[i]);
+        }
+        /* Do this before we drop lock or blocks. */
+        if (tdb->transaction->expanded) {
+                need_repack = repack_worthwhile(tdb);
+        }
         SAFE_FREE(tdb->transaction->blocks);
 …
 #endif
-        need_repack = tdb->transaction->need_repack;
         /* use a transaction cancel to free memory and remove the
            transaction locks */
 …
 /*
   recover from an aborted transaction. Must be called with exclusive
   database write access already established (including the global
+  database write access already established (including the open
   lock to prevent new processes attaching)
 */
 …
                 return -1;
+        }
-        /* reduce the file size to the old size */
-        tdb_munmap(tdb);
-        if (ftruncate(tdb->fd, recovery_eof) != 0) {
-                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to reduce to recovery size\n"));
-                tdb->ecode = TDB_ERR_IO;
-                return -1;
+        }
-        tdb->map_size = recovery_eof;
-        tdb_mmap(tdb);
         if (transaction_sync(tdb, 0, recovery_eof) == -1) {
 …
         return 0;
+}
+/* Any I/O failures we say "needs recovery". */
+bool tdb_needs_recovery(struct tdb_context *tdb)
+{
+        tdb_off_t recovery_head;
+        struct tdb_record rec;
+        /* find the recovery area */
+        if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
+                return true;
+        }
+        if (recovery_head == 0) {
+                /* we have never allocated a recovery record */
+                return false;
+        }
+        /* read the recovery record */
+        if (tdb->methods->tdb_read(tdb, recovery_head, &rec,
+                                   sizeof(rec), DOCONV()) == -1) {
+                return true;
+        }
+        return (rec.magic == TDB_RECOVERY_MAGIC);
+}

vendor/current/lib/tdb/common/traverse.c

-              r414
+              r740
    Copyright (C) Paul `Rusty' Russell              2000
    Copyright (C) Jeremy Allison                    2000-2003
      ** NOTE! The following LGPL license applies to the tdb
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
                            hashes are used. In that case we spend most of our
                            time in tdb_brlock(), locking empty hash chains.
                            To avoid this, we do an unlocked pre-check to see
                            if the hash chain is empty before starting to look
 …
                            lock, so instead we get the lock and re-fetch the
                            value below.
                            Notice that not doing this optimisation on the
                            first hash chain is critical. We must guarantee
 …
                            could miss them anyway without this trick, so the
                            semantics don't change.
                            With a non-indexed ldb search this trick gains us a
                            factor of around 80 in speed on a linux 2.6.x
 …
   a write style traverse - temporarily marks the db read only
 */
 int tdb_traverse_read(struct tdb_context *tdb,
+_PUBLIC_ int tdb_traverse_read(struct tdb_context *tdb,
                       tdb_traverse_func fn, void *private_data)
+{
 …
         /* we need to get a read lock on the transaction lock here to
            cope with the lock ordering semantics of solaris10 */
         if (tdb_transaction_lock(tdb, F_RDLCK)) {
+        if (tdb_transaction_lock(tdb, F_RDLCK, TDB_LOCK_WAIT)) {
                 return -1;
+        }
 …
         tdb->traverse_read--;
         tdb_transaction_unlock(tdb);
+        tdb_transaction_unlock(tdb, F_RDLCK);
         return ret;
 …
   alignment restrictions malloc gives you.
 */
 int tdb_traverse(struct tdb_context *tdb,
+_PUBLIC_ int tdb_traverse(struct tdb_context *tdb,
                  tdb_traverse_func fn, void *private_data)
+{
 …
+        }
         if (tdb_transaction_lock(tdb, F_WRLCK)) {
+        if (tdb_transaction_lock(tdb, F_WRLCK, TDB_LOCK_WAIT)) {
                 return -1;
+        }
 …
         tdb->traverse_write--;
         tdb_transaction_unlock(tdb);
+        tdb_transaction_unlock(tdb, F_WRLCK);
         return ret;
 …
 /* find the first entry in the database and return its key */
 TDB_DATA tdb_firstkey(struct tdb_context *tdb)
+_PUBLIC_ TDB_DATA tdb_firstkey(struct tdb_context *tdb)
+{
         TDB_DATA key;
 …
 /* find the next entry in the database, returning its key */
 TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
+_PUBLIC_ TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA oldkey)
+{
         uint32_t oldhash;

vendor/current/lib/tdb/docs/README

-              r414
+              r740
 ----------------------------------------------------------------------
+int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
+                     int (*parser)(TDB_DATA key, TDB_DATA data,
+                                   void *private_data),
+                     void *private_data);
+   Hand a record to a parser function without allocating it.
+   This function is meant as a fast tdb_fetch alternative for large records
+   that are frequently read. The "key" and "data" arguments point directly
+   into the tdb shared memory, they are not aligned at any boundary.
+   WARNING: The parser is called while tdb holds a lock on the record. DO NOT
+   call other tdb routines from within the parser. Also, for good performance
+   you should make the parser fast to allow parallel operations.
+   tdb_parse_record returns -1 if the record was not found.  If the record was
+   found, the return value of "parser" is passed up to the caller.
+----------------------------------------------------------------------
 int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key);

vendor/current/lib/tdb/include/tdb.h

-              r414
+              r740
 #endif
+#include "signal.h"
+/* flags to tdb_store() */
+#define TDB_REPLACE 1           /* Unused */
+#define TDB_INSERT 2            /* Don't overwrite an existing entry */
+#define TDB_MODIFY 3            /* Don't create an existing entry    */
+/* flags for tdb_open() */
+#define TDB_DEFAULT 0 /* just a readability place holder */
+#define TDB_CLEAR_IF_FIRST 1
+#define TDB_INTERNAL 2 /* don't store on disk */
+#define TDB_NOLOCK   4 /* don't do any locking */
+#define TDB_NOMMAP   8 /* don't use mmap */
+#define TDB_CONVERT 16 /* convert endian (internal use) */
+#define TDB_BIGENDIAN 32 /* header is big-endian (internal use) */
+#define TDB_NOSYNC   64 /* don't use synchronous transactions */
+#define TDB_SEQNUM   128 /* maintain a sequence number */
+#define TDB_VOLATILE   256 /* Activate the per-hashchain freelist, default 5 */
+#define TDB_ALLOW_NESTING 512 /* Allow transactions to nest */
+#define TDB_DISALLOW_NESTING 1024 /* Disallow transactions to nest */
+/* error codes */
+#include <signal.h>
+/**
+ * @defgroup tdb The tdb API
+ *
+ * tdb is a Trivial database. In concept, it is very much like GDBM, and BSD's
+ * DB except that it allows multiple simultaneous writers and uses locking
+ * internally to keep writers from trampling on each other. tdb is also
+ * extremely small.
+ *
+ * @section tdb_interface Interface
+ *
+ * The interface is very similar to gdbm except for the following:
+ *
+ * <ul>
+ * <li>different open interface. The tdb_open call is more similar to a
+ * traditional open()</li>
+ * <li>no tdbm_reorganise() function</li>
+ * <li>no tdbm_sync() function. No operations are cached in the library
+ *     anyway</li>
+ * <li>added a tdb_traverse() function for traversing the whole database</li>
+ * <li>added transactions support</li>
+ * </ul>
+ *
+ * A general rule for using tdb is that the caller frees any returned TDB_DATA
+ * structures. Just call free(p.dptr) to free a TDB_DATA return value called p.
+ * This is the same as gdbm.
+ *
+ * @{
+ */
+/** Flags to tdb_store() */
+#define TDB_REPLACE 1           /** Unused */
+#define TDB_INSERT 2            /** Don't overwrite an existing entry */
+#define TDB_MODIFY 3            /** Don't create an existing entry    */
+/** Flags for tdb_open() */
+#define TDB_DEFAULT 0 /** just a readability place holder */
+#define TDB_CLEAR_IF_FIRST 1 /** If this is the first open, wipe the db */
+#define TDB_INTERNAL 2 /** Don't store on disk */
+#define TDB_NOLOCK   4 /** Don't do any locking */
+#define TDB_NOMMAP   8 /** Don't use mmap */
+#define TDB_CONVERT 16 /** Convert endian (internal use) */
+#define TDB_BIGENDIAN 32 /** Header is big-endian (internal use) */
+#define TDB_NOSYNC   64 /** Don't use synchronous transactions */
+#define TDB_SEQNUM   128 /** Maintain a sequence number */
+#define TDB_VOLATILE   256 /** Activate the per-hashchain freelist, default 5 */
+#define TDB_ALLOW_NESTING 512 /** Allow transactions to nest */
+#define TDB_DISALLOW_NESTING 1024 /** Disallow transactions to nest */
+#define TDB_INCOMPATIBLE_HASH 2048 /** Better hashing: can't be opened by tdb < 1.2.6. */
+/** The tdb error codes */
 enum TDB_ERROR {TDB_SUCCESS=0, TDB_ERR_CORRUPT, TDB_ERR_IO, TDB_ERR_LOCK,
                 TDB_ERR_OOM, TDB_ERR_EXISTS, TDB_ERR_NOLOCK, TDB_ERR_LOCK_TIMEOUT,
 …
                 TDB_ERR_NESTING};
 /* debugging uses one of the following levels */
+/** Debugging uses one of the following levels */
 enum tdb_debug_level {TDB_DEBUG_FATAL = 0, TDB_DEBUG_ERROR,
                       TDB_DEBUG_WARNING, TDB_DEBUG_TRACE};
+/** The tdb data structure */
 typedef struct TDB_DATA {
         unsigned char *dptr;
 …
 #endif
 /* this is the context structure that is returned from a db open */
+/** This is the context structure that is returned from a db open. */
 typedef struct tdb_context TDB_CONTEXT;
 …
 };
+/**
+ * @brief Open the database and creating it if necessary.
+ *
+ * @param[in]  name     The name of the db to open.
+ *
+ * @param[in]  hash_size The hash size is advisory, use zero for a default
+ *                       value.
+ *
+ * @param[in]  tdb_flags The flags to use to open the db:\n\n
+ *                         TDB_CLEAR_IF_FIRST - Clear database if we are the
+ *                                              only one with it open\n
+ *                         TDB_INTERNAL - Don't use a file, instaed store the
+ *                                        data in memory. The filename is
+ *                                        ignored in this case.\n
+ *                         TDB_NOLOCK - Don't do any locking\n
+ *                         TDB_NOMMAP - Don't use mmap\n
+ *                         TDB_NOSYNC - Don't synchronise transactions to disk\n
+ *                         TDB_SEQNUM - Maintain a sequence number\n
+ *                         TDB_VOLATILE - activate the per-hashchain freelist,
+ *                                        default 5.\n
+ *                         TDB_ALLOW_NESTING - Allow transactions to nest.\n
+ *                         TDB_DISALLOW_NESTING - Disallow transactions to nest.\n
+ *
+ * @param[in]  open_flags Flags for the open(2) function.
+ *
+ * @param[in]  mode     The mode for the open(2) function.
+ *
+ * @return              A tdb context structure, NULL on error.
+ */
 struct tdb_context *tdb_open(const char *name, int hash_size, int tdb_flags,
                       int open_flags, mode_t mode);
+/**
+ * @brief Open the database and creating it if necessary.
+ *
+ * This is like tdb_open(), but allows you to pass an initial logging and
+ * hash function. Be careful when passing a hash function - all users of the
+ * database must use the same hash function or you will get data corruption.
+ *
+ * @param[in]  name     The name of the db to open.
+ *
+ * @param[in]  hash_size The hash size is advisory, use zero for a default
+ *                       value.
+ *
+ * @param[in]  tdb_flags The flags to use to open the db:\n\n
+ *                         TDB_CLEAR_IF_FIRST - Clear database if we are the
+ *                                              only one with it open\n
+ *                         TDB_INTERNAL - Don't use a file, instaed store the
+ *                                        data in memory. The filename is
+ *                                        ignored in this case.\n
+ *                         TDB_NOLOCK - Don't do any locking\n
+ *                         TDB_NOMMAP - Don't use mmap\n
+ *                         TDB_NOSYNC - Don't synchronise transactions to disk\n
+ *                         TDB_SEQNUM - Maintain a sequence number\n
+ *                         TDB_VOLATILE - activate the per-hashchain freelist,
+ *                                        default 5.\n
+ *                         TDB_ALLOW_NESTING - Allow transactions to nest.\n
+ *                         TDB_DISALLOW_NESTING - Disallow transactions to nest.\n
+ *
+ * @param[in]  open_flags Flags for the open(2) function.
+ *
+ * @param[in]  mode     The mode for the open(2) function.
+ *
+ * @param[in]  log_ctx  The logging function to use.
+ *
+ * @param[in]  hash_fn  The hash function you want to use.
+ *
+ * @return              A tdb context structure, NULL on error.
+ *
+ * @see tdb_open()
+ */
 struct tdb_context *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
                          int open_flags, mode_t mode,
                          const struct tdb_logging_context *log_ctx,
                          tdb_hash_func hash_fn);
+/**
+ * @brief Set the maximum number of dead records per hash chain.
+ *
+ * @param[in]  tdb      The database handle to set the maximum.
+ *
+ * @param[in]  max_dead The maximum number of dead records per hash chain.
+ */
 void tdb_set_max_dead(struct tdb_context *tdb, int max_dead);
+/**
+ * @brief Reopen a tdb.
+ *
+ * This can be used after a fork to ensure that we have an independent seek
+ * pointer from our parent and to re-establish locks.
+ *
+ * @param[in]  tdb      The database to reopen.
+ *
+ * @return              0 on success, -1 on error.
+ */
 int tdb_reopen(struct tdb_context *tdb);
+/**
+ * @brief Reopen all tdb's
+ *
+ * If the parent is longlived (ie. a parent daemon architecture), we know it
+ * will keep it's active lock on a tdb opened with CLEAR_IF_FIRST. Thus for
+ * child processes we don't have to add an active lock. This is essential to
+ * improve performance on systems that keep POSIX locks as a non-scalable data
+ * structure in the kernel.
+ *
+ * @param[in]  parent_longlived Wether the parent is longlived or not.
+ *
+ * @return              0 on success, -1 on error.
+ */
 int tdb_reopen_all(int parent_longlived);
+/**
+ * @brief Set a different tdb logging function.
+ *
+ * @param[in]  tdb      The tdb to set the logging function.
+ *
+ * @param[in]  log_ctx  The logging function to set.
+ */
 void tdb_set_logging_function(struct tdb_context *tdb, const struct tdb_logging_context *log_ctx);
+/**
+ * @brief Get the tdb last error code.
+ *
+ * @param[in]  tdb      The tdb to get the error code from.
+ *
+ * @return              A TDB_ERROR code.
+ *
+ * @see TDB_ERROR
+ */
 enum TDB_ERROR tdb_error(struct tdb_context *tdb);
+/**
+ * @brief Get a error string for the last tdb error
+ *
+ * @param[in]  tdb      The tdb to get the error code from.
+ *
+ * @return              An error string.
+ */
 const char *tdb_errorstr(struct tdb_context *tdb);
+/**
+ * @brief Fetch an entry in the database given a key.
+ *
+ * The caller must free the resulting data.
+ *
+ * @param[in]  tdb      The tdb to fetch the key.
+ *
+ * @param[in]  key      The key to fetch.
+ *
+ * @return              The key entry found in the database, NULL on error with
+ *                      TDB_ERROR set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key);
+/**
+ * @brief Hand a record to a parser function without allocating it.
+ *
+ * This function is meant as a fast tdb_fetch alternative for large records
+ * that are frequently read. The "key" and "data" arguments point directly
+ * into the tdb shared memory, they are not aligned at any boundary.
+ *
+ * @warning The parser is called while tdb holds a lock on the record. DO NOT
+ * call other tdb routines from within the parser. Also, for good performance
+ * you should make the parser fast to allow parallel operations.
+ *
+ * @param[in]  tdb      The tdb to parse the record.
+ *
+ * @param[in]  key      The key to parse.
+ *
+ * @param[in]  parser   The parser to use to parse the data.
+ *
+ * @param[in]  private_data A private data pointer which is passed to the parser
+ *                          function.
+ *
+ * @return              -1 if the record was not found. If the record was found,
+ *                      the return value of "parser" is passed up to the caller.
+ */
 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
+                     int (*parser)(TDB_DATA key, TDB_DATA data,
+                                   void *private_data),
+                     void *private_data);
+                              int (*parser)(TDB_DATA key, TDB_DATA data,
+                                            void *private_data),
+                              void *private_data);
+/**
+ * @brief Delete an entry in the database given a key.
+ *
+ * @param[in]  tdb      The tdb to delete the key.
+ *
+ * @param[in]  key      The key to delete.
+ *
+ * @return              0 on success, -1 if the key doesn't exist.
+ */
 int tdb_delete(struct tdb_context *tdb, TDB_DATA key);
+/**
+ * @brief Store an element in the database.
+ *
+ * This replaces any existing element with the same key.
+ *
+ * @param[in]  tdb      The tdb to store the entry.
+ *
+ * @param[in]  key      The key to use to store the entry.
+ *
+ * @param[in]  dbuf     The data to store under the key.
+ *
+ * @param[in]  flag     The flags to store the key:\n\n
+ *                      TDB_INSERT: Don't overwrite an existing entry.\n
+ *                      TDB_MODIFY: Don't create a new entry\n
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag);
+/**
+ * @brief Append data to an entry.
+ *
+ * If the entry doesn't exist, it will create a new one.
+ *
+ * @param[in]  tdb      The database to use.
+ *
+ * @param[in]  key      The key to append the data.
+ *
+ * @param[in]  new_dbuf The data to append to the key.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf);
+/**
+ * @brief Close a database.
+ *
+ * @param[in]  tdb      The database to close.
+ *
+ * @return              0 for success, -1 on error.
+ */
 int tdb_close(struct tdb_context *tdb);
+/**
+ * @brief Find the first entry in the database and return its key.
+ *
+ * The caller must free the returned data.
+ *
+ * @param[in]  tdb      The database to use.
+ *
+ * @return              The first entry of the database, an empty TDB_DATA entry
+ *                      if the database is empty.
+ */
 TDB_DATA tdb_firstkey(struct tdb_context *tdb);
+/**
+ * @brief Find the next entry in the database, returning its key.
+ *
+ * The caller must free the returned data.
+ *
+ * @param[in]  tdb      The database to use.
+ *
+ * @param[in]  key      The key from which you want the next key.
+ *
+ * @return              The next entry of the current key, an empty TDB_DATA
+ *                      entry if there is no entry.
+ */
 TDB_DATA tdb_nextkey(struct tdb_context *tdb, TDB_DATA key);
+int tdb_traverse(struct tdb_context *tdb, tdb_traverse_func fn, void *);
+int tdb_traverse_read(struct tdb_context *tdb, tdb_traverse_func fn, void *);
+/**
+ * @brief Traverse the entire database.
+ *
+ * While travering the function fn(tdb, key, data, state) is called on each
+ * element. If fn is NULL then it is not called. A non-zero return value from
+ * fn() indicates that the traversal should stop. Traversal callbacks may not
+ * start transactions.
+ *
+ * @warning The data buffer given to the callback fn does NOT meet the alignment
+ * restrictions malloc gives you.
+ *
+ * @param[in]  tdb      The database to traverse.
+ *
+ * @param[in]  fn       The function to call on each entry.
+ *
+ * @param[in]  private_data The private data which should be passed to the
+ *                          traversing function.
+ *
+ * @return              The record count traversed, -1 on error.
+ */
+int tdb_traverse(struct tdb_context *tdb, tdb_traverse_func fn, void *private_data);
+/**
+ * @brief Traverse the entire database.
+ *
+ * While traversing the database the function fn(tdb, key, data, state) is
+ * called on each element, but marking the database read only during the
+ * traversal, so any write operations will fail. This allows tdb to use read
+ * locks, which increases the parallelism possible during the traversal.
+ *
+ * @param[in]  tdb      The database to traverse.
+ *
+ * @param[in]  fn       The function to call on each entry.
+ *
+ * @param[in]  private_data The private data which should be passed to the
+ *                          traversing function.
+ *
+ * @return              The record count traversed, -1 on error.
+ */
+int tdb_traverse_read(struct tdb_context *tdb, tdb_traverse_func fn, void *private_data);
+/**
+ * @brief Check if an entry in the database exists.
+ *
+ * @note 1 is returned if the key is found and 0 is returned if not found this
+ * doesn't match the conventions in the rest of this module, but is compatible
+ * with gdbm.
+ *
+ * @param[in]  tdb      The database to check if the entry exists.
+ *
+ * @param[in]  key      The key to check if the entry exists.
+ *
+ * @return              1 if the key is found, 0 if not.
+ */
 int tdb_exists(struct tdb_context *tdb, TDB_DATA key);
+/**
+ * @brief Lock entire database with a write lock.
+ *
+ * @param[in]  tdb      The database to lock.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_lockall(struct tdb_context *tdb);
+/**
+ * @brief Lock entire database with a write lock.
+ *
+ * This is the non-blocking call.
+ *
+ * @param[in]  tdb      The database to lock.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_lockall()
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_lockall_nonblock(struct tdb_context *tdb);
+/**
+ * @brief Unlock entire database with write lock.
+ *
+ * @param[in]  tdb      The database to unlock.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_lockall()
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_unlockall(struct tdb_context *tdb);
+/**
+ * @brief Lock entire database with a read lock.
+ *
+ * @param[in]  tdb      The database to lock.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_lockall_read(struct tdb_context *tdb);
+/**
+ * @brief Lock entire database with a read lock.
+ *
+ * This is the non-blocking call.
+ *
+ * @param[in]  tdb      The database to lock.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_lockall_read()
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_lockall_read_nonblock(struct tdb_context *tdb);
+/**
+ * @brief Unlock entire database with read lock.
+ *
+ * @param[in]  tdb      The database to unlock.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_lockall_read()
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_unlockall_read(struct tdb_context *tdb);
+/**
+ * @brief Lock entire database with write lock - mark only.
+ *
+ * @todo Add more details.
+ *
+ * @param[in]  tdb      The database to mark.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_lockall_mark(struct tdb_context *tdb);
+/**
+ * @brief Lock entire database with write lock - unmark only.
+ *
+ * @todo Add more details.
+ *
+ * @param[in]  tdb      The database to mark.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_lockall_unmark(struct tdb_context *tdb);
+/**
+ * @brief Get the name of the current tdb file.
+ *
+ * This is useful for external logging functions.
+ *
+ * @param[in]  tdb      The database to get the name from.
+ *
+ * @return              The name of the database.
+ */
 const char *tdb_name(struct tdb_context *tdb);
+/**
+ * @brief Get the underlying file descriptor being used by tdb.
+ *
+ * This is useful for external routines that want to check the device/inode
+ * of the fd.
+ *
+ * @param[in]  tdb      The database to get the fd from.
+ *
+ * @return              The file descriptor or -1.
+ */
 int tdb_fd(struct tdb_context *tdb);
+/**
+ * @brief Get the current logging function.
+ *
+ * This is useful for external tdb routines that wish to log tdb errors.
+ *
+ * @param[in]  tdb      The database to get the logging function from.
+ *
+ * @return              The logging function of the database.
+ *
+ * @see tdb_get_logging_private()
+ */
 tdb_log_func tdb_log_fn(struct tdb_context *tdb);
+/**
+ * @brief Get the private data of the logging function.
+ *
+ * @param[in]  tdb      The database to get the data from.
+ *
+ * @return              The private data pointer of the logging function.
+ *
+ * @see tdb_log_fn()
+ */
 void *tdb_get_logging_private(struct tdb_context *tdb);
+/**
+ * @brief Start a transaction.
+ *
+ * All operations after the transaction start can either be committed with
+ * tdb_transaction_commit() or cancelled with tdb_transaction_cancel().
+ *
+ * If you call tdb_transaction_start() again on the same tdb context while a
+ * transaction is in progress, then the same transaction buffer is re-used. The
+ * number of tdb_transaction_{commit,cancel} operations must match the number
+ * of successful tdb_transaction_start() calls.
+ *
+ * Note that transactions are by default disk synchronous, and use a recover
+ * area in the database to automatically recover the database on the next open
+ * if the system crashes during a transaction. You can disable the synchronous
+ * transaction recovery setup using the TDB_NOSYNC flag, which will greatly
+ * speed up operations at the risk of corrupting your database if the system
+ * crashes.
+ *
+ * Operations made within a transaction are not visible to other users of the
+ * database until a successful commit.
+ *
+ * @param[in]  tdb      The database to start the transaction.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_transaction_start(struct tdb_context *tdb);
+/**
+ * @brief Start a transaction, non-blocking.
+ *
+ * @param[in]  tdb      The database to start the transaction.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ * @see tdb_transaction_start()
+ */
+int tdb_transaction_start_nonblock(struct tdb_context *tdb);
+/**
+ * @brief Prepare to commit a current transaction, for two-phase commits.
+ *
+ * Once prepared for commit, the only allowed calls are tdb_transaction_commit()
+ * or tdb_transaction_cancel(). Preparing allocates disk space for the pending
+ * updates, so a subsequent commit should succeed (barring any hardware
+ * failures).
+ *
+ * @param[in]  tdb      The database to prepare the commit.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_transaction_prepare_commit(struct tdb_context *tdb);
+/**
+ * @brief Commit a current transaction.
+ *
+ * This updates the database and releases the current transaction locks.
+ *
+ * @param[in]  tdb      The database to commit the transaction.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_transaction_commit(struct tdb_context *tdb);
+/**
+ * @brief Cancel a current transaction.
+ *
+ * This discards all write and lock operations that have been made since the
+ * transaction started.
+ *
+ * @param[in]  tdb      The tdb to cancel the transaction on.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_transaction_cancel(struct tdb_context *tdb);
+int tdb_transaction_recover(struct tdb_context *tdb);
+/**
+ * @brief Get the tdb sequence number.
+ *
+ * Only makes sense if the writers opened with TDB_SEQNUM set. Note that this
+ * sequence number will wrap quite quickly, so it should only be used for a
+ * 'has something changed' test, not for code that relies on the count of the
+ * number of changes made. If you want a counter then use a tdb record.
+ *
+ * The aim of this sequence number is to allow for a very lightweight test of a
+ * possible tdb change.
+ *
+ * @param[in]  tdb      The database to get the sequence number from.
+ *
+ * @return              The sequence number or 0.
+ *
+ * @see tdb_open()
+ * @see tdb_enable_seqnum()
+ */
 int tdb_get_seqnum(struct tdb_context *tdb);
+/**
+ * @brief Get the hash size.
+ *
+ * @param[in]  tdb      The database to get the hash size from.
+ *
+ * @return              The hash size.
+ */
 int tdb_hash_size(struct tdb_context *tdb);
+/**
+ * @brief Get the map size.
+ *
+ * @param[in]  tdb     The database to get the map size from.
+ *
+ * @return             The map size.
+ */
 size_t tdb_map_size(struct tdb_context *tdb);
+/**
+ * @brief Get the tdb flags set during open.
+ *
+ * @param[in]  tdb      The database to get the flags form.
+ *
+ * @return              The flags set to on the database.
+ */
 int tdb_get_flags(struct tdb_context *tdb);
+/**
+ * @brief Add flags to the database.
+ *
+ * @param[in]  tdb      The database to add the flags.
+ *
+ * @param[in]  flag     The tdb flags to add.
+ */
 void tdb_add_flags(struct tdb_context *tdb, unsigned flag);
+/**
+ * @brief Remove flags from the database.
+ *
+ * @param[in]  tdb      The database to remove the flags.
+ *
+ * @param[in]  flag     The tdb flags to remove.
+ */
 void tdb_remove_flags(struct tdb_context *tdb, unsigned flag);
+/**
+ * @brief Enable sequence number handling on an open tdb.
+ *
+ * @param[in]  tdb      The database to enable sequence number handling.
+ *
+ * @see tdb_get_seqnum()
+ */
 void tdb_enable_seqnum(struct tdb_context *tdb);
+/**
+ * @brief Increment the tdb sequence number.
+ *
+ * This only works if the tdb has been opened using the TDB_SEQNUM flag or
+ * enabled useing tdb_enable_seqnum().
+ *
+ * @param[in]  tdb      The database to increment the sequence number.
+ *
+ * @see tdb_enable_seqnum()
+ * @see tdb_get_seqnum()
+ */
 void tdb_increment_seqnum_nonblock(struct tdb_context *tdb);
+/**
+ * @brief Create a hash of the key.
+ *
+ * @param[in]  key      The key to hash
+ *
+ * @return              The hash.
+ */
+unsigned int tdb_jenkins_hash(TDB_DATA *key);
+/**
+ * @brief Check the consistency of the database.
+ *
+ * This check the consistency of the database calling back the check function
+ * (if non-NULL) on each record.  If some consistency check fails, or the
+ * supplied check function returns -1, tdb_check returns -1, otherwise 0.
+ *
+ * @note The logging function (if set) will be called with additional
+ * information on the corruption found.
+ *
+ * @param[in]  tdb      The database to check.
+ *
+ * @param[in]  check    The check function to use.
+ *
+ * @param[in]  private_data the private data to pass to the check function.
+ *
+ * @return              0 on success, -1 on error with error code set.
+ *
+ * @see tdb_error()
+ * @see tdb_errorstr()
+ */
 int tdb_check(struct tdb_context *tdb,
               int (*check) (TDB_DATA key, TDB_DATA data, void *private_data),
               void *private_data);
+/* @} ******************************************************************/
 /* Low level locking functions: use with care */
 …
 int tdb_validate_freelist(struct tdb_context *tdb, int *pnum_entries);
 int tdb_freelist_size(struct tdb_context *tdb);
+char *tdb_summary(struct tdb_context *tdb);
 extern TDB_DATA tdb_null;

vendor/current/lib/tdb/libtdb.m4

-              r414
+              r740
 fi
 TDB_OBJ="common/tdb.o common/dump.o common/transaction.o common/error.o common/traverse.o"
 TDB_OBJ="$TDB_OBJ common/freelist.o common/freelistcheck.o common/io.o common/lock.o common/open.o common/check.o"
+TDB_OBJ="$TDB_OBJ common/freelist.o common/freelistcheck.o common/io.o common/lock.o common/open.o common/check.o common/hash.o common/summary.o"
 AC_SUBST(TDB_OBJ)
 AC_SUBST(LIBREPLACEOBJ)
 …
 TDB_LIBS=""
 AC_SUBST(TDB_LIBS)
+TDB_DEPS=""
+if test x$libreplace_cv_HAVE_FDATASYNC_IN_LIBRT = xyes ; then
+        TDB_DEPS="$TDB_DEPS -lrt"
+fi
+AC_SUBST(TDB_DEPS)
 TDB_CFLAGS="-I$tdbdir/include"

vendor/current/lib/tdb/manpages/tdbbackup.8.xml

-              r414
+              r740
 <?xml version="1.0" encoding="iso-8859-1"?>
 <!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="tdbbackup.8">
 …
         <refmiscinfo class="source">Samba</refmiscinfo>
         <refmiscinfo class="manual">System Administration tools</refmiscinfo>
         <refmiscinfo class="version">3.5</refmiscinfo>
+        <refmiscinfo class="version">3.6</refmiscinfo>
 </refmeta>

vendor/current/lib/tdb/manpages/tdbdump.8.xml

-              r414
+              r740
 <?xml version="1.0" encoding="iso-8859-1"?>
 <!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="tdbdump.8">
 …
         <refmiscinfo class="source">Samba</refmiscinfo>
         <refmiscinfo class="manual">System Administration tools</refmiscinfo>
         <refmiscinfo class="version">3.5</refmiscinfo>
+        <refmiscinfo class="version">3.6</refmiscinfo>
 </refmeta>

vendor/current/lib/tdb/manpages/tdbtool.8.xml

-              r414
+              r740
 <?xml version="1.0" encoding="iso-8859-1"?>
 <!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="tdbtool.8">
 …
         <refmiscinfo class="source">Samba</refmiscinfo>
         <refmiscinfo class="manual">System Administration tools</refmiscinfo>
         <refmiscinfo class="version">3.5</refmiscinfo>
+        <refmiscinfo class="version">3.6</refmiscinfo>
 </refmeta>

vendor/current/lib/tdb/pytdb.c

-              r414
+              r740
      ** library. This does NOT imply that all of Samba is released
      ** under the LGPL
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
 …
 */
+#include <Python.h>
 #include "replace.h"
 #include "system/filesys.h"
-#include <Python.h>
 #ifndef Py_RETURN_NONE
 #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
 …
 } PyTdbObject;
 PyAPI_DATA(PyTypeObject) PyTdb;
+staticforward PyTypeObject PyTdb;
 static void PyErr_SetTDBError(TDB_CONTEXT *tdb)
 …
 static PyObject *py_tdb_open(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
         char *name;
+        char *name = NULL;
         int hash_size = 0, tdb_flags = TDB_DEFAULT, flags = O_RDWR, mode = 0600;
         TDB_CONTEXT *ctx;
 …
         const char *kwnames[] = { "name", "hash_size", "tdb_flags", "flags", "mode", NULL };
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|iiii", (char **)kwnames, &name, &hash_size, &tdb_flags, &flags, &mode))
+                return NULL;
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|siiii", (char **)kwnames, &name, &hash_size, &tdb_flags, &flags, &mode))
+                return NULL;
+        if (name == NULL) {
+                tdb_flags |= TDB_INTERNAL;
+        }
         ctx = tdb_open(name, hash_size, tdb_flags, flags, mode);
 …
         ret = PyObject_New(PyTdbObject, &PyTdb);
+        if (!ret) {
+                tdb_close(ctx);
+                return NULL;
+        }
         ret->ctx = ctx;
         ret->closed = false;
 …
+}
 static PyObject *obj_transaction_recover(PyTdbObject *self)
+{
         int ret = tdb_transaction_recover(self->ctx);
+static PyObject *obj_transaction_prepare_commit(PyTdbObject *self)
+{
+        int ret = tdb_transaction_prepare_commit(self->ctx);
         PyErr_TDB_ERROR_IS_ERR_RAISE(ret, self->ctx);
         Py_RETURN_NONE;
 …
+}
+static PyObject *obj_add_flags(PyTdbObject *self, PyObject *args)
+{
+        unsigned flags;
+        if (!PyArg_ParseTuple(args, "I", &flags))
+                return NULL;
+        tdb_add_flags(self->ctx, flags);
+        Py_RETURN_NONE;
+}
+static PyObject *obj_remove_flags(PyTdbObject *self, PyObject *args)
+{
+        unsigned flags;
+        if (!PyArg_ParseTuple(args, "I", &flags))
+                return NULL;
+        tdb_remove_flags(self->ctx, flags);
+        Py_RETURN_NONE;
+}
 typedef struct {
 …
         ret = PyObject_New(PyTdbIteratorObject, &PyTdbIterator);
+        if (!ret)
+                return NULL;
         ret->current = tdb_firstkey(self->ctx);
         ret->iteratee = self;
 …
         int ret = tdb_wipe_all(self->ctx);
         PyErr_TDB_ERROR_IS_ERR_RAISE(ret, self->ctx);
+        Py_RETURN_NONE;
+}
+static PyObject *obj_repack(PyTdbObject *self)
+{
+        int ret = tdb_repack(self->ctx);
+        PyErr_TDB_ERROR_IS_ERR_RAISE(ret, self->ctx);
+        Py_RETURN_NONE;
+}
+static PyObject *obj_enable_seqnum(PyTdbObject *self)
+{
+        tdb_enable_seqnum(self->ctx);
+        Py_RETURN_NONE;
+}
+static PyObject *obj_increment_seqnum_nonblock(PyTdbObject *self)
+{
+        tdb_increment_seqnum_nonblock(self->ctx);
         Py_RETURN_NONE;
+}
 …
                 "S.transaction_commit() -> None\n"
                 "Commit the currently active transaction." },
         { "transaction_recover", (PyCFunction)obj_transaction_recover, METH_NOARGS,
                 "S.transaction_recover() -> None\n"
                 "Recover the currently active transaction." },
+        { "transaction_prepare_commit", (PyCFunction)obj_transaction_prepare_commit, METH_NOARGS,
+                "S.transaction_prepare_commit() -> None\n"
+                "Prepare to commit the currently active transaction" },
         { "transaction_start", (PyCFunction)obj_transaction_start, METH_NOARGS,
                 "S.transaction_start() -> None\n"
 …
         { "store", (PyCFunction)obj_store, METH_VARARGS, "S.store(key, data, flag=REPLACE) -> None"
                 "Store data." },
+        { "add_flags", (PyCFunction)obj_add_flags, METH_VARARGS, "S.add_flags(flags) -> None" },
+        { "remove_flags", (PyCFunction)obj_remove_flags, METH_VARARGS, "S.remove_flags(flags) -> None" },
         { "iterkeys", (PyCFunction)tdb_object_iter, METH_NOARGS, "S.iterkeys() -> iterator" },
         { "clear", (PyCFunction)obj_clear, METH_NOARGS, "S.clear() -> None\n"
                 "Wipe the entire database." },
+        { "repack", (PyCFunction)obj_repack, METH_NOARGS, "S.repack() -> None\n"
+                "Repack the entire database." },
+        { "enable_seqnum", (PyCFunction)obj_enable_seqnum, METH_NOARGS,
+                "S.enable_seqnum() -> None" },
+        { "increment_seqnum_nonblock", (PyCFunction)obj_increment_seqnum_nonblock, METH_NOARGS,
+                "S.increment_seqnum_nonblock() -> None" },
         { NULL }
 };
 …
+}
+static PyObject *obj_get_freelist_size(PyTdbObject *self, void *closure)
+{
+        return PyInt_FromLong(tdb_freelist_size(self->ctx));
+}
 static PyObject *obj_get_flags(PyTdbObject *self, void *closure)
+{
 …
         return PyString_FromString(tdb_name(self->ctx));
+}
+static PyObject *obj_get_seqnum(PyTdbObject *self, void *closure)
+{
+        return PyInt_FromLong(tdb_get_seqnum(self->ctx));
+}
 static PyGetSetDef tdb_object_getsetters[] = {
         { (char *)"hash_size", (getter)obj_get_hash_size, NULL, NULL },
         { (char *)"map_size", (getter)obj_get_map_size, NULL, NULL },
+        { (char *)"freelist_size", (getter)obj_get_freelist_size, NULL, NULL },
         { (char *)"flags", (getter)obj_get_flags, NULL, NULL },
         { (char *)"max_dead", NULL, (setter)obj_set_max_dead, NULL },
         { (char *)"filename", (getter)obj_get_filename, NULL, (char *)"The filename of this TDB file."},
+        { (char *)"seqnum", (getter)obj_get_seqnum, NULL, NULL },
         { NULL }
 };
 …
 static PyObject *tdb_object_repr(PyTdbObject *self)
+{
+        return PyString_FromFormat("Tdb('%s')", tdb_name(self->ctx));
+        if (tdb_get_flags(self->ctx) & TDB_INTERNAL) {
+                return PyString_FromString("Tdb(<internal>)");
+        } else {
+                return PyString_FromFormat("Tdb('%s')", tdb_name(self->ctx));
+        }
+}
 …
         if (!self->closed)
                 tdb_close(self->ctx);
         PyObject_Del(self);
+        self->ob_type->tp_free(self);
+}
 …
         .mp_ass_subscript = (objobjargproc)obj_setitem,
 };
 PyTypeObject PyTdb = {
+static PyTypeObject PyTdb = {
         .tp_name = "Tdb",
         .tp_basicsize = sizeof(PyTdbObject),
 …
 };
+void inittdb(void);
 void inittdb(void)
+{
 …
         PyModule_AddObject(m, "CONVERT", PyInt_FromLong(TDB_CONVERT));
         PyModule_AddObject(m, "BIGENDIAN", PyInt_FromLong(TDB_BIGENDIAN));
+        PyModule_AddObject(m, "NOSYNC", PyInt_FromLong(TDB_NOSYNC));
+        PyModule_AddObject(m, "SEQNUM", PyInt_FromLong(TDB_SEQNUM));
+        PyModule_AddObject(m, "VOLATILE", PyInt_FromLong(TDB_VOLATILE));
+        PyModule_AddObject(m, "ALLOW_NESTING", PyInt_FromLong(TDB_ALLOW_NESTING));
+        PyModule_AddObject(m, "DISALLOW_NESTING", PyInt_FromLong(TDB_DISALLOW_NESTING));
+        PyModule_AddObject(m, "INCOMPATIBLE_HASH", PyInt_FromLong(TDB_INCOMPATIBLE_HASH));
         PyModule_AddObject(m, "__docformat__", PyString_FromString("restructuredText"));
+        PyModule_AddObject(m, "__version__", PyString_FromString(PACKAGE_VERSION));
         Py_INCREF(&PyTdb);

vendor/current/lib/tdb/python/tdbdump.py

r414	r740
1		#!/usr/bin/python
	1	#!/usr/bin/env python
2	2	# Trivial reimplementation of tdbdump in Python
3	3

vendor/current/lib/tdb/python/tests/simple.py

-              r414
+              r740
 #!/usr/bin/python
+#!/usr/bin/env python
 # Some simple tests for the Python bindings for TDB
 # Note that this tests the interface of the Python bindings
 …
 class OpenTdbTests(TestCase):
     def test_nonexistant_read(self):
+        self.assertRaises(IOError, tdb.Tdb, "/some/nonexistant/file", 0, tdb.DEFAULT, os.O_RDWR)
+        self.assertRaises(IOError, tdb.Tdb, "/some/nonexistant/file", 0,
+                tdb.DEFAULT, os.O_RDWR)
 class CloseTdbTests(TestCase):
     def test_double_close(self):
+        self.tdb = tdb.Tdb(tempfile.mkstemp()[1], 0, tdb.DEFAULT, os.O_CREAT|os.O_RDWR)
+        self.tdb = tdb.Tdb(tempfile.mkstemp()[1], 0, tdb.DEFAULT,
+                os.O_CREAT|os.O_RDWR)
         self.assertNotEqual(None, self.tdb)
 …
+class InternalTdbTests(TestCase):
+    def test_repr(self):
+        self.tdb = tdb.Tdb()
+        # repr used to crash on internal db
+        self.assertEquals(repr(self.tdb), "Tdb(<internal>)")
 class SimpleTdbTests(TestCase):
     def setUp(self):
         super(SimpleTdbTests, self).setUp()
+        self.tdb = tdb.Tdb(tempfile.mkstemp()[1], 0, tdb.DEFAULT, os.O_CREAT|os.O_RDWR)
+        self.tdb = tdb.Tdb(tempfile.mkstemp()[1], 0, tdb.DEFAULT,
+                os.O_CREAT|os.O_RDWR)
         self.assertNotEqual(None, self.tdb)
 …
         self.tdb.map_size
+    def test_freelist_size(self):
+        self.tdb.freelist_size
     def test_name(self):
         self.tdb.filename
 …
         self.assertEquals("1", self.tdb["bloe"])
     def test_iterator(self):
+    def test_transaction_prepare_commit(self):
         self.tdb["bloe"] = "2"
+        self.tdb["bla"] = "hoi"
+        i = iter(self.tdb)
+        self.assertEquals(set(["bloe", "bla"]), set([i.next(), i.next()]))
+        self.tdb.transaction_start()
+        self.tdb["bloe"] = "1"
+        self.tdb.transaction_prepare_commit()
+        self.tdb.transaction_commit()
+        self.assertEquals("1", self.tdb["bloe"])
     def test_iterkeys(self):
 …
         self.assertEquals(0, len(list(self.tdb)))
+    def test_repack(self):
+        self.tdb["foo"] = "abc"
+        self.tdb["bar"] = "def"
+        del self.tdb["foo"]
+        self.tdb.repack()
+    def test_seqnum(self):
+        self.tdb.enable_seqnum()
+        seq1 = self.tdb.seqnum
+        self.tdb.increment_seqnum_nonblock()
+        seq2 = self.tdb.seqnum
+        self.assertEquals(seq2-seq1, 1)
     def test_len(self):
         self.assertEquals(0, len(list(self.tdb)))
 …
         self.assertEquals(1, len(list(self.tdb)))
+    def test_add_flags(self):
+        self.tdb.add_flags(tdb.NOMMAP)
+        self.tdb.remove_flags(tdb.NOMMAP)
+class VersionTests(TestCase):
+    def test_present(self):
+        self.assertTrue(isinstance(tdb.__version__, str))
 if __name__ == '__main__':

vendor/current/lib/tdb/tdb.pc.in

r414	r740
7	7	Description: A trivial database
8	8	Version: @PACKAGE_VERSION@
9		Libs: -L${libdir} -ltdb
	9	Libs: @LIB_RPATH@ -L${libdir} -ltdb
10	10	Cflags: -I${includedir}
11	11	URL: http://tdb.samba.org/

vendor/current/lib/tdb/tools/tdbbackup.c

-              r414
+              r740
+        }
+        if (tdb_transaction_start(tdb_new) != 0) {
+                printf("Failed to start transaction on new tdb\n");
+        /* lock the backup tdb so that nobody else can change it */
+        if (tdb_lockall(tdb_new) != 0) {
+                printf("Failed to lock backup tdb\n");
                 tdb_close(tdb);
                 tdb_close(tdb_new);
 …
         tdb_close(tdb);
+        if (tdb_transaction_commit(tdb_new) != 0) {
+                fprintf(stderr, "Failed to commit new tdb\n");
+                tdb_close(tdb_new);
+                unlink(tmp_name);
+                free(tmp_name);
+                return 1;
+        /* copy done, unlock the backup tdb */
+        tdb_unlockall(tdb_new);
+#ifdef HAVE_FDATASYNC
+        if (fdatasync(tdb_fd(tdb_new)) != 0) {
+#else
+        if (fsync(tdb_fd(tdb_new)) != 0) {
+#endif
+                /* not fatal */
+                fprintf(stderr, "failed to fsync backup file\n");
+        }

vendor/current/lib/tdb/tools/tdbtest.c

-              r414
+              r740
+}
+static char *test_path(const char *filename)
+{
+        const char *prefix = getenv("TEST_DATA_PREFIX");
+        if (prefix) {
+                char *path = NULL;
+                int ret;
+                ret = asprintf(&path, "%s/%s", prefix, filename);
+                if (ret == -1) {
+                        return NULL;
+                }
+                return path;
+        }
+        return strdup(filename);
+}
  int main(int argc, const char *argv[])
+{
 …
         int loops = 10000;
         int num_entries;
+        char test_gdbm[] = "test.gdbm";
+        unlink("test.gdbm");
+        db = tdb_open("test.tdb", 0, TDB_CLEAR_IF_FIRST,
+        char test_gdbm[1] = "test.gdbm";
+        char *test_tdb;
+        test_gdbm[0] = test_path("test.gdbm");
+        test_tdb = test_path("test.tdb");
+        unlink(test_gdbm[0]);
+        db = tdb_open(test_tdb, 0, TDB_CLEAR_IF_FIRST,
                       O_RDWR | O_CREAT | O_TRUNC, 0600);
         gdbm = gdbm_open(test_gdbm, 512, GDBM_WRITER|GDBM_NEWDB|GDBM_FAST,
 …
         gdbm_close(gdbm);
+        free(test_gdbm[0]);
+        free(test_tdb);
         return 0;
+}

vendor/current/lib/tdb/tools/tdbtool.c

-              r414
+              r740
 static void info_tdb(void)
+{
         int count;
+        total_bytes = 0;
         if ((count = tdb_traverse(tdb, traverse_fn, NULL)) == -1)
+        char *summary = tdb_summary(tdb);
+        if (!summary) {
                 printf("Error = %s\n", tdb_errorstr(tdb));
+        else
+                printf("%d records totalling %d bytes\n", count, total_bytes);
+        } else {
+                printf("%s", summary);
+                free(summary);
+        }
+}

vendor/current/lib/tdb/tools/tdbtorture.c

-              r414
+              r740
 static int error_count;
 static int always_transaction = 0;
+static int hash_size = 2;
+static int loopnum;
+static int count_pipe;
+static struct tdb_logging_context log_ctx;
 #ifdef PRINTF_ATTRIBUTE
 …
         fflush(stdout);
 #if 0
+        {
+        if (level != TDB_DEBUG_TRACE) {
                 char *ptr;
+                signal(SIGUSR1, SIG_IGN);
                 asprintf(&ptr,"xterm -e gdb /proc/%d/exe %d", getpid(), getpid());
                 system(ptr);
 …
 static void usage(void)
+{
         printf("Usage: tdbtorture [-t] [-n NUM_PROCS] [-l NUM_LOOPS] [-s SEED] [-H HASH_SIZE]\n");
+        printf("Usage: tdbtorture [-t] [-k] [-n NUM_PROCS] [-l NUM_LOOPS] [-s SEED] [-H HASH_SIZE]\n");
         exit(0);
+}
+ int main(int argc, char * const *argv)
+{
+        int i, seed = -1;
+        int num_procs = 3;
+        int num_loops = 5000;
+        int hash_size = 2;
+        int c;
+        extern char *optarg;
+        pid_t *pids;
+        struct tdb_logging_context log_ctx;
+        log_ctx.log_fn = tdb_log;
+        while ((c = getopt(argc, argv, "n:l:s:H:th")) != -1) {
+                switch (c) {
+                case 'n':
+                        num_procs = strtol(optarg, NULL, 0);
+                        break;
+                case 'l':
+                        num_loops = strtol(optarg, NULL, 0);
+                        break;
+                case 'H':
+                        hash_size = strtol(optarg, NULL, 0);
+                        break;
+                case 's':
+                        seed = strtol(optarg, NULL, 0);
+                        break;
+                case 't':
+                        always_transaction = 1;
+                        break;
+                default:
+                        usage();
+                }
+        }
+        unlink("torture.tdb");
+        pids = (pid_t *)calloc(sizeof(pid_t), num_procs);
+        pids[0] = getpid();
+        for (i=0;i<num_procs-1;i++) {
+                if ((pids[i+1]=fork()) == 0) break;
+        }
+        db = tdb_open_ex("torture.tdb", hash_size, TDB_CLEAR_IF_FIRST,
+static void send_count_and_suicide(int sig)
+{
+        /* This ensures our successor can continue where we left off. */
+        write(count_pipe, &loopnum, sizeof(loopnum));
+        /* This gives a unique signature. */
+        kill(getpid(), SIGUSR2);
+}
+static int run_child(const char *filename, int i, int seed, unsigned num_loops, unsigned start)
+{
+        db = tdb_open_ex(filename, hash_size, TDB_DEFAULT,
                          O_RDWR | O_CREAT, 0600, &log_ctx, NULL);
         if (!db) {
 …
+        }
-        if (seed == -1) {
-                seed = (getpid() + time(NULL)) & 0x7FFFFFFF;
+        }
-        if (i == 0) {
-                printf("testing with %d processes, %d loops, %d hash_size, seed=%d%s\n",
-                       num_procs, num_loops, hash_size, seed, always_transaction ? " (all within transactions)" : "");
+        }
         srand(seed + i);
         srandom(seed + i);
+        for (i=0;i<num_loops && error_count == 0;i++) {
+        /* Set global, then we're ready to handle being killed. */
+        loopnum = start;
+        signal(SIGUSR1, send_count_and_suicide);
+        for (;loopnum<num_loops && error_count == 0;loopnum++) {
                 addrec_db();
+        }
 …
         tdb_close(db);
+        if (getpid() != pids[0]) {
+                return error_count;
+        }
+        for (i=1;i<num_procs;i++) {
+        return (error_count < 100 ? error_count : 100);
+}
+static char *test_path(const char *filename)
+{
+        const char *prefix = getenv("TEST_DATA_PREFIX");
+        if (prefix) {
+                char *path = NULL;
+                int ret;
+                ret = asprintf(&path, "%s/%s", prefix, filename);
+                if (ret == -1) {
+                        return NULL;
+                }
+                return path;
+        }
+        return strdup(filename);
+}
+int main(int argc, char * const *argv)
+{
+        int i, seed = -1;
+        int num_loops = 5000;
+        int num_procs = 3;
+        int c, pfds[2];
+        extern char *optarg;
+        pid_t *pids;
+        int kill_random = 0;
+        int *done;
+        char *test_tdb;
+        log_ctx.log_fn = tdb_log;
+        while ((c = getopt(argc, argv, "n:l:s:H:thk")) != -1) {
+                switch (c) {
+                case 'n':
+                        num_procs = strtol(optarg, NULL, 0);
+                        break;
+                case 'l':
+                        num_loops = strtol(optarg, NULL, 0);
+                        break;
+                case 'H':
+                        hash_size = strtol(optarg, NULL, 0);
+                        break;
+                case 's':
+                        seed = strtol(optarg, NULL, 0);
+                        break;
+                case 't':
+                        always_transaction = 1;
+                        break;
+                case 'k':
+                        kill_random = 1;
+                        break;
+                default:
+                        usage();
+                }
+        }
+        test_tdb = test_path("torture.tdb");
+        unlink(test_tdb);
+        if (seed == -1) {
+                seed = (getpid() + time(NULL)) & 0x7FFFFFFF;
+        }
+        if (num_procs == 1 && !kill_random) {
+                /* Don't fork for this case, makes debugging easier. */
+                error_count = run_child(test_tdb, 0, seed, num_loops, 0);
+                goto done;
+        }
+        pids = (pid_t *)calloc(sizeof(pid_t), num_procs);
+        done = (int *)calloc(sizeof(int), num_procs);
+        if (pipe(pfds) != 0) {
+                perror("Creating pipe");
+                exit(1);
+        }
+        count_pipe = pfds[1];
+        for (i=0;i<num_procs;i++) {
+                if ((pids[i]=fork()) == 0) {
+                        close(pfds[0]);
+                        if (i == 0) {
+                                printf("Testing with %d processes, %d loops, %d hash_size, seed=%d%s\n",
+                                       num_procs, num_loops, hash_size, seed, always_transaction ? " (all within transactions)" : "");
+                        }
+                        exit(run_child(test_tdb, i, seed, num_loops, 0));
+                }
+        }
+        while (num_procs) {
                 int status, j;
                 pid_t pid;
                 if (error_count != 0) {
                         /* try and stop the test on any failure */
                         for (j=1;j<num_procs;j++) {
+                        for (j=0;j<num_procs;j++) {
                                 if (pids[j] != 0) {
                                         kill(pids[j], SIGTERM);
 …
+                        }
+                }
+                pid = waitpid(-1, &status, 0);
+                pid = waitpid(-1, &status, kill_random ? WNOHANG : 0);
+                if (pid == 0) {
+                        struct timeval tv;
+                        /* Sleep for 1/10 second. */
+                        tv.tv_sec = 0;
+                        tv.tv_usec = 100000;
+                        select(0, NULL, NULL, NULL, &tv);
+                        /* Kill someone. */
+                        kill(pids[random() % num_procs], SIGUSR1);
+                        continue;
+                }
                 if (pid == -1) {
                         perror("failed to wait for child\n");
                         exit(1);
+                }
+                for (j=1;j<num_procs;j++) {
+                for (j=0;j<num_procs;j++) {
                         if (pids[j] == pid) break;
+                }
 …
                         exit(1);
+                }
+                if (WEXITSTATUS(status) != 0) {
+                        printf("child %d exited with status %d\n",
+                               (int)pid, WEXITSTATUS(status));
+                if (WIFSIGNALED(status)) {
+                        if (WTERMSIG(status) == SIGUSR2
+                            || WTERMSIG(status) == SIGUSR1) {
+                                /* SIGUSR2 means they wrote to pipe. */
+                                if (WTERMSIG(status) == SIGUSR2) {
+                                        read(pfds[0], &done[j],
+                                             sizeof(done[j]));
+                                }
+                                pids[j] = fork();
+                                if (pids[j] == 0)
+                                        exit(run_child(test_tdb, j, seed,
+                                                       num_loops, done[j]));
+                                printf("Restarting child %i for %u-%u\n",
+                                       j, done[j], num_loops);
+                                continue;
+                        }
+                        printf("child %d exited with signal %d\n",
+                               (int)pid, WTERMSIG(status));
                         error_count++;
+                }
+                pids[j] = 0;
+                } else {
+                        if (WEXITSTATUS(status) != 0) {
+                                printf("child %d exited with status %d\n",
+                                       (int)pid, WEXITSTATUS(status));
+                                error_count++;
+                        }
+                }
+                memmove(&pids[j], &pids[j+1],
+                        (num_procs - j - 1)*sizeof(pids[0]));
+                num_procs--;
+        }
         free(pids);
+done:
         if (error_count == 0) {
+                db = tdb_open_ex(test_tdb, hash_size, TDB_DEFAULT,
+                                 O_RDWR, 0, &log_ctx, NULL);
+                if (!db) {
+                        fatal("db open failed");
+                }
+                if (tdb_check(db, NULL, NULL) == -1) {
+                        printf("db check failed");
+                        exit(1);
+                }
+                tdb_close(db);
                 printf("OK\n");
+        }
+        free(test_tdb);
         return error_count;
+}

vendor/current/lib/tdr/tdr.c

-              r414
+              r740
         TDR_PULL_NEED_BYTES(tdr, el_size*length);
         if (!convert_string_talloc_convenience(ctx, tdr->iconv_convenience, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v), &ret, false)) {
+        if (!convert_string_talloc(ctx, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, discard_const_p(void *, v), &ret, false)) {
                 return NT_STATUS_INVALID_PARAMETER;
+        }
 …
         TDR_PUSH_NEED_BYTES(tdr, required);
+        if (!convert_string_convenience(tdr->iconv_convenience, CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required, &ret, false)) {
+        ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required, false);
+        if (ret == -1) {
                 return NT_STATUS_INVALID_PARAMETER;
+        }
 …
+}
 struct tdr_push *tdr_push_init(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic)
+struct tdr_push *tdr_push_init(TALLOC_CTX *mem_ctx)
+{
         struct tdr_push *push = talloc_zero(mem_ctx, struct tdr_push);
 …
                 return NULL;
-        push->iconv_convenience = talloc_reference(push, ic);
         return push;
+}
 struct tdr_pull *tdr_pull_init(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *ic)
+struct tdr_pull *tdr_pull_init(TALLOC_CTX *mem_ctx)
+{
         struct tdr_pull *pull = talloc_zero(mem_ctx, struct tdr_pull);
 …
                 return NULL;
-        pull->iconv_convenience = talloc_reference(pull, ic);
         return pull;
+}
 NTSTATUS tdr_push_to_fd(int fd, struct smb_iconv_convenience *iconv_convenience, tdr_push_fn_t push_fn, const void *p)
+{
         struct tdr_push *push = tdr_push_init(NULL, iconv_convenience);
+NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p)
+{
+        struct tdr_push *push = tdr_push_init(NULL);
         if (push == NULL)
 …
+}
 void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...) _PRINTF_ATTRIBUTE(2,3)
+void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...)
+{
         va_list ap;

vendor/current/lib/tdr/tdr.h

-              r414
+              r740
    TDR definitions
    Copyright (C) Jelmer Vernooij 2005
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
         uint32_t offset;
         int flags;
-        struct smb_iconv_convenience *iconv_convenience;
 };
 …
         DATA_BLOB data;
         int flags;
-        struct smb_iconv_convenience *iconv_convenience;
 };
 …
 typedef NTSTATUS (*tdr_pull_fn_t) (struct tdr_pull *, TALLOC_CTX *, void *);
+#include "../lib/tdr/tdr_proto.h"
+NTSTATUS tdr_push_expand(struct tdr_push *tdr, uint32_t size);
+NTSTATUS tdr_pull_uint8(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint8_t *v);
+NTSTATUS tdr_push_uint8(struct tdr_push *tdr, const uint8_t *v);
+NTSTATUS tdr_print_uint8(struct tdr_print *tdr, const char *name, uint8_t *v);
+NTSTATUS tdr_pull_uint16(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v);
+NTSTATUS tdr_pull_uint1632(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v);
+NTSTATUS tdr_push_uint16(struct tdr_push *tdr, const uint16_t *v);
+NTSTATUS tdr_push_uint1632(struct tdr_push *tdr, const uint16_t *v);
+NTSTATUS tdr_print_uint16(struct tdr_print *tdr, const char *name, uint16_t *v);
+NTSTATUS tdr_pull_uint32(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint32_t *v);
+NTSTATUS tdr_push_uint32(struct tdr_push *tdr, const uint32_t *v);
+NTSTATUS tdr_print_uint32(struct tdr_print *tdr, const char *name, uint32_t *v);
+NTSTATUS tdr_pull_charset(struct tdr_pull *tdr, TALLOC_CTX *ctx, const char **v, uint32_t length, uint32_t el_size, charset_t chset);
+NTSTATUS tdr_push_charset(struct tdr_push *tdr, const char **v, uint32_t length, uint32_t el_size, charset_t chset);
+NTSTATUS tdr_print_charset(struct tdr_print *tdr, const char *name, const char **v, uint32_t length, uint32_t el_size, charset_t chset);
+NTSTATUS tdr_pull_hyper(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint64_t *v);
+NTSTATUS tdr_push_hyper(struct tdr_push *tdr, uint64_t *v);
+NTSTATUS tdr_push_NTTIME(struct tdr_push *tdr, NTTIME *t);
+NTSTATUS tdr_pull_NTTIME(struct tdr_pull *tdr, TALLOC_CTX *ctx, NTTIME *t);
+NTSTATUS tdr_print_NTTIME(struct tdr_print *tdr, const char *name, NTTIME *t);
+NTSTATUS tdr_push_time_t(struct tdr_push *tdr, time_t *t);
+NTSTATUS tdr_pull_time_t(struct tdr_pull *tdr, TALLOC_CTX *ctx, time_t *t);
+NTSTATUS tdr_print_time_t(struct tdr_print *tdr, const char *name, time_t *t);
+NTSTATUS tdr_print_DATA_BLOB(struct tdr_print *tdr, const char *name, DATA_BLOB *r);
+NTSTATUS tdr_push_DATA_BLOB(struct tdr_push *tdr, DATA_BLOB *blob);
+NTSTATUS tdr_pull_DATA_BLOB(struct tdr_pull *tdr, TALLOC_CTX *ctx, DATA_BLOB *blob);
+struct tdr_push *tdr_push_init(TALLOC_CTX *mem_ctx);
+struct tdr_pull *tdr_pull_init(TALLOC_CTX *mem_ctx);
+NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p);
+void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 #endif /* __TDR_H__ */

vendor/current/lib/tdr/testsuite.c

-              r414
+              r740
+{
         uint8_t v = 4;
         struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+        struct tdr_push *tdr = tdr_push_init(tctx);
         torture_assert_ntstatus_ok(tctx, tdr_push_uint8(tdr, &v), "push failed");
 …
         uint8_t d = 2;
         uint8_t l;
         struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+        struct tdr_pull *tdr = tdr_pull_init(tctx);
         tdr->data.data = &d;
         tdr->data.length = 1;
 …
+{
         uint16_t v = 0xF32;
         struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+        struct tdr_push *tdr = tdr_push_init(tctx);
         torture_assert_ntstatus_ok(tctx, tdr_push_uint16(tdr, &v), "push failed");
 …
         uint8_t d[2] = { 782 & 0xFF, (782 & 0xFF00) / 0x100 };
         uint16_t l;
         struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+        struct tdr_pull *tdr = tdr_pull_init(tctx);
         tdr->data.data = d;
         tdr->data.length = 2;
 …
+{
         uint32_t v = 0x100F32;
         struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+        struct tdr_push *tdr = tdr_push_init(tctx);
         torture_assert_ntstatus_ok(tctx, tdr_push_uint32(tdr, &v), "push failed");
 …
         uint8_t d[4] = { 782 & 0xFF, (782 & 0xFF00) / 0x100, 0, 0 };
         uint32_t l;
         struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+        struct tdr_pull *tdr = tdr_pull_init(tctx);
         tdr->data.data = d;
         tdr->data.length = 4;
 …
 static bool test_pull_charset(struct torture_context *tctx)
+{
         struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+        struct tdr_pull *tdr = tdr_pull_init(tctx);
         const char *l = NULL;
         tdr->data.data = (uint8_t *)talloc_strdup(tctx, "bla");
 …
 static bool test_pull_charset_empty(struct torture_context *tctx)
+{
         struct tdr_pull *tdr = tdr_pull_init(tctx, global_iconv_convenience);
+        struct tdr_pull *tdr = tdr_pull_init(tctx);
         const char *l = NULL;
         tdr->data.data = (uint8_t *)talloc_strdup(tctx, "bla");
 …
+{
         const char *l = "bloe";
         struct tdr_push *tdr = tdr_push_init(tctx, global_iconv_convenience);
+        struct tdr_push *tdr = tdr_push_init(tctx);
         torture_assert_ntstatus_ok(tctx, tdr_push_charset(tdr, &l, 4, 1, CH_UTF8),
                                                            "push failed");
         torture_assert_int_equal(tctx, 4, tdr->data.length, "offset invalid");
         torture_assert(tctx, strcmp("bloe", (const char *)tdr->data.data) == 0, "right string push");
+        torture_assert(tctx, strncmp("bloe", (const char *)tdr->data.data, 4) == 0, "right string push");
         torture_assert_ntstatus_ok(tctx, tdr_push_charset(tdr, &l, -1, 1, CH_UTF8),
 …
 struct torture_suite *torture_local_tdr(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "TDR");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "tdr");
         torture_suite_add_simple_test(suite, "pull_uint8", test_pull_uint8);

vendor/current/lib/tevent/libtevent.m4

r414	r740
31	31	TEVENT_OBJ="$TEVENT_OBJ tevent_req.o tevent_wakeup.o tevent_queue.o"
32	32	TEVENT_OBJ="$TEVENT_OBJ tevent_standard.o tevent_select.o"
	33	TEVENT_OBJ="$TEVENT_OBJ tevent_poll.o"
33	34
34	35	AC_CHECK_HEADERS(sys/epoll.h)

vendor/current/lib/tevent/testsuite.c

r618	r740
149	149	struct torture_suite torture_local_event(TALLOC_CTX mem_ctx)
150	150	{
151		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~EVENT~~");
	151	struct torture_suite *suite = torture_suite_create(mem_ctx, "event");
152	152	const char **list = event_backend_list(suite);
153	153	int i;

vendor/current/lib/tevent/tevent.c

-              r427
+              r740
+        }
         e = talloc(talloc_autofree_context(), struct tevent_ops_list);
+        e = talloc(NULL, struct tevent_ops_list);
         if (e == NULL) return false;
 …
+{
         talloc_free(tevent_default_backend);
+        tevent_default_backend = talloc_strdup(talloc_autofree_context(),
+                                               backend);
+        tevent_default_backend = talloc_strdup(NULL, backend);
+}
 …
+{
         tevent_select_init();
+        tevent_poll_init();
         tevent_standard_init();
 #ifdef HAVE_EPOLL
 …
   add a fd based event
   return NULL on failure (memory allocation error)
-  if flags contains TEVENT_FD_AUTOCLOSE then the fd will be closed when
-  the returned fd_event context is freed
 */
 struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
 …
         return ev->ops->loop_wait(ev, location);
+}
+/*
+  re-initialise a tevent context. This leaves you with the same
+  event context, but all events are wiped and the structure is
+  re-initialised. This is most useful after a fork()
+  zero is returned on success, non-zero on failure
+*/
+int tevent_re_initialise(struct tevent_context *ev)
+{
+        tevent_common_context_destructor(ev);
+        return ev->ops->context_init(ev);
+}

vendor/current/lib/tevent/tevent.h

-              r414
+              r740
 struct tevent_signal;
+/**
+ * @defgroup tevent The tevent API
+ *
+ * The tevent low-level API
+ *
+ * This API provides the public interface to manage events in the tevent
+ * mainloop. Functions are provided for managing low-level events such
+ * as timer events, fd events and signal handling.
+ *
+ * @{
+ */
 /* event handler types */
+/**
+ * Called when a file descriptor monitored by tevent has
+ * data to be read or written on it.
+ */
 typedef void (*tevent_fd_handler_t)(struct tevent_context *ev,
                                     struct tevent_fd *fde,
                                     uint16_t flags,
                                     void *private_data);
+/**
+ * Called when tevent is ceasing the monitoring of a file descriptor.
+ */
 typedef void (*tevent_fd_close_fn_t)(struct tevent_context *ev,
                                      struct tevent_fd *fde,
                                      int fd,
                                      void *private_data);
+/**
+ * Called when a tevent timer has fired.
+ */
 typedef void (*tevent_timer_handler_t)(struct tevent_context *ev,
                                        struct tevent_timer *te,
                                        struct timeval current_time,
                                        void *private_data);
+/**
+ * Called when a tevent immediate event is invoked.
+ */
 typedef void (*tevent_immediate_handler_t)(struct tevent_context *ctx,
                                            struct tevent_immediate *im,
                                            void *private_data);
+/**
+ * Called after tevent detects the specified signal.
+ */
 typedef void (*tevent_signal_handler_t)(struct tevent_context *ev,
                                         struct tevent_signal *se,
 …
                                         void *private_data);
+/**
+ * @brief Create a event_context structure.
+ *
+ * This must be the first events call, and all subsequent calls pass this
+ * event_context as the first element. Event handlers also receive this as
+ * their first argument.
+ *
+ * @param[in]  mem_ctx  The memory context to use.
+ *
+ * @return              An allocated tevent context, NULL on error.
+ *
+ * @see tevent_context_init()
+ */
 struct tevent_context *tevent_context_init(TALLOC_CTX *mem_ctx);
+/**
+ * @brief Create a event_context structure and name it.
+ *
+ * This must be the first events call, and all subsequent calls pass this
+ * event_context as the first element. Event handlers also receive this as
+ * their first argument.
+ *
+ * @param[in]  mem_ctx  The memory context to use.
+ *
+ * @param[in]  name     The name for the tevent context.
+ *
+ * @return              An allocated tevent context, NULL on error.
+ */
 struct tevent_context *tevent_context_init_byname(TALLOC_CTX *mem_ctx, const char *name);
+/**
+ * @brief List available backends.
+ *
+ * @param[in]  mem_ctx  The memory context to use.
+ *
+ * @return              A string vector with a terminating NULL element, NULL
+ *                      on error.
+ */
 const char **tevent_backend_list(TALLOC_CTX *mem_ctx);
+/**
+ * @brief Set the default tevent backent.
+ *
+ * @param[in]  backend  The name of the backend to set.
+ */
 void tevent_set_default_backend(const char *backend);
+#ifdef DOXYGEN
+/**
+ * @brief Add a file descriptor based event.
+ *
+ * @param[in]  ev       The event context to work on.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  fd       The file descriptor to base the event on.
+ *
+ * @param[in]  flags    #TEVENT_FD_READ or #TEVENT_FD_WRITE
+ *
+ * @param[in]  handler  The callback handler for the event.
+ *
+ * @param[in]  private_data  The private data passed to the callback handler.
+ *
+ * @return              The file descriptor based event, NULL on error.
+ *
+ * @note To cancel the monitoring of a file descriptor, call talloc_free()
+ * on the object returned by this function.
+ */
+struct tevent_fd *tevent_add_fd(struct tevent_context *ev,
+                                TALLOC_CTX *mem_ctx,
+                                int fd,
+                                uint16_t flags,
+                                tevent_fd_handler_t handler,
+                                void *private_data);
+#else
 struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
                                  TALLOC_CTX *mem_ctx,
 …
         _tevent_add_fd(ev, mem_ctx, fd, flags, handler, private_data, \
                        #handler, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Add a timed event
+ *
+ * @param[in]  ev       The event context to work on.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  next_event  Timeval specifying the absolute time to fire this
+ * event. This is not an offset.
+ *
+ * @param[in]  handler  The callback handler for the event.
+ *
+ * @param[in]  private_data  The private data passed to the callback handler.
+ *
+ * @return The newly-created timer event, or NULL on error.
+ *
+ * @note To cancel a timer event before it fires, call talloc_free() on the
+ * event returned from this function. This event is automatically
+ * talloc_free()-ed after its event handler files, if it hasn't been freed yet.
+ *
+ * @note Unlike some mainloops, tevent timers are one-time events. To set up
+ * a recurring event, it is necessary to call tevent_add_timer() again during
+ * the handler processing.
+ *
+ * @note Due to the internal mainloop processing, a timer set to run
+ * immediately will do so after any other pending timers fire, but before
+ * any further file descriptor or signal handling events fire. Callers should
+ * not rely on this behavior!
+ */
+struct tevent_timer *tevent_add_timer(struct tevent_context *ev,
+                                      TALLOC_CTX *mem_ctx,
+                                      struct timeval next_event,
+                                      tevent_timer_handler_t handler,
+                                      void *private_data);
+#else
 struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
                                        TALLOC_CTX *mem_ctx,
 …
         _tevent_add_timer(ev, mem_ctx, next_event, handler, private_data, \
                           #handler, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * Initialize an immediate event object
+ *
+ * This object can be used to trigger an event to occur immediately after
+ * returning from the current event (before any other event occurs)
+ *
+ * @param[in] mem_ctx  The talloc memory context to use as the parent
+ *
+ * @return An empty tevent_immediate object. Use tevent_schedule_immediate
+ * to populate and use it.
+ *
+ * @note Available as of tevent 0.9.8
+ */
+struct tevent_immediate *tevent_create_immediate(TALLOC_CTX *mem_ctx);
+#else
 struct tevent_immediate *_tevent_create_immediate(TALLOC_CTX *mem_ctx,
                                                   const char *location);
 #define tevent_create_immediate(mem_ctx) \
         _tevent_create_immediate(mem_ctx, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * Schedule an event for immediate execution. This event will occur
+ * immediately after returning from the current event (before any other
+ * event occurs)
+ *
+ * @param[in] im       The tevent_immediate object to populate and use
+ * @param[in] ctx      The tevent_context to run this event
+ * @param[in] handler  The event handler to run when this event fires
+ * @param[in] private_data  Data to pass to the event handler
+ */
+void tevent_schedule_immediate(struct tevent_immediate *im,
+                struct tevent_context *ctx,
+                tevent_immediate_handler_t handler,
+                void *private_data);
+#else
 void _tevent_schedule_immediate(struct tevent_immediate *im,
                                 struct tevent_context *ctx,
 …
         _tevent_schedule_immediate(im, ctx, handler, private_data, \
                                    #handler, __location__);
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Add a tevent signal handler
+ *
+ * tevent_add_signal() creates a new event for handling a signal the next
+ * time through the mainloop. It implements a very simple traditional signal
+ * handler whose only purpose is to add the handler event into the mainloop.
+ *
+ * @param[in]  ev       The event context to work on.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  signum   The signal to trap
+ *
+ * @param[in]  handler  The callback handler for the signal.
+ *
+ * @param[in]  sa_flags sigaction flags for this signal handler.
+ *
+ * @param[in]  private_data  The private data passed to the callback handler.
+ *
+ * @return The newly-created signal handler event, or NULL on error.
+ *
+ * @note To cancel a signal handler, call talloc_free() on the event returned
+ * from this function.
+ */
+struct tevent_signal *tevent_add_signal(struct tevent_context *ev,
+                     TALLOC_CTX *mem_ctx,
+                     int signum,
+                     int sa_flags,
+                     tevent_signal_handler_t handler,
+                     void *private_data);
+#else
 struct tevent_signal *_tevent_add_signal(struct tevent_context *ev,
                                          TALLOC_CTX *mem_ctx,
 …
         _tevent_add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data, \
                            #handler, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Pass a single time through the mainloop
+ *
+ * This will process any appropriate signal, immediate, fd and timer events
+ *
+ * @param[in]  ev The event context to process
+ *
+ * @return Zero on success, nonzero if an internal error occurred
+ */
+int tevent_loop_once(struct tevent_context *ev);
+#else
 int _tevent_loop_once(struct tevent_context *ev, const char *location);
 #define tevent_loop_once(ev) \
+        _tevent_loop_once(ev, __location__) \
+        _tevent_loop_once(ev, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Run the mainloop
+ *
+ * The mainloop will run until there are no events remaining to be processed
+ *
+ * @param[in]  ev The event context to process
+ *
+ * @return Zero if all events have been processed. Nonzero if an internal
+ * error occurred.
+ */
+int tevent_loop_wait(struct tevent_context *ev);
+#else
 int _tevent_loop_wait(struct tevent_context *ev, const char *location);
 #define tevent_loop_wait(ev) \
+        _tevent_loop_wait(ev, __location__) \
+        _tevent_loop_wait(ev, __location__)
+#endif
+/**
+ * Assign a function to run when a tevent_fd is freed
+ *
+ * This function is a destructor for the tevent_fd. It does not automatically
+ * close the file descriptor. If this is the desired behavior, then it must be
+ * performed by the close_fn.
+ *
+ * @param[in] fde       File descriptor event on which to set the destructor
+ * @param[in] close_fn  Destructor to execute when fde is freed
+ */
 void tevent_fd_set_close_fn(struct tevent_fd *fde,
                             tevent_fd_close_fn_t close_fn);
+/**
+ * Automatically close the file descriptor when the tevent_fd is freed
+ *
+ * This function calls close(fd) internally.
+ *
+ * @param[in] fde  File descriptor event to auto-close
+ */
 void tevent_fd_set_auto_close(struct tevent_fd *fde);
+/**
+ * Return the flags set on this file descriptor event
+ *
+ * @param[in] fde  File descriptor event to query
+ *
+ * @return The flags set on the event. See #TEVENT_FD_READ and
+ * #TEVENT_FD_WRITE
+ */
 uint16_t tevent_fd_get_flags(struct tevent_fd *fde);
+/**
+ * Set flags on a file descriptor event
+ *
+ * @param[in] fde    File descriptor event to set
+ * @param[in] flags  Flags to set on the event. See #TEVENT_FD_READ and
+ * #TEVENT_FD_WRITE
+ */
 void tevent_fd_set_flags(struct tevent_fd *fde, uint16_t flags);
+/**
+ * Query whether tevent supports signal handling
+ *
+ * @param[in] ev  An initialized tevent context
+ *
+ * @return True if this platform and tevent context support signal handling
+ */
 bool tevent_signal_support(struct tevent_context *ev);
 …
 /* bits for file descriptor event flags */
+/**
+ * Monitor a file descriptor for write availability
+ */
 #define TEVENT_FD_READ 1
+/**
+ * Monitor a file descriptor for data to be read
+ */
 #define TEVENT_FD_WRITE 2
+/**
+ * Convenience function for declaring a tevent_fd writable
+ */
 #define TEVENT_FD_WRITEABLE(fde) \
         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) | TEVENT_FD_WRITE)
+/**
+ * Convenience function for declaring a tevent_fd readable
+ */
 #define TEVENT_FD_READABLE(fde) \
         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) | TEVENT_FD_READ)
+/**
+ * Convenience function for declaring a tevent_fd non-writable
+ */
 #define TEVENT_FD_NOT_WRITEABLE(fde) \
         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) & ~TEVENT_FD_WRITE)
+/**
+ * Convenience function for declaring a tevent_fd non-readable
+ */
 #define TEVENT_FD_NOT_READABLE(fde) \
         tevent_fd_set_flags(fde, tevent_fd_get_flags(fde) & ~TEVENT_FD_READ)
+/* DEBUG */
+/**
+ * Debug level of tevent
+ */
 enum tevent_debug_level {
         TEVENT_DEBUG_FATAL,
 …
 };
+/**
+ * @brief The tevent debug callbac.
+ *
+ * @param[in]  context  The memory context to use.
+ *
+ * @param[in]  level    The debug level.
+ *
+ * @param[in]  fmt      The format string.
+ *
+ * @param[in]  ap       The arguments for the format string.
+ */
+typedef void (*tevent_debug_fn)(void *context,
+                                enum tevent_debug_level level,
+                                const char *fmt,
+                                va_list ap) PRINTF_ATTRIBUTE(3,0);
+/**
+ * Set destination for tevent debug messages
+ *
+ * @param[in] ev        Event context to debug
+ * @param[in] debug     Function to handle output printing
+ * @param[in] context   The context to pass to the debug function.
+ *
+ * @return Always returns 0 as of version 0.9.8
+ *
+ * @note Default is to emit no debug messages
+ */
 int tevent_set_debug(struct tevent_context *ev,
+                     void (*debug)(void *context,
+                                   enum tevent_debug_level level,
+                                   const char *fmt,
+                                   va_list ap) PRINTF_ATTRIBUTE(3,0),
+                     tevent_debug_fn debug,
                      void *context);
+/**
+ * Designate stderr for debug message output
+ *
+ * @param[in] ev     Event context to debug
+ *
+ * @note This function will only output TEVENT_DEBUG_FATAL, TEVENT_DEBUG_ERROR
+ * and TEVENT_DEBUG_WARNING messages. For TEVENT_DEBUG_TRACE, please define a
+ * function for tevent_set_debug()
+ */
 int tevent_set_debug_stderr(struct tevent_context *ev);
 /**
+ * An async request moves between the following 4 states:
+ * @}
+ */
+/**
+ * @defgroup tevent_request The tevent request functions.
+ * @ingroup tevent
+ *
+ * A tevent_req represents an asynchronous computation.
+ *
+ * The tevent_req group of API calls is the recommended way of
+ * programming async computations within tevent. In particular the
+ * file descriptor (tevent_add_fd) and timer (tevent_add_timed) events
+ * are considered too low-level to be used in larger computations. To
+ * read and write from and to sockets, Samba provides two calls on top
+ * of tevent_add_fd: read_packet_send/recv and writev_send/recv. These
+ * requests are much easier to compose than the low-level event
+ * handlers called from tevent_add_fd.
+ *
+ * A lot of the simplicity tevent_req has brought to the notoriously
+ * hairy async programming came via a set of conventions that every
+ * async computation programmed should follow. One central piece of
+ * these conventions is the naming of routines and variables.
+ *
+ * Every async computation needs a name (sensibly called "computation"
+ * down from here). From this name quite a few naming conventions are
+ * derived.
+ *
+ * Every computation that requires local state needs a
+ * @code
+ * struct computation_state {
+ *     int local_var;
+ * };
+ * @endcode
+ * Even if no local variables are required, such a state struct should
+ * be created containing a dummy variable. Quite a few helper
+ * functions and macros (for example tevent_req_create()) assume such
+ * a state struct.
+ *
+ * An async computation is started by a computation_send
+ * function. When it is finished, its result can be received by a
+ * computation_recv function. For an example how to set up an async
+ * computation, see the code example in the documentation for
+ * tevent_req_create() and tevent_req_post(). The prototypes for _send
+ * and _recv functions should follow some conventions:
+ *
+ * @code
+ * struct tevent_req *computation_send(TALLOC_CTX *mem_ctx,
+ *                                     struct tevent_req *ev,
+ *                                     ... further args);
+ * int computation_recv(struct tevent_req *req, ... further output args);
+ * @endcode
+ *
+ * The "int" result of computation_recv() depends on the result the
+ * sync version of the function would have, "int" is just an example
+ * here.
+ *
+ * Another important piece of the conventions is that the program flow
+ * is interrupted as little as possible. Because a blocking
+ * sub-computation requires that the flow needs to continue in a
+ * separate function that is the logical sequel of some computation,
+ * it should lexically follow sending off the blocking
+ * sub-computation. Setting the callback function via
+ * tevent_req_set_callback() requires referencing a function lexically
+ * below the call to tevent_req_set_callback(), forward declarations
+ * are required. A lot of the async computations thus begin with a
+ * sequence of declarations such as
+ *
+ * @code
+ * static void computation_step1_done(struct tevent_req *subreq);
+ * static void computation_step2_done(struct tevent_req *subreq);
+ * static void computation_step3_done(struct tevent_req *subreq);
+ * @endcode
+ *
+ * It really helps readability a lot to do these forward declarations,
+ * because the lexically sequential program flow makes the async
+ * computations almost as clear to read as a normal, sync program
+ * flow.
+ *
+ * It is up to the user of the async computation to talloc_free it
+ * after it has finished. If an async computation should be aborted,
+ * the tevent_req structure can be talloc_free'ed. After it has
+ * finished, it should talloc_free'ed by the API user.
+ *
+ * @{
+ */
+/**
+ * An async request moves from TEVENT_REQ_INIT to
+ * TEVENT_REQ_IN_PROGRESS. All other states are valid after a request
+ * has finished.
  */
 enum tevent_req_state {
         /**
          * we are creating the request
+         * We are creating the request
          */
         TEVENT_REQ_INIT,
         /**
          * we are waiting the request to complete
+         * We are waiting the request to complete
          */
         TEVENT_REQ_IN_PROGRESS,
         /**
          * the request is finished
+         * The request is finished successfully
          */
         TEVENT_REQ_DONE,
         /**
+         * A user error has occured
+         * A user error has occurred. The user error has been
+         * indicated by tevent_req_error(), it can be retrieved via
+         * tevent_req_is_error().
          */
         TEVENT_REQ_USER_ERROR,
         /**
          * Request timed out
+         * Request timed out after the timeout set by tevent_req_set_endtime.
          */
         TEVENT_REQ_TIMED_OUT,
         /**
+         * No memory in between
+         * An internal allocation has failed, or tevent_req_nomem has
+         * been given a NULL pointer as the first argument.
          */
         TEVENT_REQ_NO_MEMORY,
         /**
+         * the request is already received by the caller
+         * The request has been received by the caller. No further
+         * action is valid.
          */
         TEVENT_REQ_RECEIVED
 …
 /**
  * @brief An async request
+ *
+ * This represents an async request being processed by callbacks via an event
+ * context. A user can issue for example a write request to a socket, giving
+ * an implementation function the fd, the buffer and the number of bytes to
+ * transfer. The function issuing the request will immediately return without
+ * blocking most likely without having sent anything. The API user then fills
+ * in req->async.fn and req->async.private_data, functions that are called
+ * when the request is finished.
+ *
+ * It is up to the user of the async request to talloc_free it after it has
+ * finished. This can happen while the completion function is called.
+ */
+ */
 struct tevent_req;
+typedef void (*tevent_req_fn)(struct tevent_req *);
+/**
+ * @brief A tevent request callback function.
+ *
+ * @param[in]  req      The tevent async request which executed this callback.
+ */
+typedef void (*tevent_req_fn)(struct tevent_req *req);
+/**
+ * @brief Set an async request callback.
+ *
+ * See the documentation of tevent_req_post() for an example how this
+ * is supposed to be used.
+ *
+ * @param[in]  req      The async request to set the callback.
+ *
+ * @param[in]  fn       The callback function to set.
+ *
+ * @param[in]  pvt      A pointer to private data to pass to the async request
+ *                      callback.
+ */
 void tevent_req_set_callback(struct tevent_req *req, tevent_req_fn fn, void *pvt);
+#ifdef DOXYGEN
+/**
+ * @brief Get the private data cast to the given type for a callback from
+ *        a tevent request structure.
+ *
+ * @code
+ * static void computation_done(struct tevent_req *subreq) {
+ *     struct tevent_req *req = tevent_req_callback_data(subreq, struct tevent_req);
+ *     struct computation_state *state = tevent_req_data(req, struct computation_state);
+ *     .... more things, eventually maybe call tevent_req_done(req);
+ * }
+ * @endcode
+ *
+ * @param[in]  req      The structure to get the callback data from.
+ *
+ * @param[in]  type     The type of the private callback data to get.
+ *
+ * @return              The type casted private data set NULL if not set.
+ */
+void *tevent_req_callback_data(struct tevent_req *req, #type);
+#else
 void *_tevent_req_callback_data(struct tevent_req *req);
-void *_tevent_req_data(struct tevent_req *req);
 #define tevent_req_callback_data(_req, _type) \
         talloc_get_type_abort(_tevent_req_callback_data(_req), _type)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Get the private data for a callback from a tevent request structure.
+ *
+ * @param[in]  req      The structure to get the callback data from.
+ *
+ * @param[in]  req      The structure to get the data from.
+ *
+ * @return              The private data or NULL if not set.
+ */
+void *tevent_req_callback_data_void(struct tevent_req *req);
+#else
 #define tevent_req_callback_data_void(_req) \
         _tevent_req_callback_data(_req)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Get the private data from a tevent request structure.
+ *
+ * When the tevent_req has been created by tevent_req_create, the
+ * result of tevent_req_data() is the state variable created by
+ * tevent_req_create() as a child of the req.
+ *
+ * @param[in]  req      The structure to get the private data from.
+ *
+ * @param[in]  type     The type of the private data
+ *
+ * @return              The private data or NULL if not set.
+ */
+void *tevent_req_data(struct tevent_req *req, #type);
+#else
+void *_tevent_req_data(struct tevent_req *req);
 #define tevent_req_data(_req, _type) \
         talloc_get_type_abort(_tevent_req_data(_req), _type)
+typedef char *(*tevent_req_print_fn)(struct tevent_req *, TALLOC_CTX *);
+#endif
+/**
+ * @brief The print function which can be set for a tevent async request.
+ *
+ * @param[in]  req      The tevent async request.
+ *
+ * @param[in]  ctx      A talloc memory context which can be uses to allocate
+ *                      memory.
+ *
+ * @return              An allocated string buffer to print.
+ *
+ * Example:
+ * @code
+ *   static char *my_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
+ *   {
+ *     struct my_data *data = tevent_req_data(req, struct my_data);
+ *     char *result;
+ *
+ *     result = tevent_req_default_print(mem_ctx, req);
+ *     if (result == NULL) {
+ *       return NULL;
+ *     }
+ *
+ *     return talloc_asprintf_append_buffer(result, "foo=%d, bar=%d",
+ *       data->foo, data->bar);
+ *   }
+ * @endcode
+ */
+typedef char *(*tevent_req_print_fn)(struct tevent_req *req, TALLOC_CTX *ctx);
+/**
+ * @brief This function sets a print function for the given request.
+ *
+ * This function can be used to setup a print function for the given request.
+ * This will be triggered if the tevent_req_print() function was
+ * called on the given request.
+ *
+ * @param[in]  req      The request to use.
+ *
+ * @param[in]  fn       A pointer to the print function
+ *
+ * @note This function should only be used for debugging.
+ */
 void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn);
+/**
+ * @brief The default print function for creating debug messages.
+ *
+ * The function should not be used by users of the async API,
+ * but custom print function can use it and append custom text
+ * to the string.
+ *
+ * @param[in]  req      The request to be printed.
+ *
+ * @param[in]  mem_ctx  The memory context for the result.
+ *
+ * @return              Text representation of request.
+ *
+ */
 char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx);
+/**
+ * @brief Print an tevent_req structure in debug messages.
+ *
+ * This function should be used by callers of the async API.
+ *
+ * @param[in]  mem_ctx  The memory context for the result.
+ *
+ * @param[in] req       The request to be printed.
+ *
+ * @return              Text representation of request.
+ */
 char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req);
+typedef bool (*tevent_req_cancel_fn)(struct tevent_req *);
+/**
+ * @brief A typedef for a cancel function for a tevent request.
+ *
+ * @param[in]  req      The tevent request calling this function.
+ *
+ * @return              True if the request could be canceled, false if not.
+ */
+typedef bool (*tevent_req_cancel_fn)(struct tevent_req *req);
+/**
+ * @brief This function sets a cancel function for the given tevent request.
+ *
+ * This function can be used to setup a cancel function for the given request.
+ * This will be triggered if the tevent_req_cancel() function was
+ * called on the given request.
+ *
+ * @param[in]  req      The request to use.
+ *
+ * @param[in]  fn       A pointer to the cancel function.
+ */
 void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn);
+#ifdef DOXYGEN
+/**
+ * @brief Try to cancel the given tevent request.
+ *
+ * This function can be used to cancel the given request.
+ *
+ * It is only possible to cancel a request when the implementation
+ * has registered a cancel function via the tevent_req_set_cancel_fn().
+ *
+ * @param[in]  req      The request to use.
+ *
+ * @return              This function returns true is the request is cancelable,
+ *                      othererwise false is returned.
+ *
+ * @note Even if the function returns true, the caller need to wait
+ *       for the function to complete normally.
+ *       Only the _recv() function of the given request indicates
+ *       if the request was really canceled.
+ */
+bool tevent_req_cancel(struct tevent_req *req);
+#else
 bool _tevent_req_cancel(struct tevent_req *req, const char *location);
 #define tevent_req_cancel(req) \
         _tevent_req_cancel(req, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Create an async tevent request.
+ *
+ * The new async request will be initialized in state TEVENT_REQ_IN_PROGRESS.
+ *
+ * @code
+ * struct tevent_req *req;
+ * struct computation_state *state;
+ * req = tevent_req_create(mem_ctx, &state, struct computation_state);
+ * @endcode
+ *
+ * Tevent_req_create() creates the state variable as a talloc child of
+ * its result. The state variable should be used as the talloc parent
+ * for all temporary variables that are allocated during the async
+ * computation. This way, when the user of the async computation frees
+ * the request, the state as a talloc child will be free'd along with
+ * all the temporary variables hanging off the state.
+ *
+ * @param[in] mem_ctx   The memory context for the result.
+ * @param[in] pstate    Pointer to the private request state.
+ * @param[in] type      The name of the request.
+ *
+ * @return              A new async request. NULL on error.
+ */
+struct tevent_req *tevent_req_create(TALLOC_CTX *mem_ctx,
+                                     void **pstate, #type);
+#else
 struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
                                       void *pstate,
 …
         _tevent_req_create((_mem_ctx), (_pstate), sizeof(_type), \
                            #_type, __location__)
+#endif
+/**
+ * @brief Set a timeout for an async request.
+ *
+ * @param[in]  req      The request to set the timeout for.
+ *
+ * @param[in]  ev       The event context to use for the timer.
+ *
+ * @param[in]  endtime  The endtime of the request.
+ *
+ * @return              True if succeeded, false if not.
+ */
 bool tevent_req_set_endtime(struct tevent_req *req,
                             struct tevent_context *ev,
                             struct timeval endtime);
+#ifdef DOXYGEN
+/**
+ * @brief Call the notify callback of the given tevent request manually.
+ *
+ * @param[in]  req      The tevent request to call the notify function from.
+ *
+ * @see tevent_req_set_callback()
+ */
+void tevent_req_notify_callback(struct tevent_req *req);
+#else
 void _tevent_req_notify_callback(struct tevent_req *req, const char *location);
 #define tevent_req_notify_callback(req)         \
         _tevent_req_notify_callback(req, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief An async request has successfully finished.
+ *
+ * This function is to be used by implementors of async requests. When a
+ * request is successfully finished, this function calls the user's completion
+ * function.
+ *
+ * @param[in]  req       The finished request.
+ */
+void tevent_req_done(struct tevent_req *req);
+#else
 void _tevent_req_done(struct tevent_req *req,
                       const char *location);
 #define tevent_req_done(req) \
         _tevent_req_done(req, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief An async request has seen an error.
+ *
+ * This function is to be used by implementors of async requests. When a
+ * request can not successfully completed, the implementation should call this
+ * function with the appropriate status code.
+ *
+ * If error is 0 the function returns false and does nothing more.
+ *
+ * @param[in]  req      The request with an error.
+ *
+ * @param[in]  error    The error code.
+ *
+ * @return              On success true is returned, false if error is 0.
+ *
+ * @code
+ * int error = first_function();
+ * if (tevent_req_error(req, error)) {
+ *      return;
+ * }
+ *
+ * error = second_function();
+ * if (tevent_req_error(req, error)) {
+ *      return;
+ * }
+ *
+ * tevent_req_done(req);
+ * return;
+ * @endcode
+ */
+bool tevent_req_error(struct tevent_req *req,
+                      uint64_t error);
+#else
 bool _tevent_req_error(struct tevent_req *req,
                        uint64_t error,
 …
 #define tevent_req_error(req, error) \
         _tevent_req_error(req, error, __location__)
+#endif
+#ifdef DOXYGEN
+/**
+ * @brief Helper function for nomem check.
+ *
+ * Convenience helper to easily check alloc failure within a callback
+ * implementing the next step of an async request.
+ *
+ * @param[in]  p        The pointer to be checked.
+ *
+ * @param[in]  req      The request being processed.
+ *
+ * @code
+ * p = talloc(mem_ctx, bla);
+ * if (tevent_req_nomem(p, req)) {
+ *      return;
+ * }
+ * @endcode
+ */
+bool tevent_req_nomem(const void *p,
+                      struct tevent_req *req);
+#else
 bool _tevent_req_nomem(const void *p,
                        struct tevent_req *req,
 …
 #define tevent_req_nomem(p, req) \
         _tevent_req_nomem(p, req, __location__)
+#endif
+/**
+ * @brief Finish a request before the caller had the change to set the callback.
+ *
+ * An implementation of an async request might find that it can either finish
+ * the request without waiting for an external event, or it can not even start
+ * the engine. To present the illusion of a callback to the user of the API,
+ * the implementation can call this helper function which triggers an
+ * immediate timed event. This way the caller can use the same calling
+ * conventions, independent of whether the request was actually deferred.
+ *
+ * @code
+ * struct tevent_req *computation_send(TALLOC_CTX *mem_ctx,
+ *                                     struct tevent_context *ev)
+ * {
+ *     struct tevent_req *req, *subreq;
+ *     struct computation_state *state;
+ *     req = tevent_req_create(mem_ctx, &state, struct computation_state);
+ *     if (req == NULL) {
+ *         return NULL;
+ *     }
+ *     subreq = subcomputation_send(state, ev);
+ *     if (tevent_req_nomem(subreq, req)) {
+ *         return tevent_req_post(req, ev);
+ *     }
+ *     tevent_req_set_callback(subreq, computation_done, req);
+ *     return req;
+ * }
+ * @endcode
+ *
+ * @param[in]  req      The finished request.
+ *
+ * @param[in]  ev       The tevent_context for the timed event.
+ *
+ * @return              The given request will be returned.
+ */
 struct tevent_req *tevent_req_post(struct tevent_req *req,
                                    struct tevent_context *ev);
+/**
+ * @brief Check if the given request is still in progress.
+ *
+ * It is typically used by sync wrapper functions.
+ *
+ * @param[in]  req      The request to poll.
+ *
+ * @return              The boolean form of "is in progress".
+ */
 bool tevent_req_is_in_progress(struct tevent_req *req);
+/**
+ * @brief Actively poll for the given request to finish.
+ *
+ * This function is typically used by sync wrapper functions.
+ *
+ * @param[in]  req      The request to poll.
+ *
+ * @param[in]  ev       The tevent_context to be used.
+ *
+ * @return              On success true is returned. If a critical error has
+ *                      happened in the tevent loop layer false is returned.
+ *                      This is not the return value of the given request!
+ *
+ * @note This should only be used if the given tevent context was created by the
+ * caller, to avoid event loop nesting.
+ *
+ * @code
+ * req = tstream_writev_queue_send(mem_ctx,
+ *                                 ev_ctx,
+ *                                 tstream,
+ *                                 send_queue,
+ *                                 iov, 2);
+ * ok = tevent_req_poll(req, tctx->ev);
+ * rc = tstream_writev_queue_recv(req, &sys_errno);
+ * TALLOC_FREE(req);
+ * @endcode
+ */
 bool tevent_req_poll(struct tevent_req *req,
                      struct tevent_context *ev);
+/**
+ * @brief Get the tevent request state and the actual error set by
+ * tevent_req_error.
+ *
+ * @code
+ * int computation_recv(struct tevent_req *req, uint64_t *perr)
+ * {
+ *     enum tevent_req_state state;
+ *     uint64_t err;
+ *     if (tevent_req_is_error(req, &state, &err)) {
+ *         *perr = err;
+ *         return -1;
+ *     }
+ *     return 0;
+ * }
+ * @endcode
+ *
+ * @param[in]  req      The tevent request to get the error from.
+ *
+ * @param[out] state    A pointer to store the tevent request error state.
+ *
+ * @param[out] error    A pointer to store the error set by tevent_req_error().
+ *
+ * @return              True if the function could set error and state, false
+ *                      otherwise.
+ *
+ * @see tevent_req_error()
+ */
 bool tevent_req_is_error(struct tevent_req *req,
                          enum tevent_req_state *state,
                          uint64_t *error);
+/**
+ * @brief Use as the last action of a _recv() function.
+ *
+ * This function destroys the attached private data.
+ *
+ * @param[in]  req      The finished request.
+ */
 void tevent_req_received(struct tevent_req *req);
+/**
+ * @brief Create a tevent subrequest at a given time.
+ *
+ * The idea is that always the same syntax for tevent requests.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  ev       The event handle to setup the request.
+ *
+ * @param[in]  wakeup_time The time to wakeup and execute the request.
+ *
+ * @return              The new subrequest, NULL on error.
+ *
+ * Example:
+ * @code
+ *   static void my_callback_wakeup_done(tevent_req *subreq)
+ *   {
+ *     struct tevent_req *req = tevent_req_callback_data(subreq,
+ *                              struct tevent_req);
+ *     bool ok;
+ *
+ *     ok = tevent_wakeup_recv(subreq);
+ *     TALLOC_FREE(subreq);
+ *     if (!ok) {
+ *         tevent_req_error(req, -1);
+ *         return;
+ *     }
+ *     ...
+ *   }
+ * @endcode
+ *
+ * @code
+ *   subreq = tevent_wakeup_send(mem_ctx, ev, wakeup_time);
+ *   if (tevent_req_nomem(subreq, req)) {
+ *     return false;
+ *   }
+ *   tevent_set_callback(subreq, my_callback_wakeup_done, req);
+ * @endcode
+ *
+ * @see tevent_wakeup_recv()
+ */
 struct tevent_req *tevent_wakeup_send(TALLOC_CTX *mem_ctx,
                                       struct tevent_context *ev,
                                       struct timeval wakeup_time);
+/**
+ * @brief Check if the wakeup has been correctly executed.
+ *
+ * This function needs to be called in the callback function set after calling
+ * tevent_wakeup_send().
+ *
+ * @param[in]  req      The tevent request to check.
+ *
+ * @return              True on success, false otherwise.
+ *
+ * @see tevent_wakeup_recv()
+ */
 bool tevent_wakeup_recv(struct tevent_req *req);
+/* @} */
+/**
+ * @defgroup tevent_helpers The tevent helper functiions
+ * @ingroup tevent
+ *
+ * @todo description
+ *
+ * @{
+ */
+/**
+ * @brief Compare two timeval values.
+ *
+ * @param[in]  tv1      The first timeval value to compare.
+ *
+ * @param[in]  tv2      The second timeval value to compare.
+ *
+ * @return              0 if they are equal.
+ *                      1 if the first time is greater than the second.
+ *                      -1 if the first time is smaller than the second.
+ */
 int tevent_timeval_compare(const struct timeval *tv1,
                            const struct timeval *tv2);
+/**
+ * @brief Get a zero timval value.
+ *
+ * @return              A zero timval value.
+ */
 struct timeval tevent_timeval_zero(void);
+/**
+ * @brief Get a timeval value for the current time.
+ *
+ * @return              A timval value with the current time.
+ */
 struct timeval tevent_timeval_current(void);
+/**
+ * @brief Get a timeval structure with the given values.
+ *
+ * @param[in]  secs     The seconds to set.
+ *
+ * @param[in]  usecs    The milliseconds to set.
+ *
+ * @return              A timeval structure with the given values.
+ */
 struct timeval tevent_timeval_set(uint32_t secs, uint32_t usecs);
+/**
+ * @brief Get the difference between two timeval values.
+ *
+ * @param[in]  tv1      The first timeval.
+ *
+ * @param[in]  tv2      The second timeval.
+ *
+ * @return              A timeval structure with the difference between the
+ *                      first and the second value.
+ */
 struct timeval tevent_timeval_until(const struct timeval *tv1,
                                     const struct timeval *tv2);
+/**
+ * @brief Check if a given timeval structure is zero.
+ *
+ * @param[in]  tv       The timeval to check if it is zero.
+ *
+ * @return              True if it is zero, false otherwise.
+ */
 bool tevent_timeval_is_zero(const struct timeval *tv);
+/**
+ * @brief Add the given amount of time to a timeval structure.
+ *
+ * @param[in]  tv        The timeval structure to add the time.
+ *
+ * @param[in]  secs      The seconds to add to the timeval.
+ *
+ * @param[in]  usecs     The milliseconds to add to the timeval.
+ *
+ * @return               The timeval structure with the new time.
+ */
 struct timeval tevent_timeval_add(const struct timeval *tv, uint32_t secs,
                                   uint32_t usecs);
+/**
+ * @brief Get a timeval in the future with a specified offset from now.
+ *
+ * @param[in]  secs     The seconds of the offset from now.
+ *
+ * @param[in]  usecs    The milliseconds of the offset from now.
+ *
+ * @return              A timval with the given offset in the future.
+ */
 struct timeval tevent_timeval_current_ofs(uint32_t secs, uint32_t usecs);
+/* @} */
+/**
+ * @defgroup tevent_queue The tevent queue functions
+ * @ingroup tevent
+ *
+ * A tevent_queue is used to queue up async requests that must be
+ * serialized. For example writing buffers into a socket must be
+ * serialized. Writing a large lump of data into a socket can require
+ * multiple write(2) or send(2) system calls. If more than one async
+ * request is outstanding to write large buffers into a socket, every
+ * request must individually be completed before the next one begins,
+ * even if multiple syscalls are required.
+ *
+ * Take a look at @ref tevent_queue_tutorial for more details.
+ * @{
+ */
 struct tevent_queue;
+#ifdef DOXYGEN
+/**
+ * @brief Create and start a tevent queue.
+ *
+ * @param[in]  mem_ctx  The talloc memory context to allocate the queue.
+ *
+ * @param[in]  name     The name to use to identify the queue.
+ *
+ * @return              An allocated tevent queue on success, NULL on error.
+ *
+ * @see tevent_start()
+ * @see tevent_stop()
+ */
+struct tevent_queue *tevent_queue_create(TALLOC_CTX *mem_ctx,
+                                         const char *name);
+#else
 struct tevent_queue *_tevent_queue_create(TALLOC_CTX *mem_ctx,
                                           const char *name,
 …
 #define tevent_queue_create(_mem_ctx, _name) \
         _tevent_queue_create((_mem_ctx), (_name), __location__)
+#endif
+/**
+ * @brief A callback trigger function run by the queue.
+ *
+ * @param[in]  req      The tevent request the trigger function is executed on.
+ *
+ * @param[in]  private_data The private data pointer specified by
+ *                          tevent_queue_add().
+ *
+ * @see tevent_queue_add()
+ */
 typedef void (*tevent_queue_trigger_fn_t)(struct tevent_req *req,
                                           void *private_data);
+/**
+ * @brief Add a tevent request to the queue.
+ *
+ * @param[in]  queue    The queue to add the request.
+ *
+ * @param[in]  ev       The event handle to use for the request.
+ *
+ * @param[in]  req      The tevent request to add to the queue.
+ *
+ * @param[in]  trigger  The function triggered by the queue when the request
+ *                      is called.
+ *
+ * @param[in]  private_data The private data passed to the trigger function.
+ *
+ * @return              True if the request has been successfully added, false
+ *                      otherwise.
+ */
 bool tevent_queue_add(struct tevent_queue *queue,
                       struct tevent_context *ev,
 …
                       tevent_queue_trigger_fn_t trigger,
                       void *private_data);
+/**
+ * @brief Start a tevent queue.
+ *
+ * The queue is started by default.
+ *
+ * @param[in]  queue    The queue to start.
+ */
 void tevent_queue_start(struct tevent_queue *queue);
+/**
+ * @brief Stop a tevent queue.
+ *
+ * The queue is started by default.
+ *
+ * @param[in]  queue    The queue to stop.
+ */
 void tevent_queue_stop(struct tevent_queue *queue);
+/**
+ * @brief Get the length of the queue.
+ *
+ * @param[in]  queue    The queue to get the length from.
+ *
+ * @return              The number of elements.
+ */
 size_t tevent_queue_length(struct tevent_queue *queue);
 …
 #endif
+/**
+int tevent_re_initialise(struct tevent_context *ev);
+/* @} */
+/**
+ * @defgroup tevent_ops The tevent operation functions
+ * @ingroup tevent
+ *
  * The following structure and registration functions are exclusively
  * needed for people writing and pluggin a different event engine.
  * There is nothing useful for normal tevent user in here.
+ * @{
  */
 …
 bool tevent_register_backend(const char *name, const struct tevent_ops *ops);
+/**
+/* @} */
+/**
+ * @defgroup tevent_compat The tevent compatibility functions
+ * @ingroup tevent
+ *
  * The following definitions are usueful only for compatibility with the
  * implementation originally developed within the samba4 code and will be
  * soon removed. Please NEVER use in new code.
+ *
+ * @todo Ignore it?
+ *
+ * @{
  */
 …
 #endif /* TEVENT_COMPAT_DEFINES */
+/* @} */
 #endif /* __TEVENT_H__ */

vendor/current/lib/tevent/tevent.pc.in

r414	r740
9	9	Requires: talloc
10	10	Libs: -L${libdir} -ltevent
11		Cflags: ~~-I${includedir}~~
	11	Cflags: @LIB_RPATH@ -I${includedir}
12	12	URL: http://samba.org/

vendor/current/lib/tevent/tevent_epoll.c

-              r414
+              r740
 /*
+  called when a epoll call fails, and we should fallback
+  to using select
+  called when a epoll call fails
 */
 static void epoll_panic(struct epoll_event_context *epoll_ev, const char *reason)
 …
 };
 bool tevent_epoll_init(void)
+_PRIVATE_ bool tevent_epoll_init(void)
+{
         return tevent_register_backend("epoll", &epoll_event_ops);

vendor/current/lib/tevent/tevent_fd.c

-              r414
+              r740
         struct tevent_fd *fde;
+        /* tevent will crash later on select() if we save
+         * a negative file descriptor. Better to fail here
+         * so that consumers will be able to debug it
+         */
+        if (fd < 0) return NULL;
         fde = talloc(mem_ctx?mem_ctx:ev, struct tevent_fd);
         if (!fde) return NULL;

vendor/current/lib/tevent/tevent_internal.h

-              r427
+              r740
         const char *location;
         /* this is private for the events_ops implementation */
         uint16_t additional_flags;
+        uint64_t additional_flags;
         void *additional_data;
 };
 …
 bool tevent_standard_init(void);
 bool tevent_select_init(void);
+bool tevent_poll_init(void);
 #ifdef HAVE_EPOLL
 bool tevent_epoll_init(void);

vendor/current/lib/tevent/tevent_liboop.c

-              r414
+              r740
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  NOTE: this code compiles fine, but is completly *UNTESTED*
        and is only commited as example
+ NOTE: this code compiles fine, but is completely *UNTESTED*
+       and is only committed as an example
  !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

vendor/current/lib/tevent/tevent_req.c

-              r414
+              r740
 #include "tevent_internal.h"
 #include "tevent_util.h"
-/**
- * @brief The default print function for creating debug messages
- * @param[in] req       The request to be printed
- * @param[in] mem_ctx   The memory context for the result
- * @retval              Text representation of req
+ *
- * The function should not be used by users of the asynx API,
- * but custom print function can use it and append custom text
- * to the string.
- */
 char *tevent_req_default_print(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 …
+}
-/**
- * @brief Print an tevent_req structure in debug messages
- * @param[in] mem_ctx   The memory context for the result
- * @param[in] req       The request to be printed
- * @retval              Text representation of req
+ *
- * This function should be used by callers of the async API
- */
 char *tevent_req_print(TALLOC_CTX *mem_ctx, struct tevent_req *req)
+{
 …
         return req->private_print(req, mem_ctx);
+}
-/**
- * @brief Create an async request
- * @param[in] mem_ctx   The memory context for the result
- * @param[in] ev        The event context this async request will be driven by
- * @retval              A new async request
+ *
- * The new async request will be initialized in state ASYNC_REQ_IN_PROGRESS
- */
 struct tevent_req *_tevent_req_create(TALLOC_CTX *mem_ctx,
 …
+}
-/**
- * @brief An async request has successfully finished
- * @param[in] req       The finished request
+ *
- * tevent_req_done is to be used by implementors of async requests. When a
- * request is successfully finished, this function calls the user's completion
- * function.
- */
 void _tevent_req_done(struct tevent_req *req,
                       const char *location)
 …
         tevent_req_finish(req, TEVENT_REQ_DONE, location);
+}
-/**
- * @brief An async request has seen an error
- * @param[in] req       The request with an error
- * @param[in] error     The error code
+ *
- * tevent_req_done is to be used by implementors of async requests. When a
- * request can not successfully completed, the implementation should call this
- * function with the appropriate status code.
+ *
- * If error is 0 the function returns false and does nothing more.
+ *
- * Call pattern would be
- * \code
- * int error = first_function();
- * if (tevent_req_error(req, error)) {
- *      return;
- * }
+ *
- * error = second_function();
- * if (tevent_req_error(req, error)) {
- *      return;
- * }
+ *
- * tevent_req_done(req);
- * return;
- * \endcode
- */
 bool _tevent_req_error(struct tevent_req *req,
 …
+}
-/**
- * @brief Helper function for nomem check
- * @param[in] p         The pointer to be checked
- * @param[in] req       The request being processed
+ *
- * Convenience helper to easily check alloc failure within a callback
- * implementing the next step of an async request.
+ *
- * Call pattern would be
- * \code
- * p = talloc(mem_ctx, bla);
- * if (tevent_req_nomem(p, req)) {
- *      return;
- * }
- * \endcode
- */
 bool _tevent_req_nomem(const void *p,
                        struct tevent_req *req,
 …
 /**
+ * @brief Immediate event callback
+ * @param[in] ev        Event context
+ * @param[in] im        The immediate event
+ * @param[in] priv      The async request to be finished
+ * @internal
+ *
+ * @brief Immediate event callback.
+ *
+ * @param[in]  ev       The event context to use.
+ *
+ * @param[in]  im       The immediate event.
+ *
+ * @param[in]  priv     The async request to be finished.
  */
 static void tevent_req_trigger(struct tevent_context *ev,
 …
+}
-/**
- * @brief Finish a request before the caller had the change to set the callback
- * @param[in] req       The finished request
- * @param[in] ev        The tevent_context for the timed event
- * @retval              req will be returned
+ *
- * An implementation of an async request might find that it can either finish
- * the request without waiting for an external event, or it can't even start
- * the engine. To present the illusion of a callback to the user of the API,
- * the implementation can call this helper function which triggers an
- * immediate timed event. This way the caller can use the same calling
- * conventions, independent of whether the request was actually deferred.
- */
 struct tevent_req *tevent_req_post(struct tevent_req *req,
                                    struct tevent_context *ev)
 …
+}
-/**
- * @brief This function destroys the attached private data
- * @param[in] req       The request to poll
- * @retval              The boolean form of "is in progress".
+ *
- * This function can be used to ask if the given request
- * is still in progress.
+ *
- * This function is typically used by sync wrapper functions.
- */
 bool tevent_req_is_in_progress(struct tevent_req *req)
+{
 …
+}
-/**
- * @brief This function destroys the attached private data
- * @param[in] req       The finished request
+ *
- * This function can be called as last action of a _recv()
- * function, it destroys the data attached to the tevent_req.
- */
 void tevent_req_received(struct tevent_req *req)
+{
 …
+}
-/**
- * @brief This function destroys the attached private data
- * @param[in] req       The request to poll
- * @param[in] ev        The tevent_context to be used
- * @retval              If a critical error has happened in the
- *                      tevent loop layer false is returned.
- *                      Otherwise true is returned.
- *                      This is not the return value of the given request!
+ *
- * This function can be used to actively poll for the
- * given request to finish.
+ *
- * Note: this should only be used if the given tevent context
- *       was created by the caller, to avoid event loop nesting.
+ *
- * This function is typically used by sync wrapper functions.
- */
 bool tevent_req_poll(struct tevent_req *req,
                      struct tevent_context *ev)
 …
+}
-/**
- * @brief This function sets a print function for the given request
- * @param[in] req       The given request
- * @param[in] fn        A pointer to the print function
+ *
- * This function can be used to setup a print function for the given request.
- * This will be triggered if the tevent_req_print() function was
- * called on the given request.
+ *
- * Note: this function should only be used for debugging.
- */
 void tevent_req_set_print_fn(struct tevent_req *req, tevent_req_print_fn fn)
+{
 …
+}
-/**
- * @brief This function sets a cancel function for the given request
- * @param[in] req       The given request
- * @param[in] fn        A pointer to the cancel function
+ *
- * This function can be used to setup a cancel function for the given request.
- * This will be triggered if the tevent_req_cancel() function was
- * called on the given request.
+ *
- */
 void tevent_req_set_cancel_fn(struct tevent_req *req, tevent_req_cancel_fn fn)
+{
 …
+}
-/**
- * @brief This function tries to cancel the given request
- * @param[in] req       The given request
- * @param[in] location  Automaticly filled with the __location__ macro
- *                      via the tevent_req_cancel() macro. This is for debugging
- *                      only!
- * @retval              This function returns true is the request is cancelable.
- *                      Otherwise false is returned.
+ *
- * This function can be used to cancel the given request.
+ *
- * It is only possible to cancel a request when the implementation
- * has registered a cancel function via the tevent_req_set_cancel_fn().
+ *
- * Note: Even if the function returns true, the caller need to wait
- *       for the function to complete normally.
- *       Only the _recv() function of the given request indicates
- *       if the request was really canceled.
- */
 bool _tevent_req_cancel(struct tevent_req *req, const char *location)
+{

vendor/current/lib/tevent/tevent_select.c

-              r591
+              r740
         if (!fde) return NULL;
+        if (fde->fd > select_ev->maxfd) {
+        if ((select_ev->maxfd != EVENT_INVALID_MAXFD)
+            && (fde->fd > select_ev->maxfd)) {
                 select_ev->maxfd = fde->fd;
+        }
 …
 };
 bool tevent_select_init(void)
+_PRIVATE_ bool tevent_select_init(void)
+{
         return tevent_register_backend("select", &select_event_ops);

vendor/current/lib/tevent/tevent_signal.c

r618	r740
211	211	multiple event contexts */
212	212	if (sig_state == NULL) {
213		sig_state = talloc_zero(~~talloc_autofree_context()~~, struct tevent_sig_state);
	213	sig_state = talloc_zero(NULL, struct tevent_sig_state);
214	214	if (sig_state == NULL) {
215	215	return NULL;

vendor/current/lib/tevent/tevent_standard.c

-              r591
+              r740
                         return -1;
+                }
                 if (fde->flags & TEVENT_FD_READ) {
                         FD_SET(fde->fd, &r_fds);
 …
                         if (FD_ISSET(fde->fd, &r_fds)) flags |= TEVENT_FD_READ;
                         if (FD_ISSET(fde->fd, &w_fds)) flags |= TEVENT_FD_WRITE;
                         if (flags) {
+                        if (flags & fde->flags) {
                                 fde->handler(std_ev->ev, fde, flags, fde->private_data);
                                 break;
 …
 bool tevent_standard_init(void)
+_PRIVATE_ bool tevent_standard_init(void)
+{
         return tevent_register_backend("standard", &std_event_ops);

vendor/current/lib/tevent/tevent_timed.c

-              r414
+              r740
   do a single event loop using the events defined in ev
   return the delay untill the next timed event,
+  return the delay until the next timed event,
   or zero if a timed event was triggered
 */
 …
                 /* have a default tick time of 30 seconds. This guarantees
                    that code that uses its own timeout checking will be
                    able to proceeed eventually */
+                   able to proceed eventually */
                 return tevent_timeval_set(30, 0);
+        }

vendor/current/lib/tevent/tevent_util.h

-              r414
+              r740
    Unix SMB/CIFS implementation.
    Copyright (C) Andrew Tridgell 1998-2005
+   Copyright (C) Andrew Tridgell 1998-2010
    Copyright (C) Jelmer Vernooij 2005
 …
 #define _DLINKLIST_H
+/*
+  February 2010 - changed list format to have a prev pointer from the
+  list head. This makes DLIST_ADD_END() O(1) even though we only have
+  one list pointer.
+/* hook into the front of the list */
+  The scheme is as follows:
+) with no entries in the list:
+          list_head == NULL
+) with 1 entry in the list:
+          list_head->next == NULL
+          list_head->prev == list_head
+) with 2 entries in the list:
+          list_head->next == element2
+          list_head->prev == element2
+          element2->prev == list_head
+          element2->next == NULL
+) with N entries in the list:
+          list_head->next == element2
+          list_head->prev == elementN
+          elementN->prev == element{N-1}
+          elementN->next == NULL
+  This allows us to find the tail of the list by using
+  list_head->prev, which means we can add to the end of the list in
+  O(1) time
+  Note that the 'type' arguments below are no longer needed, but
+  are kept for now to prevent an incompatible argument change
+ */
+/*
+   add an element at the front of a list
+*/
 #define DLIST_ADD(list, p) \
 do { \
         if (!(list)) { \
                 (list) = (p); \
                 (p)->next = (p)->prev = NULL; \
+                (p)->prev = (list) = (p);  \
+                (p)->next = NULL; \
         } else { \
+                (p)->prev = (list)->prev; \
                 (list)->prev = (p); \
                 (p)->next = (list); \
-                (p)->prev = NULL; \
                 (list) = (p); \
         }\
+        } \
 } while (0)
+/* remove an element from a list - element doesn't have to be in list. */
+/*
+   remove an element from a list
+   Note that the element doesn't have to be in the list. If it
+   isn't then this is a no-op
+*/
 #define DLIST_REMOVE(list, p) \
 do { \
         if ((p) == (list)) { \
+                if ((p)->next) (p)->next->prev = (p)->prev; \
                 (list) = (p)->next; \
+                if (list) (list)->prev = NULL; \
+        } else if ((list) && (p) == (list)->prev) {     \
+                (p)->prev->next = NULL; \
+                (list)->prev = (p)->prev; \
         } else { \
                 if ((p)->prev) (p)->prev->next = (p)->next; \
                 if ((p)->next) (p)->next->prev = (p)->prev; \
         } \
         if ((p) != (list)) (p)->next = (p)->prev = NULL; \
+        if ((p) != (list)) (p)->next = (p)->prev = NULL;        \
 } while (0)
+/* promote an element to the top of the list */
+#define DLIST_PROMOTE(list, p) \
+/*
+   find the head of the list given any element in it.
+   Note that this costs O(N), so you should avoid this macro
+   if at all possible!
+*/
+#define DLIST_HEAD(p, result_head) \
 do { \
           DLIST_REMOVE(list, p); \
           DLIST_ADD(list, p); \
 } while (0)
+       (result_head) = (p); \
+       while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
+} while(0)
+/* hook into the end of the list - needs a tmp pointer */
+#define DLIST_ADD_END(list, p, type) \
+do { \
+                if (!(list)) { \
+                        (list) = (p); \
+                        (p)->next = (p)->prev = NULL; \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (p); \
+                        (p)->next = NULL; \
+                        (p)->prev = tmp; \
+                } \
+} while (0)
+/* return the last element in the list */
+#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
+/* return the previous element in the list. */
+#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
 /* insert 'p' after the given element 'el' in a list. If el is NULL then
 …
                 DLIST_ADD(list, p); \
         } else { \
+                p->prev = el; \
+                p->next = el->next; \
+                el->next = p; \
+                if (p->next) p->next->prev = p; \
+                (p)->prev = (el);   \
+                (p)->next = (el)->next;         \
+                (el)->next = (p);               \
+                if ((p)->next) (p)->next->prev = (p);   \
+                if ((list)->prev == (el)) (list)->prev = (p); \
         }\
 } while (0)
+/* demote an element to the end of the list, needs a tmp pointer */
+#define DLIST_DEMOTE(list, p, tmp) \
+/*
+   add to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_ADD_END(list, p, type)                    \
 do { \
+                DLIST_REMOVE(list, p); \
+                DLIST_ADD_END(list, p, tmp); \
+        if (!(list)) { \
+                DLIST_ADD(list, p); \
+        } else { \
+                DLIST_ADD_AFTER(list, p, (list)->prev); \
+        } \
 } while (0)
+/* concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list */
+#define DLIST_CONCATENATE(list1, list2, type) \
+/* promote an element to the from of a list */
+#define DLIST_PROMOTE(list, p) \
 do { \
+                if (!(list1)) { \
+                        (list1) = (list2); \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list1); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (list2); \
+                        if (list2) { \
+                                (list2)->prev = tmp;    \
+                        } \
+          DLIST_REMOVE(list, p); \
+          DLIST_ADD(list, p); \
+} while (0)
+/*
+   demote an element to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_DEMOTE(list, p, type)                     \
+do { \
+        DLIST_REMOVE(list, p); \
+        DLIST_ADD_END(list, p, NULL);           \
+} while (0)
+/*
+   concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list.
+   Note that 'type' is ignored
+*/
+#define DLIST_CONCATENATE(list1, list2, type)   \
+do { \
+        if (!(list1)) { \
+                (list1) = (list2); \
+        } else { \
+                (list1)->prev->next = (list2); \
+                if (list2) { \
+                        void *_tmplist = (void *)(list1)->prev; \
+                        (list1)->prev = (list2)->prev; \
+                        (list2)->prev = _tmplist; \
                 } \
+        } \
 } while (0)

vendor/current/lib/torture/subunit.c

-              r414
+              r740
 #include "includes.h"
 #include "lib/torture/torture.h"
+#include <subunit/child.h>
 static void subunit_suite_start(struct torture_context *ctx,
+static void torture_subunit_suite_start(struct torture_context *ctx,
                                 struct torture_suite *suite)
+{
+}
 static void subunit_print_testname(struct torture_context *ctx,
+static char *torture_subunit_test_name(struct torture_context *ctx,
                                    struct torture_tcase *tcase,
                                    struct torture_test *test)
+{
         if (!strcmp(tcase->name, test->name)) {
                 printf("%s", test->name);
+                return talloc_strdup(ctx, test->name);
         } else {
                 printf("%s.%s", tcase->name, test->name);
+                return talloc_asprintf(ctx, "%s.%s", tcase->name, test->name);
+        }
+}
+static void subunit_test_start(struct torture_context *ctx,
+static void torture_subunit_report_time(struct torture_context *tctx)
+{
+        struct timespec tp;
+        struct tm *tmp;
+        char timestr[200];
+        if (clock_gettime(CLOCK_REALTIME, &tp) != 0) {
+                perror("clock_gettime");
+                return;
+        }
+        tmp = localtime(&tp.tv_sec);
+        if (!tmp) {
+                perror("localtime");
+                return;
+        }
+        if (strftime(timestr, sizeof(timestr), "%Y-%m-%d %H:%M:%S", tmp) <= 0) {
+                perror("strftime");
+                return;
+        }
+        printf("time: %s.%06ld\n", timestr, tp.tv_nsec / 1000);
+}
+static void torture_subunit_test_start(struct torture_context *context,
                                struct torture_tcase *tcase,
                                struct torture_test *test)
+{
+        printf("test: ");
+        subunit_print_testname(ctx, tcase, test);
+        printf("\n");
+        char *fullname = torture_subunit_test_name(context, context->active_tcase, context->active_test);
+        subunit_test_start(fullname);
+        torture_subunit_report_time(context);
+        talloc_free(fullname);
+}
 static void subunit_test_result(struct torture_context *context,
+static void torture_subunit_test_result(struct torture_context *context,
                                 enum torture_result res, const char *reason)
+{
+        char *fullname = torture_subunit_test_name(context, context->active_tcase, context->active_test);
+        torture_subunit_report_time(context);
         switch (res) {
         case TORTURE_OK:
                 printf("success: ");
+                subunit_test_pass(fullname);
                 break;
         case TORTURE_FAIL:
                 printf("failure: ");
+                subunit_test_fail(fullname, reason);
                 break;
         case TORTURE_ERROR:
                 printf("error: ");
+                subunit_test_error(fullname, reason);
                 break;
         case TORTURE_SKIP:
                 printf("skip: ");
+                subunit_test_skip(fullname, reason);
                 break;
+        }
+        subunit_print_testname(context, context->active_tcase, context->active_test);
+        if (reason)
+                printf(" [\n%s\n]", reason);
+        printf("\n");
+        talloc_free(fullname);
+}
 static void subunit_comment(struct torture_context *test,
+static void torture_subunit_comment(struct torture_context *test,
                             const char *comment)
+{
 …
+}
 static void subunit_warning(struct torture_context *test,
+static void torture_subunit_warning(struct torture_context *test,
                             const char *comment)
+{
 …
+}
+static void torture_subunit_progress(struct torture_context *tctx, int offset, enum torture_progress_whence whence)
+{
+        switch (whence) {
+        case TORTURE_PROGRESS_SET:
+                printf("progress: %d\n", offset);
+                break;
+        case TORTURE_PROGRESS_CUR:
+                printf("progress: %+-d\n", offset);
+                break;
+        case TORTURE_PROGRESS_POP:
+                printf("progress: pop\n");
+                break;
+        case TORTURE_PROGRESS_PUSH:
+                printf("progress: push\n");
+                break;
+        default:
+                fprintf(stderr, "Invalid call to progress()\n");
+                break;
+        }
+}
 const struct torture_ui_ops torture_subunit_ui_ops = {
+        .comment = subunit_comment,
+        .warning = subunit_warning,
+        .test_start = subunit_test_start,
+        .test_result = subunit_test_result,
+        .suite_start = subunit_suite_start
+        .comment = torture_subunit_comment,
+        .warning = torture_subunit_warning,
+        .test_start = torture_subunit_test_start,
+        .test_result = torture_subunit_test_result,
+        .suite_start = torture_subunit_suite_start,
+        .progress = torture_subunit_progress,
+        .report_time = torture_subunit_report_time,
 };

vendor/current/lib/torture/torture.c

-              r414
+              r740
 /*
+/*
    Unix SMB/CIFS implementation.
    SMB torture UI functions
    Copyright (C) Jelmer Vernooij 2006-2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "param/param.h"
 #include "system/filesys.h"
+#include "system/dir.h"
 struct torture_results *torture_results_init(TALLOC_CTX *mem_ctx, const struct torture_ui_ops *ui_ops)
 …
         return subtorture;
+}
 /**
  create a temporary directory.
+}
+/**
+ create a temporary directory under the output dir
 */
+_PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx,
+                                   const char *prefix,
+                                   char **tempdir)
+_PUBLIC_ NTSTATUS torture_temp_dir(struct torture_context *tctx,
+                                   const char *prefix, char **tempdir)
+{
         SMB_ASSERT(tctx->outputdir != NULL);
         *tempdir = talloc_asprintf(tctx, "%s/%s.XXXXXX", tctx->outputdir,
+        *tempdir = talloc_asprintf(tctx, "%s/%s.XXXXXX", tctx->outputdir,
                                    prefix);
         NT_STATUS_HAVE_NO_MEMORY(*tempdir);
 …
+        }
+        return NT_STATUS_OK;
+}
+static int local_deltree(const char *path)
+{
+        int ret = 0;
+        struct dirent *dirent;
+        DIR *dir = opendir(path);
+        if (!dir) {
+                char *error = talloc_asprintf(NULL, "Could not open directory %s", path);
+                perror(error);
+                talloc_free(error);
+                return -1;
+        }
+        while ((dirent = readdir(dir))) {
+                char *name;
+                if ((strcmp(dirent->d_name, ".") == 0) || (strcmp(dirent->d_name, "..") == 0)) {
+                        continue;
+                }
+                name = talloc_asprintf(NULL, "%s/%s", path,
+                                       dirent->d_name);
+                if (name == NULL) {
+                        closedir(dir);
+                        return -1;
+                }
+                DEBUG(0, ("About to remove %s\n", name));
+                ret = remove(name);
+                if (ret == 0) {
+                        talloc_free(name);
+                        continue;
+                }
+                if (errno == ENOTEMPTY) {
+                        ret = local_deltree(name);
+                        if (ret == 0) {
+                                ret = remove(name);
+                        }
+                }
+                talloc_free(name);
+                if (ret != 0) {
+                        char *error = talloc_asprintf(NULL, "Could not remove %s", path);
+                        perror(error);
+                        talloc_free(error);
+                        break;
+                }
+        }
+        closedir(dir);
+        rmdir(path);
+        return ret;
+}
+_PUBLIC_ NTSTATUS torture_deltree_outputdir(struct torture_context *tctx)
+{
+        if (tctx->outputdir == NULL) {
+                return NT_STATUS_OK;
+        }
+        if ((strcmp(tctx->outputdir, "/") == 0)
+            || (strcmp(tctx->outputdir, "") == 0)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        if (local_deltree(tctx->outputdir) == -1) {
+                if (errno != 0) {
+                        return map_nt_error_from_unix(errno);
+                }
+                return NT_STATUS_UNSUCCESSFUL;
+        }
         return NT_STATUS_OK;
+}
 …
         tmp = talloc_vasprintf(context, comment, ap);
         va_end(ap);
         context->results->ui_ops->comment(context, tmp);
         talloc_free(tmp);
+}
 …
+}
+int torture_suite_children_count(const struct torture_suite *suite)
+{
+        int ret = 0;
+        struct torture_tcase *tcase;
+        struct torture_test *test;
+        struct torture_suite *tsuite;
+        for (tcase = suite->testcases; tcase; tcase = tcase->next) {
+                for (test = tcase->tests; test; test = test->next) {
+                        ret++;
+                }
+        }
+        for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
+                ret ++;
+        }
+        return ret;
+}
 /**
  * Run a torture test suite.
 …
 bool torture_run_suite(struct torture_context *context,
                        struct torture_suite *suite)
+{
+        return torture_run_suite_restricted(context, suite, NULL);
+}
+bool torture_run_suite_restricted(struct torture_context *context,
+                       struct torture_suite *suite, const char **restricted)
+{
         bool ret = true;
         struct torture_tcase *tcase;
         struct torture_suite *tsuite;
-        char *old_testname;
         if (context->results->ui_ops->suite_start)
                 context->results->ui_ops->suite_start(context, suite);
+        old_testname = context->active_testname;
+        if (old_testname != NULL)
+                context->active_testname = talloc_asprintf(context, "%s-%s",
+                                                           old_testname, suite->name);
+        else
+                context->active_testname = talloc_strdup(context, suite->name);
+        /* FIXME: Adjust torture_suite_children_count if restricted != NULL */
+        context->results->ui_ops->progress(context,
+                torture_suite_children_count(suite), TORTURE_PROGRESS_SET);
         for (tcase = suite->testcases; tcase; tcase = tcase->next) {
                 ret &= torture_run_tcase(context, tcase);
+                ret &= torture_run_tcase_restricted(context, tcase, restricted);
+        }
         for (tsuite = suite->children; tsuite; tsuite = tsuite->next) {
+                ret &= torture_run_suite(context, tsuite);
+        }
+        talloc_free(context->active_testname);
+        context->active_testname = old_testname;
+                context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_PUSH);
+                ret &= torture_run_suite_restricted(context, tsuite, restricted);
+                context->results->ui_ops->progress(context, 0, TORTURE_PROGRESS_POP);
+        }
         if (context->results->ui_ops->suite_finish)
 …
+}
+static bool test_needs_running(const char *name, const char **restricted)
+{
+        int i;
+        if (restricted == NULL)
+                return true;
+        for (i = 0; restricted[i]; i++) {
+                if (!strcmp(name, restricted[i]))
+                        return true;
+        }
+        return false;
+}
 static bool internal_torture_run_test(struct torture_context *context,
                                           struct torture_tcase *tcase,
                                           struct torture_test *test,
+                                          bool already_setup)
+                                          bool already_setup,
+                                          const char **restricted)
+{
         bool success;
         char *old_testname = NULL;
+        char *subunit_testname = NULL;
         if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
+                old_testname = context->active_testname;
+                context->active_testname = talloc_asprintf(context, "%s-%s", old_testname, test->name);
+        }
+                subunit_testname = talloc_asprintf(context, "%s.%s", tcase->name, test->name);
+        } else {
+                subunit_testname = talloc_strdup(context, test->name);
+        }
+        if (!test_needs_running(subunit_testname, restricted))
+                return true;
         context->active_tcase = tcase;
 …
         talloc_free(context->last_reason);
-        if (tcase == NULL || strcmp(test->name, tcase->name) != 0) {
-                talloc_free(context->active_testname);
-                context->active_testname = old_testname;
+        }
         context->active_test = NULL;
         context->active_tcase = NULL;
 …
+}
 bool torture_run_tcase(struct torture_context *context,
+bool torture_run_tcase(struct torture_context *context,
                        struct torture_tcase *tcase)
+{
+        return torture_run_tcase_restricted(context, tcase, NULL);
+}
+bool torture_run_tcase_restricted(struct torture_context *context,
+                       struct torture_tcase *tcase, const char **restricted)
+{
         bool ret = true;
-        char *old_testname;
         struct torture_test *test;
+        bool setup_succeeded = true;
+        const char * setup_reason = "Setup failed";
         context->active_tcase = tcase;
 …
                 context->results->ui_ops->tcase_start(context, tcase);
+        if (tcase->fixture_persistent && tcase->setup
+                && !tcase->setup(context, &tcase->data)) {
+                /* FIXME: Use torture ui ops for reporting this error */
+                fprintf(stderr, "Setup failed: ");
+                if (context->last_reason != NULL)
+                        fprintf(stderr, "%s", context->last_reason);
+                fprintf(stderr, "\n");
+        if (tcase->fixture_persistent && tcase->setup) {
+                setup_succeeded = tcase->setup(context, &tcase->data);
+        }
+        if (!setup_succeeded) {
+                /* Uh-oh. The setup failed, so we can't run any of the tests
+                 * in this testcase. The subunit format doesn't specify what
+                 * to do here, so we keep the failure reason, and manually
+                 * use it to fail every test.
+                 */
+                if (context->last_reason != NULL) {
+                        setup_reason = talloc_asprintf(context,
+                                "Setup failed: %s", context->last_reason);
+                }
+        }
+        for (test = tcase->tests; test; test = test->next) {
+                if (setup_succeeded) {
+                        ret &= internal_torture_run_test(context, tcase, test,
+                                        tcase->fixture_persistent, restricted);
+                } else {
+                        context->active_tcase = tcase;
+                        context->active_test = test;
+                        torture_ui_test_start(context, tcase, test);
+                        torture_ui_test_result(context, TORTURE_FAIL, setup_reason);
+                }
+        }
+        if (setup_succeeded && tcase->fixture_persistent && tcase->teardown &&
+                !tcase->teardown(context, tcase->data)) {
                 ret = false;
+                goto done;
+        }
+        old_testname = context->active_testname;
+        context->active_testname = talloc_asprintf(context, "%s-%s",
+                                                   old_testname, tcase->name);
+        for (test = tcase->tests; test; test = test->next) {
+                ret &= internal_torture_run_test(context, tcase, test,
+                                tcase->fixture_persistent);
+        }
+        talloc_free(context->active_testname);
+        context->active_testname = old_testname;
+        if (tcase->fixture_persistent && tcase->teardown &&
+                !tcase->teardown(context, tcase->data))
+                ret = false;
+done:
+        }
         context->active_tcase = NULL;
+        context->active_test = NULL;
         if (context->results->ui_ops->tcase_finish)
                 context->results->ui_ops->tcase_finish(context, tcase);
         return ret;
+        return (!setup_succeeded) ? false : ret;
+}
 …
                                           struct torture_test *test)
+{
+        return internal_torture_run_test(context, tcase, test, false);
+        return internal_torture_run_test(context, tcase, test, false, NULL);
+}
+bool torture_run_test_restricted(struct torture_context *context,
+                                          struct torture_tcase *tcase,
+                                          struct torture_test *test,
+                                          const char **restricted)
+{
+        return internal_torture_run_test(context, tcase, test, false, restricted);
+}
 …
                                                         int default_value)
+{
+        return lp_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
+        return lpcfg_parm_int(test->lp_ctx, NULL, "torture", name, default_value);
+}
+unsigned long torture_setting_ulong(struct torture_context *test,
+                                    const char *name,
+                                    unsigned long default_value)
+{
+        return lpcfg_parm_ulong(test->lp_ctx, NULL, "torture", name,
+                             default_value);
+}
 …
                                                         double default_value)
+{
         return lp_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
+        return lpcfg_parm_double(test->lp_ctx, NULL, "torture", name, default_value);
+}
 …
                                                         bool default_value)
+{
         return lp_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
+        return lpcfg_parm_bool(test->lp_ctx, NULL, "torture", name, default_value);
+}
 …
         SMB_ASSERT(test->lp_ctx != NULL);
         ret = lp_parm_string(test->lp_ctx, NULL, "torture", name);
+        ret = lpcfg_parm_string(test->lp_ctx, NULL, "torture", name);
         if (ret == NULL)
 …
         return test;
+}
+void torture_ui_report_time(struct torture_context *context)
+{
+        if (context->results->ui_ops->report_time)
+                context->results->ui_ops->report_time(context);
+}

vendor/current/lib/torture/torture.h

-              r414
+              r740
         TORTURE_ERROR=2,
         TORTURE_SKIP=3
+};
+enum torture_progress_whence {
+        TORTURE_PROGRESS_SET,
+        TORTURE_PROGRESS_CUR,
+        TORTURE_PROGRESS_POP,
+        TORTURE_PROGRESS_PUSH,
 };
 …
         void (*test_result) (struct torture_context *,
                                                  enum torture_result, const char *reason);
+        void (*progress) (struct torture_context *, int offset, enum torture_progress_whence whence);
+        void (*report_time) (struct torture_context *);
 };
 …
                                                                 enum torture_result result,
                                                                 const char *comment);
+void torture_ui_report_time(struct torture_context *context);
 /*
 …
         struct torture_results *results;
-        char *active_testname;
         struct torture_test *active_test;
         struct torture_tcase *active_tcase;
 …
         /** Directory used for temporary test data */
         const char *outputdir;
         /** Event context */
         struct tevent_context *ev;
 …
                                            struct torture_suite *suite);
+/* Run the specified testsuite recursively, but only the specified
+ * tests */
+bool torture_run_suite_restricted(struct torture_context *context,
+                       struct torture_suite *suite, const char **restricted);
 /* Run the specified testcase */
 bool torture_run_tcase(struct torture_context *context,
                                            struct torture_tcase *tcase);
+bool torture_run_tcase_restricted(struct torture_context *context,
+                       struct torture_tcase *tcase, const char **restricted);
 /* Run the specified test */
 …
                                           struct torture_test *test);
+bool torture_run_test_restricted(struct torture_context *context,
+                                          struct torture_tcase *tcase,
+                                          struct torture_test *test,
+                                          const char **restricted);
 void torture_comment(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
 void torture_warning(struct torture_context *test, const char *comment, ...) PRINTF_ATTRIBUTE(2,3);
 …
                 torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
                 return false; \
+        }
+#define torture_assert_goto(torture_ctx,expr,ret,label,cmt) \
+        if (!(expr)) { \
+                torture_result(torture_ctx, TORTURE_FAIL, __location__": Expression `%s' failed: %s", __STRING(expr), cmt); \
+                ret = false; \
+                goto label; \
+        }
 …
                                            __location__": "#got" was %s, expected %s: %s", \
                                            __got, __expected, cmt); \
+                return false; \
+        } \
+        } while(0)
+#define torture_assert_strn_equal(torture_ctx,got,expected,len,cmt)\
+        do { const char *__got = (got), *__expected = (expected); \
+        if (strncmp(__got, __expected, len) != 0) { \
+                torture_result(torture_ctx, TORTURE_FAIL, \
+                                           __location__": "#got" %s of len %d did not match "#expected" %s: %s", \
+                                           __got, (int)len, __expected, cmt); \
                 return false; \
         } \
 …
         if (__got != __expected) { \
                 torture_result(torture_ctx, TORTURE_FAIL, \
                         __location__": "#got" was %d, expected %d: %s", \
                         __got, __expected, cmt); \
+                        __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
+                        __got, __got, __expected, __expected, cmt); \
                 return false; \
         } \
 …
         if (__got != __expected) { \
                 torture_result(torture_ctx, TORTURE_FAIL, \
                         __location__": "#got" was %d, expected %d: %s", \
                         __got, __expected, cmt); \
+                        __location__": "#got" was %d (0x%X), expected %d (0x%X): %s", \
+                        __got, __got, __expected, __expected, cmt); \
                 ret = false; \
                 goto label; \
 …
         if (__got != __expected) { \
                 torture_result(torture_ctx, TORTURE_FAIL, \
+                        __location__": "#got" was %llu, expected %llu: %s", \
+                        (unsigned long long)__got, (unsigned long long)__expected, cmt); \
+                return false; \
+                        __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
+                        (unsigned long long)__got, (unsigned long long)__got, \
+                        (unsigned long long)__expected, (unsigned long long)__expected, \
+                        cmt); \
+                return false; \
+        } \
+        } while(0)
+#define torture_assert_u64_equal_goto(torture_ctx,got,expected,ret,label,cmt)\
+        do { uint64_t __got = (got), __expected = (expected); \
+        if (__got != __expected) { \
+                torture_result(torture_ctx, TORTURE_FAIL, \
+                        __location__": "#got" was %llu (0x%llX), expected %llu (0x%llX): %s", \
+                        (unsigned long long)__got, (unsigned long long)__got, \
+                        (unsigned long long)__expected, (unsigned long long)__expected, \
+                        cmt); \
+                ret = false; \
+                goto label; \
         } \
         } while(0)
 …
         } while(0)
+#define torture_assert_nttime_equal(torture_ctx,got,expected,cmt) \
+        do { NTTIME __got = got, __expected = expected; \
+        if (!nt_time_equal(&__got, &__expected)) { \
+                torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", nt_time_string(tctx, __got), nt_time_string(tctx, __expected), cmt); \
+                return false; \
+        }\
+        } while(0)
 #define torture_skip(torture_ctx,cmt) do {\
 …
                                                                                  const char *name);
+unsigned long torture_setting_ulong(struct torture_context *test,
+                                    const char *name,
+                                    unsigned long default_value);
 NTSTATUS torture_temp_dir(struct torture_context *tctx,
                                    const char *prefix,
                                    char **tempdir);
+NTSTATUS torture_deltree_outputdir(struct torture_context *tctx);
 struct torture_test *torture_tcase_add_simple_test(struct torture_tcase *tcase,
 …
                               struct torture_tcase *tcase,
                               const char *name);
+int torture_suite_children_count(const struct torture_suite *suite);
 struct torture_context *torture_context_init(struct tevent_context *event_ctx, struct torture_results *results);

vendor/current/lib/torture/torture.pc.in

r414	r740
9	9	Requires: talloc
10	10	Version: 0.0.1
11		Libs: ~~-L${libdir} -ltorture~~
	11	Libs: @LIB_RPATH@ -L${libdir} -ltorture
12	12	Cflags: -I${includedir} -DHAVE_IMMEDIATE_STRUCTURES=1

vendor/current/lib/tsocket/tsocket.c

-              r414
+              r740
                 return -1;
         default:
+                *perrno = EIO;
+                return -1;
+                break;
+        }

vendor/current/lib/tsocket/tsocket.h

-              r478
+              r740
 /**
  * @brief Get a string representaion of the endpoint.
+ * @brief Get a string representation of the endpoint.
+ *
  * This function creates a string representation of the endpoint for debugging.
 …
  * @return              The address as a string representation, NULL on error.
+ *
+ * @see tsocket_address_is_inet()
  * @see tsocket_address_inet_addr_string()
  * @see tsocket_address_inet_port()
 …
  * @{
  */
+/**
+ * @brief Find out if the tsocket_address represents an ipv4 or ipv6 endpoint.
+ *
+ * @param[in]  addr     The tsocket_address pointer
+ *
+ * @param[in]  fam      The family can be can be "ipv4", "ipv6" or "ip". With
+ *                      "ip" is autodetects "ipv4" or "ipv6" based on the
+ *                      addr.
+ *
+ * @return              true if addr represents an address of the given family,
+ *                      otherwise false.
+ */
+bool tsocket_address_is_inet(const struct tsocket_address *addr, const char *fam);
 #if DOXYGEN
 …
  * @return              A newly allocated string of the address, NULL on error
  *                      with errno set.
+ *
+ * @see tsocket_address_is_inet()
  */
 char *tsocket_address_inet_addr_string(const struct tsocket_address *addr,
 …
                                   uint16_t port);
+/**
+ * @brief Find out if the tsocket_address represents an unix domain endpoint.
+ *
+ * @param[in]  addr     The tsocket_address pointer
+ *
+ * @return              true if addr represents an unix domain endpoint,
+ *                      otherwise false.
+ */
+bool tsocket_address_is_unix(const struct tsocket_address *addr);
 #ifdef DOXYGEN
 /**
 …
+ *
  * @return              0 on success, -1 on error with errno set.
+ *
+ * @see tsocket_address_is_unix()
  */
 int tsocket_address_unix_from_path(TALLOC_CTX *mem_ctx,
 …
  * @param[in]  mem_ctx  The talloc memory context to use.
+ *
  * @param[in]  stream   A tstream_context pointer to setup the tcp communication
+ * @param[out] stream   A tstream_context pointer to setup the tcp communication
  *                      on. This function will allocate the memory.
+ *
+ * @param[out] local    The real 'inet' tsocket_address of the local endpoint.
+ *                      This parameter is optional and can be NULL.
+ *
  * @return              0 on success, -1 on error with perrno set.
 …
                                   int *perrno,
                                   TALLOC_CTX *mem_ctx,
+                                  struct tstream_context **stream);
+                                  struct tstream_context **stream,
+                                  struct tsocket_address **local)
 #else
 int _tstream_inet_tcp_connect_recv(struct tevent_req *req,
 …
                                    TALLOC_CTX *mem_ctx,
                                    struct tstream_context **stream,
+                                   struct tsocket_address **local,
                                    const char *location);
 #define tstream_inet_tcp_connect_recv(req, perrno, mem_ctx, stream) \
         _tstream_inet_tcp_connect_recv(req, perrno, mem_ctx, stream, \
+#define tstream_inet_tcp_connect_recv(req, perrno, mem_ctx, stream, local) \
+        _tstream_inet_tcp_connect_recv(req, perrno, mem_ctx, stream, local, \
                                        __location__)
 #endif
 …
  * 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.
+ * @param[in]  mem_ctx  The talloc memory context to use.
+ *
+ * @param[in]  fd       The non blocking fd to use!
+ *
+ * @param[out] stream   A pointer to store an allocated tstream_context.
+ *
+ * @return              0 on success, -1 on error.
+ *
+ * Example:
+ * @code
+ *   fd2 = dup(fd);
+ *   rc = tstream_bsd_existing_socket(mem_ctx, fd2, &tstream);
+ *   if (rc < 0) {
+ *     stream_terminate_connection(conn, "named_pipe_accept: out of memory");
+ *     return;
+ *   }
+ * @endcode
+ *
+ * @warning This is an internal function. You should read the code to fully
+ *          understand it if you plan to use it.
  */
 int tstream_bsd_existing_socket(TALLOC_CTX *mem_ctx,

vendor/current/lib/tsocket/tsocket_bsd.c

-              r478
+              r740
         bsda->sa_socklen = sa_socklen;
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        bsda->u.sa.sa_len = bsda->sa_socklen;
+#endif
         *_addr = addr;
 …
         memcpy(sa, &bsda->u.ss, sa_socklen);
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        sa->sa_len = sa_socklen;
+#endif
         return sa_socklen;
+}
+bool tsocket_address_is_inet(const struct tsocket_address *addr, const char *fam)
+{
+        struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
+                                           struct tsocket_address_bsd);
+        if (!bsda) {
+                return false;
+        }
+        switch (bsda->u.sa.sa_family) {
+        case AF_INET:
+                if (strcasecmp(fam, "ip") == 0) {
+                        return true;
+                }
+                if (strcasecmp(fam, "ipv4") == 0) {
+                        return true;
+                }
+                return false;
+#ifdef HAVE_IPV6
+        case AF_INET6:
+                if (strcasecmp(fam, "ip") == 0) {
+                        return true;
+                }
+                if (strcasecmp(fam, "ipv6") == 0) {
+                        return true;
+                }
+                return false;
+#endif
+        }
+        return false;
+}
 …
         return 0;
+}
+bool tsocket_address_is_unix(const struct tsocket_address *addr)
+{
+        struct tsocket_address_bsd *bsda = talloc_get_type(addr->private_data,
+                                           struct tsocket_address_bsd);
+        if (!bsda) {
+                return false;
+        }
+        switch (bsda->u.sa.sa_family) {
+        case AF_UNIX:
+                return true;
+        }
+        return false;
+}
 …
         ZERO_STRUCTP(bsda);
         bsda->sa_socklen = sizeof(bsda->u.ss);
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+        bsda->u.sa.sa_len = bsda->sa_socklen;
+#endif
         ret = recvfrom(bsds->fd, state->buf, state->len, 0,
 …
+        }
+        TALLOC_FREE(bsds->fde);
         ret = close(bsds->fd);
         bsds->fd = -1;
 …
         fd = socket(sa_fam, SOCK_DGRAM, 0);
         if (fd < 0) {
                 return fd;
+                return -1;
+        }
         fd = tsocket_bsd_common_prepare_fd(fd, true);
         if (fd < 0) {
                 return fd;
+                return -1;
+        }
 …
                         talloc_free(dgram);
                         errno = saved_errno;
                         return ret;
+                        return -1;
+                }
+        }
 …
                         talloc_free(dgram);
                         errno = saved_errno;
                         return ret;
+                        return -1;
+                }
+        }
 …
                         talloc_free(dgram);
                         errno = saved_errno;
                         return ret;
+                        return -1;
+                }
+        }
 …
                         talloc_free(dgram);
                         errno = saved_errno;
                         return ret;
+                        return -1;
+                }
+        }
 …
                         talloc_free(dgram);
                         errno = saved_errno;
                         return ret;
+                        return -1;
+                }
+        }
 …
                         base = (uint8_t *)state->vector[0].iov_base;
                         base += ret;
                         state->vector[0].iov_base = base;
+                        state->vector[0].iov_base = (void *)base;
                         state->vector[0].iov_len -= ret;
                         break;
 …
                         base = (uint8_t *)state->vector[0].iov_base;
                         base += ret;
                         state->vector[0].iov_base = base;
+                        state->vector[0].iov_base = (void *)base;
                         state->vector[0].iov_len -= ret;
                         break;
 …
+        }
+        TALLOC_FREE(bsds->fde);
         ret = close(bsds->fd);
         bsds->fd = -1;
 …
         struct tevent_fd *fde;
         struct tstream_conext *stream;
+        struct tsocket_address *local;
 };
 …
                                             void *private_data);
 static struct tevent_req * tstream_bsd_connect_send(TALLOC_CTX *mem_ctx,
+static struct tevent_req *tstream_bsd_connect_send(TALLOC_CTX *mem_ctx,
                                         struct tevent_context *ev,
                                         int sys_errno,
 …
                 talloc_get_type_abort(local->private_data,
                 struct tsocket_address_bsd);
+        struct tsocket_address_bsd *lrbsda = NULL;
         struct tsocket_address_bsd *rbsda =
                 talloc_get_type_abort(remote->private_data,
 …
+        }
+        if (is_inet) {
+                state->local = tsocket_address_create(state,
+                                                      &tsocket_address_bsd_ops,
+                                                      &lrbsda,
+                                                      struct tsocket_address_bsd,
+                                                      __location__ "bsd_connect");
+                if (tevent_req_nomem(state->local, req)) {
+                        goto post;
+                }
+                ZERO_STRUCTP(lrbsda);
+                lrbsda->sa_socklen = sizeof(lrbsda->u.ss);
+#ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
+                lrbsda->u.sa.sa_len = lrbsda->sa_socklen;
+#endif
+        }
         state->fd = socket(sa_fam, SOCK_STREAM, 0);
         if (state->fd == -1) {
 …
+        }
         if (tevent_req_error(req, err)) {
+                goto post;
+        }
+        if (!state->local) {
+                tevent_req_done(req);
+                goto post;
+        }
+        ret = getsockname(state->fd, &lrbsda->u.sa, &lrbsda->sa_socklen);
+        if (ret == -1) {
+                tevent_req_error(req, errno);
                 goto post;
+        }
 …
         struct tstream_bsd_connect_state *state = tevent_req_data(req,
                                         struct tstream_bsd_connect_state);
+        struct tsocket_address_bsd *lrbsda = NULL;
         int ret;
         int error=0;
 …
+        }
+        if (!state->local) {
+                tevent_req_done(req);
+                return;
+        }
+        lrbsda = talloc_get_type_abort(state->local->private_data,
+                                       struct tsocket_address_bsd);
+        ret = getsockname(state->fd, &lrbsda->u.sa, &lrbsda->sa_socklen);
+        if (ret == -1) {
+                tevent_req_error(req, errno);
+                return;
+        }
         tevent_req_done(req);
+}
 …
                                     TALLOC_CTX *mem_ctx,
                                     struct tstream_context **stream,
+                                    struct tsocket_address **local,
                                     const char *location)
+{
 …
                 TALLOC_FREE(state->fde);
                 state->fd = -1;
+                if (local) {
+                        *local = talloc_move(mem_ctx, &state->local);
+                }
+        }
 …
                                    TALLOC_CTX *mem_ctx,
                                    struct tstream_context **stream,
+                                   struct tsocket_address **local,
                                    const char *location)
+{
+        return tstream_bsd_connect_recv(req, perrno, mem_ctx, stream, location);
+        return tstream_bsd_connect_recv(req, perrno,
+                                        mem_ctx, stream, local,
+                                        location);
+}
 …
                                       const char *location)
+{
+        return tstream_bsd_connect_recv(req, perrno, mem_ctx, stream, location);
+        return tstream_bsd_connect_recv(req, perrno,
+                                        mem_ctx, stream, NULL,
+                                        location);
+}

vendor/current/lib/tsocket/tsocket_guide.txt

-              r414
+              r740
 ===============================
 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 later sections.
+There's a function get the string representation of the
 endpoint for debugging. Callers should not try to parse
+the string! The should use additional methods of the specific
 tsocket_address implemention to get more details.
+A tsocket_address represents a generic socket endpoint.
+It behaves like an abstract class, therefore it has no direct constructor.
+Constructors are described in later sections of this document.
+A function get the string representation of an endpoint for debugging is
+available but callers SHOULD NOT try to parse this string. To get more
+details callers should use getter methods of the specific tsocket_address
+implemention.
   char *tsocket_address_string(const struct tsocket_address *addr,
       TALLOC_CTX *mem_ctx);
 There's a function to create a copy of the tsocket_address.
 This is useful when before doing modifications to a socket
+A function to create a copy of the tsocket_address is also avilable.
+This is useful before doing modifications to a socket
 via additional methods of the specific tsocket_address implementation.
 …
 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.
+functions similar to recvfrom(2)/sendto(2)/close(2) syscalls.
 The tdgram_recvfrom_send() method can be called to ask for the
 next available datagram on the abstracted tdgram_context.
+next available datagram from 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.
+when a datagram is available or an error occurs.
 The callback is then supposed to get the result by calling
 …
 ===============================
 The tstream_context is like an abstract class for stream
+A 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.
+The tstream_pending_bytes() function is able to report
+how much bytes of the incoming stream have arrived
+but not consumed yet. It returns -1 and sets 'errno' on failure.
+Otherwise it returns the number of uncomsumed bytes
+(it can return 0!).
+functions similar to the readv(2)/writev(2)/close(2) syscalls.
+The tstream_pending_bytes() function is able to report how many bytes of
+the incoming stream have been received but have not been consumed yet.
+It returns -1 and sets 'errno' on failure.
+Otherwise it returns the number of uncomsumed bytes (it can return 0!).
   ssize_t tstream_pending_bytes(struct tstream_context *stream);
 The tstream_readv_send() method can be called to read for a
+The tstream_readv_send() method can be called to read a
 specific amount of bytes from the stream into the buffers
 of the given iovec vector. The caller has to preallocate the buffers
 …
 where the caller can register a callback with tevent_req_set_callback().
 The callback is triggered when all iovec buffers are completely
 filled with bytes from the socket or an error happened.
+filled with bytes from the socket or an error occurs.
 The callback is then supposed to get the result by calling
 tstream_readv_recv() on the 'tevent_req'. It returns -1
 and sets '*perrno' to the actual 'errno' on failure.
+Otherwise it returns the length of the datagram
+(0 is never returned!).
+Otherwise it returns the length of the datagram (0 is never returned!).
 The caller can only have one outstanding tstream_readv_send()
 …
 The tstream_writev_send() method can be called to write
 buffers in the given iovec vector into the stream socket.
 It's invalid to pass an empty vector.
+It is invalid to pass an empty vector.
 tstream_writev_send() returns a 'tevent_req' handle,
 where the caller can register a callback with tevent_req_set_callback().
 …
       int *perrno);
 The tstream_disconnect_send() method should be used to normally
+The tstream_disconnect_send() method should normally be used to
 shutdown/close the abstracted socket.
 …
 ============================
 In order to make the live easier for callers which want to implement
+In order to simplify the job, for callers that want to implement
 a function to receive a full PDU with a single async function pair,
 there're some helper functions.
+some helper functions are provided.
 The caller can use the tstream_readv_pdu_send() function
 …
 The caller needs to provide a "next_vector" function and a private
 state for this function. The tstream_readv_pdu engine will ask
 the next_vector function for the next iovec vetor to be filled.
+the next_vector function for the next iovec vector to be used.
 There's a tstream_readv_send/recv pair for each vector returned
 by the next_vector function. If the next_vector function detects
 …
 of the tevent_req (returned by tstream_readv_pdu_send()) is triggered.
 Note: the buffer allocation is completely up to the next_vector function
 and it's private state.
+and its private state.
 See the 'dcerpc_read_ncacn_packet_send/recv' functions in Samba as an
 …
 ===========================================
 There're some cases where the caller wants doesn't care about the
 order of doing IO on the abstracted sockets.
+In some cases the caller doesn't care about the IO ordering on the
+abstracted socket.
 (Remember at the low level there's always only one IO in a specific
  direction allowed, only one tdgram_sendto_send() at a time).
+There're some helpers using 'tevent_queue' to make it easier
+for callers. The functions just get a 'queue' argument
 and serialize the operations.
+Some helpers that use 'tevent_queue' are avilable to simplify handling
+multiple IO requests. The functions just get a 'queue' argument and
+internally serialize all operations.
   struct tevent_req *tdgram_sendto_queue_send(TALLOC_CTX *mem_ctx,
 …
 (dns names are not allowed!). But it's valid to pass NULL,
 which gets mapped to "0.0.0.0" or "::".
 It return -1 and set errno on error. Otherwise it returns 0.
+It returns -1 and sets errno on error. Otherwise it returns 0.
   int tsocket_address_inet_from_strings(TALLOC_CTX *mem_ctx,
 …
 you can use the tsocket_address_unix_path() function.
 It will return NULL and set errno to EINVAL if the tsocket_address
 doesn't represent an unix domain endpoint path.
+doesn't represent a unix domain endpoint path.
   char *tsocket_address_unix_path(const struct tsocket_address *addr,
 …
       struct tdgram_context **dgram);
 You can use tstream_inet_tcp_connect_send to async
+You can use tstream_inet_tcp_connect_send to asynchronously
 connect to a remote ipv4 or ipv6 TCP endpoint and create a
 tstream_context for the stream based communication. "local_address" has to be
 …
       struct tstream_context **stream);
 You can use tstream_unix_connect_send to async
+You can use tstream_unix_connect_send to asynchronously
 connect to a unix domain endpoint and create a
 tstream_context for the stream based communication.
 …
 for that. This should only be used if really needed, because of
 already existing fixed APIs. Only AF_INET, AF_INET6 and AF_UNIX
 sockets are allowed. The function returns -1 and set errno on error.
+sockets are allowed. The function returns -1 and sets errno on error.
 Otherwise it returns 0.

vendor/current/lib/uid_wrapper/uid_wrapper.c

-              r414
+              r740
  */
+#ifdef _SAMBA_BUILD_
 #define UID_WRAPPER_NOT_REPLACE
+#include "includes.h"
+#include "../replace/replace.h"
+#include <talloc.h>
 #include "system/passwd.h"
+#include "system/filesys.h"
+#else /* _SAMBA_BUILD_ */
+#error uid_wrapper_only_supported_in_samba_yet
+#endif
 #ifndef _PUBLIC_
 …
                 /* put us in one group */
                 uwrap.ngroups = 1;
                 uwrap.groups = talloc_array(talloc_autofree_context(), gid_t, 1);
+                uwrap.groups = talloc_array(NULL, gid_t, 1);
                 uwrap.groups[0] = 0;
+        }
 …
         if (size != 0) {
                 uwrap.groups = talloc_array(talloc_autofree_context(), gid_t, size);
+                uwrap.groups = talloc_array(NULL, gid_t, size);
                 if (uwrap.groups == NULL) {
                         errno = ENOMEM;

vendor/current/lib/uid_wrapper/uid_wrapper.h

-              r414
+              r740
 #ifndef __UID_WRAPPER_H__
 #define __UID_WRAPPER_H__
+#ifndef uwrap_enabled
+int uwrap_enabled(void);
+int uwrap_seteuid(uid_t euid);
+uid_t uwrap_geteuid(void);
+int uwrap_setegid(gid_t egid);
+uid_t uwrap_getegid(void);
+int uwrap_setgroups(size_t size, const gid_t *list);
+int uwrap_getgroups(int size, gid_t *list);
+uid_t uwrap_getuid(void);
+gid_t uwrap_getgid(void);
 #ifdef seteuid
 …
 #define getgid  uwrap_getgid
+int uwrap_enabled(void);
+#endif
 #endif /* __UID_WRAPPER_H__ */

vendor/current/lib/util/asn1.c

-              r597
+              r740
+}
 bool ber_write_OID_String(DATA_BLOB *blob, const char *OID)
+{
         uint_t v, v2;
+bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID)
+{
+        unsigned int v, v2;
         const char *p = (const char *)OID;
         char *newp;
         int i;
+        if (!isdigit(*p)) return false;
         v = strtoul(p, &newp, 10);
         if (newp[0] != '.') return false;
         p = newp + 1;
+        if (!isdigit(*p)) return false;
         v2 = strtoul(p, &newp, 10);
         if (newp[0] != '.') return false;
 …
         /*the ber representation can't use more space then the string one */
         *blob = data_blob(NULL, strlen(OID));
+        *blob = data_blob_talloc(mem_ctx, NULL, strlen(OID));
         if (!blob->data) return false;
 …
         i = 1;
         while (*p) {
+                if (!isdigit(*p)) return false;
                 v = strtoul(p, &newp, 10);
                 if (newp[0] == '.') {
                         p = newp + 1;
+                        /* check for empty last component */
+                        if (!*p) return false;
                 } else if (newp[0] == '\0') {
                         p = newp;
 …
+}
+/**
+ * Serialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid)
+{
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        char *oid = talloc_strdup(tmp_ctx, partial_oid);
+        char *p;
+        /* truncate partial part so ber_write_OID_String() works */
+        p = strchr(oid, ':');
+        if (p) {
+                *p = '\0';
+                p++;
+        }
+        if (!ber_write_OID_String(mem_ctx, blob, oid)) {
+                talloc_free(tmp_ctx);
+                return false;
+        }
+        /* Add partially encoded sub-identifier */
+        if (p) {
+                DATA_BLOB tmp_blob = strhex_to_data_blob(tmp_ctx, p);
+                if (!data_blob_append(mem_ctx, blob, tmp_blob.data,
+                                      tmp_blob.length)) {
+                        talloc_free(tmp_ctx);
+                        return false;
+                }
+        }
+        talloc_free(tmp_ctx);
+        return true;
+}
 /* write an object ID to a ASN1 buffer */
 bool asn1_write_OID(struct asn1_data *data, const char *OID)
 …
         if (!asn1_push_tag(data, ASN1_OID)) return false;
         if (!ber_write_OID_String(&blob, OID)) {
+        if (!ber_write_OID_String(NULL, &blob, OID)) {
                 data->has_error = true;
                 return false;
 …
         return (b == tag);
+}
+/*
+ * just get the needed size the tag would consume
+ */
+bool asn1_peek_tag_needed_size(struct asn1_data *data, uint8_t tag, size_t *size)
+{
+        off_t start_ofs = data->ofs;
+        uint8_t b;
+        size_t taglen = 0;
+        if (data->has_error) {
+                return false;
+        }
+        if (!asn1_read_uint8(data, &b)) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+        if (b != tag) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+        if (!asn1_read_uint8(data, &b)) {
+                data->ofs = start_ofs;
+                data->has_error = false;
+                return false;
+        }
+        if (b & 0x80) {
+                int n = b & 0x7f;
+                if (!asn1_read_uint8(data, &b)) {
+                        data->ofs = start_ofs;
+                        data->has_error = false;
+                        return false;
+                }
+                if (n > 4) {
+                        /*
+                         * We should not allow more than 4 bytes
+                         * for the encoding of the tag length.
+                         *
+                         * Otherwise we'd overflow the taglen
+                         * variable on 32 bit systems.
+                         */
+                        data->ofs = start_ofs;
+                        data->has_error = false;
+                        return false;
+                }
+                taglen = b;
+                while (n > 1) {
+                        if (!asn1_read_uint8(data, &b)) {
+                                data->ofs = start_ofs;
+                                data->has_error = false;
+                                return false;
+                        }
+                        taglen = (taglen << 8) | b;
+                        n--;
+                }
+        } else {
+                taglen = b;
+        }
+        *size = (data->ofs - start_ofs) + taglen;
+        data->ofs = start_ofs;
+        data->has_error = false;
+        return true;
+}
 …
+}
+/* read an object ID from a data blob */
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID)
+/**
+ * Internal implementation for reading binary OIDs
+ * Reading is done as far in the buffer as valid OID
+ * till buffer ends or not valid sub-identifier is found.
+ */
+static bool _ber_read_OID_String_impl(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
+                                      char **OID, size_t *bytes_eaten)
+{
         int i;
         uint8_t *b;
         uint_t v;
+        unsigned int v;
         char *tmp_oid = NULL;
 …
         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  b[0]%40);
         if (!tmp_oid) goto nomem;
+        if (bytes_eaten != NULL) {
+                *bytes_eaten = 0;
+        }
         for(i = 1, v = 0; i < blob.length; i++) {
 …
                         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  v);
                         v = 0;
+                        if (bytes_eaten)
+                                *bytes_eaten = i+1;
+                }
                 if (!tmp_oid) goto nomem;
+        }
-        if (v != 0) {
-                talloc_free(tmp_oid);
-                return false;
+        }
         *OID = tmp_oid;
         return true;
 nomem:
+nomem:
         return false;
+}
+/* read an object ID from a data blob */
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **OID)
+{
+        size_t bytes_eaten;
+        if (!_ber_read_OID_String_impl(mem_ctx, blob, OID, &bytes_eaten))
+                return false;
+        return (bytes_eaten == blob.length);
+}
+/**
+ * Deserialize partial OID string.
+ * Partial OIDs are in the form:
+ *   1:2.5.6:0x81
+ *   1:2.5.6:0x8182
+ */
+bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
+                                 char **partial_oid)
+{
+        size_t bytes_left;
+        size_t bytes_eaten;
+        char *identifier = NULL;
+        char *tmp_oid = NULL;
+        if (!_ber_read_OID_String_impl(mem_ctx, blob, &tmp_oid, &bytes_eaten))
+                return false;
+        if (bytes_eaten < blob.length) {
+                bytes_left = blob.length - bytes_eaten;
+                identifier = hex_encode_talloc(mem_ctx, &blob.data[bytes_eaten], bytes_left);
+                if (!identifier)        goto nomem;
+                *partial_oid = talloc_asprintf_append_buffer(tmp_oid, ":0x%s", identifier);
+                if (!*partial_oid)      goto nomem;
+                TALLOC_FREE(identifier);
+        } else {
+                *partial_oid = tmp_oid;
+        }
+        return true;
+nomem:
+        TALLOC_FREE(identifier);
+        TALLOC_FREE(tmp_oid);
+        return false;
+}
 /* read an object ID from a ASN1 buffer */
 bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, const char **OID)
+bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **OID)
+{
         DATA_BLOB blob;
 …
 bool asn1_check_OID(struct asn1_data *data, const char *OID)
+{
         const char *id;
+        char *id;
         if (!asn1_read_OID(data, data, &id)) return false;
         if (strcmp(id, OID) != 0) {
                 talloc_free(discard_const(id));
                 data->has_error = true;
                 return false;
+        }
         talloc_free(discard_const(id));
+                talloc_free(id);
+                data->has_error = true;
+                return false;
+        }
+        talloc_free(id);
         return true;
+}
 …
         if (size > blob.length) {
                 return STATUS_MORE_ENTRIES;
+        }
+        }
         *packet_size = size;
         return NT_STATUS_OK;
+}
+NTSTATUS asn1_peek_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size)
+{
+        struct asn1_data asn1;
+        size_t size;
+        bool ok;
+        ZERO_STRUCT(asn1);
+        asn1.data = blob.data;
+        asn1.length = blob.length;
+        ok = asn1_peek_tag_needed_size(&asn1, tag, &size);
+        if (!ok) {
+                return NT_STATUS_INVALID_BUFFER_SIZE;
+        }
+        if (size > blob.length) {
+                *packet_size = size;
+                return STATUS_MORE_ENTRIES;
+        }
+        *packet_size = size;
+        return NT_STATUS_OK;
+}

vendor/current/lib/util/asn1.h

-              r414
+              r740
 bool asn1_write_Integer(struct asn1_data *data, int i);
 bool asn1_write_BitString(struct asn1_data *data, const void *p, size_t length, uint8_t padding);
+bool ber_write_OID_String(DATA_BLOB *blob, const char *OID);
+bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID);
+bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid);
 bool asn1_write_OID(struct asn1_data *data, const char *OID);
 bool asn1_write_OctetString(struct asn1_data *data, const void *p, size_t length);
 …
 bool asn1_read_uint8(struct asn1_data *data, uint8_t *v);
 bool asn1_peek_uint8(struct asn1_data *data, uint8_t *v);
+bool asn1_peek_tag_needed_size(struct asn1_data *data, uint8_t tag, size_t *size);
 bool asn1_peek_tag(struct asn1_data *data, uint8_t tag);
 bool asn1_start_tag(struct asn1_data *data, uint8_t tag);
 bool asn1_end_tag(struct asn1_data *data);
 int asn1_tag_remaining(struct asn1_data *data);
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, const char **OID);
+bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, const char **OID);
+bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **OID);
+bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **partial_oid);
+bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **OID);
 bool asn1_check_OID(struct asn1_data *data, const char *OID);
 bool asn1_read_LDAPString(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **s);
 …
 void asn1_load_nocopy(struct asn1_data *data, uint8_t *buf, size_t len);
 NTSTATUS asn1_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size);
+NTSTATUS asn1_peek_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size);
 #endif /* _ASN_1_H */

vendor/current/lib/util/attr.h

-              r414
+              r740
 #  define UNUSED(param) param
 /** Feel free to add definitions for other compilers here. */
-#endif
-#ifdef HAVE_VISIBILITY_ATTR
-#  define _PUBLIC_ __attribute__((visibility("default")))
-#else
-#  define _PUBLIC_
 #endif
 …
 #endif
+#ifndef FORMAT_ATTRIBUTE
+#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
+/** Use gcc attribute to check printf fns.  a1 is argument to format()
+ * in the above macro.  This is needed to support Heimdal's printf
+ * decorations. Note that some gcc 2.x versions don't handle this
+ * properly, and as such I've used the same minimum from heimdal: GCC 3.1 **/
+#define FORMAT_ATTRIBUTE(a) __attribute__ ((format a))
+#else
+#define FORMAT_ATTRIBUTE(a)
+#endif
+#endif
 #endif /* __UTIL_ATTR_H__ */

vendor/current/lib/util/become_daemon.c

-              r414
+              r740
 ****************************************************************************/
 _PUBLIC_ void become_daemon(bool do_fork, bool no_process_group)
+_PUBLIC_ void become_daemon(bool do_fork, bool no_process_group, bool log_stdout)
+{
         if (do_fork) {
 …
 #endif /* HAVE_SETSID */
+        /* Close fd's 0,1,2. Needed if started by rsh */
+        close_low_fds(false);  /* Don't close stderr, let the debug system
+                                  attach it to the logfile */
+        if (!log_stdout) {
+                /* Close fd's 0,1,2. Needed if started by rsh */
+                close_low_fds(false);  /* Don't close stderr, let the debug system
+                                          attach it to the logfile */
+        }
+}

vendor/current/lib/util/binsearch.h

-              r414
+              r740
         }} } while (0)
+/*
+  like BINARY_ARRAY_SEARCH_P, but assumes that the array is an array
+  of elements, rather than pointers to structures
+  result points to the found structure, or NULL
+ */
+#define BINARY_ARRAY_SEARCH_V(array, array_size, target, comparison_fn, result) do { \
+        int32_t _b, _e; \
+        (result) = NULL; \
+        if (array_size) { for (_b = 0, _e = (array_size)-1; _b <= _e; ) {       \
+                int32_t _i = (_b+_e)/2; \
+                int _r = comparison_fn(target, array[_i]); \
+                if (_r == 0) { (result) = &array[_i]; break; } \
+                if (_r < 0) _e = _i - 1; else _b = _i + 1; \
+        }} } while (0)
 #endif

vendor/current/lib/util/byteorder.h

-              r414
+              r740
 #define CVAL(buf,pos) (((uint8_t *)(buf))[pos])
 #define PVAL(buf,pos) ((uint_t)CVAL(buf,pos))
+#define PVAL(buf,pos) ((unsigned int)CVAL(buf,pos))
 #define SVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+1)<<8)
 …
 #endif
 #define CVAL(buf,pos) ((uint_t)(((const uint8_t *)(buf))[pos]))
+#define CVAL(buf,pos) ((unsigned int)(((const uint8_t *)(buf))[pos]))
 #define CVAL_NC(buf,pos) (((uint8_t *)(buf))[pos]) /* Non-const version of CVAL */
 #define PVAL(buf,pos) (CVAL(buf,pos))
 …
 /* get single value from an SMB buffer */
 #define SVAL(buf,pos) (*(const uint16_t *)((const char *)(buf) + (pos)))
 #define SVAL_NC(buf,pos) (*(uint16_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define SVAL_NC(buf,pos) (*(uint16_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 #define IVAL(buf,pos) (*(const uint32_t *)((const char *)(buf) + (pos)))
 #define IVAL_NC(buf,pos) (*(uint32_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define IVAL_NC(buf,pos) (*(uint32_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 #define SVALS(buf,pos) (*(const int16_t *)((const char *)(buf) + (pos)))
 #define SVALS_NC(buf,pos) (*(int16_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define SVALS_NC(buf,pos) (*(int16_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 #define IVALS(buf,pos) (*(const int32_t *)((const char *)(buf) + (pos)))
 #define IVALS_NC(buf,pos) (*(int32_t *)((char *)(buf) + (pos))) /* Non const version of above. */
+#define IVALS_NC(buf,pos) (*(int32_t *)((void *)((char *)(buf) + (pos)))) /* Non const version of above. */
 /* store single value in an SMB buffer */
 …
 #endif /* not CAREFUL_ALIGNMENT */
-/* now the reverse routines - these are used in nmb packets (mostly) */
-#define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
-#define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))
-#define RSVAL(buf,pos) SREV(SVAL(buf,pos))
-#define RSVALS(buf,pos) SREV(SVALS(buf,pos))
-#define RIVAL(buf,pos) IREV(IVAL(buf,pos))
-#define RIVALS(buf,pos) IREV(IVALS(buf,pos))
-#define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
-#define RSSVALS(buf,pos,val) SSVALS(buf,pos,SREV(val))
-#define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
-#define RSIVALS(buf,pos,val) SIVALS(buf,pos,IREV(val))
-/* Alignment macros. */
-#define ALIGN4(p,base) ((p) + ((4 - (PTR_DIFF((p), (base)) & 3)) & 3))
-#define ALIGN2(p,base) ((p) + ((2 - (PTR_DIFF((p), (base)) & 1)) & 1))
-/* macros for accessing SMB protocol elements */
-#define VWV(vwv) ((vwv)*2)
 /* 64 bit macros */
 #define BVAL(p, ofs) (IVAL(p,ofs) | (((uint64_t)IVAL(p,(ofs)+4)) << 32))
 …
 #define SBVALS(p, ofs, v) (SBVAL(p,ofs,(uint64_t)v))
+/* now the reverse routines - these are used in nmb packets (mostly) */
+#define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
+#define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))
+#define BREV(x) ((IREV(x)<<32) | (IREV((x)>>32)))
+#define RSVAL(buf,pos) SREV(SVAL(buf,pos))
+#define RSVALS(buf,pos) SREV(SVALS(buf,pos))
+#define RIVAL(buf,pos) IREV(IVAL(buf,pos))
+#define RIVALS(buf,pos) IREV(IVALS(buf,pos))
+#define RBVAL(buf,pos) BREV(BVAL(buf,pos))
+#define RBVALS(buf,pos) BREV(BVALS(buf,pos))
+#define RSSVAL(buf,pos,val) SSVAL(buf,pos,SREV(val))
+#define RSSVALS(buf,pos,val) SSVALS(buf,pos,SREV(val))
+#define RSIVAL(buf,pos,val) SIVAL(buf,pos,IREV(val))
+#define RSIVALS(buf,pos,val) SIVALS(buf,pos,IREV(val))
+#define RSBVAL(buf,pos,val) SBVAL(buf,pos,BREV(val))
+#define RSBVALS(buf,pos,val) SBVALS(buf,pos,BREV(val))
+/* Alignment macros. */
+#define ALIGN4(p,base) ((p) + ((4 - (PTR_DIFF((p), (base)) & 3)) & 3))
+#define ALIGN2(p,base) ((p) + ((2 - (PTR_DIFF((p), (base)) & 1)) & 1))
+/* macros for accessing SMB protocol elements */
+#define VWV(vwv) ((vwv)*2)
 #endif /* _BYTEORDER_H */

vendor/current/lib/util/charset/charcnv.c

-              r414
+              r740
  */
-struct smb_iconv_convenience {
-        const char *unix_charset;
-        const char *dos_charset;
-        bool native_iconv;
-        smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
-};
-/**
- * Return the name of a charset to give to iconv().
- **/
-static const char *charset_name(struct smb_iconv_convenience *ic, charset_t ch)
+{
-        switch (ch) {
-        case CH_UTF16: return "UTF-16LE";
-        case CH_UNIX: return ic->unix_charset;
-        case CH_DOS: return ic->dos_charset;
-        case CH_UTF8: return "UTF8";
-        case CH_UTF16BE: return "UTF-16BE";
-        case CH_UTF16MUNGED: return "UTF16_MUNGED";
-        default:
-        return "ASCII";
+        }
+}
-/**
- re-initialize iconv conversion descriptors
-**/
-static int close_iconv_convenience(struct smb_iconv_convenience *data)
+{
-        unsigned c1, c2;
-        for (c1=0;c1<NUM_CHARSETS;c1++) {
-                for (c2=0;c2<NUM_CHARSETS;c2++) {
-                        if (data->conv_handles[c1][c2] != NULL) {
-                                if (data->conv_handles[c1][c2] != (smb_iconv_t)-1) {
-                                        smb_iconv_close(data->conv_handles[c1][c2]);
+                                }
-                                data->conv_handles[c1][c2] = NULL;
+                        }
+                }
+        }
-        return 0;
+}
-_PUBLIC_ struct smb_iconv_convenience *smb_iconv_convenience_init(TALLOC_CTX *mem_ctx,
-                                                         const char *dos_charset,
-                                                         const char *unix_charset,
-                                                         bool native_iconv)
+{
-        struct smb_iconv_convenience *ret = talloc_zero(mem_ctx,
-                                        struct smb_iconv_convenience);
-        if (ret == NULL) {
-                return NULL;
+        }
-        talloc_set_destructor(ret, close_iconv_convenience);
-        ret->dos_charset = talloc_strdup(ret, dos_charset);
-        ret->unix_charset = talloc_strdup(ret, unix_charset);
-        ret->native_iconv = native_iconv;
-        return ret;
+}
-/*
-  on-demand initialisation of conversion handles
-*/
-static smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
-                                   charset_t from, charset_t to)
+{
-        const char *n1, *n2;
-        static bool initialised;
-        if (initialised == false) {
-                initialised = true;
-#ifdef LC_ALL
-                /* we set back the locale to C to get ASCII-compatible
-                   toupper/lower functions.  For now we do not need
-                   any other POSIX localisations anyway. When we
-                   should really need localized string functions one
-                   day we need to write our own ascii_tolower etc.
-                */
-                setlocale(LC_ALL, "C");
-#endif
+        }
-        if (ic->conv_handles[from][to]) {
-                return ic->conv_handles[from][to];
+        }
-        n1 = charset_name(ic, from);
-        n2 = charset_name(ic, to);
-        ic->conv_handles[from][to] = smb_iconv_open_ex(ic, n2, n1,
-                                                       ic->native_iconv);
-        if (ic->conv_handles[from][to] == (smb_iconv_t)-1) {
-                if ((from == CH_DOS || to == CH_DOS) &&
-                    strcasecmp(charset_name(ic, CH_DOS), "ASCII") != 0) {
-                        DEBUG(0,("dos charset '%s' unavailable - using ASCII\n",
-                                 charset_name(ic, CH_DOS)));
-                        ic->dos_charset = "ASCII";
-                        n1 = charset_name(ic, from);
-                        n2 = charset_name(ic, to);
-                        ic->conv_handles[from][to] =
-                                smb_iconv_open_ex(ic, n2, n1, ic->native_iconv);
+                }
+        }
-        return ic->conv_handles[from][to];
+}
 /**
  * Convert string from one encoding to another, making error checking etc
 …
                                 break;
+                }
+                DEBUG(0,("Conversion error: %s(%s)\n",reason,inbuf));
+                DEBUG(0,("Conversion error: %s - ",reason));
+                dump_data(0, (const uint8_t *) inbuf, i_len);
                 talloc_free(ob);
                 return (size_t)-1;
 …
+}
-/*
-  return the unicode codepoint for the next multi-byte CH_UNIX character
-  in the string
-  also return the number of bytes consumed (which tells the caller
-  how many bytes to skip to get to the next CH_UNIX character)
-  return INVALID_CODEPOINT if the next character cannot be converted
-*/
-_PUBLIC_ codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic,
-                                    const char *str, size_t *size)
+{
-        /* it cannot occupy more than 4 bytes in UTF16 format */
-        uint8_t buf[4];
-        smb_iconv_t descriptor;
-        size_t ilen_orig;
-        size_t ilen;
-        size_t olen;
-        char *outbuf;
-        if ((str[0] & 0x80) == 0) {
-                *size = 1;
-                return (codepoint_t)str[0];
+        }
-        /* we assume that no multi-byte character can take
-           more than 5 bytes. This is OK as we only
-           support codepoints up to 1M */
-        ilen_orig = strnlen(str, 5);
-        ilen = ilen_orig;
-        descriptor = get_conv_handle(ic, CH_UNIX, CH_UTF16);
-        if (descriptor == (smb_iconv_t)-1) {
-                *size = 1;
-                return INVALID_CODEPOINT;
+        }
-        /* this looks a little strange, but it is needed to cope
-           with codepoints above 64k */
-        olen = 2;
-        outbuf = (char *)buf;
-        smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
-        if (olen == 2) {
-                olen = 4;
-                outbuf = (char *)buf;
-                smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
-                if (olen == 4) {
-                        /* we didn't convert any bytes */
-                        *size = 1;
-                        return INVALID_CODEPOINT;
+                }
-                olen = 4 - olen;
-        } else {
-                olen = 2 - olen;
+        }
-        *size = ilen_orig - ilen;
-        if (olen == 2) {
-                return (codepoint_t)SVAL(buf, 0);
+        }
-        if (olen == 4) {
-                /* decode a 4 byte UTF16 character manually */
-                return (codepoint_t)0x10000 +
-                        (buf[2] | ((buf[3] & 0x3)<<8) |
-                         (buf[0]<<10) | ((buf[1] & 0x3)<<18));
+        }
-        /* no other length is valid */
-        return INVALID_CODEPOINT;
+}
-/*
-  push a single codepoint into a CH_UNIX string the target string must
-  be able to hold the full character, which is guaranteed if it is at
-  least 5 bytes in size. The caller may pass less than 5 bytes if they
-  are sure the character will fit (for example, you can assume that
-  uppercase/lowercase of a character will not add more than 1 byte)
-  return the number of bytes occupied by the CH_UNIX character, or
-  -1 on failure
-*/
-_PUBLIC_ ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic,
-                                char *str, codepoint_t c)
+{
-        smb_iconv_t descriptor;
-        uint8_t buf[4];
-        size_t ilen, olen;
-        const char *inbuf;
-        if (c < 128) {
-                *str = c;
-                return 1;
+        }
-        descriptor = get_conv_handle(ic,
-                                     CH_UTF16, CH_UNIX);
-        if (descriptor == (smb_iconv_t)-1) {
-                return -1;
+        }
-        if (c < 0x10000) {
-                ilen = 2;
-                olen = 5;
-                inbuf = (char *)buf;
-                SSVAL(buf, 0, c);
-                smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
-                if (ilen != 0) {
-                        return -1;
+                }
-                return 5 - olen;
+        }
-        c -= 0x10000;
-        buf[0] = (c>>10) & 0xFF;
-        buf[1] = (c>>18) | 0xd8;
-        buf[2] = c & 0xFF;
-        buf[3] = ((c>>8) & 0x3) | 0xdc;
-        ilen = 4;
-        olen = 5;
-        inbuf = (char *)buf;
-        smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
-        if (ilen != 0) {
-                return -1;
+        }
-        return 5 - olen;
+}

vendor/current/lib/util/charset/charset.h

-              r587
+              r740
 typedef uint16_t smb_ucs2_t;
+#ifdef WORDS_BIGENDIAN
+#define UCS2_SHIFT 8
+#else
+#define UCS2_SHIFT 0
+#endif
+/* turn a 7 bit character into a ucs2 character */
+#define UCS2_CHAR(c) ((c) << UCS2_SHIFT)
+/* return an ascii version of a ucs2 character */
+#define UCS2_TO_CHAR(c) (((c) >> UCS2_SHIFT) & 0xff)
+/* Copy into a smb_ucs2_t from a possibly unaligned buffer. Return the copied smb_ucs2_t */
+#define COPY_UCS2_CHAR(dest,src) (((unsigned char *)(dest))[0] = ((unsigned char *)(src))[0],\
+                                ((unsigned char *)(dest))[1] = ((unsigned char *)(src))[1], (dest))
 /*
  *   for each charset we have a function that pulls from that charset to
 …
 char *strchr_m(const char *s, char c);
+size_t strlen_m_ext(const char *s, charset_t src_charset, charset_t dst_charset);
+size_t strlen_m_ext_term(const char *s, charset_t src_charset,
+                         charset_t dst_charset);
 size_t strlen_m_term(const char *s);
 size_t strlen_m_term_null(const char *s);
 …
 extern struct smb_iconv_convenience *global_iconv_convenience;
+struct smb_iconv_convenience *get_iconv_convenience(void);
+smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
+                            charset_t from, charset_t to);
+const char *charset_name(struct smb_iconv_convenience *ic, charset_t ch);
+codepoint_t next_codepoint_ext(const char *str, charset_t src_charset,
+                               size_t *size);
 codepoint_t next_codepoint(const char *str, size_t *size);
 ssize_t push_codepoint(char *str, codepoint_t c);
 /* codepoints */
+codepoint_t next_codepoint_convenience_ext(struct smb_iconv_convenience *ic,
+                            const char *str, charset_t src_charset,
+                            size_t *size);
 codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic,
                             const char *str, size_t *size);
 ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic,
                                 char *str, codepoint_t c);
 codepoint_t toupper_m(codepoint_t val);
 codepoint_t tolower_m(codepoint_t val);
+bool islower_m(codepoint_t val);
+bool isupper_m(codepoint_t val);
 int codepoint_cmpi(codepoint_t c1, codepoint_t c2);
 /* Iconv convenience functions */
+struct smb_iconv_convenience *smb_iconv_convenience_init(TALLOC_CTX *mem_ctx,
+                                                         const char *dos_charset,
+                                                         const char *unix_charset,
+                                                         bool native_iconv);
+struct smb_iconv_convenience *smb_iconv_convenience_reinit(TALLOC_CTX *mem_ctx,
+                                                           const char *dos_charset,
+                                                           const char *unix_charset,
+                                                           const char *display_charset,
+                                                           bool native_iconv,
+                                                           struct smb_iconv_convenience *old_ic);
 bool convert_string_convenience(struct smb_iconv_convenience *ic,
 …
 void load_case_tables(void);
+bool charset_register_backend(const void *_funcs);
+void load_case_tables_library(void);
+bool smb_register_charset(const struct charset_functions *funcs_in);
 /*
 …
 NTSTATUS charset_ ## CHARSETNAME ## _init(void)                                                 \
 {                                                                                               \
+        return smb_register_charset(& CHARSETNAME ## _functions);                               \
+}                                                                                               \
+        if (!smb_register_charset(& CHARSETNAME ## _functions)) {       \
+                return NT_STATUS_INTERNAL_ERROR;                        \
+        }                                                               \
+        return NT_STATUS_OK; \
+}                                               \

vendor/current/lib/util/charset/codepoints.c

-              r414
+              r740
 /*
    Unix SMB/CIFS implementation.
+   Samba utility functions
+   Copyright (C) Andrew Tridgell 1992-2001
+   Character set conversion Extensions
+   Copyright (C) Igor Vergeichik <iverg@mail.ru> 2001
+   Copyright (C) Andrew Tridgell 2001
    Copyright (C) Simo Sorce 2001
+   Copyright (C) Jelmer Vernooij 2007
    This program is free software; you can redistribute it and/or modify
 …
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "includes.h"
+#include "lib/util/charset/charset.h"
 #include "system/locale.h"
+#include "dynconfig/dynconfig.h"
+#include "dynconfig.h"
+#ifdef strcasecmp
+#undef strcasecmp
+#endif
 /**
 …
 /*******************************************************************
 load the case handling tables
+This is the function that should be called from library code.
 ********************************************************************/
 void load_case_tables(void)
+void load_case_tables_library(void)
+{
         TALLOC_CTX *mem_ctx;
 …
                 smb_panic("No memory for case_tables");
+        }
         upcase_table = map_file(talloc_asprintf(mem_ctx, "%s/upcase.dat", dyn_DATADIR), 0x20000);
         lowcase_table = map_file(talloc_asprintf(mem_ctx, "%s/lowcase.dat", dyn_DATADIR), 0x20000);
+        upcase_table = map_file(talloc_asprintf(mem_ctx, "%s/upcase.dat", get_dyn_CODEPAGEDIR()), 0x20000);
+        lowcase_table = map_file(talloc_asprintf(mem_ctx, "%s/lowcase.dat", get_dyn_CODEPAGEDIR()), 0x20000);
         talloc_free(mem_ctx);
         if (upcase_table == NULL) {
+                /* try also under codepages for testing purposes */
+                upcase_table = map_file("codepages/upcase.dat", 0x20000);
+                if (upcase_table == NULL) {
+                        upcase_table = (void *)-1;
+                }
+                DEBUG(1, ("Failed to load upcase.dat, will use lame ASCII-only case sensitivity rules\n"));
+                upcase_table = (void *)-1;
+        }
         if (lowcase_table == NULL) {
+                /* try also under codepages for testing purposes */
+                lowcase_table = map_file("codepages/lowcase.dat", 0x20000);
+                if (lowcase_table == NULL) {
+                        lowcase_table = (void *)-1;
+                }
+        }
+                DEBUG(1, ("Failed to load lowcase.dat, will use lame ASCII-only case sensitivity rules\n"));
+                lowcase_table = (void *)-1;
+        }
+}
+/*******************************************************************
+load the case handling tables
+This MUST only be called from main() in application code, never from a
+library.  We don't know if the calling program has already done
+setlocale() to another value, and can't tell if they have.
+********************************************************************/
+void load_case_tables(void)
+{
+        /* This is a useful global hook where we can ensure that the
+         * locale is set from the environment.  This is needed so that
+         * we can use LOCALE as a codepage */
+#ifdef HAVE_SETLOCALE
+        setlocale(LC_ALL, "");
+#endif
+        load_case_tables_library();
+}
 …
+        }
         if (upcase_table == NULL) {
                 load_case_tables();
+                load_case_tables_library();
+        }
         if (upcase_table == (void *)-1) {
 …
+        }
         if (lowcase_table == NULL) {
                 load_case_tables();
+                load_case_tables_library();
+        }
         if (lowcase_table == (void *)-1) {
 …
+        }
         return SVAL(lowcase_table, val*2);
+}
+/**
+ If we upper cased this character, would we get the same character?
+**/
+_PUBLIC_ bool islower_m(codepoint_t val)
+{
+        return (toupper_m(val) != val);
+}
+/**
+ If we lower cased this character, would we get the same character?
+**/
+_PUBLIC_ bool isupper_m(codepoint_t val)
+{
+        return (tolower_m(val) != val);
+}
 …
+struct smb_iconv_convenience {
+        TALLOC_CTX *child_ctx;
+        const char *unix_charset;
+        const char *dos_charset;
+        const char *display_charset;
+        bool native_iconv;
+        smb_iconv_t conv_handles[NUM_CHARSETS][NUM_CHARSETS];
+};
+struct smb_iconv_convenience *global_iconv_convenience = NULL;
+struct smb_iconv_convenience *get_iconv_convenience(void)
+{
+        if (global_iconv_convenience == NULL)
+                global_iconv_convenience = smb_iconv_convenience_reinit(talloc_autofree_context(),
+                                                                        "ASCII", "UTF-8", "ASCII", true, NULL);
+        return global_iconv_convenience;
+}
+/**
+ * Return the name of a charset to give to iconv().
+ **/
+const char *charset_name(struct smb_iconv_convenience *ic, charset_t ch)
+{
+        switch (ch) {
+        case CH_UTF16: return "UTF-16LE";
+        case CH_UNIX: return ic->unix_charset;
+        case CH_DOS: return ic->dos_charset;
+        case CH_DISPLAY: return ic->display_charset;
+        case CH_UTF8: return "UTF8";
+        case CH_UTF16BE: return "UTF-16BE";
+        case CH_UTF16MUNGED: return "UTF16_MUNGED";
+        default:
+        return "ASCII";
+        }
+}
+/**
+ re-initialize iconv conversion descriptors
+**/
+static int close_iconv_convenience(struct smb_iconv_convenience *data)
+{
+        unsigned c1, c2;
+        for (c1=0;c1<NUM_CHARSETS;c1++) {
+                for (c2=0;c2<NUM_CHARSETS;c2++) {
+                        if (data->conv_handles[c1][c2] != NULL) {
+                                if (data->conv_handles[c1][c2] != (smb_iconv_t)-1) {
+                                        smb_iconv_close(data->conv_handles[c1][c2]);
+                                }
+                                data->conv_handles[c1][c2] = NULL;
+                        }
+                }
+        }
+        return 0;
+}
+static const char *map_locale(const char *charset)
+{
+        if (strcmp(charset, "LOCALE") != 0) {
+                return charset;
+        }
+#if defined(HAVE_NL_LANGINFO) && defined(CODESET)
+        {
+                const char *ln;
+                smb_iconv_t handle;
+                ln = nl_langinfo(CODESET);
+                if (ln == NULL) {
+                        DEBUG(1,("Unable to determine charset for LOCALE - using ASCII\n"));
+                        return "ASCII";
+                }
+                /* Check whether the charset name is supported
+                   by iconv */
+                handle = smb_iconv_open(ln, "UCS-2LE");
+                if (handle == (smb_iconv_t) -1) {
+                        DEBUG(5,("Locale charset '%s' unsupported, using ASCII instead\n", ln));
+                        return "ASCII";
+                } else {
+                        DEBUG(5,("Substituting charset '%s' for LOCALE\n", ln));
+                        smb_iconv_close(handle);
+                }
+                return ln;
+        }
+#endif
+        return "ASCII";
+}
+/*
+  the old_ic is passed in here as the smb_iconv_convenience structure
+  is used as a global pointer in some places (eg. python modules). We
+  don't want to invalidate those global pointers, but we do want to
+  update them with the right charset information when loadparm
+  runs. To do that we need to re-use the structure pointer, but
+  re-fill the elements in the structure with the updated values
+ */
+_PUBLIC_ struct smb_iconv_convenience *smb_iconv_convenience_reinit(TALLOC_CTX *mem_ctx,
+                                                                    const char *dos_charset,
+                                                                    const char *unix_charset,
+                                                                    const char *display_charset,
+                                                                    bool native_iconv,
+                                                                    struct smb_iconv_convenience *old_ic)
+{
+        struct smb_iconv_convenience *ret;
+        display_charset = map_locale(display_charset);
+        if (old_ic != NULL) {
+                ret = old_ic;
+                close_iconv_convenience(ret);
+                talloc_free(ret->child_ctx);
+                ZERO_STRUCTP(ret);
+        } else {
+                ret = talloc_zero(mem_ctx, struct smb_iconv_convenience);
+        }
+        if (ret == NULL) {
+                return NULL;
+        }
+        /* we use a child context to allow us to free all ptrs without
+           freeing the structure itself */
+        ret->child_ctx = talloc_new(ret);
+        if (ret->child_ctx == NULL) {
+                return NULL;
+        }
+        talloc_set_destructor(ret, close_iconv_convenience);
+        ret->dos_charset = talloc_strdup(ret->child_ctx, dos_charset);
+        ret->unix_charset = talloc_strdup(ret->child_ctx, unix_charset);
+        ret->display_charset = talloc_strdup(ret->child_ctx, display_charset);
+        ret->native_iconv = native_iconv;
+        return ret;
+}
+/*
+  on-demand initialisation of conversion handles
+*/
+smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
+                            charset_t from, charset_t to)
+{
+        const char *n1, *n2;
+        static bool initialised;
+        if (initialised == false) {
+                initialised = true;
+        }
+        if (ic->conv_handles[from][to]) {
+                return ic->conv_handles[from][to];
+        }
+        n1 = charset_name(ic, from);
+        n2 = charset_name(ic, to);
+        ic->conv_handles[from][to] = smb_iconv_open_ex(ic, n2, n1,
+                                                       ic->native_iconv);
+        if (ic->conv_handles[from][to] == (smb_iconv_t)-1) {
+                if ((from == CH_DOS || to == CH_DOS) &&
+                    strcasecmp(charset_name(ic, CH_DOS), "ASCII") != 0) {
+                        DEBUG(0,("dos charset '%s' unavailable - using ASCII\n",
+                                 charset_name(ic, CH_DOS)));
+                        ic->dos_charset = "ASCII";
+                        n1 = charset_name(ic, from);
+                        n2 = charset_name(ic, to);
+                        ic->conv_handles[from][to] =
+                                smb_iconv_open_ex(ic, n2, n1, ic->native_iconv);
+                }
+        }
+        return ic->conv_handles[from][to];
+}
+/**
+ * Return the unicode codepoint for the next character in the input
+ * string in the given src_charset.
+ * The unicode codepoint (codepoint_t) is an unsinged 32 bit value.
+ *
+ * Also return the number of bytes consumed (which tells the caller
+ * how many bytes to skip to get to the next src_charset-character).
+ *
+ * This is implemented (in the non-ascii-case) by first converting the
+ * next character in the input string to UTF16_LE and then calculating
+ * the unicode codepoint from that.
+ *
+ * Return INVALID_CODEPOINT if the next character cannot be converted.
+ */
+_PUBLIC_ codepoint_t next_codepoint_convenience_ext(
+                        struct smb_iconv_convenience *ic,
+                        const char *str, charset_t src_charset,
+                        size_t *bytes_consumed)
+{
+        /* it cannot occupy more than 4 bytes in UTF16 format */
+        uint8_t buf[4];
+        smb_iconv_t descriptor;
+        size_t ilen_orig;
+        size_t ilen;
+        size_t olen;
+        char *outbuf;
+        if ((str[0] & 0x80) == 0) {
+                *bytes_consumed = 1;
+                return (codepoint_t)str[0];
+        }
+        /*
+         * we assume that no multi-byte character can take more than 5 bytes.
+         * This is OK as we only support codepoints up to 1M (U+100000)
+         */
+        ilen_orig = strnlen(str, 5);
+        ilen = ilen_orig;
+        descriptor = get_conv_handle(ic, src_charset, CH_UTF16);
+        if (descriptor == (smb_iconv_t)-1) {
+                *bytes_consumed = 1;
+                return INVALID_CODEPOINT;
+        }
+        /*
+         * this looks a little strange, but it is needed to cope with
+         * codepoints above 64k (U+1000) which are encoded as per RFC2781.
+         */
+        olen = 2;
+        outbuf = (char *)buf;
+        smb_iconv(descriptor, &str, &ilen, &outbuf, &olen);
+        if (olen == 2) {
+                olen = 4;
+                outbuf = (char *)buf;
+                smb_iconv(descriptor,  &str, &ilen, &outbuf, &olen);
+                if (olen == 4) {
+                        /* we didn't convert any bytes */
+                        *bytes_consumed = 1;
+                        return INVALID_CODEPOINT;
+                }
+                olen = 4 - olen;
+        } else {
+                olen = 2 - olen;
+        }
+        *bytes_consumed = ilen_orig - ilen;
+        if (olen == 2) {
+                return (codepoint_t)SVAL(buf, 0);
+        }
+        if (olen == 4) {
+                /* decode a 4 byte UTF16 character manually */
+                return (codepoint_t)0x10000 +
+                        (buf[2] | ((buf[3] & 0x3)<<8) |
+                         (buf[0]<<10) | ((buf[1] & 0x3)<<18));
+        }
+        /* no other length is valid */
+        return INVALID_CODEPOINT;
+}
+/*
+  return the unicode codepoint for the next multi-byte CH_UNIX character
+  in the string
+  also return the number of bytes consumed (which tells the caller
+  how many bytes to skip to get to the next CH_UNIX character)
+  return INVALID_CODEPOINT if the next character cannot be converted
+*/
+_PUBLIC_ codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic,
+                                    const char *str, size_t *size)
+{
+        return next_codepoint_convenience_ext(ic, str, CH_UNIX, size);
+}
+/*
+  push a single codepoint into a CH_UNIX string the target string must
+  be able to hold the full character, which is guaranteed if it is at
+  least 5 bytes in size. The caller may pass less than 5 bytes if they
+  are sure the character will fit (for example, you can assume that
+  uppercase/lowercase of a character will not add more than 1 byte)
+  return the number of bytes occupied by the CH_UNIX character, or
+  -1 on failure
+*/
+_PUBLIC_ ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic,
+                                char *str, codepoint_t c)
+{
+        smb_iconv_t descriptor;
+        uint8_t buf[4];
+        size_t ilen, olen;
+        const char *inbuf;
+        if (c < 128) {
+                *str = c;
+                return 1;
+        }
+        descriptor = get_conv_handle(ic,
+                                     CH_UTF16, CH_UNIX);
+        if (descriptor == (smb_iconv_t)-1) {
+                return -1;
+        }
+        if (c < 0x10000) {
+                ilen = 2;
+                olen = 5;
+                inbuf = (char *)buf;
+                SSVAL(buf, 0, c);
+                smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
+                if (ilen != 0) {
+                        return -1;
+                }
+                return 5 - olen;
+        }
+        c -= 0x10000;
+        buf[0] = (c>>10) & 0xFF;
+        buf[1] = (c>>18) | 0xd8;
+        buf[2] = c & 0xFF;
+        buf[3] = ((c>>8) & 0x3) | 0xdc;
+        ilen = 4;
+        olen = 5;
+        inbuf = (char *)buf;
+        smb_iconv(descriptor, &inbuf, &ilen, &str, &olen);
+        if (ilen != 0) {
+                return -1;
+        }
+        return 5 - olen;
+}
+_PUBLIC_ codepoint_t next_codepoint_ext(const char *str, charset_t src_charset,
+                                        size_t *size)
+{
+        return next_codepoint_convenience_ext(get_iconv_convenience(), str,
+                                              src_charset, size);
+}
+_PUBLIC_ codepoint_t next_codepoint(const char *str, size_t *size)
+{
+        return next_codepoint_convenience(get_iconv_convenience(), str, size);
+}
+_PUBLIC_ ssize_t push_codepoint(char *str, codepoint_t c)
+{
+        return push_codepoint_convenience(get_iconv_convenience(), str, c);
+}

vendor/current/lib/util/charset/iconv.c

-              r414
+              r740
 #include "system/filesys.h"
+#ifdef strcasecmp
+#undef strcasecmp
+#endif
+#ifdef static_decl_charset
+static_decl_charset;
+#endif
 /**
 …
 static size_t ascii_pull  (void *,const char **, size_t *, char **, size_t *);
 static size_t ascii_push  (void *,const char **, size_t *, char **, size_t *);
+static size_t latin1_push(void *,const char **, size_t *, char **, size_t *);
 static size_t utf8_pull   (void *,const char **, size_t *, char **, size_t *);
 static size_t utf8_push   (void *,const char **, size_t *, char **, size_t *);
 …
         {"ASCII", ascii_pull, ascii_push},
+        {"646", ascii_pull, ascii_push},
+        {"ISO-8859-1", ascii_pull, latin1_push},
         {"UCS2-HEX", ucs2hex_pull, ucs2hex_push}
 };
 …
 static struct charset_functions *charsets = NULL;
+bool charset_register_backend(const void *_funcs)
+{
+        struct charset_functions *funcs = (struct charset_functions *)memdup(_funcs,sizeof(struct charset_functions));
+static struct charset_functions *find_charset_functions(const char *name)
+{
         struct charset_functions *c;
         /* Check whether we already have this charset... */
         for (c = charsets; c != NULL; c = c->next) {
+                if(!strcasecmp(c->name, funcs->name)) {
+                        DEBUG(2, ("Duplicate charset %s, not registering\n", funcs->name));
+                        return false;
+                }
+        }
+                if(strcasecmp(c->name, name) == 0) {
+                        return c;
+                }
+                c = c->next;
+        }
+        return NULL;
+}
+bool smb_register_charset(const struct charset_functions *funcs_in)
+{
+        struct charset_functions *funcs;
+        DEBUG(5, ("Attempting to register new charset %s\n", funcs_in->name));
+        /* Check whether we already have this charset... */
+        if (find_charset_functions(funcs_in->name)) {
+                DEBUG(0, ("Duplicate charset %s, not registering\n", funcs_in->name));
+                return false;
+        }
+        funcs = talloc(NULL, struct charset_functions);
+        if (!funcs) {
+                DEBUG(0, ("Out of memory duplicating charset %s\n", funcs_in->name));
+                return false;
+        }
+        *funcs = *funcs_in;
         funcs->next = funcs->prev = NULL;
+        DEBUG(5, ("Registered charset %s\n", funcs->name));
         DLIST_ADD(charsets, funcs);
         return true;
+}
+static void lazy_initialize_iconv(void)
+{
+        static bool initialized;
+#ifdef static_init_charset
+        if (!initialized) {
+                static_init_charset;
+                initialized = true;
+        }
+#endif
+}
 …
+}
 int smb_iconv_t_destructor(smb_iconv_t hwd)
+{
+static int smb_iconv_t_destructor(smb_iconv_t hwd)
+{
 #ifdef HAVE_NATIVE_ICONV
         if (hwd->cd_pull != NULL && hwd->cd_pull != (iconv_t)-1)
 …
         int i;
+        lazy_initialize_iconv();
         ret = (smb_iconv_t)talloc_named(mem_ctx,
                                         sizeof(*ret),
 …
         if (is_utf16(tocode)) {
                 ret->direct = sys_iconv;
-                /* could be set just above - so we need to close iconv */
-                if (ret->cd_direct != NULL && ret->cd_direct != (iconv_t)-1)
-                        iconv_close(ret->cd_direct);
                 ret->cd_direct = ret->cd_pull;
                 ret->cd_pull = NULL;
 …
 _PUBLIC_ smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
+{
         return smb_iconv_open_ex(talloc_autofree_context(), tocode, fromcode, true);
+        return smb_iconv_open_ex(NULL, tocode, fromcode, true);
+}
 …
+}
+static size_t latin1_push(void *cd, const char **inbuf, size_t *inbytesleft,
+                         char **outbuf, size_t *outbytesleft)
+{
+        int ir_count=0;
+        while (*inbytesleft >= 2 && *outbytesleft >= 1) {
+                (*outbuf)[0] = (*inbuf)[0];
+                if ((*inbuf)[1]) ir_count++;
+                (*inbytesleft)  -= 2;
+                (*outbytesleft) -= 1;
+                (*inbuf)  += 2;
+                (*outbuf) += 1;
+        }
+        if (*inbytesleft == 1) {
+                errno = EINVAL;
+                return -1;
+        }
+        if (*inbytesleft > 1) {
+                errno = E2BIG;
+                return -1;
+        }
+        return ir_count;
+}
 static size_t ucs2hex_pull(void *cd, const char **inbuf, size_t *inbytesleft,
 …
+{
         while (*inbytesleft >= 1 && *outbytesleft >= 2) {
                 uint_t v;
+                unsigned int v;
                 if ((*inbuf)[0] != '@') {

vendor/current/lib/util/charset/tests/charset.c

r414	r740
247	247	struct torture_suite torture_local_charset(TALLOC_CTX mem_ctx)
248	248	{
249		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~CHARSET~~");
	249	struct torture_suite *suite = torture_suite_create(mem_ctx, "charset");
250	250
251	251	torture_suite_add_simple_test(suite, "toupper_m", test_toupper_m);

vendor/current/lib/util/charset/tests/iconv.c

-              r414
+              r740
         iconv_t cd;
         if (!lp_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true))
+        if (!lpcfg_parm_bool(tctx->lp_ctx, NULL, "iconv", "native", true))
                 torture_skip(tctx, "system iconv disabled - skipping test");
 …
         uint8_t buf1[1000], buf2[1000], buf3[1000];
         size_t outsize1, outsize2, outsize3;
         const char *ptr_in;
+        char *ptr_in;
         char *ptr_out;
         size_t size_in1, size_in2, size_in3;
 …
                                                      charset));
+                }
                 cd2 = smb_iconv_open_ex(test, charset, "UTF-16LE", lp_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
                 cd3 = smb_iconv_open_ex(test, "UTF-16LE", charset, lp_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
+                cd2 = smb_iconv_open_ex(test, charset, "UTF-16LE", lpcfg_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
+                cd3 = smb_iconv_open_ex(test, "UTF-16LE", charset, lpcfg_parm_bool(test->lp_ctx, NULL, "iconv", "native", true));
                 last_charset = charset;
+        }
         /* internal convert to charset - placing result in buf1 */
         ptr_in = (const char *)inbuf;
+        ptr_in = (char *)inbuf;
         ptr_out = (char *)buf1;
         size_in1 = size;
 …
         memset(ptr_out, 0, outsize1);
         errno = 0;
         ret1 = smb_iconv(cd2, &ptr_in, &size_in1, &ptr_out, &outsize1);
+        ret1 = smb_iconv(cd2, (const char **) &ptr_in, &size_in1, &ptr_out, &outsize1);
         errno1 = errno;
         /* system convert to charset - placing result in buf2 */
         ptr_in = (const char *)inbuf;
+        ptr_in = (char *)inbuf;
         ptr_out = (char *)buf2;
         size_in2 = size;
 …
         memset(ptr_out, 0, outsize2);
         errno = 0;
         ret2 = iconv(cd, discard_const_p(char *, &ptr_in), &size_in2, &ptr_out, &outsize2);
+        ret2 = iconv(cd, &ptr_in, &size_in2, &ptr_out, &outsize2);
         errno2 = errno;
 …
         /* convert back to UTF-16, putting result in buf3 */
         size = size - size_in1;
         ptr_in = (const char *)buf1;
+        ptr_in = (char *)buf1;
         ptr_out = (char *)buf3;
         size_in3 = len1;
 …
         memset(ptr_out, 0, outsize3);
         ret3 = smb_iconv(cd3, &ptr_in, &size_in3, &ptr_out, &outsize3);
+        ret3 = smb_iconv(cd3, (const char **) &ptr_in, &size_in3, &ptr_out, &outsize3);
         /* we only internally support the first 1M codepoints */
 …
         codepoint_t c;
         size = push_codepoint_convenience(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
+        size = push_codepoint_convenience(lpcfg_iconv_convenience(tctx->lp_ctx), (char *)buf, codepoint);
         torture_assert(tctx, size != -1 || (codepoint >= 0xd800 && codepoint <= 0x10000),
                        "Invalid Codepoint range");
 …
         buf[size+3] = random();
         c = next_codepoint_convenience(lp_iconv_convenience(tctx->lp_ctx), (char *)buf, &size2);
+        c = next_codepoint_convenience(lpcfg_iconv_convenience(tctx->lp_ctx), (char *)buf, &size2);
         torture_assert(tctx, c == codepoint,
 …
 struct torture_suite *torture_local_iconv(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "ICONV");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "iconv");
         torture_suite_add_simple_test(suite, "string2key",

vendor/current/lib/util/charset/util_unistr.c

-              r414
+              r740
 #include "system/locale.h"
-struct smb_iconv_convenience *global_iconv_convenience = NULL;
-static inline struct smb_iconv_convenience *get_iconv_convenience(void)
+{
-        if (global_iconv_convenience == NULL)
-                global_iconv_convenience = smb_iconv_convenience_init(talloc_autofree_context(), "ASCII", "UTF-8", true);
-        return global_iconv_convenience;
+}
 /**
  Case insensitive string compararison
 …
         return *s1 - *s2;
+}
-/**
- * Get the next token from a string, return False if none found.
- * Handles double-quotes.
+ *
- * Based on a routine by GJC@VILLAGE.COM.
- * Extensively modified by Andrew.Tridgell@anu.edu.au
- **/
-_PUBLIC_ bool next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
+{
-        const char *s;
-        bool quoted;
-        size_t len=1;
-        if (!ptr)
-                return false;
-        s = *ptr;
-        /* default to simple separators */
-        if (!sep)
-                sep = " \t\n\r";
-        /* find the first non sep char */
-        while (*s && strchr_m(sep,*s))
-                s++;
-        /* nothing left? */
-        if (!*s)
-                return false;
-        /* copy over the token */
-        for (quoted = false; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
-                if (*s == '\"') {
-                        quoted = !quoted;
-                } else {
-                        len++;
-                        *buff++ = *s;
+                }
+        }
-        *ptr = (*s) ? s+1 : s;
-        *buff = 0;
-        return true;
+}
 …
 /**
+ Count the number of UCS2 characters in a string. Normally this will
+ be the same as the number of bytes in a string for single byte strings,
+ but will be different for multibyte.
+**/
+_PUBLIC_ size_t strlen_m(const char *s)
+ * Calculate the number of units (8 or 16-bit, depending on the
+ * destination charset), that would be needed to convert the input
+ * string which is expected to be in in src_charset encoding to the
+ * destination charset (which should be a unicode charset).
+ */
+_PUBLIC_ size_t strlen_m_ext(const char *s, charset_t src_charset, charset_t dst_charset)
+{
         size_t count = 0;
 …
         while (*s) {
                 size_t c_size;
+                codepoint_t c = next_codepoint_convenience(ic, s, &c_size);
+                if (c < 0x10000) {
+                codepoint_t c = next_codepoint_convenience_ext(ic, s, src_charset, &c_size);
+                s += c_size;
+                switch (dst_charset) {
+                case CH_UTF16LE:
+                case CH_UTF16BE:
+                case CH_UTF16MUNGED:
+                        if (c < 0x10000) {
+                                count += 1;
+                        } else {
+                                count += 2;
+                        }
+                        break;
+                case CH_UTF8:
+                        /*
+                         * this only checks ranges, and does not
+                         * check for invalid codepoints
+                         */
+                        if (c < 0x80) {
+                                count += 1;
+                        } else if (c < 0x800) {
+                                count += 2;
+                        } else if (c < 0x1000) {
+                                count += 3;
+                        } else {
+                                count += 4;
+                        }
+                        break;
+                default:
+                        /*
+                         * non-unicode encoding:
+                         * assume that each codepoint fits into
+                         * one unit in the destination encoding.
+                         */
                         count += 1;
+                } else {
+                        count += 2;
+                }
+                s += c_size;
+                }
+        }
         return count;
+}
+_PUBLIC_ size_t strlen_m_ext_term(const char *s, const charset_t src_charset,
+                                  const charset_t dst_charset)
+{
+        if (!s) {
+                return 0;
+        }
+        return strlen_m_ext(s, src_charset, dst_charset) + 1;
+}
+/**
+ * Calculate the number of 16-bit units that would be needed to convert
+ * the input string which is expected to be in CH_UNIX encoding to UTF16.
+ *
+ * This will be the same as the number of bytes in a string for single
+ * byte strings, but will be different for multibyte.
+ */
+_PUBLIC_ size_t strlen_m(const char *s)
+{
+        return strlen_m_ext(s, CH_UNIX, CH_UTF16LE);
+}
 …
         char *dest;
         struct smb_iconv_convenience *iconv_convenience = get_iconv_convenience();
+        if(src == NULL) {
+                return NULL;
+        }
         /* this takes advantage of the fact that upper/lower can't
 …
+}
-_PUBLIC_ codepoint_t next_codepoint(const char *str, size_t *size)
+{
-        return next_codepoint_convenience(get_iconv_convenience(), str, size);
+}
-_PUBLIC_ ssize_t push_codepoint(char *str, codepoint_t c)
+{
-        return push_codepoint_convenience(get_iconv_convenience(), str, c);
+}

vendor/current/lib/util/data_blob.c

-              r414
+              r740
 _PUBLIC_ DATA_BLOB data_blob_named(const void *p, size_t length, const char *name)
+{
+        return data_blob_talloc_named(NULL, p, length, name);
+}
+/**
+ construct a data blob, using supplied TALLOC_CTX
+**/
+_PUBLIC_ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name)
+{
         DATA_BLOB ret;
 …
         if (p) {
                 ret.data = (uint8_t *)talloc_memdup(NULL, p, length);
+                ret.data = (uint8_t *)talloc_memdup(mem_ctx, p, length);
         } else {
                 ret.data = talloc_array(NULL, uint8_t, length);
+                ret.data = talloc_array(mem_ctx, uint8_t, length);
+        }
         if (ret.data == NULL) {
 …
         talloc_set_name_const(ret.data, name);
         ret.length = length;
-        return ret;
+}
-/**
- construct a data blob, using supplied TALLOC_CTX
-**/
-_PUBLIC_ DATA_BLOB data_blob_talloc_named(TALLOC_CTX *mem_ctx, const void *p, size_t length, const char *name)
+{
-        DATA_BLOB ret = data_blob_named(p, length, name);
-        if (ret.data) {
-                talloc_steal(mem_ctx, ret.data);
+        }
-        return ret;
+}
-/**
- reference a data blob, to the supplied TALLOC_CTX.
- Returns a NULL DATA_BLOB on failure
-**/
-_PUBLIC_ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
+{
-        DATA_BLOB ret = *blob;
-        ret.data = talloc_reference(mem_ctx, blob->data);
-        if (!ret.data) {
-                return data_blob(NULL, 0);
+        }
         return ret;
+}
 …
 print the data_blob as hex string
 **/
 _PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+_PUBLIC_ char *data_blob_hex_string_lower(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+{
         int i;
 …
+}
+_PUBLIC_ char *data_blob_hex_string_upper(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+{
+        int i;
+        char *hex_string;
+        hex_string = talloc_array(mem_ctx, char, (blob->length*2)+1);
+        if (!hex_string) {
+                return NULL;
+        }
+        for (i = 0; i < blob->length; i++)
+                slprintf(&hex_string[i*2], 3, "%02X", blob->data[i]);
+        hex_string[(blob->length*2)] = '\0';
+        return hex_string;
+}
 /**
   useful for constructing data blobs in test suites, while

vendor/current/lib/util/data_blob.h

-              r414
+              r740
    Unix SMB/CIFS implementation.
    DATA BLOB
+   Copyright (C) Andrew Tridgell 2001
+   Copyright (C) Andrew Bartlett 2001
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 …
 /**
- reference a data blob, to the supplied TALLOC_CTX.
- Returns a NULL DATA_BLOB on failure
-**/
-_PUBLIC_ DATA_BLOB data_blob_talloc_reference(TALLOC_CTX *mem_ctx, DATA_BLOB *blob);
-/**
  construct a zero data blob, using supplied TALLOC_CTX.
  use this sparingly as it initialises data - better to initialise
 …
 print the data_blob as hex string
 **/
+_PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
+_PUBLIC_ char *data_blob_hex_string_upper(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
+/**
+print the data_blob as hex string
+**/
+_PUBLIC_ char *data_blob_hex_string_lower(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
 /**

vendor/current/lib/util/debug.c

-              r414
+              r740
 /*
    Unix SMB/CIFS implementation.
+   Samba debug functions
+   Copyright (C) Andrew Tridgell 2003
+   Copyright (C) James J Myers   2003
+   Samba utility functions
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Elrond               2002
+   Copyright (C) Simo Sorce           2002
    This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
 #include "system/filesys.h"
+#include "system/time.h"
+#include "dynconfig/dynconfig.h"
+#include "system/syslog.h"
+#include "lib/util/time.h"
+/* define what facility to use for syslog */
+#ifndef SYSLOG_FACILITY
+#define SYSLOG_FACILITY LOG_DAEMON
+#endif
+/* -------------------------------------------------------------------------- **
+ * Defines...
+ *
+ *  FORMAT_BUFR_MAX - Index of the last byte of the format buffer;
+ *                    format_bufr[FORMAT_BUFR_MAX] should always be reserved
+ *                    for a terminating null byte.
+ */
+#define FORMAT_BUFR_SIZE 1024
+#define FORMAT_BUFR_MAX (FORMAT_BUFR_SIZE - 1)
+/* -------------------------------------------------------------------------- **
+ * This module implements Samba's debugging utility.
+ *
+ * The syntax of a debugging log file is represented as:
+ *
+ *  <debugfile> :== { <debugmsg> }
+ *
+ *  <debugmsg>  :== <debughdr> '\n' <debugtext>
+ *
+ *  <debughdr>  :== '[' TIME ',' LEVEL ']' [ [FILENAME ':'] [FUNCTION '()'] ]
+ *
+ *  <debugtext> :== { <debugline> }
+ *
+ *  <debugline> :== TEXT '\n'
+ *
+ * TEXT     is a string of characters excluding the newline character.
+ * LEVEL    is the DEBUG level of the message (an integer in the range 0..10).
+ * TIME     is a timestamp.
+ * FILENAME is the name of the file from which the debug message was generated.
+ * FUNCTION is the function from which the debug message was generated.
+ *
+ * Basically, what that all means is:
+ *
+ * - A debugging log file is made up of debug messages.
+ *
+ * - Each debug message is made up of a header and text.  The header is
+ *   separated from the text by a newline.
+ *
+ * - The header begins with the timestamp and debug level of the message
+ *   enclosed in brackets.  The filename and function from which the
+ *   message was generated may follow.  The filename is terminated by a
+ *   colon, and the function name is terminated by parenthesis.
+ *
+ * - The message text is made up of zero or more lines, each terminated by
+ *   a newline.
+ */
+/* state variables for the debug system */
+static struct {
+        bool initialized;
+        int fd;   /* The log file handle */
+        enum debug_logtype logtype; /* The type of logging we are doing: eg stdout, file, stderr */
+        const char *prog_name;
+        bool reopening_logs;
+        bool schedule_reopen_logs;
+        struct debug_settings settings;
+        char *debugf;
+} state = {
+        .settings = {
+                .timestamp_logs = true
+        }
+};
+/* -------------------------------------------------------------------------- **
+ * External variables.
+ *
+ *  debugf        - Debug file name.
+ *  DEBUGLEVEL    - System-wide debug message limit.  Messages with message-
+ *                  levels higher than DEBUGLEVEL will not be processed.
+ */
+/*
+   used to check if the user specified a
+   logfile on the command line
+*/
+bool    override_logfile;
+/*
+ * This is to allow reading of DEBUGLEVEL_CLASS before the debug
+ * system has been initialized.
+ */
+static const int debug_class_list_initial[DBGC_MAX_FIXED + 1];
+static int debug_num_classes = 0;
+int     *DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
+/* -------------------------------------------------------------------------- **
+ * Internal variables.
+ *
+ *  debug_count     - Number of debug messages that have been output.
+ *                    Used to check log size.
+ *
+ *  syslog_level    - Internal copy of the message debug level.  Written by
+ *                    dbghdr() and read by Debug1().
+ *
+ *  format_bufr     - Used to format debug messages.  The dbgtext() function
+ *                    prints debug messages to a string, and then passes the
+ *                    string to format_debug_text(), which uses format_bufr
+ *                    to build the formatted output.
+ *
+ *  format_pos      - Marks the first free byte of the format_bufr.
+ *
+ *
+ *  log_overflow    - When this variable is true, never attempt to check the
+ *                    size of the log. This is a hack, so that we can write
+ *                    a message using DEBUG, from open_logs() when we
+ *                    are unable to open a new log file for some reason.
+ */
+static int     debug_count    = 0;
+#ifdef WITH_SYSLOG
+static int     syslog_level   = 0;
+#endif
+static char *format_bufr = NULL;
+static size_t     format_pos     = 0;
+static bool    log_overflow   = false;
+/*
+ * Define all the debug class selection names here. Names *MUST NOT* contain
+ * white space. There must be one name for each DBGC_<class name>, and they
+ * must be in the table in the order of DBGC_<class name>..
+ */
+static const char *default_classname_table[] = {
+        "all",               /* DBGC_ALL; index refs traditional DEBUGLEVEL */
+        "tdb",               /* DBGC_TDB          */
+        "printdrivers",      /* DBGC_PRINTDRIVERS */
+        "lanman",            /* DBGC_LANMAN       */
+        "smb",               /* DBGC_SMB          */
+        "rpc_parse",         /* DBGC_RPC_PARSE    */
+        "rpc_srv",           /* DBGC_RPC_SRV      */
+        "rpc_cli",           /* DBGC_RPC_CLI      */
+        "passdb",            /* DBGC_PASSDB       */
+        "sam",               /* DBGC_SAM          */
+        "auth",              /* DBGC_AUTH         */
+        "winbind",           /* DBGC_WINBIND      */
+        "vfs",               /* DBGC_VFS          */
+        "idmap",             /* DBGC_IDMAP        */
+        "quota",             /* DBGC_QUOTA        */
+        "acls",              /* DBGC_ACLS         */
+        "locking",           /* DBGC_LOCKING      */
+        "msdfs",             /* DBGC_MSDFS        */
+        "dmapi",             /* DBGC_DMAPI        */
+        "registry",          /* DBGC_REGISTRY     */
+        NULL
+};
+static char **classname_table = NULL;
+/* -------------------------------------------------------------------------- **
+ * Functions...
+ */
+static void debug_init(void);
+/***************************************************************************
+ Free memory pointed to by global pointers.
+****************************************************************************/
+void gfree_debugsyms(void)
+{
+        TALLOC_FREE(classname_table);
+        if ( DEBUGLEVEL_CLASS != debug_class_list_initial ) {
+                TALLOC_FREE( DEBUGLEVEL_CLASS );
+                DEBUGLEVEL_CLASS = discard_const_p(int, debug_class_list_initial);
+        }
+        TALLOC_FREE(format_bufr);
+        debug_num_classes = DBGC_MAX_FIXED;
+        state.initialized = false;
+}
+/****************************************************************************
+utility lists registered debug class names's
+****************************************************************************/
+char *debug_list_class_names_and_levels(void)
+{
+        char *buf = NULL;
+        unsigned int i;
+        /* prepare strings */
+        for (i = 0; i < debug_num_classes; i++) {
+                buf = talloc_asprintf_append(buf,
+                                             "%s:%d%s",
+                                             classname_table[i],
+                                             DEBUGLEVEL_CLASS[i],
+                                             i == (debug_num_classes - 1) ? "\n" : " ");
+                if (buf == NULL) {
+                        return NULL;
+                }
+        }
+        return buf;
+}
+/****************************************************************************
+ Utility to translate names to debug class index's (internal version).
+****************************************************************************/
+static int debug_lookup_classname_int(const char* classname)
+{
+        int i;
+        if (!classname) return -1;
+        for (i=0; i < debug_num_classes; i++) {
+                if (strcmp(classname, classname_table[i])==0)
+                        return i;
+        }
+        return -1;
+}
+/****************************************************************************
+ Add a new debug class to the system.
+****************************************************************************/
+int debug_add_class(const char *classname)
+{
+        int ndx;
+        int *new_class_list;
+        char **new_name_list;
+        int default_level;
+        if (!classname)
+                return -1;
+        /* check the init has yet been called */
+        debug_init();
+        ndx = debug_lookup_classname_int(classname);
+        if (ndx >= 0)
+                return ndx;
+        ndx = debug_num_classes;
+        if (DEBUGLEVEL_CLASS == debug_class_list_initial) {
+                /* Initial loading... */
+                new_class_list = NULL;
+        } else {
+                new_class_list = DEBUGLEVEL_CLASS;
+        }
+        default_level = DEBUGLEVEL_CLASS[DBGC_ALL];
+        new_class_list = talloc_realloc(NULL, new_class_list, int, ndx + 1);
+        if (!new_class_list)
+                return -1;
+        DEBUGLEVEL_CLASS = new_class_list;
+        DEBUGLEVEL_CLASS[ndx] = default_level;
+        new_name_list = talloc_realloc(NULL, classname_table, char *, ndx + 1);
+        if (!new_name_list)
+                return -1;
+        classname_table = new_name_list;
+        classname_table[ndx] = talloc_strdup(classname_table, classname);
+        if (! classname_table[ndx])
+                return -1;
+        debug_num_classes = ndx + 1;
+        return ndx;
+}
+/****************************************************************************
+ Utility to translate names to debug class index's (public version).
+****************************************************************************/
+int debug_lookup_classname(const char *classname)
+{
+        int ndx;
+        if (!classname || !*classname)
+                return -1;
+        ndx = debug_lookup_classname_int(classname);
+        if (ndx != -1)
+                return ndx;
+        DEBUG(0, ("debug_lookup_classname(%s): Unknown class\n",
+                  classname));
+        return debug_add_class(classname);
+}
+/****************************************************************************
+ Dump the current registered debug levels.
+****************************************************************************/
+static void debug_dump_status(int level)
+{
+        int q;
+        DEBUG(level, ("INFO: Current debug levels:\n"));
+        for (q = 0; q < debug_num_classes; q++) {
+                const char *classname = classname_table[q];
+                DEBUGADD(level, ("  %s: %d\n",
+                                 classname,
+                                 DEBUGLEVEL_CLASS[q]));
+        }
+}
+/****************************************************************************
+ parse the debug levels from smbcontrol. Example debug level parameter:
+ printdrivers:7
+****************************************************************************/
+static bool debug_parse_params(char **params)
+{
+        int   i, ndx;
+        char *class_name;
+        char *class_level;
+        if (!params)
+                return false;
+        /* Allow DBGC_ALL to be specified w/o requiring its class name e.g."10"
+         * v.s. "all:10", this is the traditional way to set DEBUGLEVEL
+         */
+        if (isdigit((int)params[0][0])) {
+                DEBUGLEVEL_CLASS[DBGC_ALL] = atoi(params[0]);
+                i = 1; /* start processing at the next params */
+        } else {
+                DEBUGLEVEL_CLASS[DBGC_ALL] = 0;
+                i = 0; /* DBGC_ALL not specified OR class name was included */
+        }
+        /* Array is debug_num_classes long */
+        for (ndx = DBGC_ALL; ndx < debug_num_classes; ndx++) {
+                DEBUGLEVEL_CLASS[ndx] = DEBUGLEVEL_CLASS[DBGC_ALL];
+        }
+        /* Fill in new debug class levels */
+        for (; i < debug_num_classes && params[i]; i++) {
+                char *saveptr;
+                if ((class_name = strtok_r(params[i],":", &saveptr)) &&
+                        (class_level = strtok_r(NULL, "\0", &saveptr)) &&
+            ((ndx = debug_lookup_classname(class_name)) != -1)) {
+                                DEBUGLEVEL_CLASS[ndx] = atoi(class_level);
+                } else {
+                        DEBUG(0,("debug_parse_params: unrecognized debug class name or format [%s]\n", params[i]));
+                        return false;
+                }
+        }
+        return true;
+}
+/****************************************************************************
+ Parse the debug levels from smb.conf. Example debug level string:
+tdb:5 printdrivers:7
+ Note: the 1st param has no "name:" preceeding it.
+****************************************************************************/
+bool debug_parse_levels(const char *params_str)
+{
+        char **params;
+        /* Just in case */
+        debug_init();
+        params = str_list_make(NULL, params_str, NULL);
+        if (debug_parse_params(params)) {
+                debug_dump_status(5);
+                TALLOC_FREE(params);
+                return true;
+        } else {
+                TALLOC_FREE(params);
+                return false;
+        }
+}
+/* setup for logging of talloc warnings */
+static void talloc_log_fn(const char *msg)
+{
+        DEBUG(0,("%s", msg));
+}
+void debug_setup_talloc_log(void)
+{
+        talloc_set_log_fn(talloc_log_fn);
+}
+/****************************************************************************
+Init debugging (one time stuff)
+****************************************************************************/
+static void debug_init(void)
+{
+        const char **p;
+        if (state.initialized)
+                return;
+        state.initialized = true;
+        debug_setup_talloc_log();
+        for(p = default_classname_table; *p; p++) {
+                debug_add_class(*p);
+        }
+        format_bufr = talloc_array(NULL, char, FORMAT_BUFR_SIZE);
+        if (!format_bufr) {
+                smb_panic("debug_init: unable to create buffer");
+        }
+}
+/* This forces in some smb.conf derived values into the debug system.
+ * There are no pointers in this structure, so we can just
+ * structure-assign it in */
+void debug_set_settings(struct debug_settings *settings)
+{
+        state.settings = *settings;
+}
 /**
+ * @file
+ * @brief Debug logging
+ **/
+/**
+ * this global variable determines what messages are printed
+ */
+int _debug_level = 0;
+_PUBLIC_ int *debug_level = &_debug_level;
+static int debug_all_class_hack = 1;
+int *DEBUGLEVEL_CLASS = &debug_all_class_hack; /* For samba 3 */
+static bool debug_all_class_isset_hack = true;
+bool    *DEBUGLEVEL_CLASS_ISSET = &debug_all_class_isset_hack; /* For samba 3 */
+XFILE *dbf = NULL; /* For Samba 3*/
+  control the name of the logfile and whether logging will be to stdout, stderr
+  or a file, and set up syslog
+  new_log indicates the destination for the debug log (an enum in
+  order of precedence - once set to DEBUG_FILE, it is not possible to
+  reset to DEBUG_STDOUT for example.  This makes it easy to override
+  for debug to stderr on the command line, as the smb.conf cannot
+  reset it back to file-based logging
+*/
+void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
+{
+        debug_init();
+        if (state.logtype < new_logtype) {
+                state.logtype = new_logtype;
+        }
+        if (prog_name) {
+                state.prog_name = prog_name;
+        }
+        reopen_logs_internal();
+        if (state.logtype == DEBUG_FILE) {
+#ifdef WITH_SYSLOG
+                const char *p = strrchr_m( prog_name,'/' );
+                if (p)
+                        prog_name = p + 1;
+#ifdef LOG_DAEMON
+                openlog( prog_name, LOG_PID, SYSLOG_FACILITY );
+#else
+                /* for old systems that have no facility codes. */
+                openlog( prog_name, LOG_PID );
+#endif
+#endif
+        }
+}
+/***************************************************************************
+ Set the logfile name.
+**************************************************************************/
+void debug_set_logfile(const char *name)
+{
+        if (name == NULL || *name == 0) {
+                /* this copes with calls when smb.conf is not loaded yet */
+                return;
+        }
+        TALLOC_FREE(state.debugf);
+        state.debugf = talloc_strdup(NULL, name);
+}
+static void debug_close_fd(int fd)
+{
+        if (fd > 2) {
+                close(fd);
+        }
+}
+bool debug_get_output_is_stderr(void)
+{
+        return (state.logtype == DEBUG_DEFAULT_STDERR) || (state.logtype == DEBUG_STDERR);
+}
+/**************************************************************************
+ reopen the log files
+ note that we now do this unconditionally
+ We attempt to open the new debug fp before closing the old. This means
+ if we run out of fd's we just keep using the old fd rather than aborting.
+ Fix from dgibson@linuxcare.com.
+**************************************************************************/
+/**
+  reopen the log file (usually called because the log file name might have changed)
+*/
+bool reopen_logs_internal(void)
+{
+        mode_t oldumask;
+        int new_fd = 0;
+        int old_fd = 0;
+        bool ret = true;
+        char *fname = NULL;
+        if (state.reopening_logs) {
+                return true;
+        }
+        /* Now clear the SIGHUP induced flag */
+        state.schedule_reopen_logs = false;
+        switch (state.logtype) {
+        case DEBUG_STDOUT:
+                debug_close_fd(state.fd);
+                state.fd = 1;
+                return true;
+        case DEBUG_DEFAULT_STDERR:
+        case DEBUG_STDERR:
+                debug_close_fd(state.fd);
+                state.fd = 2;
+                return true;
+        case DEBUG_FILE:
+                break;
+        }
+        oldumask = umask( 022 );
+        fname = state.debugf;
+        if (!fname) {
+                return false;
+        }
+        state.reopening_logs = true;
+        new_fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644);
+        if (new_fd == -1) {
+                log_overflow = true;
+                DEBUG(0, ("Unable to open new log file '%s': %s\n", state.debugf, strerror(errno)));
+                log_overflow = false;
+                ret = false;
+        } else {
+                old_fd = state.fd;
+                state.fd = new_fd;
+                debug_close_fd(old_fd);
+        }
+        /* Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
+         * to fix problem where smbd's that generate less
+         * than 100 messages keep growing the log.
+         */
+        force_check_log_size();
+        (void)umask(oldumask);
+        /* Take over stderr to catch output into logs */
+        if (state.fd > 0 && dup2(state.fd, 2) == -1) {
+                close_low_fds(true); /* Close stderr too, if dup2 can't point it
+                                        at the logfile */
+        }
+        state.reopening_logs = false;
+        return ret;
+}
+/**************************************************************************
+ Force a check of the log size.
+ ***************************************************************************/
+void force_check_log_size( void )
+{
+        debug_count = 100;
+}
+_PUBLIC_ void debug_schedule_reopen_logs(void)
+{
+        state.schedule_reopen_logs = true;
+}
+/***************************************************************************
+ Check to see if there is any need to check if the logfile has grown too big.
+**************************************************************************/
+bool need_to_check_log_size( void )
+{
+        int maxlog;
+        if( debug_count < 100)
+                return( false );
+        maxlog = state.settings.max_log_size * 1024;
+        if ( state.fd <=2 || maxlog <= 0 ) {
+                debug_count = 0;
+                return(false);
+        }
+        return( true );
+}
+/**************************************************************************
+ Check to see if the log has grown to be too big.
+ **************************************************************************/
+void check_log_size( void )
+{
+        int         maxlog;
+        struct stat st;
+        /*
+         *  We need to be root to check/change log-file, skip this and let the main
+         *  loop check do a new check as root.
+         */
+        if( geteuid() != 0) {
+                /* We don't check sec_initial_uid() here as it isn't
+                 * available in common code and we don't generally
+                 * want to rotate and the possibly lose logs in
+                 * make test or the build farm */
+                return;
+        }
+        if(log_overflow || (!state.schedule_reopen_logs && !need_to_check_log_size())) {
+                return;
+        }
+        maxlog = state.settings.max_log_size * 1024;
+        if (state.schedule_reopen_logs ||
+           (fstat(state.fd, &st) == 0
+            && st.st_size > maxlog )) {
+                (void)reopen_logs_internal();
+                if (state.fd > 0 && fstat(state.fd, &st) == 0) {
+                        if (st.st_size > maxlog) {
+                                char *name = NULL;
+                                if (asprintf(&name, "%s.old", state.debugf ) < 0) {
+                                        return;
+                                }
+                                (void)rename(state.debugf, name);
+                                if (!reopen_logs_internal()) {
+                                        /* We failed to reopen a log - continue using the old name. */
+                                        (void)rename(name, state.debugf);
+                                }
+                                SAFE_FREE(name);
+                        }
+                }
+        }
+        /*
+         * Here's where we need to panic if state.fd == 0 or -1 (invalid values)
+         */
+        if (state.fd <= 0) {
+                /* This code should only be reached in very strange
+                 * circumstances. If we merely fail to open the new log we
+                 * should stick with the old one. ergo this should only be
+                 * reached when opening the logs for the first time: at
+                 * startup or when the log level is increased from zero.
+                 * -dwg 6 June 2000
+                 */
+                int fd = open( "/dev/console", O_WRONLY, 0);
+                if (fd != -1) {
+                        state.fd = fd;
+                        DEBUG(0,("check_log_size: open of debug file %s failed - using console.\n",
+                                        state.debugf ));
+                } else {
+                        /*
+                         * We cannot continue without a debug file handle.
+                         */
+                        abort();
+                }
+        }
+        debug_count = 0;
+}
+/*************************************************************************
+ Write an debug message on the debugfile.
+ This is called by dbghdr() and format_debug_text().
+************************************************************************/
+ int Debug1( const char *format_str, ... )
+{
+        va_list ap;
+        int old_errno = errno;
+        debug_count++;
+        if ( state.logtype != DEBUG_FILE ) {
+                va_start( ap, format_str );
+                if (state.fd > 0)
+                        (void)vdprintf( state.fd, format_str, ap );
+                va_end( ap );
+                errno = old_errno;
+                goto done;
+        }
+#ifdef WITH_SYSLOG
+        if( !state.settings.syslog_only)
+#endif
+        {
+                if( state.fd <= 0 ) {
+                        mode_t oldumask = umask( 022 );
+                        int fd = open( state.debugf, O_WRONLY|O_APPEND|O_CREAT, 0644 );
+                        (void)umask( oldumask );
+                        if(fd == -1) {
+                                errno = old_errno;
+                                goto done;
+                        }
+                        state.fd = fd;
+                }
+        }
+#ifdef WITH_SYSLOG
+        if( syslog_level < state.settings.syslog ) {
+                /* map debug levels to syslog() priorities
+                 * note that not all DEBUG(0, ...) calls are
+                 * necessarily errors */
+                static const int priority_map[4] = {
+                        LOG_ERR,     /* 0 */
+                        LOG_WARNING, /* 1 */
+                        LOG_NOTICE,  /* 2 */
+                        LOG_INFO,    /* 3 */
+                };
+                int     priority;
+                char *msgbuf = NULL;
+                int ret;
+                if( syslog_level >= ARRAY_SIZE(priority_map) || syslog_level < 0)
+                        priority = LOG_DEBUG;
+                else
+                        priority = priority_map[syslog_level];
+                /*
+                 * Specify the facility to interoperate with other syslog
+                 * callers (vfs_full_audit for example).
+                 */
+                priority |= SYSLOG_FACILITY;
+                va_start(ap, format_str);
+                ret = vasprintf(&msgbuf, format_str, ap);
+                va_end(ap);
+                if (ret != -1) {
+                        syslog(priority, "%s", msgbuf);
+                }
+                SAFE_FREE(msgbuf);
+        }
+#endif
+        check_log_size();
+#ifdef WITH_SYSLOG
+        if( !state.settings.syslog_only)
+#endif
+        {
+                va_start( ap, format_str );
+                if (state.fd > 0)
+                        (void)vdprintf( state.fd, format_str, ap );
+                va_end( ap );
+        }
+ done:
+        errno = old_errno;
+        return( 0 );
+}
+/**************************************************************************
+ Print the buffer content via Debug1(), then reset the buffer.
+ Input:  none
+ Output: none
+****************************************************************************/
+static void bufr_print( void )
+{
+        format_bufr[format_pos] = '\0';
+        (void)Debug1( "%s", format_bufr );
+        format_pos = 0;
+}
+/***************************************************************************
+ Format the debug message text.
+ Input:  msg - Text to be added to the "current" debug message text.
+ Output: none.
+ Notes:  The purpose of this is two-fold.  First, each call to syslog()
+         (used by Debug1(), see above) generates a new line of syslog
+         output.  This is fixed by storing the partial lines until the
+         newline character is encountered.  Second, printing the debug
+         message lines when a newline is encountered allows us to add
+         spaces, thus indenting the body of the message and making it
+         more readable.
+**************************************************************************/
+static void format_debug_text( const char *msg )
+{
+        size_t i;
+        bool timestamp = (state.logtype == DEBUG_FILE && (state.settings.timestamp_logs));
+        if (!format_bufr) {
+                debug_init();
+        }
+        for( i = 0; msg[i]; i++ ) {
+                /* Indent two spaces at each new line. */
+                if(timestamp && 0 == format_pos) {
+                        format_bufr[0] = format_bufr[1] = ' ';
+                        format_pos = 2;
+                }
+                /* If there's room, copy the character to the format buffer. */
+                if( format_pos < FORMAT_BUFR_MAX )
+                        format_bufr[format_pos++] = msg[i];
+                /* If a newline is encountered, print & restart. */
+                if( '\n' == msg[i] )
+                        bufr_print();
+                /* If the buffer is full dump it out, reset it, and put out a line
+                 * continuation indicator.
+                 */
+                if( format_pos >= FORMAT_BUFR_MAX ) {
+                        bufr_print();
+                        (void)Debug1( " +>\n" );
+                }
+        }
+        /* Just to be safe... */
+        format_bufr[format_pos] = '\0';
+}
+/***************************************************************************
+ Flush debug output, including the format buffer content.
+ Input:  none
+ Output: none
+***************************************************************************/
+void dbgflush( void )
+{
+        bufr_print();
+}
+/***************************************************************************
+ Print a Debug Header.
+ Input:  level - Debug level of the message (not the system-wide debug
+                  level. )
+          cls   - Debuglevel class of the calling module.
+          file  - Pointer to a string containing the name of the file
+                  from which this function was called, or an empty string
+                  if the __FILE__ macro is not implemented.
+          func  - Pointer to a string containing the name of the function
+                  from which this function was called, or an empty string
+                  if the __FUNCTION__ macro is not implemented.
+         line  - line number of the call to dbghdr, assuming __LINE__
+                 works.
+  Output: Always true.  This makes it easy to fudge a call to dbghdr()
+          in a macro, since the function can be called as part of a test.
+          Eg: ( (level <= DEBUGLEVEL) && (dbghdr(level,"",line)) )
+  Notes:  This function takes care of setting syslog_level.
+****************************************************************************/
+bool dbghdrclass(int level, int cls, const char *location, const char *func)
+{
+        /* Ensure we don't lose any real errno value. */
+        int old_errno = errno;
+        if( format_pos ) {
+                /* This is a fudge.  If there is stuff sitting in the format_bufr, then
+                 * the *right* thing to do is to call
+                 *   format_debug_text( "\n" );
+                 * to write the remainder, and then proceed with the new header.
+                 * Unfortunately, there are several places in the code at which
+                 * the DEBUG() macro is used to build partial lines.  That in mind,
+                 * we'll work under the assumption that an incomplete line indicates
+                 * that a new header is *not* desired.
+                 */
+                return( true );
+        }
+#ifdef WITH_SYSLOG
+        /* Set syslog_level. */
+        syslog_level = level;
+#endif
+        /* Don't print a header if we're logging to stdout. */
+        if ( state.logtype != DEBUG_FILE ) {
+                return( true );
+        }
+        /* Print the header if timestamps are turned on.  If parameters are
+         * not yet loaded, then default to timestamps on.
+         */
+        if( state.settings.timestamp_logs || state.settings.debug_prefix_timestamp) {
+                char header_str[200];
+                header_str[0] = '\0';
+                if( state.settings.debug_pid)
+                        slprintf(header_str,sizeof(header_str)-1,", pid=%u",(unsigned int)getpid());
+                if( state.settings.debug_uid) {
+                        size_t hs_len = strlen(header_str);
+                        slprintf(header_str + hs_len,
+                        sizeof(header_str) - 1 - hs_len,
+                                ", effective(%u, %u), real(%u, %u)",
+                                (unsigned int)geteuid(), (unsigned int)getegid(),
+                                (unsigned int)getuid(), (unsigned int)getgid());
+                }
+                if (state.settings.debug_class && (cls != DBGC_ALL)) {
+                        size_t hs_len = strlen(header_str);
+                        slprintf(header_str + hs_len,
+                                 sizeof(header_str) -1 - hs_len,
+                                 ", class=%s",
+                                 default_classname_table[cls]);
+                }
+                /* Print it all out at once to prevent split syslog output. */
+                if( state.settings.debug_prefix_timestamp ) {
+                        char *time_str = current_timestring(NULL,
+                                                            state.settings.debug_hires_timestamp);
+                        (void)Debug1( "[%s, %2d%s] ",
+                                      time_str,
+                                      level, header_str);
+                        talloc_free(time_str);
+                } else {
+                        char *time_str = current_timestring(NULL,
+                                                            state.settings.debug_hires_timestamp);
+                        (void)Debug1( "[%s, %2d%s] %s(%s)\n",
+                                      time_str,
+                                      level, header_str, location, func );
+                        talloc_free(time_str);
+                }
+        }
+        errno = old_errno;
+        return( true );
+}
+/***************************************************************************
+ Add text to the body of the "current" debug message via the format buffer.
+  Input:  format_str  - Format string, as used in printf(), et. al.
+          ...         - Variable argument list.
+  ..or..  va_alist    - Old style variable parameter list starting point.
+  Output: Always true.  See dbghdr() for more info, though this is not
+          likely to be used in the same way.
+***************************************************************************/
+ bool dbgtext( const char *format_str, ... )
+{
+        va_list ap;
+        char *msgbuf = NULL;
+        bool ret = true;
+        int res;
+        va_start(ap, format_str);
+        res = vasprintf(&msgbuf, format_str, ap);
+        va_end(ap);
+        if (res != -1) {
+                format_debug_text(msgbuf);
+        } else {
+                ret = false;
+        }
+        SAFE_FREE(msgbuf);
+        return ret;
+}
 /* the registered mutex handlers */
 …
 } debug_handlers;
-/* state variables for the debug system */
-static struct {
-        int fd;
-        enum debug_logtype logtype;
-        const char *prog_name;
-        bool reopening_logs;
-} state;
-static bool reopen_logs_scheduled;
-static bool check_reopen_logs(void)
+{
-        if (state.fd == 0 || reopen_logs_scheduled) {
-                reopen_logs_scheduled = false;
-                reopen_logs();
+        }
-        if (state.fd <= 0)
-                return false;
-        return true;
+}
-_PUBLIC_ void debug_schedule_reopen_logs(void)
+{
-        reopen_logs_scheduled = true;
+}
-static void log_timestring(int level, const char *location, const char *func)
+{
-        char *t = NULL;
-        char *s = NULL;
-        if (!check_reopen_logs()) return;
-        if (state.logtype != DEBUG_FILE) return;
-        t = timestring(NULL, time(NULL));
-        if (!t) return;
-        asprintf(&s, "[%s, %d %s:%s()]\n", t, level, location, func);
-        talloc_free(t);
-        if (!s) return;
-        write(state.fd, s, strlen(s));
-        free(s);
+}
-/**
-  the backend for debug messages. Note that the DEBUG() macro has already
-  ensured that the log level has been met before this is called
-*/
-_PUBLIC_ void dbghdr(int level, const char *location, const char *func)
+{
-        log_timestring(level, location, func);
-        log_task_id();
+}
-_PUBLIC_ void dbghdrclass(int level, int dclass, const char *location, const char *func)
+{
-        /* Simple wrapper, Samba 4 doesn't do debug classes */
-        dbghdr(level, location, func);
+}
-/**
-  the backend for debug messages. Note that the DEBUG() macro has already
-  ensured that the log level has been met before this is called
-  @note You should never have to call this function directly. Call the DEBUG()
-  macro instead.
-*/
-_PUBLIC_ void dbgtext(const char *format, ...)
+{
-        va_list ap;
-        char *s = NULL;
-        if (!check_reopen_logs()) return;
-        va_start(ap, format);
-        vasprintf(&s, format, ap);
-        va_end(ap);
-        write(state.fd, s, strlen(s));
-        free(s);
+}
-_PUBLIC_ const char *logfile = NULL;
-/**
-  reopen the log file (usually called because the log file name might have changed)
-*/
-_PUBLIC_ void reopen_logs(void)
+{
-        char *fname = NULL;
-        int old_fd = state.fd;
-        if (state.reopening_logs) {
-                return;
+        }
-        switch (state.logtype) {
-        case DEBUG_STDOUT:
-                state.fd = 1;
-                break;
-        case DEBUG_STDERR:
-                state.fd = 2;
-                break;
-        case DEBUG_FILE:
-                state.reopening_logs = true;
-                if (logfile && (*logfile) == '/') {
-                        fname = strdup(logfile);
-                } else {
-                        asprintf(&fname, "%s/%s.log", dyn_LOGFILEBASE, state.prog_name);
+                }
-                if (fname) {
-                        int newfd = open(fname, O_CREAT|O_APPEND|O_WRONLY, 0600);
-                        if (newfd == -1) {
-                                DEBUG(1, ("Failed to open new logfile: %s\n", fname));
-                                old_fd = -1;
-                        } else {
-                                state.fd = newfd;
+                        }
-                        free(fname);
-                } else {
-                        DEBUG(1, ("Failed to find name for file-based logfile!\n"));
+                }
-                state.reopening_logs = false;
-                break;
+        }
-        if (old_fd > 2) {
-                close(old_fd);
+        }
+}
-/**
-  control the name of the logfile and whether logging will be to stdout, stderr
-  or a file
-*/
-_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype)
+{
-        if (state.logtype < new_logtype) {
-                state.logtype = new_logtype;
+        }
-        if (prog_name) {
-                state.prog_name = prog_name;
+        }
-        reopen_logs();
+}
-/**
-   Just run logging to stdout for this program
-*/
-_PUBLIC_ void setup_logging_stdout(void)
+{
-        setup_logging(NULL, DEBUG_STDOUT);
+}
-/**
-  return a string constant containing n tabs
-  no more than 10 tabs are returned
-*/
-_PUBLIC_ const char *do_debug_tab(int n)
+{
-        const char *tabs[] = {"", "\t", "\t\t", "\t\t\t", "\t\t\t\t", "\t\t\t\t\t",
-                              "\t\t\t\t\t\t", "\t\t\t\t\t\t\t", "\t\t\t\t\t\t\t\t",
-                              "\t\t\t\t\t\t\t\t\t", "\t\t\t\t\t\t\t\t\t\t"};
-        return tabs[MIN(n, 10)];
+}
 /**
   log suspicious usage - print comments and backtrace
 …
         if (!debug_handlers.ops.log_task_id) return;
         if (!check_reopen_logs()) return;
+        if (!reopen_logs_internal()) return;
         debug_handlers.ops.log_task_id(state.fd);

vendor/current/lib/util/debug.h

-              r414
+              r740
 /*
    Unix SMB/CIFS implementation.
+   Samba debug defines
+   Copyright (C) Andrew Tridgell 2003
+   SMB debug stuff
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) John H Terpstra 1996-1998
+   Copyright (C) Luke Kenneth Casson Leighton 1996-1998
+   Copyright (C) Paul Ashton 1998
    This program is free software; you can redistribute it and/or modify
 …
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
+#ifndef _SAMBA_DEBUG_H_
+#define _SAMBA_DEBUG_H_
+/**
+ * @file
+ * @brief Debugging macros
+ */
+/* the debug operations structure - contains function pointers to
+   various debug implementations of each operation */
+struct debug_ops {
+        /* function to log (using DEBUG) suspicious usage of data structure */
+        void (*log_suspicious_usage)(const char* from, const char* info);
+        /* function to log (using printf) suspicious usage of data structure.
+         * To be used in circumstances when using DEBUG would cause loop. */
+        void (*print_suspicious_usage)(const char* from, const char* info);
+        /* function to return process/thread id */
+        uint32_t (*get_task_id)(void);
+        /* function to log process/thread id */
+        void (*log_task_id)(int fd);
+};
+#define DEBUGLEVEL *debug_level
+extern int DEBUGLEVEL;
+#define debug_ctx() (_debug_ctx?_debug_ctx:(_debug_ctx=talloc_new(NULL)))
+#define DEBUGLVL(level) ((level) <= DEBUGLEVEL)
+#define _DEBUG(level, body, header) do { \
+        if (DEBUGLVL(level)) { \
+                void* _debug_ctx=NULL; \
+                if (header) { \
+                        dbghdr(level, __location__, __FUNCTION__); \
+                } \
+                dbgtext body; \
+                talloc_free(_debug_ctx); \
+        } \
+} while (0)
+/**
+ * Write to the debug log.
+ */
+#define DEBUG(level, body) _DEBUG(level, body, true)
+/**
+ * Add data to an existing debug log entry.
+ */
+#define DEBUGADD(level, body) _DEBUG(level, body, false)
+/**
+ * Obtain indentation string for the debug log.
+ *
+ * Level specified by n.
+ */
+#define DEBUGTAB(n) do_debug_tab(n)
+#ifndef _DEBUG_H
+#define _DEBUG_H
+/* -------------------------------------------------------------------------- **
+ * Debugging code.  See also debug.c
+ */
+/* the maximum debug level to compile into the code. This assumes a good
+   optimising compiler that can remove unused code
+   for embedded or low-memory systems set this to a value like 2 to get
+   only important messages. This gives *much* smaller binaries
+*/
+#ifndef MAX_DEBUG_LEVEL
+#define MAX_DEBUG_LEVEL 1000
+#endif
+int  Debug1( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
+bool dbgtext( const char *, ... ) PRINTF_ATTRIBUTE(1,2);
+bool dbghdrclass( int level, int cls, const char *location, const char *func);
+bool dbghdr( int level, const char *location, const char *func);
+/*
+ * Redefine DEBUGLEVEL because so we don't have to change every source file
+ * that *unnecessarily* references it.
+ */
+#define DEBUGLEVEL DEBUGLEVEL_CLASS[DBGC_ALL]
+/*
+ * Define all new debug classes here. A class is represented by an entry in
+ * the DEBUGLEVEL_CLASS array. Index zero of this arrray is equivalent to the
+ * old DEBUGLEVEL. Any source file that does NOT add the following lines:
+ *
+ *   #undef  DBGC_CLASS
+ *   #define DBGC_CLASS DBGC_<your class name here>
+ *
+ * at the start of the file (after #include "includes.h") will default to
+ * using index zero, so it will behaive just like it always has.
+ */
+#define DBGC_ALL                0 /* index equivalent to DEBUGLEVEL */
+#define DBGC_TDB                1
+#define DBGC_PRINTDRIVERS       2
+#define DBGC_LANMAN             3
+#define DBGC_SMB                4
+#define DBGC_RPC_PARSE          5
+#define DBGC_RPC_SRV            6
+#define DBGC_RPC_CLI            7
+#define DBGC_PASSDB             8
+#define DBGC_SAM                9
+#define DBGC_AUTH               10
+#define DBGC_WINBIND            11
+#define DBGC_VFS                12
+#define DBGC_IDMAP              13
+#define DBGC_QUOTA              14
+#define DBGC_ACLS               15
+#define DBGC_LOCKING            16
+#define DBGC_MSDFS              17
+#define DBGC_DMAPI              18
+#define DBGC_REGISTRY           19
+/* Always ensure this is updated when new fixed classes area added, to ensure the array in debug.c is the right size */
+#define DBGC_MAX_FIXED          19
+/* So you can define DBGC_CLASS before including debug.h */
+#ifndef DBGC_CLASS
+#define DBGC_CLASS            0     /* override as shown above */
+#endif
+extern int  *DEBUGLEVEL_CLASS;
+/* Debugging macros
+ *
+ * DEBUGLVL()
+ *   If the 'file specific' debug class level >= level OR the system-wide
+ *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ *   generate a header using the default macros for file, line, and
+ *   function name. Returns True if the debug level was <= DEBUGLEVEL.
+ *
+ *   Example: if( DEBUGLVL( 2 ) ) dbgtext( "Some text.\n" );
+ *
+ * DEBUG()
+ *   If the 'file specific' debug class level >= level OR the system-wide
+ *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ *   generate a header using the default macros for file, line, and
+ *   function name. Each call to DEBUG() generates a new header *unless* the
+ *   previous debug output was unterminated (i.e. no '\n').
+ *   See debug.c:dbghdr() for more info.
+ *
+ *   Example: DEBUG( 2, ("Some text and a value %d.\n", value) );
+ *
+ * DEBUGC()
+ *   If the 'macro specified' debug class level >= level OR the system-wide
+ *   DEBUGLEVEL (synomym for DEBUGLEVEL_CLASS[ DBGC_ALL ]) >= level then
+ *   generate a header using the default macros for file, line, and
+ *   function name. Each call to DEBUG() generates a new header *unless* the
+ *   previous debug output was unterminated (i.e. no '\n').
+ *   See debug.c:dbghdr() for more info.
+ *
+ *   Example: DEBUGC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
+ *
+ *  DEBUGADD(), DEBUGADDC()
+ *    Same as DEBUG() and DEBUGC() except the text is appended to the previous
+ *    DEBUG(), DEBUGC(), DEBUGADD(), DEBUGADDC() with out another interviening
+ *    header.
+ *
+ *    Example: DEBUGADD( 2, ("Some text and a value %d.\n", value) );
+ *             DEBUGADDC( DBGC_TDB, 2, ("Some text and a value %d.\n", value) );
+ *
+ * Note: If the debug class has not be redeined (see above) then the optimizer
+ * will remove the extra conditional test.
+ */
+/*
+ * From talloc.c:
+ */
+/* these macros gain us a few percent of speed on gcc */
+#if (__GNUC__ >= 3)
+/* the strange !! is to ensure that __builtin_expect() takes either 0 or 1
+   as its first argument */
+#ifndef likely
+#define likely(x)   __builtin_expect(!!(x), 1)
+#endif
+#ifndef unlikely
+#define unlikely(x) __builtin_expect(!!(x), 0)
+#endif
+#else
+#ifndef likely
+#define likely(x) (x)
+#endif
+#ifndef unlikely
+#define unlikely(x) (x)
+#endif
+#endif
+#define CHECK_DEBUGLVL( level ) \
+  ( ((level) <= MAX_DEBUG_LEVEL) && \
+    unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level)))
+#define DEBUGLVL( level ) \
+  ( CHECK_DEBUGLVL(level) \
+   && dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ ) )
+#define DEBUG( level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))           \
+       && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
+       && (dbgtext body) )
+#define DEBUGC( dbgc_class, level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely(DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))           \
+       && (dbghdrclass( level, DBGC_CLASS, __location__, __FUNCTION__ )) \
+       && (dbgtext body) )
+#define DEBUGADD( level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely(DEBUGLEVEL_CLASS[ DBGC_CLASS ] >= (level))   \
+       && (dbgtext body) )
+#define DEBUGADDC( dbgc_class, level, body ) \
+  (void)( ((level) <= MAX_DEBUG_LEVEL) && \
+          unlikely((DEBUGLEVEL_CLASS[ dbgc_class ] >= (level))) \
+       && (dbgtext body) )
+/* Print a separator to the debug log. */
+#define DEBUGSEP(level)\
+        DEBUG((level),("===============================================================\n"))
+/* The following definitions come from lib/debug.c  */
 /** Possible destinations for the debug log (in order of precedence -
 …
  * the command line, as the smb.conf cannot reset it back to
  * file-based logging */
+enum debug_logtype {DEBUG_STDOUT = 0, DEBUG_FILE = 1, DEBUG_STDERR = 2};
+/**
+  the backend for debug messages. Note that the DEBUG() macro has already
+  ensured that the log level has been met before this is called
+*/
+_PUBLIC_ void dbghdr(int level, const char *location, const char *func);
+_PUBLIC_ void dbghdrclass(int level, int cls, const char *location, const char *func);
+/**
+  reopen the log file (usually called because the log file name might have changed)
+*/
+_PUBLIC_ void reopen_logs(void);
+/**
+ * this global variable determines what messages are printed
+ */
+_PUBLIC_ void debug_schedule_reopen_logs(void);
+/**
+  control the name of the logfile and whether logging will be to stdout, stderr
+  or a file
+*/
+_PUBLIC_ void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
+/**
+   Just run logging to stdout for this program
+*/
+_PUBLIC_ void setup_logging_stdout(void);
+/**
+  return a string constant containing n tabs
+  no more than 10 tabs are returned
+*/
+_PUBLIC_ const char *do_debug_tab(int n);
+enum debug_logtype {DEBUG_DEFAULT_STDERR = 0, DEBUG_STDOUT = 1, DEBUG_FILE = 2, DEBUG_STDERR = 3};
+struct debug_settings {
+        size_t max_log_size;
+        bool syslog;
+        bool syslog_only;
+        bool timestamp_logs;
+        bool debug_prefix_timestamp;
+        bool debug_hires_timestamp;
+        bool debug_pid;
+        bool debug_uid;
+        bool debug_class;
+};
+void setup_logging(const char *prog_name, enum debug_logtype new_logtype);
+void debug_close_dbf(void);
+void gfree_debugsyms(void);
+int debug_add_class(const char *classname);
+int debug_lookup_classname(const char *classname);
+bool debug_parse_levels(const char *params_str);
+void debug_setup_talloc_log(void);
+void debug_set_logfile(const char *name);
+void debug_set_settings(struct debug_settings *settings);
+bool reopen_logs_internal( void );
+void force_check_log_size( void );
+bool need_to_check_log_size( void );
+void check_log_size( void );
+void dbgflush( void );
+bool dbghdrclass(int level, int cls, const char *location, const char *func);
+bool dbghdr(int level, const char *location, const char *func);
+bool debug_get_output_is_stderr(void);
+void debug_schedule_reopen_logs(void);
+char *debug_list_class_names_and_levels(void);
 /**
 …
 _PUBLIC_ void log_task_id(void);
+/* the debug operations structure - contains function pointers to
+   various debug implementations of each operation */
+struct debug_ops {
+        /* function to log (using DEBUG) suspicious usage of data structure */
+        void (*log_suspicious_usage)(const char* from, const char* info);
+        /* function to log (using printf) suspicious usage of data structure.
+         * To be used in circumstances when using DEBUG would cause loop. */
+        void (*print_suspicious_usage)(const char* from, const char* info);
+        /* function to return process/thread id */
+        uint32_t (*get_task_id)(void);
+        /* function to log process/thread id */
+        void (*log_task_id)(int fd);
+};
 /**
   register a set of debug handlers.
 …
 _PUBLIC_ void register_debug_handlers(const char *name, struct debug_ops *ops);
+/**
+  the backend for debug messages. Note that the DEBUG() macro has already
+  ensured that the log level has been met before this is called
+  @note You should never have to call this function directly. Call the DEBUG()
+  macro instead.
+*/
+_PUBLIC_ void dbgtext(const char *format, ...) PRINTF_ATTRIBUTE(1,2);
+struct _XFILE;
+extern struct _XFILE *dbf;
+#endif
+#endif

vendor/current/lib/util/dlinklist.h

-              r414
+              r740
    Unix SMB/CIFS implementation.
    some simple double linked list macros
+   Copyright (C) Andrew Tridgell 1998
+   Copyright (C) Andrew Tridgell 1998-2010
    This program is free software; you can redistribute it and/or modify
 …
 #define _DLINKLIST_H
+/*
+  February 2010 - changed list format to have a prev pointer from the
+  list head. This makes DLIST_ADD_END() O(1) even though we only have
+  one list pointer.
+/* hook into the front of the list */
+  The scheme is as follows:
+) with no entries in the list:
+          list_head == NULL
+) with 1 entry in the list:
+          list_head->next == NULL
+          list_head->prev == list_head
+) with 2 entries in the list:
+          list_head->next == element2
+          list_head->prev == element2
+          element2->prev == list_head
+          element2->next == NULL
+) with N entries in the list:
+          list_head->next == element2
+          list_head->prev == elementN
+          elementN->prev == element{N-1}
+          elementN->next == NULL
+  This allows us to find the tail of the list by using
+  list_head->prev, which means we can add to the end of the list in
+  O(1) time
+  Note that the 'type' arguments below are no longer needed, but
+  are kept for now to prevent an incompatible argument change
+ */
+/*
+   add an element at the front of a list
+*/
 #define DLIST_ADD(list, p) \
 do { \
         if (!(list)) { \
                 (list) = (p); \
                 (p)->next = (p)->prev = NULL; \
+                (p)->prev = (list) = (p);  \
+                (p)->next = NULL; \
         } else { \
+                (p)->prev = (list)->prev; \
                 (list)->prev = (p); \
                 (p)->next = (list); \
-                (p)->prev = NULL; \
                 (list) = (p); \
         }\
+        } \
 } while (0)
+/* remove an element from a list - element doesn't have to be in list. */
+/*
+   remove an element from a list
+   Note that the element doesn't have to be in the list. If it
+   isn't then this is a no-op
+*/
 #define DLIST_REMOVE(list, p) \
 do { \
         if ((p) == (list)) { \
+                if ((p)->next) (p)->next->prev = (p)->prev; \
                 (list) = (p)->next; \
+                if (list) (list)->prev = NULL; \
+        } else if ((list) && (p) == (list)->prev) {     \
+                (p)->prev->next = NULL; \
+                (list)->prev = (p)->prev; \
         } else { \
                 if ((p)->prev) (p)->prev->next = (p)->next; \
                 if ((p)->next) (p)->next->prev = (p)->prev; \
         } \
         if ((p) != (list)) (p)->next = (p)->prev = NULL; \
+        if ((p) != (list)) (p)->next = (p)->prev = NULL;        \
 } while (0)
+/* promote an element to the top of the list */
+#define DLIST_PROMOTE(list, p) \
+/*
+   find the head of the list given any element in it.
+   Note that this costs O(N), so you should avoid this macro
+   if at all possible!
+*/
+#define DLIST_HEAD(p, result_head) \
 do { \
           DLIST_REMOVE(list, p); \
           DLIST_ADD(list, p); \
 } while (0)
+       (result_head) = (p); \
+       while (DLIST_PREV(result_head)) (result_head) = (result_head)->prev; \
+} while(0)
+/* hook into the end of the list - needs the entry type */
+#define DLIST_ADD_END(list, p, type) \
+do { \
+                if (!(list)) { \
+                        (list) = (p); \
+                        (p)->next = (p)->prev = NULL; \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (p); \
+                        (p)->next = NULL; \
+                        (p)->prev = tmp; \
+                } \
+} while (0)
+/* return the last element in the list */
+#define DLIST_TAIL(list) ((list)?(list)->prev:NULL)
+/* return the previous element in the list. */
+#define DLIST_PREV(p) (((p)->prev && (p)->prev->next != NULL)?(p)->prev:NULL)
 /* insert 'p' after the given element 'el' in a list. If el is NULL then
 …
                 DLIST_ADD(list, p); \
         } else { \
+                p->prev = el; \
+                p->next = el->next; \
+                el->next = p; \
+                if (p->next) p->next->prev = p; \
+                (p)->prev = (el);   \
+                (p)->next = (el)->next;         \
+                (el)->next = (p);               \
+                if ((p)->next) (p)->next->prev = (p);   \
+                if ((list)->prev == (el)) (list)->prev = (p); \
         }\
 } while (0)
+/* demote an element to the end of the list, needs the entry type */
+#define DLIST_DEMOTE(list, p, type) \
+/*
+   add to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_ADD_END(list, p, type)                    \
 do { \
+                DLIST_REMOVE(list, p); \
+                DLIST_ADD_END(list, p, type); \
+        if (!(list)) { \
+                DLIST_ADD(list, p); \
+        } else { \
+                DLIST_ADD_AFTER(list, p, (list)->prev); \
+        } \
 } while (0)
+/* concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list */
+#define DLIST_CONCATENATE(list1, list2, type) \
+/* promote an element to the from of a list */
+#define DLIST_PROMOTE(list, p) \
 do { \
+                if (!(list1)) { \
+                        (list1) = (list2); \
+                } else { \
+                        type tmp; \
+                        for (tmp = (list1); tmp->next; tmp = tmp->next) ; \
+                        tmp->next = (list2); \
+                        if (list2) { \
+                                (list2)->prev = tmp;    \
+                        } \
+          DLIST_REMOVE(list, p); \
+          DLIST_ADD(list, p); \
+} while (0)
+/*
+   demote an element to the end of a list.
+   Note that 'type' is ignored
+*/
+#define DLIST_DEMOTE(list, p, type)                     \
+do { \
+        DLIST_REMOVE(list, p); \
+        DLIST_ADD_END(list, p, NULL);           \
+} while (0)
+/*
+   concatenate two lists - putting all elements of the 2nd list at the
+   end of the first list.
+   Note that 'type' is ignored
+*/
+#define DLIST_CONCATENATE(list1, list2, type)   \
+do { \
+        if (!(list1)) { \
+                (list1) = (list2); \
+        } else { \
+                (list1)->prev->next = (list2); \
+                if (list2) { \
+                        void *_tmplist = (void *)(list1)->prev; \
+                        (list1)->prev = (list2)->prev; \
+                        (list2)->prev = _tmplist; \
                 } \
+        } \
 } while (0)

vendor/current/lib/util/fault.c

-              r414
+              r740
 #endif
         void *backtrace_stack[BACKTRACE_STACK_SIZE];
         size_t backtrace_size;
+        int backtrace_size;
         char **backtrace_strings;
 …
                 char cmdstring[200];
                 safe_strcpy(cmdstring, panic_action, sizeof(cmdstring));
                 snprintf(pidstr, sizeof(pidstr), "%u", getpid());
+                snprintf(pidstr, sizeof(pidstr), "%d", (int) getpid());
                 all_string_sub(cmdstring, "%PID%", pidstr, sizeof(cmdstring));
                 if (progname) {
 …
 #ifdef SIGABRT
         CatchSignal(SIGABRT,SIGNAL_CAST SIG_DFL);
+        CatchSignal(SIGABRT, SIG_DFL);
 #endif
         abort();
 …
 _PUBLIC_ void fault_setup(const char *pname)
+{
+        if (progname == NULL) {
+                progname = pname;
+        }
+        if (progname != NULL) {
+                return;
+        }
+        progname = pname;
 #ifdef SIGSEGV
         CatchSignal(SIGSEGV,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGSEGV, sig_fault);
 #endif
 #ifdef SIGBUS
         CatchSignal(SIGBUS,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGBUS, sig_fault);
 #endif
 #ifdef SIGABRT
         CatchSignal(SIGABRT,SIGNAL_CAST sig_fault);
+        CatchSignal(SIGABRT, sig_fault);
 #endif
 #ifdef SIGFPE
+        CatchSignal(SIGFPE,SIGNAL_CAST sig_fault);
+#endif
+}
+        CatchSignal(SIGFPE, sig_fault);
+#endif
+}
+/**
+   disable setting up fault handlers
+**/
+_PUBLIC_ void fault_setup_disable(void)
+{
+        progname = "fault disabled";
+}
 /**

vendor/current/lib/util/genrand.c

-              r414
+              r740
 /**
+ * Generate a random text password.
+ */
+_PUBLIC_ char *generate_random_password(TALLOC_CTX *mem_ctx, size_t min, size_t max)
+{
+        char *retstr;
+        /* This list does not include { or } because they cause
+         * problems for our provision (it can create a substring
+         * ${...}, and for Fedora DS (which treats {...} at the start
+         * of a stored password as special
+         *  -- Andrew Bartlett 2010-03-11
+         */
+        const char *c_list = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_-#.,@$%&!?:;<=>()[]~";
+        size_t len = max;
+        size_t diff;
+        if (min > max) {
+                errno = EINVAL;
+                return NULL;
+        }
+        diff = max - min;
+        if (diff > 0 ) {
+                size_t tmp;
+                generate_random_buffer((uint8_t *)&tmp, sizeof(tmp));
+                tmp %= diff;
+                len = min + tmp;
+        }
+again:
+        retstr = generate_random_str_list(mem_ctx, len, c_list);
+        if (!retstr) return NULL;
+        /* we need to make sure the random string passes basic quality tests
+           or it might be rejected by windows as a password */
+        if (len >= 7 && !check_password_quality(retstr)) {
+                talloc_free(retstr);
+                goto again;
+        }
+        return retstr;
+}
+/**
  * Generate an array of unique text strings all of the same length.
  * The returned string will be allocated.

vendor/current/lib/util/idtree.c

-              r414
+              r740
         int n, m, sh;
         struct idr_layer *p, *pn;
         struct idr_layer *pa[MAX_LEVEL];
         int l, id, oid;
+        struct idr_layer *pa[MAX_LEVEL+1];
+        unsigned int l, id, oid;
         uint32_t bm;
 …
+{
         struct idr_layer *p = idp->top;
         struct idr_layer **pa[MAX_LEVEL];
+        struct idr_layer **pa[1+MAX_LEVEL];
         struct idr_layer ***paa = &pa[0];
         int n;
 …
          * present.  If so, tain't one of ours!
          */
+        if ((id & ~(~0 << MAX_ID_SHIFT)) >> (n + IDR_BITS))
+             return NULL;
+        if (n + IDR_BITS < 31 &&
+            ((id & ~(~0 << MAX_ID_SHIFT)) >> (n + IDR_BITS))) {
+                return NULL;
+        }
         /* Mask off upper bits we don't use for the search. */

vendor/current/lib/util/memory.h

r414	r740
29	29	* always be ignored.
30	30	**/
31		#define SAFE_FREE(x) do { if ((x) != NULL) {free(~~discard_const_p(void *, (x))~~); (x)=NULL;} } while(0)
	31	#define SAFE_FREE(x) do { if ((x) != NULL) {free(x); (x)=NULL;} } while(0)
32	32	#endif
33	33

vendor/current/lib/util/params.c

-              r594
+              r740
   } /* Parse */
 static myFILE *OpenConfFile( const char *FileName )
+static myFILE *OpenConfFile(TALLOC_CTX *mem_ctx, const char *FileName )
   /* ------------------------------------------------------------------------ **
    * Open a configuration file.
 …
   myFILE *ret;
   ret = talloc(talloc_autofree_context(), myFILE);
+  ret = talloc(mem_ctx, myFILE);
   if (!ret) return NULL;
 …
   const char *func = "params.c:pm_process() -";
   InFile = OpenConfFile( FileName );          /* Open the config file. */
+  InFile = OpenConfFile(NULL, FileName); /* Open the config file. */
   if( NULL == InFile )
     return( false );

vendor/current/lib/util/system.c

-              r414
+              r740
         return mypid;
+}
+_PUBLIC_ int sys_getpeereid( int s, uid_t *uid)
+{
+#if defined(HAVE_PEERCRED)
+        struct ucred cred;
+        socklen_t cred_len = sizeof(struct ucred);
+        int ret;
+        ret = getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void *)&cred, &cred_len);
+        if (ret != 0) {
+                return -1;
+        }
+        if (cred_len != sizeof(struct ucred)) {
+                errno = EINVAL;
+                return -1;
+        }
+        *uid = cred.uid;
+        return 0;
+#else
+#if defined(HAVE_GETPEEREID)
+        gid_t gid;
+        return getpeereid(s, uid, &gid);
+#endif
+        errno = ENOSYS;
+        return -1;
+#endif
+}
+_PUBLIC_ int sys_getnameinfo(const struct sockaddr *psa,
+                             int salen,
+                             char *host,
+                             size_t hostlen,
+                             char *service,
+                             size_t servlen,
+                             int flags)
+{
+        /*
+         * For Solaris we must make sure salen is the
+         * correct length for the incoming sa_family.
+         */
+        if (salen == sizeof(struct sockaddr_storage)) {
+                salen = sizeof(struct sockaddr_in);
+#if defined(HAVE_IPV6)
+                if (psa->sa_family == AF_INET6) {
+                        salen = sizeof(struct sockaddr_in6);
+                }
+#endif
+        }
+        return getnameinfo(psa, salen, host, hostlen, service, servlen, flags);
+}
+_PUBLIC_ int sys_connect(int fd, const struct sockaddr * addr)
+{
+        socklen_t salen = (socklen_t)-1;
+        if (addr->sa_family == AF_INET) {
+            salen = sizeof(struct sockaddr_in);
+        } else if (addr->sa_family == AF_UNIX) {
+            salen = sizeof(struct sockaddr_un);
+        }
+#if defined(HAVE_IPV6)
+        else if (addr->sa_family == AF_INET6) {
+            salen = sizeof(struct sockaddr_in6);
+        }
+#endif
+        return connect(fd, addr, salen);
+}

vendor/current/lib/util/talloc_stack.c

-              r427
+              r740
+{
 #if defined(PARANOID_MALLOC_CHECKER)
 #ifdef malloc
 #undef malloc
+#ifdef calloc
+#undef calloc
 #endif
 #endif
         struct talloc_stackframe *ts =
                 (struct talloc_stackframe *)malloc(sizeof(struct talloc_stackframe));
+        struct talloc_stackframe *ts = (struct talloc_stackframe *)calloc(
+, sizeof(struct talloc_stackframe));
 #if defined(PARANOID_MALLOC_CHECKER)
 #define malloc(s) __ERROR_DONT_USE_MALLOC_DIRECTLY
+#define calloc(n, s) __ERROR_DONT_USE_MALLOC_DIRECTLY
 #endif
 …
                 smb_panic("talloc_stackframe_init malloc failed");
+        }
-        ZERO_STRUCTP(ts);
         SMB_THREAD_ONCE(&ts_initialized, talloc_stackframe_init, NULL);
 …
                         break;
+                }
+                talloc_free(ts->talloc_stack[i]);
+                ts->talloc_stack[i] = NULL;
+                TALLOC_FREE(ts->talloc_stack[i]);
+        }

vendor/current/lib/util/talloc_stack.h

r414	r740
36	36	#define _TALLOC_STACK_H
37	37
38		#include ~~"talloc.h"~~
	38	#include <talloc.h>
39	39
40	40	/*

vendor/current/lib/util/tests/data_blob.c

r414	r740
79	79	{
80	80	DATA_BLOB a = data_blob_string_const("\xC\xA\xF\xE");
81		torture_assert_str_equal(tctx, data_blob_hex_string(tctx, &a), "0C0A0F0E", "hex string");
	81	torture_assert_str_equal(tctx, data_blob_hex_string_lower(tctx, &a), "0c0a0f0e", "hex string");
	82	torture_assert_str_equal(tctx, data_blob_hex_string_upper(tctx, &a), "0C0A0F0E", "hex string");
82	83	return true;
83	84	}
…	…
85	86	struct torture_suite torture_local_util_data_blob(TALLOC_CTX mem_ctx)
86	87	{
87		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~DATABLOB~~");
	88	struct torture_suite *suite = torture_suite_create(mem_ctx, "datablob");
88	89
89	90	torture_suite_add_simple_test(suite, "string", test_string);

vendor/current/lib/util/tests/file.c

-              r414
+              r740
 struct torture_suite *torture_local_util_file(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "FILE");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "file");
         torture_suite_add_simple_test(suite, "file_load_save",
                                       test_file_load_save);
+        torture_suite_add_simple_test(suite, "afdgets",
+                                      test_afdgets);
+        torture_suite_add_simple_test(suite, "afdgets", test_afdgets);
         return suite;

vendor/current/lib/util/tests/genrand.c

r414	r740
60	60	struct torture_suite torture_local_genrand(TALLOC_CTX mem_ctx)
61	61	{
62		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~GENRAND~~");
	62	struct torture_suite *suite = torture_suite_create(mem_ctx, "genrand");
63	63	torture_suite_add_simple_test(suite, "reseed_callback", test_reseed_callback);
64	64	torture_suite_add_simple_test(suite, "check_password_quality", test_check_password_quality);

vendor/current/lib/util/tests/idtree.c

r414	r740
116	116	struct torture_suite torture_local_idtree(TALLOC_CTX mem_ctx)
117	117	{
118		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~IDTREE~~");
	118	struct torture_suite *suite = torture_suite_create(mem_ctx, "idtree");
119	119	torture_suite_add_simple_test(suite, "idtree", torture_local_idtree_simple);
120	120	return suite;

vendor/current/lib/util/tests/parmlist.c

-              r414
+              r740
         torture_assert_str_equal(tctx, e->value, "mystring", "value");
         e = parmlist_get(pctx, "nonexistant");
         torture_assert(tctx, e == NULL, "nonexistant");
+        e = parmlist_get(pctx, "non-existent");
+        torture_assert(tctx, e == NULL, "non-existent");
         return true;
+}
 …
         torture_assert_str_equal(tctx, "true", ret[0], "ret[0]");
         torture_assert_str_equal(tctx, "false", ret[1], "ret[1]");
         torture_assert(tctx, NULL == parmlist_get_string_list(pctx, "nonexistant", NULL), "nonexistant");
+        torture_assert(tctx, NULL == parmlist_get_string_list(pctx, "non-existent", NULL), "non-existent");
         return true;
 …
 struct torture_suite *torture_local_util_parmlist(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "PARMLIST");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "parmlist");
         torture_suite_add_simple_test(suite, "get_int", test_get_int);

vendor/current/lib/util/tests/str.c

r414	r740
95	95	struct torture_suite torture_local_util_str(TALLOC_CTX mem_ctx)
96	96	{
97		struct torture_suite *suite = torture_suite_create(mem_ctx, "~~STR~~");
	97	struct torture_suite *suite = torture_suite_create(mem_ctx, "str");
98	98
99	99	torture_suite_add_simple_test(suite, "string_sub_simple",

vendor/current/lib/util/tests/strlist.c

-              r414
+              r740
 struct test_list_element {
         const char *list_as_string;
         const char *seperators;
+        const char *separators;
         const char *list[5];
 };
 struct test_list_element test_lists_strings[] = {
+const struct test_list_element test_lists_strings[] = {
+        {
                 .list_as_string = "",
 …
                 .list_as_string = "foo bar",
                 .list = { "foo bar", NULL },
                 .seperators = ";"
+                .separators = ";"
         },
+        {
 …
                 .list_as_string = "\"foo bar\",comma;semicolon",
                 .list = { "\"foo bar\",comma", "semicolon", NULL },
                 .seperators = ";"
+                .separators = ";"
+        }
 };
 struct test_list_element test_lists_shell_strings[] = {
+const struct test_list_element test_lists_shell_strings[] = {
+        {
                 .list_as_string = "",
 …
                 .list_as_string = "foo bar",
                 .list = { "foo bar", NULL },
                 .seperators = ";"
+                .separators = ";"
         },
+        {
 …
 };
+static bool test_lists_shell(struct torture_context *tctx,
+                             const void *data)
+static bool test_lists_shell(struct torture_context *tctx, const void *data)
+{
         const struct test_list_element *element = data;
+        const char **ret1, **ret2, *tmp;
+        char **ret1, **ret2, *tmp;
         bool match = true;
         TALLOC_CTX *mem_ctx = tctx;
         ret1 = str_list_make_shell(mem_ctx, element->list_as_string, element->seperators);
+        ret1 = str_list_make_shell(mem_ctx, element->list_as_string, element->separators);
         torture_assert(tctx, ret1, "str_list_make_shell() must not return NULL");
         tmp = str_list_join_shell(mem_ctx, ret1, element->seperators ? *element->seperators : ' ');
         ret2 = str_list_make_shell(mem_ctx, tmp, element->seperators);
+        tmp = str_list_join_shell(mem_ctx, (const char **) ret1, element->separators ? *element->separators : ' ');
+        ret2 = str_list_make_shell(mem_ctx, tmp, element->separators);
         if ((ret1 == NULL || ret2 == NULL) && ret2 != ret1) {
 …
         torture_assert(tctx, match, talloc_asprintf(tctx,
                 "str_list_{make,join}_shell: Error double parsing, first run:\n%s\nSecond run: \n%s", element->list_as_string, tmp));
+        torture_assert(tctx, str_list_equal(ret1, element->list),
+        torture_assert(tctx, str_list_equal((const char * const *) ret1,
+                                            element->list),
                        talloc_asprintf(tctx,
                                        "str_list_make_shell(%s) failed to create correct list",
 …
+{
         const struct test_list_element *element = data;
         char **result;
         result = str_list_make(tctx, element->list_as_string, element->seperators);
+        result = str_list_make(tctx, element->list_as_string, element->separators);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
+        torture_assert(tctx, str_list_equal((const char **)result, element->list),
+        torture_assert(tctx, str_list_equal((const char * const *) result,
+                                            element->list),
                        talloc_asprintf(tctx,
                                        "str_list_make(%s) failed to create correct list",
 …
 static bool test_list_add(struct torture_context *tctx)
+{
         char **result, **result2;
+        const char **result, **result2;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_make(tctx, "element_0, element_1, element_2", NULL);
+        result = (const char **) str_list_make(tctx, "element_0, element_1, element_2", NULL);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
         result2 = str_list_add(result, "element_3");
+        result2 = str_list_add((const char **) result, "element_3");
         torture_assert(tctx, result2, "str_list_add() must not return NULL");
         torture_assert(tctx, str_list_equal(result2, list),
 …
 static bool test_list_add_const(struct torture_context *tctx)
+{
         char **result, **result2;
+        const char **result, **result2;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_make(tctx, "element_0, element_1, element_2", NULL);
+        result = (const char **) str_list_make(tctx, "element_0, element_1, element_2", NULL);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
         result2 = str_list_add_const(result, "element_3");
 …
 static bool test_list_remove(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_make(tctx, "element_0, element_1, element_2, element_3", NULL);
+        result = (const char **) str_list_make(tctx, "element_0, element_1, element_2, element_3", NULL);
         torture_assert(tctx, result, "str_list_make() must not return NULL");
         str_list_remove(result, "element_2");
 …
 static bool test_list_unique(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_copy(tctx, list_dup);
+        result = (const char **) str_list_copy(tctx, list_dup);
         /* We must copy the list, as str_list_unique does a talloc_realloc() on it's parameter */
         result = str_list_unique(result);
 …
         const char **list_dup = (const char **)str_list_make_empty(tctx);
         count = lp_parm_int(tctx->lp_ctx, NULL, "list_unique", "count", 9);
         num_dups = lp_parm_int(tctx->lp_ctx, NULL, "list_unique", "dups", 7);
+        count = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "count", 9);
+        num_dups = lpcfg_parm_int(tctx->lp_ctx, NULL, "list_unique", "dups", 7);
         torture_comment(tctx, "test_list_unique_2() with %d elements and %d dups\n", count, num_dups);
 …
 static bool test_list_append(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_copy(tctx, list);
+        result = (const char **) str_list_copy(tctx, list);
         torture_assert(tctx, result, "str_list_copy() must not return NULL");
         result = str_list_append(result, list2);
 …
 static bool test_list_append_const(struct torture_context *tctx)
+{
         char **result;
+        const char **result;
         const char *list[] = {
                 "element_0",
 …
                 NULL
         };
         result = str_list_copy(tctx, list);
+        result = (const char **) str_list_copy(tctx, list);
         torture_assert(tctx, result, "str_list_copy() must not return NULL");
         result = str_list_append_const(result, list2);
 …
 struct torture_suite *torture_local_util_strlist(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "STRLIST");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "strlist");
         int i;
         for (i = 0; i < ARRAY_SIZE(test_lists_shell_strings); i++) {
+                torture_suite_add_simple_tcase_const(suite, "lists_shell",
+                                test_lists_shell, &test_lists_shell_strings[i]);
+                char *name;
+                name = talloc_asprintf(suite, "lists_shell(%s)",
+                                                           test_lists_shell_strings[i].list_as_string);
+                torture_suite_add_simple_tcase_const(suite, name,
+                        test_lists_shell,  &test_lists_shell_strings[i]);
+        }
         for (i = 0; i < ARRAY_SIZE(test_lists_strings); i++) {
+                torture_suite_add_simple_tcase_const(suite, "lists",
+                                                     test_list_make, &test_lists_strings[i]);
+                char *name;
+                name = talloc_asprintf(suite, "list_make(%s)",
+                                                           test_lists_strings[i].list_as_string);
+                torture_suite_add_simple_tcase_const(suite, name,
+                        test_list_make, &test_lists_strings[i]);
+        }

vendor/current/lib/util/tests/time.c

-              r414
+              r740
         result = timestring(tctx, 42 - (utc_offset < 0 ? utc_offset : 0));
+        torture_assert(tctx, !strncmp(start, result, strlen(start)),
+                                   result);
+        torture_assert(tctx, !strncmp(start, result, strlen(start)), result);
         return true;
+}
 …
 struct torture_suite *torture_local_util_time(TALLOC_CTX *mem_ctx)
+{
         struct torture_suite *suite = torture_suite_create(mem_ctx, "TIME");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "time");
         torture_suite_add_simple_test(suite, "null_time", test_null_time);

vendor/current/lib/util/tevent_ntstatus.c

-              r414
+              r740
 #include "tevent_ntstatus.h"
+bool tevent_req_nterror(struct tevent_req *req, NTSTATUS status)
+#define TEVENT_NTERROR_MAGIC (0x917b5acd)
+bool _tevent_req_nterror(struct tevent_req *req,
+                         NTSTATUS status,
+                         const char *location)
+{
+        return tevent_req_error(req, NT_STATUS_V(status));
+        uint64_t err;
+        if (NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        /*
+         * I've put this variable here, because I'm not 100% certain
+         * how to correctly assign a 64-bit constant and left-shift it
+         * by 32 bits in a single expression. If anyone knows, feel
+         * free :-)
+         */
+        err = TEVENT_NTERROR_MAGIC;
+        err <<= 32;
+        err |= NT_STATUS_V(status);
+        return _tevent_req_error(req, err, location);
+}
 …
                 break;
         case TEVENT_REQ_USER_ERROR:
+                *status = NT_STATUS(err);
+                if ((err >> 32) != TEVENT_NTERROR_MAGIC) {
+                        abort();
+                }
+                *status = NT_STATUS(err & 0xffffffff);
                 break;
         default:
 …
         return NT_STATUS_OK;
+}
+void tevent_req_simple_finish_ntstatus(struct tevent_req *subreq,
+                                       NTSTATUS subreq_status)
+{
+        struct tevent_req *req = tevent_req_callback_data(
+                subreq, struct tevent_req);
+        TALLOC_FREE(subreq);
+        if (!NT_STATUS_IS_OK(subreq_status)) {
+                tevent_req_nterror(req, subreq_status);
+                return;
+        }
+        tevent_req_done(req);
+}

vendor/current/lib/util/tevent_ntstatus.h

-              r414
+              r740
 #include <stdbool.h>
 #include "../libcli/util/ntstatus.h"
 #include "../tevent/tevent.h"
+#include <tevent.h>
+bool tevent_req_nterror(struct tevent_req *req, NTSTATUS status);
+bool _tevent_req_nterror(struct tevent_req *req,
+                         NTSTATUS status,
+                         const char *location);
+#define tevent_req_nterror(req, status) \
+        _tevent_req_nterror(req, status, __location__)
 bool tevent_req_is_nterror(struct tevent_req *req, NTSTATUS *pstatus);
 NTSTATUS tevent_req_simple_recv_ntstatus(struct tevent_req *req);
+/*
+ * Helper routine to pass the subreq_ntstatus to the req embedded in
+ * tevent_req_callback_data(subreq), which will be freed.
+ */
+void tevent_req_simple_finish_ntstatus(struct tevent_req *subreq,
+                                       NTSTATUS subreq_status);
 #endif

vendor/current/lib/util/tevent_unix.c

-              r414
+              r740
 */
+#include "../replace/replace.h"
 #include "tevent_unix.h"
-#include "../replace/replace.h"
 bool tevent_req_is_unix_error(struct tevent_req *req, int *perrno)

vendor/current/lib/util/tevent_unix.h

r414	r740
25	25	#define _TEVENT_UNIX_H
26	26
27		#include ~~"../tevent/tevent.h"~~
	27	#include <tevent.h>
28	28
29	29	bool tevent_req_is_unix_error(struct tevent_req req, int perrno);

vendor/current/lib/util/time.c

-              r478
+              r740
    Copyright (C) Andrew Tridgell                1992-2004
    Copyright (C) Stefan (metze) Metzmacher      2002
+   Copyright (C) Jeremy Allison                 2007
+   Copyright (C) Andrew Bartlett                2011
    This program is free software; you can redistribute it and/or modify
 …
+}
+/**
+a wrapper to preferably get the monotonic time
+**/
+_PUBLIC_ void clock_gettime_mono(struct timespec *tp)
+{
+        if (clock_gettime(CUSTOM_CLOCK_MONOTONIC,tp) != 0) {
+                clock_gettime(CLOCK_REALTIME,tp);
+        }
+}
+/**
+a wrapper to preferably get the monotonic time in seconds
+as this is only second resolution we can use the cached
+(and much faster) COARSE clock variant
+**/
+_PUBLIC_ time_t time_mono(time_t *t)
+{
+        struct timespec tp;
+        int rc = -1;
+#ifdef CLOCK_MONOTONIC_COARSE
+        rc = clock_gettime(CLOCK_MONOTONIC_COARSE,&tp);
+#endif
+        if (rc != 0) {
+                clock_gettime_mono(&tp);
+        }
+        if (t != NULL) {
+                *t = tp.tv_sec;
+        }
+        return tp.tv_sec;
+}
 #define TIME_FIXUP_CONSTANT 11644473600LL
 …
 time_t convert_timespec_to_time_t(struct timespec ts)
+{
+        /* Ensure tv_nsec is less than 1sec. */
+        while (ts.tv_nsec > 1000000000) {
+                ts.tv_sec += 1;
+                ts.tv_nsec -= 1000000000;
+        }
         /* 1 ns == 1,000,000,000 - one thousand millionths of a second.
            increment if it's greater than 500 millionth of a second. */
         if (ts.tv_nsec > 500000000) {
                 return ts.tv_sec + 1;
 …
+/****************************************************************************
+ Return the date and time as a string
+****************************************************************************/
+char *timeval_string(TALLOC_CTX *ctx, const struct timeval *tp, bool hires)
+{
+        time_t t;
+        struct tm *tm;
+        t = (time_t)tp->tv_sec;
+        tm = localtime(&t);
+        if (!tm) {
+                if (hires) {
+                        return talloc_asprintf(ctx,
+                                               "%ld.%06ld seconds since the Epoch",
+                                               (long)tp->tv_sec,
+                                               (long)tp->tv_usec);
+                } else {
+                        return talloc_asprintf(ctx,
+                                               "%ld seconds since the Epoch",
+                                               (long)t);
+                }
+        } else {
+#ifdef HAVE_STRFTIME
+                char TimeBuf[60];
+                if (hires) {
+                        strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
+                        return talloc_asprintf(ctx,
+                                               "%s.%06ld", TimeBuf,
+                                               (long)tp->tv_usec);
+                } else {
+                        strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
+                        return talloc_strdup(ctx, TimeBuf);
+                }
+#else
+                if (hires) {
+                        const char *asct = asctime(tm);
+                        return talloc_asprintf(ctx, "%s.%06ld",
+                                        asct ? asct : "unknown",
+                                        (long)tp->tv_usec);
+                } else {
+                        const char *asct = asctime(tm);
+                        return talloc_asprintf(ctx, asct ? asct : "unknown");
+                }
+#endif
+        }
+}
+char *current_timestring(TALLOC_CTX *ctx, bool hires)
+{
+        struct timeval tv;
+        GetTimeOfDay(&tv);
+        return timeval_string(ctx, &tv, hires);
+}
 /**
 return a HTTP/1.0 time string
 …
 #ifdef HAVE_STRFTIME
+        /* some versions of gcc complain about using %c. This is a bug
+           in the gcc warning, not a bug in this code. See a recent
+           strftime() manual page for details.
+         */
+        strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
+        /* Some versions of gcc complain about using some special format
+         * specifiers. This is a bug in gcc, not a bug in this code. See a
+         * recent strftime() manual page for details. */
+        strftime(tempTime,sizeof(tempTime)-1,"%a %b %e %X %Y %Z",tm);
         TimeBuf = talloc_strdup(mem_ctx, tempTime);
 #else
 …
         int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
         return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
+}
+/**
+  return (tp1 - tp2) in microseconds
+*/
+_PUBLIC_ int64_t nsec_time_diff(const struct timespec *tp1, const struct timespec *tp2)
+{
+        int64_t sec_diff = tp1->tv_sec - tp2->tv_sec;
+        return (sec_diff * 1000000000) + (int64_t)(tp1->tv_nsec - tp2->tv_nsec);
+}

vendor/current/lib/util/time.h

-              r478
+              r740
    Unix SMB/CIFS implementation.
    time utility functions
+   Copyright (C) Andrew Tridgell                1992-2004
+   Copyright (C) Stefan (metze) Metzmacher      2002
+   Copyright (C) Jeremy Allison                 2007
+   Copyright (C) Andrew Bartlett                2011
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 …
 /**
+a wrapper to preferably get the monotonic time
+**/
+_PUBLIC_ void clock_gettime_mono(struct timespec *tp);
+/**
+a wrapper to preferably get the monotonic time in s
+**/
+_PUBLIC_ time_t time_mono(time_t *t);
+/**
 interpret an 8 byte "filetime" structure to a time_t
 It's originally in "100ns units since jan 1st 1601"
 …
 /**
+ Return a date and time as a string (optionally with microseconds)
+ format is %Y/%m/%d %H:%M:%S if strftime is available
+**/
+char *timeval_string(TALLOC_CTX *ctx, const struct timeval *tp, bool hires);
+/**
+ Return the current date and time as a string (optionally with microseconds)
+ format is %Y/%m/%d %H:%M:%S if strftime is available
+**/
+char *current_timestring(TALLOC_CTX *ctx, bool hires);
+/**
 return a HTTP/1.0 time string
 **/
 …
 /**
  Return the date and time as a string
+ format is %a %b %e %X %Y %Z
 **/
 _PUBLIC_ char *timestring(TALLOC_CTX *mem_ctx, time_t t);
 …
 */
 _PUBLIC_ int64_t usec_time_diff(const struct timeval *tv1, const struct timeval *tv2);
+/**
+  return (tp1 - tp2) in nanoseconds
+*/
+_PUBLIC_ int64_t nsec_time_diff(const struct timespec *tp1, const struct timespec *tp2);
 /**

vendor/current/lib/util/unix_privs.c

-              r414
+              r740
 #include "includes.h"
 #include "system/filesys.h"
+#include "system/passwd.h"
 #include "../lib/util/unix_privs.h"
+#if defined(UID_WRAPPER)
+#if !defined(UID_WRAPPER_REPLACE) && !defined(UID_WRAPPER_NOT_REPLACE)
+#define UID_WRAPPER_REPLACE
+#include "../uid_wrapper/uid_wrapper.h"
+#endif
+#else
+#define uwrap_enabled() 0
+#endif
 /**
 …
         return s;
+}
+uid_t root_privileges_original_uid(void *s)
+{
+        struct saved_state *saved = talloc_get_type_abort(s, struct saved_state);
+        return saved->uid;
+}

vendor/current/lib/util/util.c

-              r414
+              r740
 #include "system/filesys.h"
 #include "system/locale.h"
+#include "system/shmem.h"
 #undef malloc
 #undef strcasecmp
 …
 #undef strdup
 #undef realloc
+#if defined(UID_WRAPPER)
+#if !defined(UID_WRAPPER_REPLACE) && !defined(UID_WRAPPER_NOT_REPLACE)
+#define UID_WRAPPER_REPLACE
+#include "../uid_wrapper/uid_wrapper.h"
+#endif
+#else
+#define uwrap_enabled() 0
+#endif
 /**
 …
 **/
+_PUBLIC_ void msleep(unsigned int t)
+{
+        struct timeval tval;
+        tval.tv_sec = t/1000;
+        tval.tv_usec = 1000*(t%1000);
+        /* this should be the real select - do NOT replace
+           with sys_select() */
+        select(0,NULL,NULL,NULL,&tval);
+_PUBLIC_ void smb_msleep(unsigned int t)
+{
+#if defined(HAVE_NANOSLEEP)
+        struct timespec ts;
+        int ret;
+        ts.tv_sec = t/1000;
+        ts.tv_nsec = 1000000*(t%1000);
+        do {
+                errno = 0;
+                ret = nanosleep(&ts, &ts);
+        } while (ret < 0 && errno == EINTR && (ts.tv_sec > 0 || ts.tv_nsec > 0));
+#else
+        unsigned int tdiff=0;
+        struct timeval tval,t1,t2;
+        fd_set fds;
+        GetTimeOfDay(&t1);
+        t2 = t1;
+        while (tdiff < t) {
+                tval.tv_sec = (t-tdiff)/1000;
+                tval.tv_usec = 1000*((t-tdiff)%1000);
+                /* Never wait for more than 1 sec. */
+                if (tval.tv_sec > 1) {
+                        tval.tv_sec = 1;
+                        tval.tv_usec = 0;
+                }
+                FD_ZERO(&fds);
+                errno = 0;
+                select(0,&fds,NULL,NULL,&tval);
+                GetTimeOfDay(&t2);
+                if (t2.tv_sec < t1.tv_sec) {
+                        /* Someone adjusted time... */
+                        t1 = t2;
+                }
+                tdiff = usec_time_diff(&t2,&t1)/1000;
+        }
+#endif
+}
 …
+}
+static void debugadd_cb(const char *buf, void *private_data)
+{
+        int *plevel = (int *)private_data;
+        DEBUGADD(*plevel, ("%s", buf));
+}
+void print_asc_cb(const uint8_t *buf, int len,
+                  void (*cb)(const char *buf, void *private_data),
+                  void *private_data)
+{
+        int i;
+        char s[2];
+        s[1] = 0;
+        for (i=0; i<len; i++) {
+                s[0] = isprint(buf[i]) ? buf[i] : '.';
+                cb(s, private_data);
+        }
+}
 void print_asc(int level, const uint8_t *buf,int len)
+{
+        int i;
+        for (i=0;i<len;i++)
+                DEBUGADD(level,("%c", isprint(buf[i])?buf[i]:'.'));
+}
+/**
+ * Write dump of binary data to the log file.
+ *
+ * The data is only written if the log level is at least level.
+        print_asc_cb(buf, len, debugadd_cb, &level);
+}
+/**
+ * Write dump of binary data to a callback
  */
+static void _dump_data(int level, const uint8_t *buf, int len,
+                       bool omit_zero_bytes)
+void dump_data_cb(const uint8_t *buf, int len,
+                  bool omit_zero_bytes,
+                  void (*cb)(const char *buf, void *private_data),
+                  void *private_data)
+{
         int i=0;
         static const uint8_t empty[16] = { 0, };
         bool skipped = false;
+        char tmp[16];
         if (len<=0) return;
-        if (!DEBUGLVL(level)) return;
         for (i=0;i<len;) {
 …
                         if (i<len)  {
+                                DEBUGADD(level,("[%04X] ",i));
+                                snprintf(tmp, sizeof(tmp), "[%04X] ", i);
+                                cb(tmp, private_data);
+                        }
+                }
+                DEBUGADD(level,("%02X ",(int)buf[i]));
+                snprintf(tmp, sizeof(tmp), "%02X ", (int)buf[i]);
+                cb(tmp, private_data);
                 i++;
+                if (i%8 == 0) DEBUGADD(level,("  "));
+                if (i%8 == 0) {
+                        cb("  ", private_data);
+                }
                 if (i%16 == 0) {
+                        print_asc(level,&buf[i-16],8); DEBUGADD(level,(" "));
+                        print_asc(level,&buf[i-8],8); DEBUGADD(level,("\n"));
+                        print_asc_cb(&buf[i-16], 8, cb, private_data);
+                        cb(" ", private_data);
+                        print_asc_cb(&buf[i-8], 8, cb, private_data);
+                        cb("\n", private_data);
                         if ((omit_zero_bytes == true) &&
 …
                             (memcmp(&buf[i], &empty, 16) == 0)) {
                                 if (!skipped) {
+                                        DEBUGADD(level,("skipping zero buffer bytes\n"));
+                                        cb("skipping zero buffer bytes\n",
+                                           private_data);
                                         skipped = true;
+                                }
 …
                 int n;
                 n = 16 - (i%16);
+                DEBUGADD(level,(" "));
+                if (n>8) DEBUGADD(level,(" "));
+                while (n--) DEBUGADD(level,("   "));
+                cb(" ", private_data);
+                if (n>8) {
+                        cb(" ", private_data);
+                }
+                while (n--) {
+                        cb("   ", private_data);
+                }
                 n = MIN(8,i%16);
+                print_asc(level,&buf[i-(i%16)],n); DEBUGADD(level,( " " ));
+                print_asc_cb(&buf[i-(i%16)], n, cb, private_data);
+                cb(" ", private_data);
                 n = (i%16) - n;
+                if (n>0) print_asc(level,&buf[i-n],n);
+                DEBUGADD(level,("\n"));
+                if (n>0) {
+                        print_asc_cb(&buf[i-n], n, cb, private_data);
+                }
+                cb("\n", private_data);
+        }
 …
 _PUBLIC_ void dump_data(int level, const uint8_t *buf, int len)
+{
+        _dump_data(level, buf, len, false);
+        if (!DEBUGLVL(level)) {
+                return;
+        }
+        dump_data_cb(buf, len, false, debugadd_cb, &level);
+}
 …
+ *
  * The data is only written if the log level is at least level.
  * 16 zero bytes in a row are ommited
+ * 16 zero bytes in a row are omitted
  */
 _PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len)
+{
+        _dump_data(level, buf, len, true);
+        if (!DEBUGLVL(level)) {
+                return;
+        }
+        dump_data_cb(buf, len, true, debugadd_cb, &level);
+}
 …
 _PUBLIC_ size_t strhex_to_str(char *p, size_t p_len, const char *strhex, size_t strhex_len)
+{
         size_t i;
+        size_t i = 0;
         size_t num_chars = 0;
         uint8_t   lonybble, hinybble;
 …
         char           *p1 = NULL, *p2 = NULL;
         for (i = 0; i < strhex_len && strhex[i] != 0; i++) {
                 if (strncasecmp(hexchars, "0x", 2) == 0) {
                         i++; /* skip two chars */
                         continue;
+                }
+        /* skip leading 0x prefix */
+        if (strncasecmp(strhex, "0x", 2) == 0) {
+                i += 2; /* skip two chars */
+        }
+        for (; i < strhex_len && strhex[i] != 0; i++) {
                 if (!(p1 = strchr(hexchars, toupper((unsigned char)strhex[i]))))
                         break;
 …
                                 bool ltrim)
+{
         char *s;
         char *saved_s;
+        const char *s;
+        const char *saved_s;
         char *pbuf;
         bool quoted;
 …
+        }
         s = (char *)*ptr;
+        s = *ptr;
         /* default to simple separators */
 …
+}
+/**
+ * Get the next token from a string, return False if none found.
+ * Handles double-quotes.
+ *
+ * Based on a routine by GJC@VILLAGE.COM.
+ * Extensively modified by Andrew.Tridgell@anu.edu.au
+ **/
+_PUBLIC_ bool next_token(const char **ptr,char *buff, const char *sep, size_t bufsize)
+{
+        const char *s;
+        bool quoted;
+        size_t len=1;
+        if (!ptr)
+                return false;
+        s = *ptr;
+        /* default to simple separators */
+        if (!sep)
+                sep = " \t\n\r";
+        /* find the first non sep char */
+        while (*s && strchr_m(sep,*s))
+                s++;
+        /* nothing left? */
+        if (!*s)
+                return false;
+        /* copy over the token */
+        for (quoted = false; len < bufsize && *s && (quoted || !strchr_m(sep,*s)); s++) {
+                if (*s == '\"') {
+                        quoted = !quoted;
+                } else {
+                        len++;
+                        *buff++ = *s;
+                }
+        }
+        *ptr = (*s) ? s+1 : s;
+        *buff = 0;
+        return true;
+}
+struct anonymous_shared_header {
+        union {
+                size_t length;
+                uint8_t pad[16];
+        } u;
+};
+/* Map a shared memory buffer of at least nelem counters. */
+void *anonymous_shared_allocate(size_t orig_bufsz)
+{
+        void *ptr;
+        void *buf;
+        size_t pagesz = getpagesize();
+        size_t pagecnt;
+        size_t bufsz = orig_bufsz;
+        struct anonymous_shared_header *hdr;
+        bufsz += sizeof(*hdr);
+        /* round up to full pages */
+        pagecnt = bufsz / pagesz;
+        if (bufsz % pagesz) {
+                pagecnt += 1;
+        }
+        bufsz = pagesz * pagecnt;
+        if (orig_bufsz >= bufsz) {
+                /* integer wrap */
+                errno = ENOMEM;
+                return NULL;
+        }
+#ifdef MAP_ANON
+        /* BSD */
+        buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED,
+                        -1 /* fd */, 0 /* offset */);
+#else
+        buf = mmap(NULL, bufsz, PROT_READ|PROT_WRITE, MAP_FILE|MAP_SHARED,
+                        open("/dev/zero", O_RDWR), 0 /* offset */);
+#endif
+        if (buf == MAP_FAILED) {
+                return NULL;
+        }
+        hdr = (struct anonymous_shared_header *)buf;
+        hdr->u.length = bufsz;
+        ptr = (void *)(&hdr[1]);
+        return ptr;
+}
+void anonymous_shared_free(void *ptr)
+{
+        struct anonymous_shared_header *hdr;
+        if (ptr == NULL) {
+                return;
+        }
+        hdr = (struct anonymous_shared_header *)ptr;
+        hdr--;
+        munmap(hdr, hdr->u.length);
+}
+#ifdef DEVELOPER
+/* used when you want a debugger started at a particular point in the
+   code. Mostly useful in code that runs as a child process, where
+   normal gdb attach is harder to organise.
+*/
+void samba_start_debugger(void)
+{
+        char *cmd = NULL;
+        if (asprintf(&cmd, "xterm -e \"gdb --pid %u\"&", getpid()) == -1) {
+                return;
+        }
+        if (system(cmd) == -1) {
+                free(cmd);
+                return;
+        }
+        free(cmd);
+        sleep(2);
+}
+#endif

vendor/current/lib/util/util.h

-              r414
+              r740
 #define _SAMBA_UTIL_H_
+#if _SAMBA_BUILD_ == 4
+#include "../lib/util/charset/charset.h"
+#endif
+#include "../lib/util/attr.h"
+#include "lib/util/charset/charset.h"
+#include "lib/util/attr.h"
 /* for TALLOC_CTX */
 …
 extern const char *panic_action;
+#include "../lib/util/time.h"
+#include "../lib/util/data_blob.h"
+#include "../lib/util/xfile.h"
+#include "../lib/util/mutex.h"
+#include "../lib/util/byteorder.h"
+#include "../lib/util/talloc_stack.h"
+#include "lib/util/time.h"
+#include "lib/util/data_blob.h"
+#include "lib/util/xfile.h"
+#include "lib/util/byteorder.h"
+#include "lib/util/talloc_stack.h"
 /**
 …
 #endif
-#if _SAMBA_BUILD_ == 4
-#ifdef VALGRIND
-#define strlen(x) valgrind_strlen(x)
-size_t valgrind_strlen(const char *s);
-#endif
-#endif
 #ifndef ABS
 #define ABS(a) ((a)>0?(a):(-(a)))
 #endif
 #include "../lib/util/memory.h"
+#include "lib/util/memory.h"
 /**
 …
 **/
 _PUBLIC_ void fault_setup(const char *pname);
+_PUBLIC_ void fault_setup_disable(void);
 #endif
 …
 _PUBLIC_ pid_t sys_getpid(void);
+_PUBLIC_ int sys_getpeereid( int s, uid_t *uid);
+struct sockaddr;
+_PUBLIC_ int sys_getnameinfo(const struct sockaddr *psa,
+                             int salen,
+                             char *host,
+                             size_t hostlen,
+                             char *service,
+                             size_t servlen,
+                             int flags);
+_PUBLIC_ int sys_connect(int fd, const struct sockaddr * addr);
 /* The following definitions come from lib/util/genrand.c  */
 /**
  Copy any user given reseed data.
 …
 **/
 _PUBLIC_ bool check_password_quality(const char *s);
+/**
+ * Generate a random text password.
+ */
+_PUBLIC_ char *generate_random_password(TALLOC_CTX *mem_ctx, size_t min, size_t max);
 /**
 …
 /**
  * build a null terminated list of strings from an argv-like input string
  * Entries are seperated by spaces and can be enclosed by quotes.
+ * Entries are separated by spaces and can be enclosed by quotes.
  * Does NOT support escaping
  */
 …
  * join a list back to one string
  */
 _PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator);
+_PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char separator);
 /** join a list back to one (shell-like) string; entries
  * seperated by spaces, using quotes where necessary */
+ * separated by spaces, using quotes where necessary */
 _PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep);
 …
    Return true if all the elements of the list match exactly.
  */
 _PUBLIC_ bool str_list_equal(const char **list1, const char **list2);
+_PUBLIC_ bool str_list_equal(const char * const *list1, const char * const *list2);
 /**
 …
 _PUBLIC_ const char **str_list_copy_const(TALLOC_CTX *mem_ctx,
                                           const char **list);
+/**
+ * Needed for making an "unconst" list "const"
+ */
+_PUBLIC_ const char **const_str_list(char **list);
 …
 _PUBLIC_ bool large_file_support(const char *path);
+/*
+  compare two files, return true if the two files have the same content
+ */
+bool file_compare(const char *path1, const char *path2);
 /* The following definitions come from lib/util/util.c  */
 …
  Sleep for a specified number of milliseconds.
 **/
 _PUBLIC_ void msleep(unsigned int t);
+_PUBLIC_ void smb_msleep(unsigned int t);
 /**
 …
 **/
 _PUBLIC_ char* get_myname(TALLOC_CTX *mem_ctx);
-/**
- Return true if a string could be a pure IP address.
-**/
-_PUBLIC_ bool is_ipaddress(const char *str);
-/**
- Interpret an internet address or name into an IP address in 4 byte form.
-**/
-_PUBLIC_ uint32_t interpret_addr(const char *str);
-/**
- A convenient addition to interpret_addr().
-**/
-_PUBLIC_ struct in_addr interpret_addr2(const char *str);
-/**
- Check if an IP is the 0.0.0.0.
-**/
-_PUBLIC_ bool is_zero_ip_v4(struct in_addr ip);
-/**
- Are two IPs on the same subnet?
-**/
-_PUBLIC_ bool same_net_v4(struct in_addr ip1,struct in_addr ip2,struct in_addr mask);
-_PUBLIC_ bool is_ipaddress_v4(const char *str);
 /**
 …
 /**
+ * Write dump of binary data to a callback
+ */
+void dump_data_cb(const uint8_t *buf, int len,
+                  bool omit_zero_bytes,
+                  void (*cb)(const char *buf, void *private_data),
+                  void *private_data);
+/**
  * Write dump of binary data to the log file.
+ *
 …
+ *
  * The data is only written if the log level is at least level.
  * 16 zero bytes in a row are ommited
+ * 16 zero bytes in a row are omitted
  */
 _PUBLIC_ void dump_data_skip_zeros(int level, const uint8_t *buf, int len);
 …
 #endif
-/* The following definitions come from lib/util/mutex.c  */
-/**
-  register a set of mutex/rwlock handlers.
-  Should only be called once in the execution of smbd.
-*/
-_PUBLIC_ bool register_mutex_handlers(const char *name, struct mutex_ops *ops);
 /* The following definitions come from lib/util/idtree.c  */
 …
  Become a daemon, discarding the controlling terminal.
 **/
 _PUBLIC_ void become_daemon(bool do_fork, bool no_process_group);
+_PUBLIC_ void become_daemon(bool do_fork, bool no_process_group, bool log_stdout);
 /**
 …
 void print_asc(int level, const uint8_t *buf,int len);
+void print_asc_cb(const uint8_t *buf, int len,
+                  void (*cb)(const char *buf, void *private_data),
+                  void *private_data);
 /**
 …
 bool add_uid_to_array_unique(TALLOC_CTX *mem_ctx, uid_t uid,
                              uid_t **uids, size_t *num_uids);
+                             uid_t **uids, uint32_t *num_uids);
 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
+                             gid_t **gids, size_t *num_gids);
+                             gid_t **gids, uint32_t *num_gids);
+/**
+ * Allocate anonymous shared memory of the given size
+ */
+void *anonymous_shared_allocate(size_t bufsz);
+void anonymous_shared_free(void *ptr);
+/*
+  run a command as a child process, with a timeout.
+  any stdout/stderr from the child will appear in the Samba logs with
+  the specified log levels
+  If callback is set then the callback is called on completion
+  with the return code from the command
+ */
+struct tevent_context;
+struct tevent_req;
+struct tevent_req *samba_runcmd_send(TALLOC_CTX *mem_ctx,
+                                     struct tevent_context *ev,
+                                     struct timeval endtime,
+                                     int stdout_log_level,
+                                     int stderr_log_level,
+                                     const char * const *argv0, ...);
+int samba_runcmd_recv(struct tevent_req *req, int *perrno);
+#ifdef DEVELOPER
+void samba_start_debugger(void);
+#endif
 #endif /* _SAMBA_UTIL_H_ */

vendor/current/lib/util/util_file.c

-              r414
+              r740
 #endif
         if (!p) {
                 p = file_load(fname, &s2, 0, talloc_autofree_context());
+                p = file_load(fname, &s2, 0, NULL);
                 if (!p) return NULL;
                 if (s2 != size) {
 …
+/*
+  compare two files, return true if the two files have the same content
+ */
+bool file_compare(const char *path1, const char *path2)
+{
+        size_t size1, size2;
+        char *p1, *p2;
+        TALLOC_CTX *mem_ctx = talloc_new(NULL);
+        p1 = file_load(path1, &size1, 0, mem_ctx);
+        p2 = file_load(path2, &size2, 0, mem_ctx);
+        if (!p1 || !p2 || size1 != size2) {
+                talloc_free(mem_ctx);
+                return false;
+        }
+        if (memcmp(p1, p2, size1) != 0) {
+                talloc_free(mem_ctx);
+                return false;
+        }
+        talloc_free(mem_ctx);
+        return true;
+}

vendor/current/lib/util/util_id.c

-              r414
+              r740
 bool add_gid_to_array_unique(TALLOC_CTX *mem_ctx, gid_t gid,
                              gid_t **gids, size_t *num_gids)
+                             gid_t **gids, uint32_t *num_gids)
+{
         int i;
 …
 bool add_uid_to_array_unique(TALLOC_CTX *mem_ctx, uid_t uid,
                              uid_t **uids, size_t *num_uids)
+                             uid_t **uids, uint32_t *num_uids)
+{
         int i;

vendor/current/lib/util/util_ldb.c

-              r414
+              r740
 #include "includes.h"
 #include "lib/ldb/include/ldb.h"
+#include <ldb.h>
 #include "../lib/util/util_ldb.h"
 /*
   search the sam for the specified attributes - va_list variant
 */
+ * search the LDB for the specified attributes - va_list variant
+ */
 int gendb_search_v(struct ldb_context *ldb,
                    TALLOC_CTX *mem_ctx,
 …
                    const char * const *attrs,
                    const char *format,
                    va_list ap)
+                   va_list ap)
+{
         enum ldb_scope scope = LDB_SCOPE_SUBTREE;
 …
         if (ret == LDB_SUCCESS) {
-                talloc_steal(mem_ctx, res->msgs);
                 DEBUG(6,("gendb_search_v: %s %s -> %d\n",
                          basedn?ldb_dn_get_linearized(basedn):"NULL",
 …
                 ret = res->count;
+                *msgs = res->msgs;
+                if (msgs != NULL) {
+                        *msgs = talloc_steal(mem_ctx, res->msgs);
+                }
                 talloc_free(res);
         } else if (scope == LDB_SCOPE_BASE && ret == LDB_ERR_NO_SUCH_OBJECT) {
                 ret = 0;
                 *msgs = NULL;
+                if (msgs != NULL) *msgs = NULL;
         } else {
                 DEBUG(4,("gendb_search_v: search failed: %s\n",
                                         ldb_errstring(ldb)));
                 ret = -1;
+                if (msgs != NULL) *msgs = NULL;
+        }
 …
 /*
   search the LDB for the specified attributes - varargs variant
 */
+ * search the LDB for the specified attributes - varargs variant
+ */
 int gendb_search(struct ldb_context *ldb,
                  TALLOC_CTX *mem_ctx,
 …
                  struct ldb_message ***res,
                  const char * const *attrs,
                  const char *format, ...)
+                 const char *format, ...)
+{
         va_list ap;
 …
 /*
+  search the LDB for a specified record (by DN)
+*/
+ * search the LDB for a specified record (by DN)
+ */
 int gendb_search_dn(struct ldb_context *ldb,
                  TALLOC_CTX *mem_ctx,
 …
+}
-/*
-  setup some initial ldif in a ldb
-*/
-int gendb_add_ldif(struct ldb_context *ldb, const char *ldif_string)
+{
-        struct ldb_ldif *ldif;
-        int ret;
-        ldif = ldb_ldif_read_string(ldb, &ldif_string);
-        if (ldif == NULL) return -1;
-        ret = ldb_add(ldb, ldif->msg);
-        talloc_free(ldif);
-        return ret;
+}
-char *wrap_casefold(void *context, void *mem_ctx, const char *s, size_t n)
+{
-        return strupper_talloc_n(mem_ctx, s, n);
+}
-/*
-  search the LDB for a single record, with the extended_dn control
-  return LDB_SUCCESS on success, or an ldb error code on error
-  if the search returns 0 entries, return LDB_ERR_NO_SUCH_OBJECT
-  if the search returns more than 1 entry, return LDB_ERR_CONSTRAINT_VIOLATION
-*/
-int gendb_search_single_extended_dn(struct ldb_context *ldb,
-                                    TALLOC_CTX *mem_ctx,
-                                    struct ldb_dn *basedn,
-                                    enum ldb_scope scope,
-                                    struct ldb_message **msg,
-                                    const char * const *attrs,
-                                    const char *format, ...)
+{
-        va_list ap;
-        int ret;
-        struct ldb_request *req;
-        char *filter;
-        TALLOC_CTX *tmp_ctx;
-        struct ldb_result *res;
-        struct ldb_extended_dn_control *ctrl;
-        tmp_ctx = talloc_new(mem_ctx);
-        res = talloc_zero(tmp_ctx, struct ldb_result);
-        if (!res) {
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        va_start(ap, format);
-        filter = talloc_vasprintf(tmp_ctx, format, ap);
-        va_end(ap);
-        if (filter == NULL) {
-                talloc_free(tmp_ctx);
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        ret = ldb_build_search_req(&req, ldb, tmp_ctx,
-                                   basedn,
-                                   scope,
-                                   filter,
-                                   attrs,
-                                   NULL,
-                                   res,
-                                   ldb_search_default_callback,
-                                   NULL);
-        if (ret != LDB_SUCCESS) {
-                talloc_free(tmp_ctx);
-                return ret;
+        }
-        ctrl = talloc(tmp_ctx, struct ldb_extended_dn_control);
-        if (ctrl == NULL) {
-                talloc_free(tmp_ctx);
-                return LDB_ERR_OPERATIONS_ERROR;
+        }
-        ctrl->type = 1;
-        ret = ldb_request_add_control(req, LDB_CONTROL_EXTENDED_DN_OID, true, ctrl);
-        if (ret != LDB_SUCCESS) {
-                return ret;
+        }
-        ret = ldb_request(ldb, req);
-        if (ret == LDB_SUCCESS) {
-                ret = ldb_wait(req->handle, LDB_WAIT_ALL);
+        }
-        if (ret != LDB_SUCCESS) {
-                talloc_free(tmp_ctx);
-                return ret;
+        }
-        if (res->count == 0) {
-                talloc_free(tmp_ctx);
-                return LDB_ERR_NO_SUCH_OBJECT;
+        }
-        if (res->count > 1) {
-                /* the function is only supposed to return a single entry */
-                DEBUG(0,(__location__ ": More than one return for baseDN %s  filter %s\n",
-                         ldb_dn_get_linearized(basedn), filter));
-                talloc_free(tmp_ctx);
-                return LDB_ERR_CONSTRAINT_VIOLATION;
+        }
-        *msg = talloc_steal(mem_ctx, res->msgs[0]);
-        talloc_free(tmp_ctx);
-        return LDB_SUCCESS;
+}

vendor/current/lib/util/util_ldb.h

-              r414
+              r740
+/*
+   Unix SMB/CIFS implementation.
+   common share info functions
+   Copyright (C) Andrew Tridgell 2004
+   Copyright (C) Tim Potter 2004
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
 #ifndef __LIB_UTIL_UTIL_LDB_H__
 #define __LIB_UTIL_UTIL_LDB_H__
 …
                  struct ldb_message ***res,
                  const char * const *attrs);
-int gendb_add_ldif(struct ldb_context *ldb, const char *ldif_string);
-char *wrap_casefold(void *context, void *mem_ctx, const char *s, size_t n);
-int gendb_search_single_extended_dn(struct ldb_context *ldb,
-                                    TALLOC_CTX *mem_ctx,
-                                    struct ldb_dn *basedn,
-                                    enum ldb_scope scope,
-                                    struct ldb_message **msg,
-                                    const char * const *attrs,
-                                    const char *format, ...)  PRINTF_ATTRIBUTE(7,8);
 #endif /* __LIB_UTIL_UTIL_LDB_H__ */

vendor/current/lib/util/util_net.c

-              r414
+              r740
 #include "system/locale.h"
 #include "system/filesys.h"
+#include "lib/util/util_net.h"
 #undef strcasecmp
 …
 void zero_sockaddr(struct sockaddr_storage *pss)
+{
         memset(pss, '\0', sizeof(*pss));
+        ZERO_STRUCTP(pss);
         /* Ensure we're at least a valid sockaddr-storage. */
         pss->ss_family = AF_INET;
 …
         struct addrinfo hints;
+        memset(&hints, '\0', sizeof(hints));
+        ZERO_STRUCT(hints);
         /* By default make sure it supports TCP. */
         hints.ai_socktype = SOCK_STREAM;
         hints.ai_flags = flags;
         /* Linux man page on getaddinfo() says port will be
            uninitialized when service string in NULL */
+        /* Linux man page on getaddrinfo() says port will be
+           uninitialized when service string is NULL */
         ret = getaddrinfo(str, NULL,
 …
  * Check if a struct sockaddr has an unspecified address.
  */
 bool is_zero_addr(const struct sockaddr *pss)
+{
 #if defined(HAVE_IPV6)
         if (pss->sa_family == AF_INET6) {
+bool is_zero_addr(const struct sockaddr_storage *pss)
+{
+#if defined(HAVE_IPV6)
+        if (pss->ss_family == AF_INET6) {
                 const struct in6_addr *pin6 =
                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 …
+        }
 #endif
         if (pss->sa_family == AF_INET) {
+        if (pss->ss_family == AF_INET) {
                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
                 return is_zero_ip_v4(*pin);
 …
+/****************************************************************************
+ Get a port number in host byte order from a sockaddr_storage.
+****************************************************************************/
+uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
+{
+        uint16_t port = 0;
+        if (pss->ss_family != AF_INET) {
+#if defined(HAVE_IPV6)
+                /* IPv6 */
+                const struct sockaddr_in6 *sa6 =
+                        (const struct sockaddr_in6 *)pss;
+                port = ntohs(sa6->sin6_port);
+#endif
+        } else {
+                const struct sockaddr_in *sa =
+                        (const struct sockaddr_in *)pss;
+                port = ntohs(sa->sin_port);
+        }
+        return port;
+}
+/****************************************************************************
+ Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_sockaddr_len(char *dest,
+                         size_t destlen,
+                        const struct sockaddr *psa,
+                        socklen_t psalen)
+{
+        if (destlen > 0) {
+                dest[0] = '\0';
+        }
+        (void)sys_getnameinfo(psa,
+                        psalen,
+                        dest, destlen,
+                        NULL, 0,
+                        NI_NUMERICHOST);
+        return dest;
+}
+/****************************************************************************
+ Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_sockaddr(char *dest,
+                        size_t destlen,
+                        const struct sockaddr_storage *psa)
+{
+        return print_sockaddr_len(dest, destlen, (struct sockaddr *)psa,
+                        sizeof(struct sockaddr_storage));
+}
+/****************************************************************************
+ Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
+****************************************************************************/
+char *print_canonical_sockaddr(TALLOC_CTX *ctx,
+                        const struct sockaddr_storage *pss)
+{
+        char addr[INET6_ADDRSTRLEN];
+        char *dest = NULL;
+        int ret;
+        /* Linux getnameinfo() man pages says port is unitialized if
+           service name is NULL. */
+        ret = sys_getnameinfo((const struct sockaddr *)pss,
+                        sizeof(struct sockaddr_storage),
+                        addr, sizeof(addr),
+                        NULL, 0,
+                        NI_NUMERICHOST);
+        if (ret != 0) {
+                return NULL;
+        }
+        if (pss->ss_family != AF_INET) {
+#if defined(HAVE_IPV6)
+                dest = talloc_asprintf(ctx, "[%s]", addr);
+#else
+                return NULL;
+#endif
+        } else {
+                dest = talloc_asprintf(ctx, "%s", addr);
+        }
+        return dest;
+}
+/****************************************************************************
+ Return the port number we've bound to on a socket.
+****************************************************************************/
+int get_socket_port(int fd)
+{
+        struct sockaddr_storage sa;
+        socklen_t length = sizeof(sa);
+        if (fd == -1) {
+                return -1;
+        }
+        if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
+                int level = (errno == ENOTCONN) ? 2 : 0;
+                DEBUG(level, ("getsockname failed. Error was %s\n",
+                               strerror(errno)));
+                return -1;
+        }
+#if defined(HAVE_IPV6)
+        if (sa.ss_family == AF_INET6) {
+                return ntohs(((struct sockaddr_in6 *)&sa)->sin6_port);
+        }
+#endif
+        if (sa.ss_family == AF_INET) {
+                return ntohs(((struct sockaddr_in *)&sa)->sin_port);
+        }
+        return -1;
+}
+/****************************************************************************
+ Return the string of an IP address (IPv4 or IPv6).
+****************************************************************************/
+static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
+{
+        struct sockaddr_storage sa;
+        socklen_t length = sizeof(sa);
+        /* Ok, returning a hard coded IPv4 address
+         * is bogus, but it's just as bogus as a
+         * zero IPv6 address. No good choice here.
+         */
+        strlcpy(addr_buf, "0.0.0.0", addr_len);
+        if (fd == -1) {
+                return addr_buf;
+        }
+        if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
+                DEBUG(0,("getsockname failed. Error was %s\n",
+                        strerror(errno) ));
+                return addr_buf;
+        }
+        return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
+}
+const char *client_socket_addr(int fd, char *addr, size_t addr_len)
+{
+        return get_socket_addr(fd, addr, addr_len);
+}

vendor/current/lib/util/util_net.h

-              r414
+              r740
                                        int flags);
+void set_sockaddr_port(struct sockaddr *psa, uint16_t port);
+/**
+ Check if an IP is the 0.0.0.0.
+**/
+_PUBLIC_ bool is_zero_ip_v4(struct in_addr ip);
+void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
+                                 struct in_addr ip);
+#if defined(HAVE_IPV6)
+/**
+ * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
+ */
+void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
+                                  struct in6_addr ip);
+#endif
+/**
+ Are two IPs on the same subnet?
+**/
+_PUBLIC_ bool same_net_v4(struct in_addr ip1,struct in_addr ip2,struct in_addr mask);
+/**
+ Return true if a string could be a pure IP address.
+**/
+_PUBLIC_ bool is_ipaddress(const char *str);
+bool is_broadcast_addr(const struct sockaddr *pss);
+bool is_loopback_ip_v4(struct in_addr ip);
+bool is_loopback_addr(const struct sockaddr *pss);
+bool is_zero_addr(const struct sockaddr_storage *pss);
+void zero_ip_v4(struct in_addr *ip);
+/**
+ Interpret an internet address or name into an IP address in 4 byte form.
+**/
+_PUBLIC_ uint32_t interpret_addr(const char *str);
+/**
+ A convenient addition to interpret_addr().
+**/
+_PUBLIC_ struct in_addr interpret_addr2(const char *str);
+_PUBLIC_ bool is_ipaddress_v4(const char *str);
+bool is_address_any(const struct sockaddr *psa);
+bool same_net(const struct sockaddr *ip1,
+              const struct sockaddr *ip2,
+              const struct sockaddr *mask);
+bool sockaddr_equal(const struct sockaddr *ip1,
+                    const struct sockaddr *ip2);
+bool is_address_any(const struct sockaddr *psa);
+uint16_t get_sockaddr_port(const struct sockaddr_storage *pss);
+char *print_sockaddr_len(char *dest,
+                         size_t destlen,
+                         const struct sockaddr *psa,
+                         socklen_t psalen);
+char *print_sockaddr(char *dest,
+                        size_t destlen,
+                        const struct sockaddr_storage *psa);
+char *print_canonical_sockaddr(TALLOC_CTX *ctx,
+                        const struct sockaddr_storage *pss);
+const char *client_name(int fd);
+int get_socket_port(int fd);
+const char *client_socket_addr(int fd, char *addr, size_t addr_len);
 #endif /* _SAMBA_UTIL_NET_H_ */

vendor/current/lib/util/util_pw.c

-              r414
+              r740
    Safe versions of getpw* calls
+   Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Jeremy Allison  1998-2005
    Copyright (C) Andrew Bartlett 2002
+   Copyright (C) Timur Bakeyev        2005
+   Copyright (C) Bjoern Jacke    2006-2007
    This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
+#include "system/passwd.h"
+#include "lib/util/util_pw.h"
+static struct passwd *alloc_copy_passwd(TALLOC_CTX *mem_ctx,
+                                        const struct passwd *from)
+/**************************************************************************
+ Wrappers for setpwent(), getpwent() and endpwent()
+****************************************************************************/
+void sys_setpwent(void)
+{
+        setpwent();
+}
+struct passwd *sys_getpwent(void)
+{
+        return getpwent();
+}
+void sys_endpwent(void)
+{
+        endpwent();
+}
+/**************************************************************************
+ Wrappers for getpwnam(), getpwuid(), getgrnam(), getgrgid()
+****************************************************************************/
+struct passwd *sys_getpwnam(const char *name)
+{
+        return getpwnam(name);
+}
+struct passwd *sys_getpwuid(uid_t uid)
+{
+        return getpwuid(uid);
+}
+struct group *sys_getgrnam(const char *name)
+{
+        return getgrnam(name);
+}
+struct group *sys_getgrgid(gid_t gid)
+{
+        return getgrgid(gid);
+}
+struct passwd *tcopy_passwd(TALLOC_CTX *mem_ctx,
+                            const struct passwd *from)
+{
         struct passwd *ret = talloc_zero(mem_ctx, struct passwd);
 …
+}
 struct passwd *getpwnam_alloc(TALLOC_CTX *mem_ctx, const char *name)
+struct passwd *getpwnam_alloc(TALLOC_CTX *mem_ctx, const char *name)
+{
         struct passwd *temp;
 …
+        }
         return alloc_copy_passwd(mem_ctx, temp);
+        return tcopy_passwd(mem_ctx, temp);
+}
+struct passwd *getpwuid_alloc(TALLOC_CTX *mem_ctx, uid_t uid)
+/****************************************************************************
+ talloc'ed version of getpwuid.
+****************************************************************************/
+struct passwd *getpwuid_alloc(TALLOC_CTX *mem_ctx, uid_t uid)
+{
         struct passwd *temp;
 …
+        }
         return alloc_copy_passwd(mem_ctx, temp);
+        return tcopy_passwd(mem_ctx, temp);
+}

vendor/current/lib/util/util_str.c

-              r414
+              r740
         if (len > maxlength) {
                 DEBUG(0,("ERROR: string overflow by %u (%u - %u) in safe_strcpy [%.50s]\n",
                          (uint_t)(len-maxlength), (unsigned)len, (unsigned)maxlength, src));
+                         (unsigned int)(len-maxlength), (unsigned)len, (unsigned)maxlength, src));
                 len = maxlength;
+        }
 …
         return dest;
+}
-#ifdef VALGRIND
-size_t valgrind_strlen(const char *s)
+{
-        size_t count;
-        for(count = 0; *s++; count++)
+                ;
-        return count;
+}
-#endif
 /**

vendor/current/lib/util/util_strlist.c

-              r414
+              r740
 #include "includes.h"
 #include "system/locale.h"
+#include "lib/util/tsort.h"
 #undef strcasecmp
 …
 /**
  * build a null terminated list of strings from an argv-like input string
  * Entries are seperated by spaces and can be enclosed by quotes.
+ * Entries are separated by spaces and can be enclosed by quotes.
  * Does NOT support escaping
  */
 …
  * join a list back to one string
  */
 _PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char seperator)
+_PUBLIC_ char *str_list_join(TALLOC_CTX *mem_ctx, const char **list, char separator)
+{
         char *ret = NULL;
 …
         for (i = 1; list[i]; i++) {
                 ret = talloc_asprintf_append_buffer(ret, "%c%s", seperator, list[i]);
+                ret = talloc_asprintf_append_buffer(ret, "%c%s", separator, list[i]);
+        }
 …
 /** join a list back to one (shell-like) string; entries
  * seperated by spaces, using quotes where necessary */
+ * separated by spaces, using quotes where necessary */
 _PUBLIC_ char *str_list_join_shell(TALLOC_CTX *mem_ctx, const char **list, char sep)
+{
 …
    Return true if all the elements of the list match exactly.
  */
+_PUBLIC_ bool str_list_equal(const char **list1, const char **list2)
+_PUBLIC_ bool str_list_equal(const char * const *list1,
+                             const char * const *list2)
+{
         int i;
 …
         list2 = (const char **)talloc_memdup(list, list,
                                              sizeof(list[0])*(len+1));
         qsort(list2, len, sizeof(list2[0]), QSORT_CAST list_cmp);
+        TYPESAFE_QSORT(list2, len, list_cmp);
         list[0] = list2[0];
         for (i=j=1;i<len;i++) {
 …
         return ret;
+}
+/**
+ * Needed for making an "unconst" list "const"
+ */
+_PUBLIC_ const char **const_str_list(char **list)
+{
+        return (const char **)list;
+}

vendor/current/lib/util/util_tdb.c

-              r427
+              r740
 #include "includes.h"
 #include "tdb.h"
+#include <tdb.h>
 #include "../lib/util/util_tdb.h"
 …
 /****************************************************************************
  Store a int32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a int32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is int32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/
 …
 /****************************************************************************
  Store a uint32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a uint32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/

vendor/current/lib/util/util_tdb.h

-              r427
+              r740
+/*
+   Unix SMB/CIFS implementation.
+   tdb utility functions
+   Copyright (C) Andrew Tridgell 1992-2006
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
 #ifndef _____LIB_UTIL_UTIL_TDB_H__
 #define _____LIB_UTIL_UTIL_TDB_H__
 /***************************************************************
 …
 /****************************************************************************
  Store a int32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a int32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is int32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/
 …
 /****************************************************************************
  Store a uint32_t value by an arbitary blob key, return 0 on success, -1 on failure.
+ Store a uint32_t value by an arbitrary blob key, return 0 on success, -1 on failure.
  Input is uint32_t in native byte order. Output in tdb is in little-endian.
 ****************************************************************************/

vendor/current/lib/util/wrap_xattr.h

-              r414
+              r740
+/*
+   Unix SMB/CIFS implementation.
+   POSIX NTVFS backend - xattr support using filesystem xattrs
+   Copyright (C) Andrew Tridgell 2004
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
 #ifndef __LIB_UTIL_WRAP_XATTR_H__
 #define __LIB_UTIL_WRAP_XATTR_H__

vendor/current/lib/zlib/contrib/ada/zlib-streams.ads

-              r414
+              r740
    --  Flush the written data to the back stream,
    --  all data placed to the compressor is flushing to the Back stream.
    --  Should not be used untill necessary, becouse it is decreasing
+   --  Should not be used untill necessary, because it is decreasing
    --  compression.
 …
       --  Buffer for Read operation.
       --  We need to have this buffer in the record
       --  becouse not all read data from back stream
+      --  because not all read data from back stream
       --  could be processed during the read operation.
 …
       --  Buffer size for write operation.
       --  We do not need to have this buffer
       --  in the record becouse all data could be
+      --  in the record because all data could be
       --  processed in the write operation.

vendor/current/lib/zlib/contrib/ada/zlib-thin.ads

r414	r740
437	437	pragma Import (C, inflateBackInit, "inflateBackInit_");
438	438
439		-- I stopped binding the inflateBack routines, becouse realize that
	439	-- I stopped binding the inflateBack routines, because realize that
440	440	-- it does not support zlib and gzip headers for now, and have no
441	441	-- symmetric deflateBack routines.

vendor/current/lib/zlib/contrib/minizip/miniunz.c

r414	r740
537	537
538	538	strncpy(filename_try, zipfilename,MAXFILENAME-1);
539		/* strncpy doesn~~t append the trailing NULL, o~~f the string is too long. */
	539	/* strncpy doesn't append the trailing NULL, if the string is too long. */
540	540	filename_try[ MAXFILENAME ] = '\0';
541	541

vendor/current/lib/zlib/contrib/minizip/minizip.c

-              r414
+              r740
     strncpy(name, f,MAXFILENAME-1);
     /* strncpy doesnt append the trailing NULL, of the string is too long. */
+    /* strncpy doesn't append the trailing NULL, if the string is too long. */
     name[ MAXFILENAME ] = '\0';
 …
         zipok = 1 ;
         strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
         /* strncpy doesnt append the trailing NULL, of the string is too long. */
+        /* strncpy doesn't append the trailing NULL, if the string is too long. */
         filename_try[ MAXFILENAME ] = '\0';

vendor/current/lib/zlib/contrib/minizip/unzip.c

-              r414
+              r740
      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
    for end of file.
    IN assertion: the stream s has been sucessfully opened for reading.
+   IN assertion: the stream s has been successfully opened for reading.
 */
 …
 /*
    Compare two filename (fileName1,fileName2).
    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+   If iCaseSensitivity = 1, comparison is case sensitive (like strcmp)
+   If iCaseSensitivity = 2, comparison is not case sensitive (like strcmpi
                                                                 or strcasecmp)
    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+   If iCaseSensitivity = 0, case sensitivity is default of your operating system
         (like 1 on Unix, 2 on Windows)

vendor/current/lib/zlib/contrib/minizip/unzip.h

-              r414
+              r740
 /*
    Compare two filename (fileName1,fileName2).
    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+   If iCaseSensitivity = 1, comparison is case sensitive (like strcmp)
+   If iCaseSensitivity = 2, comparison is not case sensitive (like strcmpi
                                 or strcasecmp)
    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+   If iCaseSensitivity = 0, case sensitivity is default of your operating system
     (like 1 on Unix, 2 on Windows)
 */

vendor/current/lib/zlib/contrib/minizip/zip.c

-              r414
+              r740
   uLong  avail_in_this_block;
   uLong  filled_in_this_block;
   uLong  unused; /* for future use and alignement */
+  uLong  unused; /* for future use and alignment */
   unsigned char data[SIZEDATA_INDATABLOCK];
 } linkedlist_datablock_internal;
 …
     uLong pos_local_header;     /* offset of the local header of the file
                                      currenty writing */
+                                     currently writing */
     char* central_header;       /* central header data for the current file */
     uLong size_centralheader;   /* size of the central header for cur file */
     uLong flag;                 /* flag of the file currently writing */
     int  method;                /* compression method of file currenty wr.*/
+    int  method;                /* compression method of file currently wr.*/
     int  raw;                   /* 1 for directly writing raw data */
     Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/

vendor/current/lib/zlib/contrib/puff/puff.c

r414	r740
586	586	* the list of code lengths, a 0 symbol means no code, a 1..15 symbol means
587	587	* that length, and the symbols 16, 17, and 18 are run-length instructions.
588		* Each of 16, 17, and 18 are follwed by extra bits to define the length of
	588	* Each of 16, 17, and 18 are followed by extra bits to define the length of
589	589	* the run. 16 copies the last length 3 to 6 times. 17 represents 3 to 10
590	590	* zero lengths, and 18 represents 11 to 138 zero lengths. Unused symbols

vendor/current/lib/zlib/deflate.h

r414	r740
189	189
190	190	/* used by trees.c: */
191		/* Didn't use ct_data typedef below to supress compiler warning */
	191	/* Didn't use ct_data typedef below to suppress compiler warning */
192	192	struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */
193	193	struct ct_data_s dyn_dtree[2D_CODES+1]; / distance tree */

vendor/current/lib/zlib/examples/fitblk.c

r414	r740
18	18	nearly the requested output block size. The first pass generates
19	19	enough deflate blocks to produce output to fill the requested
20		output size plus a specfied excess amount (see the EXCESS define
	20	output size plus a specified excess amount (see the EXCESS define
21	21	below). The last deflate block may go quite a bit past that, but
22	22	is discarded. The second pass decompresses and recompresses just

vendor/current/lib/zlib/examples/gun.c

r414	r740
43	43	encountered in an input file, it is the last stream in that file.
44	44
45		Like gunzip and uncompress, the file attributes of the orignal compressed
	45	Like gunzip and uncompress, the file attributes of the original compressed
46	46	file are maintained in the final uncompressed file, to the extent that the
47	47	user permissions allow it.

vendor/current/lib/zlib/gzio.c

-              r414
+              r740
      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
    for end of file.
    IN assertion: the stream s has been sucessfully opened for reading.
+   IN assertion: the stream s has been successfully opened for reading.
 */
 local int get_byte(s)
 …
     to Z_DATA_ERROR if the magic header is present but the rest of the header
     is incorrect.
     IN assertion: the stream s has already been created sucessfully;
+    IN assertion: the stream s has already been created successfully;
        s->stream.avail_in is zero for the first time, but may be non-zero
        for concatenated .gz files.

vendor/current/lib/zlib/zlib.h

r414	r740
886	886
887	887	inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
888		the paramaters are invalid, Z_MEM_ERROR if the internal state could not
	888	the parameters are invalid, Z_MEM_ERROR if the internal state could not
889	889	be allocated, or Z_VERSION_ERROR if the version of the library does not
890	890	match the version of the header file.

Context Navigation

Legend: