Changeset 988 for vendor/current/librpc/ndr

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/librpc/ndr

Files:

• libndr.h (modified) (11 diffs)
• ndr.c (modified) (6 diffs)
• ndr_auth.c (added)
• ndr_auth.h (added)
• ndr_backupkey.c (modified) (1 diff)
• ndr_basic.c (modified) (19 diffs)
• ndr_bkupblobs.c (added)
• ndr_dcerpc.c (modified) (1 diff)
• ndr_dcerpc.h (modified) (1 diff)
• ndr_dns.c (modified) (7 diffs)
• ndr_dnsp.c (modified) (7 diffs)
• ndr_dnsp.h (modified) (1 diff)
• ndr_dnsserver.c (added)
• ndr_dnsserver.h (added)
• ndr_drsblobs.c (modified) (3 diffs)
• ndr_drsuapi.c (modified) (4 diffs)
• ndr_ioctl.c (added)
• ndr_krb5pac.c (modified) (1 diff)
• ndr_nbt.c (added)
• ndr_nbt.h (added)
• ndr_negoex.c (added)
• ndr_negoex.h (added)
• ndr_ntprinting.c (modified) (1 diff)
• ndr_orpc.c (modified) (3 diffs)
• ndr_sec_helper.c (modified) (3 diffs)
• ndr_spoolss_buf.c (modified) (1 diff)
• ndr_string.c (modified) (18 diffs)
• ndr_table.c (modified) (4 diffs)
• ndr_table.h (modified) (1 diff)
• ndr_witness.c (added)
• ndr_witness.h (added)
• ndr_wmi.c (modified) (1 diff)
• ndr_wmi.h (added)
• util.c (added)
• uuid.c (modified) (4 diffs)

vendor/current/librpc/ndr/libndr.h

@@ -27 +27 @@
 
 #include <talloc.h>
-#include <sys/time.h>
-#if _SAMBA_BUILD_ == 4
-#include "../lib/util/util.h" /* for discard_const */
+#include "../lib/util/memory.h" /* for discard_const */
+#include "../lib/util/byteorder.h"
+#include "../lib/util/data_blob.h"
+#include "../lib/util/time.h"
 #include "../lib/util/charset/charset.h"
-#endif
 
 /*
@@ -123 +123 @@
 #define LIBNDR_FLAG_STR_CHARLEN         (1<<11)
 #define LIBNDR_FLAG_STR_UTF8            (1<<12)
+#define LIBNDR_FLAG_STR_RAW8            (1<<13)
 #define LIBNDR_STRING_FLAGS             (0x7FFC)
 
@@ -386 +387 @@
 #include "librpc/gen_ndr/misc.h"
 
-extern const struct ndr_syntax_id ndr_transfer_syntax;
-extern const struct ndr_syntax_id ndr64_transfer_syntax;
-extern const struct ndr_syntax_id null_ndr_syntax_id;
+extern const struct ndr_syntax_id ndr_transfer_syntax_ndr;
+extern const struct ndr_syntax_id ndr_transfer_syntax_ndr64;
+extern const struct ndr_syntax_id ndr_syntax_id_null;
 
 struct ndr_interface_call_pipe {
@@ -434 +435 @@
 };
 
+struct sockaddr_storage;
+
 /*********************************************************************
  Map an NT error code from a NDR error code.
 *********************************************************************/
 NTSTATUS ndr_map_error2ntstatus(enum ndr_err_code ndr_err);
+int ndr_map_error2errno(enum ndr_err_code ndr_err);
 const char *ndr_map_error2string(enum ndr_err_code ndr_err);
 #define ndr_errstr ndr_map_error2string
@@ -455 +459 @@
 size_t ndr_size_dom_sid0(const struct dom_sid *sid, int flags);
 void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid);
+void ndr_print_sockaddr_storage(struct ndr_print *ndr, const char *name, const struct sockaddr_storage *ss);
 bool ndr_syntax_id_equal(const struct ndr_syntax_id *i1, const struct ndr_syntax_id *i2); 
 char *ndr_syntax_id_to_string(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *id);
@@ -554 +559 @@
 void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, type v); 
 
+#define NDR_SCALAR_PTR_PROTO(name, type) \
+enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, int ndr_flags, const type *v); \
+enum ndr_err_code ndr_pull_ ## name(struct ndr_pull *ndr, int ndr_flags, type **v); \
+void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, const type *v);
+
 #define NDR_BUFFER_PROTO(name, type) \
 enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, int ndr_flags, const type *v); \
@@ -578 +588 @@
 NDR_SCALAR_PROTO(NTSTATUS, NTSTATUS)
 NDR_SCALAR_PROTO(WERROR, WERROR)
+NDR_SCALAR_PROTO(HRESULT, HRESULT)
 NDR_SCALAR_PROTO(NTTIME, NTTIME)
 NDR_SCALAR_PROTO(NTTIME_1sec, NTTIME)
@@ -590 +601 @@
 enum ndr_err_code ndr_push_policy_handle(struct ndr_push *ndr, int ndr_flags, const struct policy_handle *r);
 void ndr_print_policy_handle(struct ndr_print *ndr, const char *name, const struct policy_handle *r);
-bool policy_handle_empty(const struct policy_handle *h);
-bool is_valid_policy_hnd(const struct policy_handle *hnd);
-bool policy_handle_equal(const struct policy_handle *hnd1,
+bool ndr_policy_handle_empty(const struct policy_handle *h);
+#define is_valid_policy_hnd(hnd) (!ndr_policy_handle_empty(hnd))
+bool ndr_policy_handle_equal(const struct policy_handle *hnd1,
                          const struct policy_handle *hnd2);
 
@@ -643 +654 @@
 NTSTATUS GUID_from_data_blob(const DATA_BLOB *s, struct GUID *guid);
 NTSTATUS GUID_from_string(const char *s, struct GUID *guid);
-NTSTATUS NS_GUID_from_string(const char *s, struct GUID *guid);
 struct GUID GUID_zero(void);
 bool GUID_all_zero(const struct GUID *u);
@@ -650 +660 @@
 char *GUID_string2(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 char *GUID_hexstring(TALLOC_CTX *mem_ctx, const struct GUID *guid);
-char *NS_GUID_string(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 struct GUID GUID_random(void);
+
+/* Format is "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" */
+ /* 32 chars + 4 ' ' + \0 + 2 for adding {}  */
+struct GUID_txt_buf { char buf[39]; };
+_PUBLIC_ char* GUID_buf_string(const struct GUID *guid,
+                               struct GUID_txt_buf *dst);
 
 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v);
@@ -664 +679 @@
 _PUBLIC_ void ndr_print_bool(struct ndr_print *ndr, const char *name, const bool b);
 
+_PUBLIC_ enum ndr_err_code ndr_push_timespec(struct ndr_push *ndr,
+                                             int ndr_flags,
+                                             const struct timespec *t);
+_PUBLIC_ enum ndr_err_code ndr_pull_timespec(struct ndr_pull *ndr,
+                                             int ndr_flags,
+                                             struct timespec *t);
+_PUBLIC_ void ndr_print_timespec(struct ndr_print *ndr, const char *name,
+                                 const struct timespec *t);
+
+_PUBLIC_ enum ndr_err_code ndr_push_timeval(struct ndr_push *ndr,
+                                            int ndr_flags,
+                                            const struct timeval *t);
+_PUBLIC_ enum ndr_err_code ndr_pull_timeval(struct ndr_pull *ndr,
+                                            int ndr_flags,
+                                            struct timeval *t);
+_PUBLIC_ void ndr_print_timeval(struct ndr_print *ndr, const char *name,
+                                const struct timeval *t);
+
+
+
 #endif /* __LIBNDR_H__ */

vendor/current/librpc/ndr/ndr.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
 
@@ -5 +5 @@
 
    Copyright (C) Andrew Tridgell 2003
-   
+   Copyright (C) Jelmer Vernooij 2005-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/>.
@@ -30 +31 @@
 #include "librpc/ndr/libndr.h"
 #include "../lib/util/dlinklist.h"
-#if _SAMBA_BUILD_ == 4
-#include "param/param.h"
-#endif
 
 #define NDR_BASE_MARSHALL_SIZE 1024
 
 /* this guid indicates NDR encoding in a protocol tower */
-const struct ndr_syntax_id ndr_transfer_syntax = {
+const struct ndr_syntax_id ndr_transfer_syntax_ndr = {
   { 0x8a885d04, 0x1ceb, 0x11c9, {0x9f, 0xe8}, {0x08,0x00,0x2b,0x10,0x48,0x60} },
   2
 };
 
-const struct ndr_syntax_id ndr64_transfer_syntax = {
+const struct ndr_syntax_id ndr_transfer_syntax_ndr64 = {
   { 0x71710533, 0xbeba, 0x4937, {0x83, 0x19}, {0xb5,0xdb,0xef,0x9c,0xcc,0x36} },
   1
 };
 
-const struct ndr_syntax_id null_ndr_syntax_id = {
+const struct ndr_syntax_id ndr_syntax_id_null = {
   { 0, 0, 0, { 0, 0 }, { 0, 0, 0, 0, 0, 0 } },
   0
@@ -225 +223 @@
         ndr->data = talloc_array(ndr, uint8_t, ndr->alloc_size);
         if (!ndr->data) {
+                talloc_free(ndr);
                 return NULL;
         }
@@ -638 +637 @@
                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &content_size));
                 if (size_is >= 0 && size_is != content_size) {
-                        return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) size_is(%d) mismatch content_size %d", 
-                                                (int)size_is, (int)content_size);
+                        return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) size_is(%d) (0x%04x) mismatch content_size %d (0x%04x)",
+                                                (int)size_is, (int)size_is,
+                                                (int)content_size,
+                                                (int)content_size);
                 }
                 r_content_size = content_size;
@@ -649 +650 @@
                 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &content_size));
                 if (size_is >= 0 && size_is != content_size) {
-                        return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) size_is(%d) mismatch content_size %d", 
-                                                (int)size_is, (int)content_size);
+                        return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) size_is(%d) (0x%08x) mismatch content_size %d (0x%08x)",
+                                                (int)size_is, (int)size_is,
+                                                (int)content_size,
+                                                (int)content_size);
                 }
                 r_content_size = content_size;

vendor/current/librpc/ndr/ndr_backupkey.c

@@ -72 +72 @@
 
                 level = backupkeyguid_to_uint(r->in.guidActionAgent);
+                ndr_err = ndr_print_set_switch_value(ndr, &inblob, level);
+                if (unlikely(!NDR_ERR_CODE_IS_SUCCESS(ndr_err))) {      \
+                        DEBUG(0,("ERROR: ndr_print_bkrp_BackupKey ndr_print_set_switch_value failed: %d\n", ndr_err));
+                        return;
+                }
                 blob.data = r->in.data_in;
                 blob.length = r->in.data_in_len;

vendor/current/librpc/ndr/ndr_basic.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
 
@@ -5 +5 @@
 
    Copyright (C) Andrew Tridgell 2003
-   
+
    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 "includes.h"
+#include "replace.h"
 #include "system/network.h"
 #include "librpc/ndr/libndr.h"
 #include "lib/util/util_net.h"
+#include "lib/util/debug.h"
+#include "lib/util/util.h"
 
 #define NDR_SVAL(ndr, ofs) (NDR_BE(ndr)?RSVAL(ndr->data,ofs):SVAL(ndr->data,ofs))
@@ -32 +34 @@
 #define NDR_SIVALS(ndr, ofs, v) do { if (NDR_BE(ndr))  { RSIVALS(ndr->data,ofs,v); } else SIVALS(ndr->data,ofs,v); } while (0)
 
+
+static void ndr_dump_data(struct ndr_print *ndr, const uint8_t *buf, int len);
 
 /*
@@ -168 +172 @@
                 DEBUG(0,(__location__ ": non-zero upper 32 bits 0x%016llx\n",
                          (unsigned long long)v64));
-                return NDR_ERR_NDR64;
+                return ndr_pull_error(ndr, NDR_ERR_NDR64, __location__ ": non-zero upper 32 bits 0x%016llx\n",
+                         (unsigned long long)v64);
         }
         return err;
@@ -322 +327 @@
 }
 
+/*
+  pull a HRESULT
+*/
+_PUBLIC_ enum ndr_err_code ndr_pull_HRESULT(struct ndr_pull *ndr, int ndr_flags, HRESULT *status)
+{
+        uint32_t v;
+        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
+        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
+        *status = HRES_ERROR(v);
+        return NDR_ERR_SUCCESS;
+}
 
 /*
@@ -412 +428 @@
         ndr->print(ndr, "%-25s: %s", name, win_errstr(r));
 }
+
+/*
+  push a HRESULT
+*/
+_PUBLIC_ enum ndr_err_code ndr_push_HRESULT(struct ndr_push *ndr, int ndr_flags, HRESULT status)
+{
+        return ndr_push_uint32(ndr, NDR_SCALARS, HRES_ERROR_V(status));
+}
+
+_PUBLIC_ void ndr_print_HRESULT(struct ndr_print *ndr, const char *name, HRESULT r)
+{
+        ndr->print(ndr, "%-25s: %s", name, hresult_errstr(r));
+}
+
 
 /*
@@ -1003 +1033 @@
 }
 
-_PUBLIC_ void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type, 
+_PUBLIC_ void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type,
                     const char *val, uint32_t value)
 {
@@ -1015 +1045 @@
 _PUBLIC_ void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint32_t flag, uint32_t value)
 {
+        if (flag == 0) {
+                return;
+        }
+
         /* this is an attempt to support multi-bit bitmap masks */
         value &= flag;
@@ -1021 +1055 @@
                 flag >>= 1;
                 value >>= 1;
-        }       
+        }
         if (flag == 1) {
                 ndr->print(ndr, "   %d: %-25s", value, flag_name);
@@ -1159 +1193 @@
 }
 
-_PUBLIC_ void ndr_print_array_uint8(struct ndr_print *ndr, const char *name, 
+_PUBLIC_ void ndr_print_array_uint8(struct ndr_print *ndr, const char *name,
                            const uint8_t *data, uint32_t count)
 {
         int i;
+#define _ONELINE_LIMIT 32
 
         if (data == NULL) {
@@ -1169 +1204 @@
         }
 
-        if (count <= 600 && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
-                char s[1202];
+        if (count <= _ONELINE_LIMIT && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
+                char s[(_ONELINE_LIMIT + 1) * 2];
                 for (i=0;i<count;i++) {
                         snprintf(&s[i*2], 3, "%02x", data[i]);
@@ -1180 +1215 @@
 
         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
+        if (count > _ONELINE_LIMIT && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
+                ndr_dump_data(ndr, data, count);
+                return;
+        }
+
         ndr->depth++;
         for (i=0;i<count;i++) {
@@ -1188 +1228 @@
                 }
         }
-        ndr->depth--;   
-}
-
-static void ndr_print_asc(struct ndr_print *ndr, const uint8_t *buf, int len)
-{
-        int i;
-        for (i=0;i<len;i++)
-                ndr->print(ndr, "%c", isprint(buf[i])?buf[i]:'.');
+        ndr->depth--;
+#undef _ONELINE_LIMIT
+}
+
+static void ndr_print_dump_data_cb(const char *buf, void *private_data)
+{
+        struct ndr_print *ndr = (struct ndr_print *)private_data;
+
+        ndr->print(ndr, "%s", buf);
 }
 
@@ -1203 +1244 @@
 static void ndr_dump_data(struct ndr_print *ndr, const uint8_t *buf, int len)
 {
-        int i=0;
-
         ndr->no_newline = true;
-
-        for (i=0;i<len;) {
-                if (i%16 == 0 && i<len) {
-                        ndr->print(ndr, "[%04X] ",i);
-                }
-
-                ndr->print(ndr, "%02X ",(int)buf[i]);
-                i++;
-                if (i%8 == 0) ndr->print(ndr,"  ");
-                if (i%16 == 0) {
-                        ndr_print_asc(ndr,&buf[i-16],8); ndr->print(ndr," ");
-                        ndr_print_asc(ndr,&buf[i-8],8); ndr->print(ndr, "\n");
-                }
-        }
-
-        if (i%16) {
-                int n;
-                n = 16 - (i%16);
-                ndr->print(ndr, " ");
-                if (n>8) ndr->print(ndr," ");
-                while (n--) ndr->print(ndr,"   ");
-                n = MIN(8,i%16);
-                ndr_print_asc(ndr,&buf[i-(i%16)],n); ndr->print(ndr, " ");
-                n = (i%16) - n;
-                if (n>0) ndr_print_asc(ndr,&buf[i-n],n);
-                ndr->print(ndr,"\n");
-        }
-
+        dump_data_cb(buf, len, true, ndr_print_dump_data_cb, ndr);
         ndr->no_newline = false;
 }
@@ -1254 +1266 @@
  * 2) When called with the LIBNDR_FLAG_REMAINING flag, push the byte array to
  *    the ndr buffer.
- * 3) Otherwise, push a uint32 length _and_ a corresponding byte array to the
+ * 3) Otherwise, push a uint3264 length _and_ a corresponding byte array to the
  *    ndr buffer.
  */
@@ -1272 +1284 @@
                 data_blob_clear(&blob);
         } else {
-                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, blob.length));
+                NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, blob.length));
         }
         NDR_CHECK(ndr_push_bytes(ndr, blob.data, blob.length));
@@ -1285 +1297 @@
  * 2) When called with the LIBNDR_FLAG_REMAINING flag, pull all remaining bytes
  *    from the ndr buffer.
- * 3) Otherwise, pull a uint32 length _and_ a corresponding byte array from the
+ * 3) Otherwise, pull a uint3264 length _and_ a corresponding byte array from the
  *    ndr buffer.
  */
@@ -1306 +1318 @@
                 }
         } else {
-                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &length));
+                NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &length));
         }
         NDR_PULL_NEED_BYTES(ndr, length);
@@ -1349 +1361 @@
         return NT_STATUS_INVALID_PARAMETER;
 }
+
+_PUBLIC_ int ndr_map_error2errno(enum ndr_err_code ndr_err)
+{
+        switch (ndr_err) {
+        case NDR_ERR_SUCCESS:
+                return 0;
+        case NDR_ERR_BUFSIZE:
+                return ENOSPC;
+        case NDR_ERR_TOKEN:
+                return EINVAL;
+        case NDR_ERR_ALLOC:
+                return ENOMEM;
+        case NDR_ERR_ARRAY_SIZE:
+                return EMSGSIZE;
+        case NDR_ERR_INVALID_POINTER:
+                return EINVAL;
+        case NDR_ERR_UNREAD_BYTES:
+                return EOVERFLOW;
+        default:
+                break;
+        }
+
+        /* we should map all error codes to different status codes */
+        return EINVAL;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_timespec(struct ndr_push *ndr,
+                                             int ndr_flags,
+                                             const struct timespec *t)
+{
+        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
+        NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t->tv_sec));
+        NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, t->tv_nsec));
+        return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_timespec(struct ndr_pull *ndr,
+                                             int ndr_flags,
+                                             struct timespec *t)
+{
+        uint64_t secs;
+        uint32_t nsecs;
+        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
+        NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &secs));
+        NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &nsecs));
+        t->tv_sec = secs;
+        t->tv_nsec = nsecs;
+        return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_timespec(struct ndr_print *ndr, const char *name,
+                                 const struct timespec *t)
+{
+        ndr->print(ndr, "%-25s: %s.%ld", name, timestring(ndr, t->tv_sec),
+                   (long)t->tv_nsec);
+}
+
+_PUBLIC_ enum ndr_err_code ndr_push_timeval(struct ndr_push *ndr,
+                                            int ndr_flags,
+                                            const struct timeval *t)
+{
+        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
+        NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t->tv_sec));
+        NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, t->tv_usec));
+        return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_timeval(struct ndr_pull *ndr,
+                                            int ndr_flags,
+                                            struct timeval *t)
+{
+        uint64_t secs;
+        uint32_t usecs;
+        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
+        NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &secs));
+        NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &usecs));
+        t->tv_sec = secs;
+        t->tv_usec = usecs;
+        return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_timeval(struct ndr_print *ndr, const char *name,
+                                const struct timeval *t)
+{
+        ndr->print(ndr, "%-25s: %s.%ld", name, timestring(ndr, t->tv_sec),
+                   (long)t->tv_usec);
+}

vendor/current/librpc/ndr/ndr_dcerpc.c

@@ -23 +23 @@
 #include "includes.h"
 #include "librpc/gen_ndr/ndr_dcerpc.h"
-
 #include "librpc/gen_ndr/ndr_misc.h"
-#include "lib/util/bitmap.h"
+
+/*
+ * This function was generated by pidl and
+ * has been extended by the (_available == 0) check.
+ *
+ * That's why we ignore the 80 char per line limit.
+ */
+enum ndr_err_code ndr_pull_dcerpc_bind_nak(struct ndr_pull *ndr, int ndr_flags, struct dcerpc_bind_nak *r)
+{
+        uint32_t size_versions_0 = 0;
+        uint32_t cntr_versions_0;
+        TALLOC_CTX *_mem_save_versions_0 = NULL;
+        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
+        if (ndr_flags & NDR_SCALARS) {
+                uint32_t _available;
+                NDR_CHECK(ndr_pull_align(ndr, 4));
+                NDR_CHECK(ndr_pull_dcerpc_bind_nak_reason(ndr, NDR_SCALARS, &r->reject_reason));
+                _available = ndr->data_size - ndr->offset;
+                if (_available == 0) {
+                        /*
+                         * This works around a bug in older
+                         * Samba (<= 4.1) releases.
+                         *
+                         * See bug #11327.
+                         */
+                        r->num_versions = 0;
+                } else {
+                        NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->num_versions));
+                }
+                size_versions_0 = r->num_versions;
+                NDR_PULL_ALLOC_N(ndr, r->versions, size_versions_0);
+                _mem_save_versions_0 = NDR_PULL_GET_MEM_CTX(ndr);
+                NDR_PULL_SET_MEM_CTX(ndr, r->versions, 0);
+                for (cntr_versions_0 = 0; cntr_versions_0 < (size_versions_0); cntr_versions_0++) {
+                        NDR_CHECK(ndr_pull_dcerpc_bind_nak_version(ndr, NDR_SCALARS, &r->versions[cntr_versions_0]));
+                }
+                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_versions_0, 0);
+                {
+                        uint32_t _flags_save_DATA_BLOB = ndr->flags;
+                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
+                        NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->_pad));
+                        ndr->flags = _flags_save_DATA_BLOB;
+                }
+                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
+        }
+        if (ndr_flags & NDR_BUFFERS) {
+        }
+        return NDR_ERR_SUCCESS;
+}
 
 const uint8_t DCERPC_SEC_VT_MAGIC[] = {0x8a,0xe3,0x13,0x71,0x02,0xf4,0x36,0x71};

vendor/current/librpc/ndr/ndr_dcerpc.h

@@ -24 +24 @@
         struct ndr_pull *ndr, TALLOC_CTX *mem_ctx,
         struct dcerpc_sec_verification_trailer **_r);
+
+#ifndef NDR_DCERPC_REQUEST_OBJECT_PRESENT
+#define NDR_DCERPC_REQUEST_OBJECT_PRESENT (ndr->flags & LIBNDR_FLAG_OBJECT_PRESENT)
+#endif /* NDR_DCERPC_REQUEST_OBJECT_PRESENT */

vendor/current/librpc/ndr/ndr_dns.c

@@ -31 +31 @@
 #include "librpc/gen_ndr/ndr_dns.h"
 #include "librpc/gen_ndr/ndr_misc.h"
+#include "librpc/gen_ndr/ndr_dnsp.h"
 #include "system/locale.h"
 #include "lib/util/util_net.h"
@@ -86 +87 @@
                         return ndr_pull_error(ndr, NDR_ERR_STRING,
                                               "BAD DNS NAME component, " \
-                                              "reserved lenght field: 0x%02x",
+                                              "reserved length field: 0x%02x",
                                               (len &0xC));
                 }
-                if (*offset + len + 2 > ndr->data_size) {
+                if (*offset + len + 1 > ndr->data_size) {
                         return ndr_pull_error(ndr, NDR_ERR_STRING,
                                               "BAD DNS NAME component, "\
@@ -169 +170 @@
                 uint32_t offset;
 
-                /* see if we have pushed the remaing string allready,
+                /* see if we have pushed the remaining string already,
                  * if so we use a label pointer to this string
                  */
@@ -229 +230 @@
          */
         return ndr_push_bytes(ndr, (const uint8_t *)"", 1);
+}
+
+_PUBLIC_ enum ndr_err_code ndr_pull_dns_txt_record(struct ndr_pull *ndr, int ndr_flags, struct dns_txt_record *r)
+{
+        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
+        if (ndr_flags & NDR_SCALARS) {
+                enum ndr_err_code ndr_err;
+                uint32_t data_size = ndr->data_size;
+                uint32_t record_size = 0;
+                ndr_err = ndr_token_retrieve(&ndr->array_size_list, r,
+                                             &record_size);
+                if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        NDR_PULL_NEED_BYTES(ndr, record_size);
+                        ndr->data_size = ndr->offset + record_size;
+                }
+                NDR_CHECK(ndr_pull_align(ndr, 1));
+                NDR_CHECK(ndr_pull_dnsp_string_list(ndr, NDR_SCALARS, &r->txt));
+                NDR_CHECK(ndr_pull_trailer_align(ndr, 1));
+                ndr->data_size = data_size;
+        }
+        if (ndr_flags & NDR_BUFFERS) {
+        }
+        return NDR_ERR_SUCCESS;
 }
 
@@ -257 +281 @@
                                                       NDR_ERR_LENGTH,
                                                       "Invalid...Unexpected " \
-                                                      "blob lenght is too " \
+                                                      "blob length is too " \
                                                       "large");
                         }
@@ -263 +287 @@
                 if (r->unexpected.length > UINT16_MAX) {
                         return ndr_push_error(ndr, NDR_ERR_LENGTH,
-                                              "Unexpected blob lenght "\
+                                              "Unexpected blob length "\
                                               "is too large");
                 }
@@ -303 +327 @@
                 _saved_offset1 = ndr->offset;
                 if (r->length > 0) {
+                        NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list,
+                                                  &r->rdata,
+                                                  r->length));
                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->rdata,
                                                             r->rr_type));

vendor/current/librpc/ndr/ndr_dnsp.c

@@ -49 +49 @@
         ret = talloc_strdup(ndr->current_mem_ctx, "");
         if (!ret) {
-                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp");
+                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_name");
         }
         total_len = 1;
@@ -62 +62 @@
                 ret = talloc_realloc(ndr->current_mem_ctx, ret, char, newlen);
                 if (!ret) {
-                        return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp");
+                        return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_name");
                 }
                 NDR_CHECK(ndr_pull_bytes(ndr, (uint8_t *)&ret[total_len-1], sublen));
@@ -73 +73 @@
         NDR_CHECK(ndr_pull_uint8(ndr, ndr_flags, &termination));
         if (termination != 0) {
-                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp - not NUL terminated");
+                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_name - not NUL terminated");
         }
         if (ndr->offset > raw_offset + len) {
-                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp - overrun by %u bytes",
+                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_name - overrun by %u bytes",
                                       ndr->offset - (raw_offset + len));
         }
@@ -136 +136 @@
 {
         uint8_t len;
-        uint32_t total_len;
         char *ret;
 
@@ -143 +142 @@
         ret = talloc_strdup(ndr->current_mem_ctx, "");
         if (!ret) {
-                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp");
-        }
-        total_len = 1;
-        ret = talloc_zero_array(ndr->current_mem_ctx, char, len+1);
+                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_string");
+        }
+        ret = talloc_zero_array(ndr->current_mem_ctx, char, len + 1);
         if (!ret) {
-                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp");
-        }
-        NDR_CHECK(ndr_pull_bytes(ndr, (uint8_t *)&ret[total_len-1], len));
-        total_len = len;
+                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_string");
+        }
+        NDR_CHECK(ndr_pull_bytes(ndr, (uint8_t *)ret, len));
 
         (*string) = ret;
@@ -161 +158 @@
 {
         int total_len;
-        total_len = strlen(string) + 1;
+        total_len = strlen(string);
         if (total_len > 255) {
                 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
@@ -167 +164 @@
         }
         NDR_CHECK(ndr_push_uint8(ndr, ndr_flags, (uint8_t)total_len));
-        NDR_CHECK(ndr_push_bytes(ndr, (const uint8_t *)string, total_len - 1));
-        NDR_PUSH_ALIGN(ndr, 1);
-
-        return NDR_ERR_SUCCESS;
-}
+        NDR_CHECK(ndr_push_bytes(ndr, (const uint8_t *)string, total_len));
+
+        return NDR_ERR_SUCCESS;
+}
+
+/*
+ * print a dnsp_string_list
+ */
+_PUBLIC_ void ndr_print_dnsp_string_list(struct ndr_print *ndr, const char *name,
+                                         const struct dnsp_string_list *list)
+{
+        uint32_t i;
+
+        ndr->no_newline = true;
+        for (i=0; i<ndr->depth; i++) {
+                ndr->print(ndr, "    ");
+        }
+        ndr->print(ndr, "%-25s:", name);
+        for (i=0; i<list->count; i++) {
+                ndr->print(ndr, " \"%s\"", list->str[i]);
+        }
+        ndr->print(ndr, "\n");
+        ndr->no_newline = false;
+}
+
+/*
+ * pull a dnsp_string_list
+ */
+_PUBLIC_ enum ndr_err_code ndr_pull_dnsp_string_list(struct ndr_pull *ndr, int ndr_flags, struct dnsp_string_list *list)
+{
+        list->count = 0;
+        list->str = talloc_array(ndr->current_mem_ctx, const char *,
+                                 list->count);
+        if (! list->str) {
+                return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_string_list");
+        }
+
+        while (ndr->offset < ndr->data_size) {
+                list->str = talloc_realloc(ndr->current_mem_ctx, list->str,
+                                           const char *, list->count+1);
+                if (! list->str) {
+                        return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Failed to pull dnsp_string_list");
+                }
+                NDR_CHECK(ndr_pull_dnsp_string(ndr, ndr_flags, &list->str[list->count]));
+                list->count++;
+        }
+
+        return NDR_ERR_SUCCESS;
+}
+
+enum ndr_err_code ndr_push_dnsp_string_list(struct ndr_push *ndr, int ndr_flags, const struct dnsp_string_list *list)
+{
+        uint8_t i;
+
+        for (i=0; i<list->count; i++) {
+                NDR_CHECK(ndr_push_dnsp_string(ndr, ndr_flags, list->str[i]));
+        }
+        return NDR_ERR_SUCCESS;
+}
+
+enum ndr_err_code ndr_dnsp_string_list_copy(TALLOC_CTX *mem_ctx,
+                                            const struct dnsp_string_list *src,
+                                            struct dnsp_string_list *dst)
+{
+        size_t i;
+
+        dst->count = 0;
+        dst->str = talloc_zero_array(mem_ctx, const char *, src->count);
+        if (dst->str == NULL) {
+                return NDR_ERR_ALLOC;
+        }
+
+        for (i = 0; i < src->count; i++) {
+                dst->str[i] = talloc_strdup(dst->str, src->str[i]);
+                if (dst->str[i] == NULL) {
+                        TALLOC_FREE(dst->str);
+                        return NDR_ERR_ALLOC;
+                }
+        }
+
+        dst->count = src->count;
+        return NDR_ERR_SUCCESS;
+}

vendor/current/librpc/ndr/ndr_dnsp.h

@@ -28 +28 @@
 enum ndr_err_code ndr_pull_dnsp_string(struct ndr_pull *ndr, int ndr_flags, const char **string);
 enum ndr_err_code ndr_push_dnsp_string(struct ndr_push *ndr, int ndr_flags, const char *string);
+
+enum ndr_err_code ndr_dnsp_string_list_copy(TALLOC_CTX *mem_ctx,
+                                            const struct dnsp_string_list *src,
+                                            struct dnsp_string_list *dst);

vendor/current/librpc/ndr/ndr_drsblobs.c

@@ -33 +33 @@
                         NDR_CHECK(ndr_push_AuthenticationInformation(ndr, NDR_SCALARS, &r->array[cntr_array_0]));
                 }
-                NDR_CHECK(ndr_push_trailer_align(ndr, 4));
+                NDR_CHECK(ndr_push_align(ndr, 4));
         }
         if (ndr_flags & NDR_BUFFERS) {
@@ -52 +52 @@
                         r->count++;
                 }
-                NDR_CHECK(ndr_pull_trailer_align(ndr, 4));
+                NDR_CHECK(ndr_pull_align(ndr, 4));
         }
         if (ndr_flags & NDR_BUFFERS) {
@@ -65 +65 @@
                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->count > 0)?12:0));
-                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->count > 0)?12 + ndr_size_AuthenticationInformationArray(&r->current, ndr_flags):0));
+                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (r->count > 0)?12 + ndr_size_AuthenticationInformationArray(&r->current, 0):0));
                 {
                         struct ndr_push *_ndr_current;
-                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_current, 0, ((r->count > 0)?12 + ndr_size_AuthenticationInformationArray(&r->current, ndr_flags):0) - ((r->count > 0)?12:0)));
+                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_current, 0, ((r->count > 0)?12 + ndr_size_AuthenticationInformationArray(&r->current, 0):0) - ((r->count > 0)?12:0)));
                         NDR_CHECK(ndr_push_AuthenticationInformationArray(_ndr_current, NDR_SCALARS, &r->current));
-                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_current, 0, ((r->count > 0)?12 + ndr_size_AuthenticationInformationArray(&r->current, ndr_flags):0) - ((r->count > 0)?12:0)));
+                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_current, 0, ((r->count > 0)?12 + ndr_size_AuthenticationInformationArray(&r->current, 0):0) - ((r->count > 0)?12:0)));
                 }
                 {

vendor/current/librpc/ndr/ndr_drsuapi.c

@@ -5 +5 @@
 
    Copyright (C) Stefan (metze) Metzmacher 2005
+   Copyright (C) Matthieu Patou 2013
 
    This program is free software; you can redistribute it and/or modify
@@ -102 +103 @@
                                                 const struct drsuapi_DsAttributeValue *r)
 {
-        char *str;
+        void *p;
+        size_t converted_size = 0;
 
         ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
@@ -110 +112 @@
                                    r->blob->data,
                                    r->blob->length,
-                                   (void **)&str, NULL, false)) {
+                                   &p, &converted_size)) {
                 ndr_print_string(ndr, "string", "INVALID CONVERSION");
         } else {
+                char *str = (char *)p;
                 ndr_print_string(ndr, "string", str);
                 talloc_free(str);
@@ -405 +408 @@
         }
 }
+
+enum ndr_err_code ndr_push_drsuapi_DsBindInfo(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsBindInfo *r)
+{
+        uint32_t _flags_save = ndr->flags;
+        ndr->flags = ndr->flags & ~LIBNDR_FLAG_NDR64;
+        NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
+        if (ndr_flags & NDR_SCALARS) {
+                uint32_t level = ndr_push_get_switch_value(ndr, r);
+                NDR_CHECK(ndr_push_union_align(ndr, 4));
+                switch (level) {
+                        case 24: {
+                                {
+                                        struct ndr_push *_ndr_info24;
+                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info24, 0, 24));
+                                        NDR_CHECK(ndr_push_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
+                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info24, 0, 24));
+                                }
+                        break; }
+
+                        case 28: {
+                                {
+                                        struct ndr_push *_ndr_info28;
+                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info28, 0, 28));
+                                        NDR_CHECK(ndr_push_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
+                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info28, 0, 28));
+                                }
+                        break; }
+
+                        case 48: {
+                                {
+                                        struct ndr_push *_ndr_info48;
+                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info48, 0, 48));
+                                        NDR_CHECK(ndr_push_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
+                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info48, 0, 48));
+                                }
+                        break; }
+
+                        case 52: {
+                                {
+                                        struct ndr_push *_ndr_info52;
+                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info52, 0, 52));
+                                        NDR_CHECK(ndr_push_drsuapi_DsBindInfo52(_ndr_info52, NDR_SCALARS, &r->info52));
+                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info52, 0, 52));
+                                }
+                        break; }
+
+                        default: {
+                                {
+                                        struct ndr_push *_ndr_Fallback;
+                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_Fallback, 0, level));
+                                        NDR_CHECK(ndr_push_drsuapi_DsBindInfoFallBack(_ndr_Fallback, NDR_SCALARS, &r->Fallback));
+                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_Fallback, 0, level));
+                                }
+                        break; }
+
+                }
+        }
+        if (ndr_flags & NDR_BUFFERS) {
+                uint32_t level = ndr_push_get_switch_value(ndr, r);
+                switch (level) {
+                        case 24:
+                        break;
+
+                        case 28:
+                        break;
+
+                        case 48:
+                        break;
+
+                        case 52:
+                        break;
+
+                        default:
+                        break;
+
+                }
+        }
+        ndr->flags = _flags_save;
+        return NDR_ERR_SUCCESS;
+}
+
+enum ndr_err_code ndr_pull_drsuapi_DsBindInfo(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsBindInfo *r)
+{
+        uint32_t level;
+        uint32_t _flags_save = ndr->flags;
+        ndr->flags = ndr->flags & ~LIBNDR_FLAG_NDR64;
+        level = ndr_pull_get_switch_value(ndr, r);
+        NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
+        if (ndr_flags & NDR_SCALARS) {
+                NDR_CHECK(ndr_pull_union_align(ndr, 4));
+                switch (level) {
+                        case 24: {
+                                {
+                                        struct ndr_pull *_ndr_info24;
+                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info24, 0, 24));
+                                        NDR_CHECK(ndr_pull_drsuapi_DsBindInfo24(_ndr_info24, NDR_SCALARS, &r->info24));
+                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info24, 0, 24));
+                                }
+                        break; }
+
+                        case 28: {
+                                {
+                                        struct ndr_pull *_ndr_info28;
+                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info28, 0, 28));
+                                        NDR_CHECK(ndr_pull_drsuapi_DsBindInfo28(_ndr_info28, NDR_SCALARS, &r->info28));
+                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info28, 0, 28));
+                                }
+                        break; }
+
+                        case 48: {
+                                {
+                                        struct ndr_pull *_ndr_info48;
+                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info48, 0, 48));
+                                        NDR_CHECK(ndr_pull_drsuapi_DsBindInfo48(_ndr_info48, NDR_SCALARS, &r->info48));
+                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info48, 0, 48));
+                                }
+                        break; }
+
+                        case 52: {
+                                {
+                                        struct ndr_pull *_ndr_info52;
+                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info52, 0, 52));
+                                        NDR_CHECK(ndr_pull_drsuapi_DsBindInfo52(_ndr_info52, NDR_SCALARS, &r->info52));
+                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info52, 0, 52));
+                                }
+                        break; }
+
+                        default: {
+                                {
+                                        struct ndr_pull *_ndr_Fallback;
+                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_Fallback, 0, level));
+                                        NDR_CHECK(ndr_pull_drsuapi_DsBindInfoFallBack(_ndr_Fallback, NDR_SCALARS, &r->Fallback));
+                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_Fallback, 0, level));
+                                }
+                        break; }
+
+                }
+        }
+        if (ndr_flags & NDR_BUFFERS) {
+                switch (level) {
+                        case 24:
+                        break;
+
+                        case 28:
+                        break;
+
+                        case 48:
+                        break;
+
+                        case 52:
+                        break;
+
+                        default:
+                        break;
+
+                }
+        }
+        ndr->flags = _flags_save;
+        return NDR_ERR_SUCCESS;
+}
+
+_PUBLIC_ void ndr_print_drsuapi_DsBindInfo(struct ndr_print *ndr, const char *name, const union drsuapi_DsBindInfo *r)
+{
+        uint32_t level;
+        level = ndr_print_get_switch_value(ndr, r);
+        ndr_print_union(ndr, name, level, "drsuapi_DsBindInfo");
+        switch (level) {
+                case 24:
+                        ndr_print_drsuapi_DsBindInfo24(ndr, "info24", &r->info24);
+                break;
+
+                case 28:
+                        ndr_print_drsuapi_DsBindInfo28(ndr, "info28", &r->info28);
+                break;
+
+                case 48:
+                        ndr_print_drsuapi_DsBindInfo48(ndr, "info48", &r->info48);
+                break;
+
+                case 52:
+                        ndr_print_drsuapi_DsBindInfo52(ndr, "info52", &r->info52);
+                break;
+
+                default:
+                        ndr_print_drsuapi_DsBindInfoFallBack(ndr, "Fallback", &r->Fallback);
+                break;
+
+        }
+}

vendor/current/librpc/ndr/ndr_krb5pac.c

@@ -116 +116 @@
                                 }
                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
+                                if (ndr->offset > ndr->relative_highest_offset) {
+                                        ndr->relative_highest_offset = ndr->offset;
+                                }
                                 ndr->offset = _relative_save_offset;
                         }

vendor/current/librpc/ndr/ndr_ntprinting.c

@@ -29 +29 @@
         if (string_flags & LIBNDR_FLAG_STR_ASCII) {
                 flags |= LIBNDR_FLAG_STR_ASCII;
+        } else if (string_flags & LIBNDR_FLAG_STR_RAW8) {
+                flags |= LIBNDR_FLAG_STR_RAW8;
         } else {
                 flags |= LIBNDR_FLAG_STR_UTF8;

vendor/current/librpc/ndr/ndr_orpc.c

@@ -94 +94 @@
         ndr->depth++;
         for (i=0;ar->stringbindings[i];i++)     {
-                char *idx = NULL;
-                asprintf(&idx, "[%d]", i);
-                if (idx) {
-                        ndr_print_STRINGBINDING(ndr, idx, ar->stringbindings[i]);
-                        free(idx);
-                }
+                char idx[13];   /* 2^32 has 10 digits */
+                snprintf(idx, sizeof(idx), "[%d]", i);
+                ndr_print_STRINGBINDING(ndr, idx, ar->stringbindings[i]);
         }
         ndr->depth--;
@@ -105 +102 @@
         ndr->depth++;
         for (i=0;ar->securitybindings[i];i++)   {
-                char *idx = NULL;
-                asprintf(&idx, "[%d]", i);
-                if (idx) {
-                        ndr_print_SECURITYBINDING(ndr, idx, ar->securitybindings[i]);
-                        free(idx);
-                }
+                char idx[13];   /* 2^32 has 10 digits */
+                snprintf(idx, sizeof(idx), "[%d]", i);
+                ndr_print_SECURITYBINDING(ndr, idx, ar->securitybindings[i]);
         }
         ndr->depth--;
@@ -163 +157 @@
         ndr->depth++;
         for (i=0;ar->stringbindings[i];i++)     {
-                char *idx = NULL;
-                asprintf(&idx, "[%d]", i);
-                if (idx) {
-                        ndr_print_STRINGBINDING(ndr, idx, ar->stringbindings[i]);
-                        free(idx);
-                }
+                char idx[13];   /* 2^32 has 10 digits */
+                snprintf(idx, sizeof(idx), "[%d]", i);
+                ndr_print_STRINGBINDING(ndr, idx, ar->stringbindings[i]);
         }
         ndr->depth--;

vendor/current/librpc/ndr/ndr_sec_helper.c

@@ -229 +229 @@
                 /* handle a w2k bug which send random data in the buffer */
                 ZERO_STRUCTP(sid);
-        } else if (sid->num_auths == 0 && sid->sub_auths) {
+        } else if (sid->num_auths == 0) {
                 ZERO_STRUCT(sid->sub_auths);
         }
@@ -315 +315 @@
                 NDR_CHECK(ndr_push_int8(ndr, NDR_SCALARS, r->num_auths));
                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->id_auth, 6));
+                if (r->num_auths < 0 || r->num_auths > ARRAY_SIZE(r->sub_auths)) {
+                        return ndr_push_error(ndr, NDR_ERR_RANGE, "value out of range");
+                }
                 for (cntr_sub_auths_0 = 0; cntr_sub_auths_0 < r->num_auths; cntr_sub_auths_0++) {
                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sub_auths[cntr_sub_auths_0]));
@@ -329 +332 @@
                 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &r->sid_rev_num));
                 NDR_CHECK(ndr_pull_int8(ndr, NDR_SCALARS, &r->num_auths));
-                if (r->num_auths < 0 || r->num_auths > 15) {
+                if (r->num_auths < 0 || r->num_auths > ARRAY_SIZE(r->sub_auths)) {
                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
                 }
                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->id_auth, 6));
+                ZERO_STRUCT(r->sub_auths);
                 for (cntr_sub_auths_0 = 0; cntr_sub_auths_0 < r->num_auths; cntr_sub_auths_0++) {
                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sub_auths[cntr_sub_auths_0]));

vendor/current/librpc/ndr/ndr_spoolss_buf.c

@@ -26 +26 @@
 #include "librpc/gen_ndr/ndr_spoolss.h"
 #include "librpc/gen_ndr/ndr_security.h"
-#if (_SAMBA_BUILD_ >= 4)
-#include "param/param.h"
-#endif
 
 #define NDR_SPOOLSS_PUSH_ENUM_IN(fn) do { \

vendor/current/librpc/ndr/ndr_string.c

@@ -31 +31 @@
         uint32_t len1, ofs, len2;
         uint16_t len3;
-        size_t converted_size;
-        int chset = CH_UTF16;
+        size_t conv_src_len = 0, converted_size;
+        int do_convert = 1, chset = CH_UTF16;
         unsigned byte_mul = 2;
         unsigned flags = ndr->flags;
@@ -55 +55 @@
                 byte_mul = 1;
                 flags &= ~LIBNDR_FLAG_STR_UTF8;
+        }
+
+        if (flags & LIBNDR_FLAG_STR_RAW8) {
+                do_convert = 0;
+                byte_mul = 1;
+                flags &= ~LIBNDR_FLAG_STR_RAW8;
         }
 
@@ -74 +80 @@
                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len2));
                 if (len2 > len1) {
-                        return ndr_pull_error(ndr, NDR_ERR_STRING, 
-                                              "Bad string lengths len1=%u ofs=%u len2=%u\n", 
+                        return ndr_pull_error(ndr, NDR_ERR_STRING,
+                                              "Bad string lengths len1=%u ofs=%u len2=%u\n",
                                               len1, ofs, len2);
-                }
-                NDR_PULL_NEED_BYTES(ndr, (len2 + c_len_term)*byte_mul);
-                if (len2 == 0) {
-                        as = talloc_strdup(ndr->current_mem_ctx, "");
-                } else {
-                        if (!convert_string_talloc(ndr->current_mem_ctx, chset,
-                                                   CH_UNIX,
-                                                   ndr->data+ndr->offset,
-                                                   (len2 + c_len_term)*byte_mul,
-                                                   (void **)(void *)&as,
-                                                   &converted_size, false))
-                        {
-                                return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
-                                                      "Bad character conversion with flags 0x%x", flags);
-                        }
-                }
-                NDR_CHECK(ndr_pull_advance(ndr, (len2 + c_len_term)*byte_mul));
-
-                if (len1 != len2) {
+                } else if (len1 != len2) {
                         DEBUG(6,("len1[%u] != len2[%u] '%s'\n", len1, len2, as));
                 }
-
-                /* this is a way of detecting if a string is sent with the wrong
-                   termination */
-                if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
-                        if (strlen(as) < (len2 + c_len_term)) {
-                                DEBUG(6,("short string '%s'\n", as));
-                        }
-                } else {
-                        if (strlen(as) == (len2 + c_len_term)) {
-                                DEBUG(6,("long string '%s'\n", as));
-                        }
-                }
-                *s = as;
+                conv_src_len = len2 + c_len_term;
                 break;
 
@@ -116 +92 @@
         case LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
-                NDR_PULL_NEED_BYTES(ndr, (len1 + c_len_term)*byte_mul);
-                if (len1 == 0) {
-                        as = talloc_strdup(ndr->current_mem_ctx, "");
-                } else {
-                        if (!convert_string_talloc(ndr->current_mem_ctx, chset,
-                                                   CH_UNIX,
-                                                   ndr->data+ndr->offset,
-                                                   (len1 + c_len_term)*byte_mul,
-                                                   (void **)(void *)&as,
-                                                   &converted_size, false))
-                        {
-                                return ndr_pull_error(ndr, NDR_ERR_CHARCNV, 
-                                                      "Bad character conversion with flags 0x%x", flags);
-                        }
-                }
-                NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
-
-                /* this is a way of detecting if a string is sent with the wrong
-                   termination */
-                if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
-                        if (strlen(as) < (len1 + c_len_term)) {
-                                DEBUG(6,("short string '%s'\n", as));
-                        }
-                } else {
-                        if (strlen(as) == (len1 + c_len_term)) {
-                                DEBUG(6,("long string '%s'\n", as));
-                        }
-                }
-                *s = as;
+                conv_src_len = len1 + c_len_term;
                 break;
 
@@ -155 +103 @@
                 }
                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
-                NDR_PULL_NEED_BYTES(ndr, (len1 + c_len_term)*byte_mul);
-                if (len1 == 0) {
-                        as = talloc_strdup(ndr->current_mem_ctx, "");
-                } else {
-                        if (!convert_string_talloc(ndr->current_mem_ctx, chset,
-                                                   CH_UNIX,
-                                                   ndr->data+ndr->offset,
-                                                   (len1 + c_len_term)*byte_mul,
-                                                   (void **)(void *)&as,
-                                                   &converted_size, false))
-                        {
-                                return ndr_pull_error(ndr, NDR_ERR_CHARCNV, 
-                                                      "Bad character conversion with flags 0x%x", flags);
-                        }
-                }
-                NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
-
-                /* this is a way of detecting if a string is sent with the wrong
-                   termination */
-                if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
-                        if (strlen(as) < (len1 + c_len_term)) {
-                                DEBUG(6,("short string '%s'\n", as));
-                        }
-                } else {
-                        if (strlen(as) == (len1 + c_len_term)) {
-                                DEBUG(6,("long string '%s'\n", as));
-                        }
-                }
-                *s = as;
-                break;
-
+                conv_src_len = len1 + c_len_term;
+                break;
 
         case LIBNDR_FLAG_STR_SIZE2:
         case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM:
                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
-                NDR_PULL_NEED_BYTES(ndr, (len3 + c_len_term)*byte_mul);
-                if (len3 == 0) {
-                        as = talloc_strdup(ndr->current_mem_ctx, "");
-                } else {
-                        if (!convert_string_talloc(ndr->current_mem_ctx, chset,
-                                                   CH_UNIX,
-                                                   ndr->data+ndr->offset,
-                                                   (len3 + c_len_term)*byte_mul,
-                                                   (void **)(void *)&as,
-                                                   &converted_size, false))
-                        {
-                                return ndr_pull_error(ndr, NDR_ERR_CHARCNV, 
-                                                      "Bad character conversion with flags 0x%x", flags);
-                        }
-                }
-                NDR_CHECK(ndr_pull_advance(ndr, (len3 + c_len_term)*byte_mul));
-
-                /* this is a way of detecting if a string is sent with the wrong
-                   termination */
-                if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
-                        if (strlen(as) < (len3 + c_len_term)) {
-                                DEBUG(6,("short string '%s'\n", as));
-                        }
-                } else {
-                        if (strlen(as) == (len3 + c_len_term)) {
-                                DEBUG(6,("long string '%s'\n", as));
-                        }
-                }
-                *s = as;
+                conv_src_len = len3 + c_len_term;
                 break;
 
         case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_BYTESIZE:
                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
-                NDR_PULL_NEED_BYTES(ndr, len3);
-                if (len3 == 0) {
-                        as = talloc_strdup(ndr->current_mem_ctx, "");
-                } else {
-                        if (!convert_string_talloc(ndr->current_mem_ctx, chset,
-                                                   CH_UNIX,
-                                                   ndr->data+ndr->offset, len3,
-                                                   (void **)(void *)&as,
-                                                   &converted_size, false))
-                        {
-                                return ndr_pull_error(ndr, NDR_ERR_CHARCNV, 
-                                                      "Bad character conversion with flags 0x%x", flags);
-                        }
-                }
-                NDR_CHECK(ndr_pull_advance(ndr, len3));
-                *s = as;
+                conv_src_len = len3;
+                byte_mul = 1; /* the length is now absolute */
                 break;
 
         case LIBNDR_FLAG_STR_NULLTERM:
                 if (byte_mul == 1) {
-                        len1 = ascii_len_n((const char *)(ndr->data+ndr->offset), ndr->data_size - ndr->offset);
+                        conv_src_len = ascii_len_n((const char *)(ndr->data+ndr->offset), ndr->data_size - ndr->offset);
                 } else {
-                        len1 = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
-                }
-                if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
-                                           ndr->data+ndr->offset, len1,
-                                           (void **)(void *)&as,
-                                           &converted_size, false))
-                {
-                        return ndr_pull_error(ndr, NDR_ERR_CHARCNV, 
-                                              "Bad character conversion with flags 0x%x", flags);
-                }
-                NDR_CHECK(ndr_pull_advance(ndr, len1));
-                *s = as;
+                        conv_src_len = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
+                }
+                byte_mul = 1; /* the length is now absolute */
                 break;
 
@@ -264 +132 @@
                                               ndr->flags & LIBNDR_STRING_FLAGS);
                 }
-
-                len1 = ndr->data_size - ndr->offset;
-
-                NDR_PULL_NEED_BYTES(ndr, len1);
-                if (len1 == 0) {
-                        as = talloc_strdup(ndr->current_mem_ctx, "");
-                } else {
-                        if (!convert_string_talloc(ndr->current_mem_ctx, chset,
-                                                   CH_UNIX,
-                                                   ndr->data+ndr->offset, len1,
-                                                   (void **)(void *)&as,
-                                                   &converted_size, false))
-                        {
-                                return ndr_pull_error(ndr, NDR_ERR_CHARCNV, 
-                                                      "Bad character conversion with flags 0x%x", flags);
-                        }
-                }
-                NDR_CHECK(ndr_pull_advance(ndr, len1));
-
-                *s = as;
+                conv_src_len = ndr->data_size - ndr->offset;
+                byte_mul = 1; /* the length is now absolute */
                 break;
 
@@ -290 +140 @@
                                       ndr->flags & LIBNDR_STRING_FLAGS);
         }
+
+        NDR_PULL_NEED_BYTES(ndr, conv_src_len * byte_mul);
+        if (conv_src_len == 0) {
+                as = talloc_strdup(ndr->current_mem_ctx, "");
+                converted_size = 0;
+        } else {
+                if (!do_convert) {
+                        as = talloc_strndup(ndr->current_mem_ctx,
+                                            (char *)ndr->data + ndr->offset,
+                                            conv_src_len);
+                        if (!as) {
+                                return ndr_pull_error(ndr, NDR_ERR_ALLOC,
+                                                      "Failed to talloc_strndup() in RAW8 ndr_string_pull()");
+                        }
+                        converted_size = MIN(strlen(as)+1, conv_src_len);
+                } else if (!convert_string_talloc(ndr->current_mem_ctx, chset,
+                                           CH_UNIX, ndr->data + ndr->offset,
+                                           conv_src_len * byte_mul,
+                                           (void **)(void *)&as,
+                                           &converted_size)) {
+                        return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
+                                              "Bad character conversion with flags 0x%x", flags);
+                }
+        }
+
+        /* this is a way of detecting if a string is sent with the wrong
+           termination */
+        if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
+                if (as && converted_size > 0 && as[converted_size-1] == '\0') {
+                        DEBUG(6,("short string '%s', sent with NULL termination despite NOTERM flag in IDL\n", as));
+                }
+        } else {
+                if (as && converted_size > 0 && as[converted_size-1] != '\0') {
+                        DEBUG(6,("long string '%s', send without NULL termination (which was expected)\n", as));
+                }
+        }
+
+        NDR_CHECK(ndr_pull_advance(ndr, conv_src_len * byte_mul));
+        *s = as;
 
         return NDR_ERR_SUCCESS;
@@ -302 +191 @@
         ssize_t s_len, c_len;
         size_t d_len;
-        int chset = CH_UTF16;
+        int do_convert = 1, chset = CH_UTF16;
         unsigned flags = ndr->flags;
         unsigned byte_mul = 2;
@@ -329 +218 @@
         }
 
+        if (flags & LIBNDR_FLAG_STR_RAW8) {
+                do_convert = 0;
+                byte_mul = 1;
+                flags &= ~LIBNDR_FLAG_STR_RAW8;
+        }
+
         flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
 
@@ -334 +229 @@
                 s_len++;
         }
-        if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
-                                   (void **)(void *)&dest, &d_len, false))
+
+        if (!do_convert) {
+                d_len = s_len;
+                dest = (uint8_t *)talloc_strndup(ndr, s, s_len);
+        } else if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
+                                   (void **)(void *)&dest, &d_len))
         {
                 return ndr_push_error(ndr, NDR_ERR_CHARCNV, 
@@ -404 +303 @@
         unsigned c_len_term = 1;
 
-        c_len = s?strlen_m(s):0;
-
-        if (flags & (LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_UTF8)) {
+        if (flags & LIBNDR_FLAG_STR_RAW8) {
+                c_len = s?strlen(s):0;
+        } else {
+                c_len = s?strlen_m(s):0;
+        }
+
+        if (flags & (LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_RAW8|LIBNDR_FLAG_STR_UTF8)) {
                 byte_mul = 1;
         }
@@ -612 +515 @@
         uint32_t i;
         size_t size = 0;
+        int rawbytes = 0;
+
+        if (flags & LIBNDR_FLAG_STR_RAW8) {
+                rawbytes = 1;
+                flags &= ~LIBNDR_FLAG_STR_RAW8;
+        }
 
         switch (flags & LIBNDR_STRING_FLAGS) {
         case LIBNDR_FLAG_STR_NULLTERM:
                 for (i = 0; i < count; i++) {
-                        size += strlen_m_term(a[i]);
+                        size += rawbytes?strlen(a[i]) + 1:strlen_m_term(a[i]);
                 }
                 break;
         case LIBNDR_FLAG_STR_NOTERM:
                 for (i = 0; i < count; i++) {
-                        size += strlen_m(a[i]);
+                        size += rawbytes?strlen(a[i]):strlen_m(a[i]);
                 }
                 break;
@@ -651 +560 @@
 
         save_offset = ndr->offset;
-        ndr_pull_advance(ndr, (count - 1) * element_size);
+        NDR_CHECK(ndr_pull_advance(ndr, (count - 1) * element_size));
         NDR_PULL_NEED_BYTES(ndr, element_size);
 
@@ -685 +594 @@
                                    ndr->data+ndr->offset, length*byte_mul,
                                    discard_const_p(void *, var),
-                                   &converted_size, false))
+                                   &converted_size))
         {
                 return ndr_pull_error(ndr, NDR_ERR_CHARCNV, 
@@ -712 +621 @@
 
         str_len = ndr_string_length(ndr->data+ndr->offset, byte_mul);
-        str_len = MIN(str_len, length); /* overrun protection */
-
+        str_len = MIN(str_len, length); /* overrun protection */
         if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
                                    ndr->data+ndr->offset, str_len*byte_mul,
                                    discard_const_p(void *, var),
-                                   &converted_size, false))
+                                   &converted_size))
         {
                 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
@@ -729 +637 @@
 _PUBLIC_ enum ndr_err_code ndr_push_charset(struct ndr_push *ndr, int ndr_flags, const char *var, uint32_t length, uint8_t byte_mul, charset_t chset)
 {
-        ssize_t ret, required;
+        ssize_t required;
 
         if (NDR_BE(ndr) && chset == CH_UTF16) {
@@ -740 +648 @@
 
         if (required) {
-                ret = convert_string(CH_UNIX, chset,
+                size_t size = 0;
+                if (!convert_string(CH_UNIX, chset,
                              var, strlen(var),
-                             ndr->data+ndr->offset, required, false);
-                if (ret == -1) {
-                        return ndr_push_error(ndr, NDR_ERR_CHARCNV,
-                                              "Bad character conversion");
+                             ndr->data+ndr->offset, required, &size)) {
+                        return ndr_push_error(ndr, NDR_ERR_CHARCNV, 
+                                      "Bad character conversion");
                 }
 
                 /* Make sure the remaining part of the string is filled with zeroes */
-                if (ret < required) {
-                        memset(ndr->data+ndr->offset+ret, 0, required-ret);
+                if (size < required) {
+                        memset(ndr->data+ndr->offset+size, 0, required-size);
                 }
         }
@@ -769 +677 @@
         case CH_UTF8:
                 return strlen_m_ext_term((const char *)var, CH_UNIX, chset);
-        case CH_DISPLAY:
         case CH_DOS:
         case CH_UNIX:

vendor/current/librpc/ndr/ndr_table.c

@@ -74 +74 @@
 {
         const struct ndr_interface_list *l;
-        for (l=ndr_interfaces;l;l=l->next){
+        for (l=ndr_table_list();l;l=l->next){
                 if (GUID_equal(&l->table->syntax_id.uuid, uuid) &&
                     l->table->syntax_id.if_version == if_version) {
@@ -90 +90 @@
 {
         const struct ndr_interface_list *l;
-        for (l=ndr_interfaces;l;l=l->next) {
+        for (l=ndr_table_list();l;l=l->next) {
                 if (strcasecmp(l->table->name, name) == 0) {
+                        return l->table;
+                }
+        }
+        return NULL;
+}
+
+/*
+  find a dcerpc interface by syntax
+*/
+const struct ndr_interface_table *ndr_table_by_syntax(const struct ndr_syntax_id *syntax)
+{
+        const struct ndr_interface_list *l;
+        for (l=ndr_table_list();l;l=l->next) {
+                if (ndr_syntax_id_equal(&l->table->syntax_id, syntax)) {
                         return l->table;
                 }
@@ -104 +118 @@
 {
         const struct ndr_interface_list *l;
-        for (l=ndr_interfaces;l;l=l->next) {
+        for (l=ndr_table_list();l;l=l->next) {
                 if (GUID_equal(&l->table->syntax_id.uuid, uuid)) {
                         return l->table;
@@ -117 +131 @@
 const struct ndr_interface_list *ndr_table_list(void)
 {
+        ndr_table_init();
         return ndr_interfaces;
 }

vendor/current/librpc/ndr/ndr_table.h

@@ -28 +28 @@
 int ndr_interface_num_calls(const struct GUID *uuid, uint32_t if_version);
 const struct ndr_interface_table *ndr_table_by_name(const char *name);
+const struct ndr_interface_table *ndr_table_by_syntax(const struct ndr_syntax_id *syntax);
 const struct ndr_interface_table *ndr_table_by_uuid(const struct GUID *uuid);
 const struct ndr_interface_list *ndr_table_list(void);

vendor/current/librpc/ndr/ndr_wmi.c

@@ -24 +24 @@
 #include "librpc/gen_ndr/ndr_dcom.h"
 #include "librpc/gen_ndr/ndr_wmi.h"
+#include "librpc/ndr/ndr_wmi.h"
 
 // Just for debugging

vendor/current/librpc/ndr/uuid.c

@@ -158 +158 @@
 
 /**
-  build a GUID from a string
-*/
-_PUBLIC_ NTSTATUS NS_GUID_from_string(const char *s, struct GUID *guid)
-{
-        NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
-        uint32_t time_low;
-        uint32_t time_mid, time_hi_and_version;
-        uint32_t clock_seq[2];
-        uint32_t node[6];
-        int i;
-
-        if (s == NULL) {
-                return NT_STATUS_INVALID_PARAMETER;
-        }
-
-        if (11 == sscanf(s, "%08x-%04x%04x-%02x%02x%02x%02x-%02x%02x%02x%02x",
-                         &time_low, &time_mid, &time_hi_and_version, 
-                         &clock_seq[0], &clock_seq[1],
-                         &node[0], &node[1], &node[2], &node[3], &node[4], &node[5])) {
-                status = NT_STATUS_OK;
-        }
-
-        if (!NT_STATUS_IS_OK(status)) {
-                return status;
-        }
-
-        guid->time_low = time_low;
-        guid->time_mid = time_mid;
-        guid->time_hi_and_version = time_hi_and_version;
-        guid->clock_seq[0] = clock_seq[0];
-        guid->clock_seq[1] = clock_seq[1];
-        for (i=0;i<6;i++) {
-                guid->node[i] = node[i];
-        }
-
-        return NT_STATUS_OK;
-}
-
-/**
  * generate a random GUID
  */
@@ -237 +198 @@
 _PUBLIC_ bool GUID_equal(const struct GUID *u1, const struct GUID *u2)
 {
-        if (u1->time_low != u2->time_low ||
-            u1->time_mid != u2->time_mid ||
-            u1->time_hi_and_version != u2->time_hi_and_version ||
-            u1->clock_seq[0] != u2->clock_seq[0] ||
-            u1->clock_seq[1] != u2->clock_seq[1] ||
-            memcmp(u1->node, u2->node, 6) != 0) {
-                return false;
-        }
-        return true;
+        return (GUID_compare(u1, u2) == 0);
 }
 
@@ -278 +231 @@
 _PUBLIC_ char *GUID_string(TALLOC_CTX *mem_ctx, const struct GUID *guid)
 {
-        return talloc_asprintf(mem_ctx, 
-                               "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
-                               guid->time_low, guid->time_mid,
-                               guid->time_hi_and_version,
-                               guid->clock_seq[0],
-                               guid->clock_seq[1],
-                               guid->node[0], guid->node[1],
-                               guid->node[2], guid->node[3],
-                               guid->node[4], guid->node[5]);
+        struct GUID_txt_buf buf;
+        return talloc_strdup(mem_ctx, GUID_buf_string(guid, &buf));
+}
+
+/**
+ * Does the same without allocating memory, using the structure buffer.
+ * Useful for debug messages, so that you do not have to talloc_free the result
+ */
+_PUBLIC_ char* GUID_buf_string(const struct GUID *guid,
+                               struct GUID_txt_buf *dst)
+{
+        if (!guid) {
+                return NULL;
+        }
+        snprintf(dst->buf, sizeof(dst->buf),
+                 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+                 guid->time_low, guid->time_mid,
+                 guid->time_hi_and_version,
+                 guid->clock_seq[0],
+                 guid->clock_seq[1],
+                 guid->node[0], guid->node[1],
+                 guid->node[2], guid->node[3],
+                 guid->node[4], guid->node[5]);
+        return dst->buf;
 }
 
@@ -319 +287 @@
 }
 
-_PUBLIC_ char *NS_GUID_string(TALLOC_CTX *mem_ctx, const struct GUID *guid)
-{
-        return talloc_asprintf(mem_ctx, 
-                               "%08x-%04x%04x-%02x%02x%02x%02x-%02x%02x%02x%02x",
-                               guid->time_low, guid->time_mid,
-                               guid->time_hi_and_version,
-                               guid->clock_seq[0],
-                               guid->clock_seq[1],
-                               guid->node[0], guid->node[1],
-                               guid->node[2], guid->node[3],
-                               guid->node[4], guid->node[5]);
-}
-
-_PUBLIC_ bool policy_handle_empty(const struct policy_handle *h)
+_PUBLIC_ bool ndr_policy_handle_empty(const struct policy_handle *h)
 {
         return (h->handle_type == 0 && GUID_all_zero(&h->uuid));
 }
 
-_PUBLIC_ bool is_valid_policy_hnd(const struct policy_handle *hnd)
-{
-        return !policy_handle_empty(hnd);
-}
-
-_PUBLIC_ bool policy_handle_equal(const struct policy_handle *hnd1,
+_PUBLIC_ bool ndr_policy_handle_equal(const struct policy_handle *hnd1,
                                   const struct policy_handle *hnd2)
 {