librpc/ndr/libndr.h

   1 /*
   2    Unix SMB/CIFS implementation.
   3    rpc interface definitions
   4
   5    Copyright (C) Andrew Tridgell 2003
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 /* This is a public header file that is installed as part of Samba.
  22  * If you remove any functions or change their signature, update
  23  * the so version number. */
  24
  25 #ifndef __LIBNDR_H__
  26 #define __LIBNDR_H__
  27
  28 #include <talloc.h>
  29 #include "lib/util/discard.h" /* for discard_const */
  30 #include "lib/util/data_blob.h"
  31 #include "lib/util/time.h"
  32 #include "lib/util/charset/charset.h"
  33
  34 /*
  35   this provides definitions for the libcli/rpc/ MSRPC library
  36 */
  37
  38
  39 /*
  40   We store the token mapping in an array that is resized as necessary.
  41 */
  42 struct ndr_token;
  43
  44 struct ndr_token_list {
  45         struct ndr_token *tokens;
  46         uint32_t count;
  47 };
  48
  49 struct ndr_compression_state;
  50
  51 #define LIBNDR_STATIC_ASSERT(msg, cond) \
  52         typedef char static_assert_##msg[(cond) ? 1 : -1]
  53
  54 /*
  55  * If you’re considering changing the size of this type, see also
  56  * $scalar_alignment in pidl/lib/Parse/Pidl/NDR.pm.
  57  */
  58 typedef enum {
  59         LIBNDR_FLAG_BIGENDIAN = 1U << 0,
  60         LIBNDR_FLAG_NOALIGN = 1U << 1,
  61
  62         LIBNDR_FLAG_STR_ASCII = 1U << 2,
  63         LIBNDR_FLAG_STR_LEN4 = 1U << 3,
  64         LIBNDR_FLAG_STR_SIZE4 = 1U << 4,
  65         LIBNDR_FLAG_STR_NOTERM = 1U << 5,
  66         LIBNDR_FLAG_STR_NULLTERM = 1U << 6,
  67         LIBNDR_FLAG_STR_SIZE2 = 1U << 7,
  68         LIBNDR_FLAG_STR_BYTESIZE = 1U << 8,
  69         LIBNDR_FLAG_STR_NO_EMBEDDED_NUL = 1U << 9,
  70         LIBNDR_FLAG_STR_CONFORMANT = 1U << 10,
  71         LIBNDR_FLAG_STR_CHARLEN = 1U << 11,
  72         LIBNDR_FLAG_STR_UTF8 = 1U << 12,
  73         LIBNDR_FLAG_STR_RAW8 = 1U << 13,
  74
  75         /*
  76          * Mark an element as SECRET, it won't be printed via
  77          * ndr_print* unless NDR_PRINT_SECRETS is specified.
  78          */
  79         LIBNDR_FLAG_IS_SECRET = 1U << 14,
  80
  81         /* Disable string token compression  */
  82         LIBNDR_FLAG_NO_COMPRESSION = 1U << 15,
  83
  84         /*
  85          * don't debug NDR_ERR_BUFSIZE failures,
  86          * as the available buffer might be incomplete.
  87          *
  88          * return NDR_ERR_INCOMPLETE_BUFFER instead.
  89          */
  90         LIBNDR_FLAG_INCOMPLETE_BUFFER = 1U << 16,
  91
  92         /*
  93          * This lets ndr_pull_subcontext_end() return
  94          * NDR_ERR_UNREAD_BYTES.
  95          */
  96         LIBNDR_FLAG_SUBCONTEXT_NO_UNREAD_BYTES = 1U << 17,
  97
  98         /* set if relative pointers should *not* be marshalled in reverse order */
  99         LIBNDR_FLAG_NO_RELATIVE_REVERSE = 1U << 18,
 100
 101         /* set if relative pointers are marshalled in reverse order */
 102         LIBNDR_FLAG_RELATIVE_REVERSE = 1U << 19,
 103
 104         LIBNDR_FLAG_REF_ALLOC = 1U << 20,
 105         LIBNDR_FLAG_REMAINING = 1U << 21,
 106         LIBNDR_FLAG_ALIGN2 = 1U << 22,
 107         LIBNDR_FLAG_ALIGN4 = 1U << 23,
 108         LIBNDR_FLAG_ALIGN8 = 1U << 24,
 109
 110         LIBNDR_PRINT_ARRAY_HEX = 1U << 25,
 111         LIBNDR_PRINT_SET_VALUES = 1U << 26,
 112
 113         /* used to force a section of IDL to be little-endian */
 114         LIBNDR_FLAG_LITTLE_ENDIAN = 1U << 27,
 115
 116         /* used to check if alignment padding is zero */
 117         LIBNDR_FLAG_PAD_CHECK = 1U << 28,
 118
 119         LIBNDR_FLAG_NDR64 = 1U << 29,
 120
 121         /* set if an object uuid will be present */
 122         LIBNDR_FLAG_OBJECT_PRESENT = 1U << 30,
 123
 124         /* set to avoid recursion in ndr_size_*() calculation */
 125         LIBNDR_FLAG_NO_NDR_SIZE = 1U << 31,
 126
 127         /*
 128          * present to keep the size of this enumeration 64 bits until we need a
 129          * 33rd flag.
 130          */
 131         LIBNDR_FLAG_0x100000000 = UINT64_C(1) << 32,
 132 } libndr_flags;
 133 LIBNDR_STATIC_ASSERT(libndr_flags_are_64_bit, sizeof (libndr_flags) == 8);
 134 #define PRI_LIBNDR_FLAGS PRIx64
 135 #define PRI_LIBNDR_FLAGS_DECIMAL PRIu64
 136
 137 /*
 138 * If you’re considering changing the size of this type, see also
 139 * $scalar_alignment in pidl/lib/Parse/Pidl/NDR.pm.
 140 */
 141 typedef enum {
 142         /*
 143           flags passed to control parse flow
 144           These are deliberately in a different range to the NDR_IN/NDR_OUT
 145           flags to catch mixups
 146         */
 147         NDR_SCALARS = 0x100,
 148         NDR_BUFFERS = 0x200,
 149
 150         /*
 151           flags passed to ndr_print_*() and ndr pull/push for functions
 152           These are deliberately in a different range to the
 153           NDR_SCALARS/NDR_BUFFERS flags to catch mixups
 154         */
 155         NDR_IN = 0x10,
 156         NDR_OUT = 0x20,
 157         NDR_BOTH = 0x30,
 158         NDR_SET_VALUES = 0x40,
 159 } ndr_flags_type;
 160 LIBNDR_STATIC_ASSERT(ndr_flags_are_32_bit, sizeof (ndr_flags_type) == 4);
 161 #define PRI_NDR_FLAGS_TYPE PRIx32
 162
 163 #undef LIBNDR_STATIC_ASSERT
 164
 165 /* this is the base structure passed to routines that
 166    parse MSRPC formatted data
 167
 168    note that in Samba4 we use separate routines and structures for
 169    MSRPC marshalling and unmarshalling. Also note that these routines
 170    are being kept deliberately very simple, and are not tied to a
 171    particular transport
 172 */
 173 struct ndr_pull {
 174         libndr_flags flags; /* LIBNDR_FLAG_* */
 175         uint8_t *data;
 176         uint32_t data_size;
 177         uint32_t offset;
 178
 179         uint32_t relative_highest_offset;
 180         uint32_t relative_base_offset;
 181         uint32_t relative_rap_convert;
 182         struct ndr_token_list relative_base_list;
 183
 184         struct ndr_token_list relative_list;
 185         struct ndr_token_list array_size_list;
 186         struct ndr_token_list array_length_list;
 187         struct ndr_token_list switch_list;
 188
 189         struct ndr_compression_state *cstate;
 190
 191         TALLOC_CTX *current_mem_ctx;
 192
 193         /* this is used to ensure we generate unique reference IDs
 194            between request and reply */
 195         uint32_t ptr_count;
 196         uint32_t recursion_depth;
 197         /*
 198          * The global maximum depth for recursion. When set it overrides the
 199          * value supplied by the max_recursion idl attribute.  This is needed
 200          * for fuzzing as ASAN uses a low threshold for stack depth to check
 201          * for stack overflow.
 202          */
 203         uint32_t global_max_recursion;
 204 };
 205
 206 /* structure passed to functions that generate NDR formatted data */
 207 struct ndr_push {
 208         libndr_flags flags; /* LIBNDR_FLAG_* */
 209         uint8_t *data;
 210         uint32_t alloc_size;
 211         uint32_t offset;
 212         bool fixed_buf_size;
 213
 214         uint32_t relative_base_offset;
 215         uint32_t relative_end_offset;
 216         struct ndr_token_list relative_base_list;
 217
 218         struct ndr_token_list switch_list;
 219         struct ndr_token_list relative_list;
 220         struct ndr_token_list relative_begin_list;
 221         struct ndr_token_list nbt_string_list;
 222         struct ndr_token_list dns_string_list;
 223         struct ndr_token_list full_ptr_list;
 224
 225         struct ndr_compression_state *cstate;
 226
 227         /* this is used to ensure we generate unique reference IDs */
 228         uint32_t ptr_count;
 229 };
 230
 231 /* structure passed to functions that print IDL structures */
 232 struct ndr_print {
 233         libndr_flags flags; /* LIBNDR_FLAG_* */
 234         uint32_t depth;
 235         struct ndr_token_list switch_list;
 236         void (*print)(struct ndr_print *, const char *, ...) PRINTF_ATTRIBUTE(2,3);
 237         void *private_data;
 238         bool no_newline;
 239         bool print_secrets;
 240 };
 241
 242 #define LIBNDR_STRING_FLAGS             (0U | \
 243                 LIBNDR_FLAG_STR_ASCII | \
 244                 LIBNDR_FLAG_STR_LEN4 | \
 245                 LIBNDR_FLAG_STR_SIZE4 | \
 246                 LIBNDR_FLAG_STR_NOTERM | \
 247                 LIBNDR_FLAG_STR_NULLTERM | \
 248                 LIBNDR_FLAG_STR_SIZE2 | \
 249                 LIBNDR_FLAG_STR_BYTESIZE | \
 250                 LIBNDR_FLAG_STR_NO_EMBEDDED_NUL | \
 251                 LIBNDR_FLAG_STR_CONFORMANT | \
 252                 LIBNDR_FLAG_STR_CHARLEN | \
 253                 LIBNDR_FLAG_STR_UTF8 | \
 254                 LIBNDR_FLAG_STR_RAW8 | \
 255                 0)
 256
 257 #define LIBNDR_ENCODING_FLAGS           (0U | \
 258                 LIBNDR_FLAG_STR_ASCII | \
 259                 LIBNDR_FLAG_STR_UTF8 | \
 260                 LIBNDR_FLAG_STR_RAW8 | \
 261                 0)
 262
 263 #define LIBNDR_ALIGN_FLAGS ( 0        | \
 264                 LIBNDR_FLAG_NOALIGN   | \
 265                 LIBNDR_FLAG_REMAINING | \
 266                 LIBNDR_FLAG_ALIGN2    | \
 267                 LIBNDR_FLAG_ALIGN4    | \
 268                 LIBNDR_FLAG_ALIGN8    | \
 269                 0)
 270
 271 /* useful macro for debugging */
 272 #define NDR_PRINT_DEBUG(type, p) (void)ndr_print_debug(1, (ndr_print_fn_t)ndr_print_ ##type, #p, p, __location__, __func__)
 273 #define NDR_PRINT_DEBUGC(dbgc_class, type, p) ndr_print_debugc(dbgc_class, (ndr_print_fn_t)ndr_print_ ##type, #p, p)
 274 #define NDR_PRINT_UNION_DEBUG(type, level, p) ndr_print_union_debug((ndr_print_fn_t)ndr_print_ ##type, #p, level, p)
 275 #define NDR_PRINT_FUNCTION_DEBUG(type, flags, p) ndr_print_function_debug((ndr_print_function_t)ndr_print_ ##type, #type, flags, p)
 276 #define NDR_PRINT_BOTH_DEBUG(type, p) NDR_PRINT_FUNCTION_DEBUG(type, NDR_BOTH, p)
 277 #define NDR_PRINT_OUT_DEBUG(type, p) NDR_PRINT_FUNCTION_DEBUG(type, NDR_OUT, p)
 278 #define NDR_PRINT_IN_DEBUG(type, p) NDR_PRINT_FUNCTION_DEBUG(type, NDR_IN | NDR_SET_VALUES, p)
 279
 280 /**
 281  * @brief Prints NDR structure.
 282  *
 283  * Like NDR_PRINT_DEBUG, but takes a debug level parameter.
 284  *
 285  * @param[in]  l        The debug level.
 286  * @param[in]  type     ndr_print_#type is the function that will be called.
 287  * @param[in]  p        Pointer to the struct.
 288  *
 289  * @code
 290  *     NDR_PRINT_DEBUG_LEVEL(DBGLVL_DEBUG, wbint_userinfo, state->info);
 291  * @endcode
 292  *
 293  * @return void.
 294  */
 295 #define NDR_PRINT_DEBUG_LEVEL(l, type, p) \
 296         (void) ( CHECK_DEBUGLVL(l) \
 297                 && ndr_print_debug(l, (ndr_print_fn_t)ndr_print_ ##type, #p, p, __location__, __func__) )
 298
 299 /* useful macro for debugging in strings */
 300 #define NDR_PRINT_STRUCT_STRING(ctx, type, p) ndr_print_struct_string(ctx, (ndr_print_fn_t)ndr_print_ ##type, #p, p)
 301 #define NDR_PRINT_UNION_STRING(ctx, type, level, p) ndr_print_union_string(ctx, (ndr_print_fn_t)ndr_print_ ##type, #p, level, p)
 302 #define NDR_PRINT_FUNCTION_STRING(ctx, type, flags, p) ndr_print_function_string(ctx, (ndr_print_function_t)ndr_print_ ##type, #type, flags, p)
 303 #define NDR_PRINT_BOTH_STRING(ctx, type, p) NDR_PRINT_FUNCTION_STRING(ctx, type, NDR_BOTH, p)
 304 #define NDR_PRINT_OUT_STRING(ctx, type, p) NDR_PRINT_FUNCTION_STRING(ctx, type, NDR_OUT, p)
 305 #define NDR_PRINT_IN_STRING(ctx, type, p) NDR_PRINT_FUNCTION_STRING(ctx, type, NDR_IN | NDR_SET_VALUES, p)
 306
 307 #define NDR_HIDE_SECRET(ndr) \
 308         (unlikely(((ndr)->flags & LIBNDR_FLAG_IS_SECRET) && !(ndr)->print_secrets))
 309
 310 #define NDR_BE(ndr) (unlikely(((ndr)->flags & (LIBNDR_FLAG_BIGENDIAN|LIBNDR_FLAG_LITTLE_ENDIAN)) == LIBNDR_FLAG_BIGENDIAN))
 311
 312 enum ndr_err_code {
 313         NDR_ERR_SUCCESS = 0,
 314         NDR_ERR_ARRAY_SIZE,
 315         NDR_ERR_BAD_SWITCH,
 316         NDR_ERR_OFFSET,
 317         NDR_ERR_RELATIVE,
 318         NDR_ERR_CHARCNV,
 319         NDR_ERR_LENGTH,
 320         NDR_ERR_SUBCONTEXT,
 321         NDR_ERR_COMPRESSION,
 322         NDR_ERR_STRING,
 323         NDR_ERR_VALIDATE,
 324         NDR_ERR_BUFSIZE,
 325         NDR_ERR_ALLOC,
 326         NDR_ERR_RANGE,
 327         NDR_ERR_TOKEN,
 328         NDR_ERR_IPV4ADDRESS,
 329         NDR_ERR_IPV6ADDRESS,
 330         NDR_ERR_INVALID_POINTER,
 331         NDR_ERR_UNREAD_BYTES,
 332         NDR_ERR_NDR64,
 333         NDR_ERR_FLAGS,
 334         NDR_ERR_INCOMPLETE_BUFFER,
 335         NDR_ERR_MAX_RECURSION_EXCEEDED,
 336         NDR_ERR_UNDERFLOW
 337 };
 338
 339 #define NDR_ERR_CODE_IS_SUCCESS(x) (x == NDR_ERR_SUCCESS)
 340
 341 #define NDR_ERR_HAVE_NO_MEMORY(x) do { \
 342         if (NULL == (x)) { \
 343                 return NDR_ERR_ALLOC; \
 344         } \
 345 } while (0)
 346
 347 /*
 348  * Values here are chosen to be distinct from but recognisable as the
 349  * values in ntifs.h and claims.idl
 350  */
 351 enum ndr_compression_alg {
 352         NDR_COMPRESSION_NONE            = 0,   /* 0x00 in ntifs.h */
 353         NDR_COMPRESSION_XPRESS_LZNT1    = 102, /* MS-XCA 0x02 in ntifs.h
 354                                                 * (Unimplemented)
 355                                                 */
 356         NDR_COMPRESSION_XPRESS_RAW      = 103, /* MS-XCA 0x03 in ntifs.h
 357                                                 * (implemented in
 358                                                 * lib/compression but
 359                                                 * not connected to libndr)
 360                                                 */
 361         NDR_COMPRESSION_XPRESS_HUFF_RAW = 104, /* MS-XCA 0x04 in ntifs.h */
 362         NDR_COMPRESSION_MSZIP_CAB       = 201,
 363         NDR_COMPRESSION_MSZIP           = 202,
 364         NDR_COMPRESSION_XPRESS          = 203,
 365         NDR_COMPRESSION_WIN2K3_LZ77_DIRECT2     = 204, /* Unimplemented */
 366         NDR_COMPRESSION_INVALID         = 255,
 367 };
 368
 369 #define NDR_PULL_CHECK_FLAGS(ndr, ndr_flags) do { \
 370         if (unlikely((ndr_flags) & ~(NDR_SCALARS|NDR_BUFFERS))) { \
 371                 return ndr_pull_error(ndr, NDR_ERR_FLAGS, "Invalid pull struct ndr_flags 0x%"PRI_NDR_FLAGS_TYPE, ndr_flags); \
 372         } \
 373 } while (0)
 374
 375 #define NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags) do { \
 376         if ((ndr_flags) & ~(NDR_SCALARS|NDR_BUFFERS)) \
 377                 return ndr_push_error(ndr, NDR_ERR_FLAGS, "Invalid push struct ndr_flags 0x%"PRI_NDR_FLAGS_TYPE, ndr_flags); \
 378 } while (0)
 379
 380 #define NDR_PULL_CHECK_FN_FLAGS(ndr, flags) do { \
 381         if ((flags) & ~(NDR_BOTH|NDR_SET_VALUES)) { \
 382                 return ndr_pull_error(ndr, NDR_ERR_FLAGS, "Invalid fn pull flags 0x%"PRI_NDR_FLAGS_TYPE, flags); \
 383         } \
 384 } while (0)
 385
 386 #define NDR_PUSH_CHECK_FN_FLAGS(ndr, flags) do { \
 387         if ((flags) & ~(NDR_BOTH|NDR_SET_VALUES)) \
 388                 return ndr_push_error(ndr, NDR_ERR_FLAGS, "Invalid fn push flags 0x%"PRI_NDR_FLAGS_TYPE, flags); \
 389 } while (0)
 390
 391 #define NDR_PULL_NEED_BYTES(ndr, n) do { \
 392         if (unlikely(\
 393                 (n) > ndr->data_size || \
 394                 ndr->offset + (n) > ndr->data_size || \
 395                 ndr->offset + (n) < ndr->offset)) { \
 396                 if (ndr->flags & LIBNDR_FLAG_INCOMPLETE_BUFFER) { \
 397                         uint32_t _available = ndr->data_size - ndr->offset; \
 398                         uint32_t _missing = n - _available; \
 399                         ndr->relative_highest_offset = _missing; \
 400                 } \
 401                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE, "Pull bytes %zu (%s)", (size_t)n, __location__); \
 402         } \
 403 } while(0)
 404
 405 #define NDR_ALIGN(ndr, n) ndr_align_size(ndr->offset, n)
 406
 407 #define NDR_ROUND(size, n) (((size)+((n)-1)) & ~((n)-1))
 408
 409 #define NDR_PULL_ALIGN(ndr, n) do { \
 410         if (unlikely(!(ndr->flags & LIBNDR_FLAG_NOALIGN))) {    \
 411                 if (unlikely(ndr->flags & LIBNDR_FLAG_PAD_CHECK)) {     \
 412                         ndr_check_padding(ndr, n); \
 413                 } \
 414                 if(unlikely( \
 415                         ((ndr->offset + (n-1)) & (~(n-1))) < ndr->offset)) {\
 416                         return ndr_pull_error( \
 417                                 ndr, \
 418                                 NDR_ERR_BUFSIZE, \
 419                                 "Pull align (overflow) %zu", (size_t)n); \
 420                 } \
 421                 ndr->offset = (ndr->offset + (n-1)) & ~(n-1); \
 422         } \
 423         if (unlikely(ndr->offset > ndr->data_size)) {                   \
 424                 if (ndr->flags & LIBNDR_FLAG_INCOMPLETE_BUFFER) { \
 425                         uint32_t _missing = ndr->offset - ndr->data_size; \
 426                         ndr->relative_highest_offset = _missing; \
 427                 } \
 428                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE, "Pull align %zu", (size_t)n); \
 429         } \
 430 } while(0)
 431
 432 #define NDR_PUSH_NEED_BYTES(ndr, n) NDR_CHECK(ndr_push_expand(ndr, n))
 433
 434 #define NDR_PUSH_ALIGN(ndr, n) do { \
 435         if (likely(!(ndr->flags & LIBNDR_FLAG_NOALIGN))) {      \
 436                 uint32_t _pad = ((ndr->offset + (n-1)) & ~(n-1)) - ndr->offset; \
 437                 while (_pad--) NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 0)); \
 438         } \
 439 } while(0)
 440
 441 #define NDR_RECURSION_CHECK(ndr, d) do { \
 442         uint32_t _ndr_min_ = (d); \
 443         if (ndr->global_max_recursion &&  ndr->global_max_recursion < (d)) { \
 444                 _ndr_min_ = ndr->global_max_recursion; \
 445         } \
 446         ndr->recursion_depth++; \
 447         if (unlikely(ndr->recursion_depth > _ndr_min_)) { \
 448                 return ndr_pull_error( \
 449                         ndr, \
 450                         NDR_ERR_MAX_RECURSION_EXCEEDED, \
 451                         "Depth of recursion exceeds (%u)", \
 452                         (unsigned) d); \
 453         } \
 454 } while (0)
 455
 456 #define NDR_RECURSION_UNWIND(ndr) do { \
 457         if (unlikely(ndr->recursion_depth == 0)) { \
 458                 return ndr_pull_error( \
 459                         ndr, \
 460                         NDR_ERR_UNDERFLOW, \
 461                         "ndr_pull.recursion_depth is 0"); \
 462         } \
 463         ndr->recursion_depth--; \
 464 } while (0)
 465
 466 /* these are used to make the error checking on each element in libndr
 467    less tedious, hopefully making the code more readable */
 468 #define NDR_CHECK(call) do { \
 469         enum ndr_err_code _status; \
 470         _status = call; \
 471         if (unlikely(!NDR_ERR_CODE_IS_SUCCESS(_status))) {      \
 472                 return _status; \
 473         } \
 474 } while (0)
 475
 476 /* if the call fails then free the ndr pointer */
 477 #define NDR_CHECK_FREE(call) do { \
 478         enum ndr_err_code _status; \
 479         _status = call; \
 480         if (unlikely(!NDR_ERR_CODE_IS_SUCCESS(_status))) {      \
 481                 TALLOC_FREE(ndr);                \
 482                 return _status; \
 483         } \
 484 } while (0)
 485
 486 #define NDR_PULL_GET_MEM_CTX(ndr) (ndr->current_mem_ctx)
 487
 488 #define NDR_PULL_SET_MEM_CTX(ndr, mem_ctx, flgs) do {\
 489         if ( (flgs == 0) || (ndr->flags & flgs) ) {\
 490                 if (!(mem_ctx)) {\
 491                         return ndr_pull_error(ndr, NDR_ERR_ALLOC, "NDR_PULL_SET_MEM_CTX(NULL): %s\n", __location__); \
 492                 }\
 493                 ndr->current_mem_ctx = discard_const(mem_ctx);\
 494         }\
 495 } while(0)
 496
 497 #define _NDR_PULL_FIX_CURRENT_MEM_CTX(ndr) do {\
 498         if (!ndr->current_mem_ctx) {\
 499                 ndr->current_mem_ctx = talloc_new(ndr);\
 500                 if (!ndr->current_mem_ctx) {\
 501                         return ndr_pull_error(ndr, NDR_ERR_ALLOC, "_NDR_PULL_FIX_CURRENT_MEM_CTX() failed: %s\n", __location__); \
 502                 }\
 503         }\
 504 } while(0)
 505
 506 #define NDR_PULL_ALLOC(ndr, s) do { \
 507         _NDR_PULL_FIX_CURRENT_MEM_CTX(ndr);\
 508         (s) = talloc_ptrtype(ndr->current_mem_ctx, (s)); \
 509         if (unlikely(!(s))) return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Alloc %s failed: %s\n", # s, __location__); \
 510 } while (0)
 511
 512 #define NDR_PULL_ALLOC_N(ndr, s, n) do { \
 513         _NDR_PULL_FIX_CURRENT_MEM_CTX(ndr);\
 514         (s) = talloc_array_ptrtype(ndr->current_mem_ctx, (s), n); \
 515         if (unlikely(!(s))) return ndr_pull_error(ndr, NDR_ERR_ALLOC, "Alloc %zu * %s failed: %s\n", (size_t)n, # s, __location__); \
 516 } while (0)
 517
 518 #define NDR_PUSH_ALLOC(ndr, s) do { \
 519        (s) = talloc_ptrtype(ndr, (s)); \
 520        if (unlikely(!(s))) return ndr_push_error(ndr, NDR_ERR_ALLOC, "push alloc %s failed: %s\n", # s, __location__); \
 521 } while (0)
 522
 523 #define NDR_ZERO_STRUCT(x) ndr_zero_memory(&(x), sizeof(x))
 524 #define NDR_ZERO_STRUCTP(x) do { \
 525         if ((x) != NULL) { \
 526                 ndr_zero_memory((x), sizeof(*(x))); \
 527         } \
 528 } while(0)
 529
 530 /* these are used when generic fn pointers are needed for ndr push/pull fns */
 531 typedef enum ndr_err_code (*ndr_push_flags_fn_t)(struct ndr_push *, ndr_flags_type ndr_flags, const void *);
 532 typedef enum ndr_err_code (*ndr_pull_flags_fn_t)(struct ndr_pull *, ndr_flags_type ndr_flags, void *);
 533 typedef void (*ndr_print_fn_t)(struct ndr_print *, const char *, const void *);
 534 typedef void (*ndr_print_function_t)(struct ndr_print *, const char *, ndr_flags_type, const void *);
 535
 536 #include "libcli/util/error.h"
 537 #include "librpc/gen_ndr/misc.h"
 538
 539 extern const struct ndr_syntax_id ndr_transfer_syntax_ndr;
 540 extern const struct ndr_syntax_id ndr_transfer_syntax_ndr64;
 541 extern const struct ndr_syntax_id ndr_syntax_id_null;
 542
 543 struct ndr_interface_call_pipe {
 544         const char *name;
 545         const char *chunk_struct_name;
 546         size_t chunk_struct_size;
 547         ndr_push_flags_fn_t ndr_push;
 548         ndr_pull_flags_fn_t ndr_pull;
 549         ndr_print_fn_t ndr_print;
 550 };
 551
 552 struct ndr_interface_call_pipes {
 553         uint32_t num_pipes;
 554         const struct ndr_interface_call_pipe *pipes;
 555 };
 556
 557 struct ndr_interface_call {
 558         const char *name;
 559         size_t struct_size;
 560         ndr_push_flags_fn_t ndr_push;
 561         ndr_pull_flags_fn_t ndr_pull;
 562         ndr_print_function_t ndr_print;
 563         struct ndr_interface_call_pipes in_pipes;
 564         struct ndr_interface_call_pipes out_pipes;
 565 };
 566
 567 struct ndr_interface_public_struct {
 568         const char *name;
 569         size_t struct_size;
 570         ndr_push_flags_fn_t ndr_push;
 571         ndr_pull_flags_fn_t ndr_pull;
 572         ndr_print_function_t ndr_print;
 573 };
 574
 575 struct ndr_interface_string_array {
 576         uint32_t count;
 577         const char * const *names;
 578 };
 579
 580 struct ndr_interface_table {
 581         const char *name;
 582         struct ndr_syntax_id syntax_id;
 583         const char *helpstring;
 584         uint32_t num_calls;
 585         const struct ndr_interface_call *calls;
 586         uint32_t num_public_structs;
 587         const struct ndr_interface_public_struct *public_structs;
 588         const struct ndr_interface_string_array *endpoints;
 589         const struct ndr_interface_string_array *authservices;
 590 };
 591
 592 struct ndr_interface_list {
 593         struct ndr_interface_list *prev, *next;
 594         const struct ndr_interface_table *table;
 595 };
 596
 597 struct sockaddr_storage;
 598
 599 /*********************************************************************
 600  Map an NT error code from a NDR error code.
 601 *********************************************************************/
 602 NTSTATUS ndr_map_error2ntstatus(enum ndr_err_code ndr_err);
 603 int ndr_map_error2errno(enum ndr_err_code ndr_err);
 604 const char *ndr_map_error2string(enum ndr_err_code ndr_err);
 605 #define ndr_errstr ndr_map_error2string
 606
 607 /* FIXME: Use represent_as instead */
 608 struct dom_sid;
 609 enum ndr_err_code ndr_push_dom_sid2(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dom_sid *sid);
 610 enum ndr_err_code ndr_pull_dom_sid2(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dom_sid *sid);
 611 void ndr_print_dom_sid2(struct ndr_print *ndr, const char *name, const struct dom_sid *sid);
 612 enum ndr_err_code ndr_push_dom_sid28(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dom_sid *sid);
 613 enum ndr_err_code ndr_pull_dom_sid28(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dom_sid *sid);
 614 void ndr_print_dom_sid28(struct ndr_print *ndr, const char *name, const struct dom_sid *sid);
 615 size_t ndr_size_dom_sid28(const struct dom_sid *sid, libndr_flags flags);
 616 enum ndr_err_code ndr_push_dom_sid0(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dom_sid *sid);
 617 enum ndr_err_code ndr_pull_dom_sid0(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dom_sid *sid);
 618 void ndr_print_dom_sid0(struct ndr_print *ndr, const char *name, const struct dom_sid *sid);
 619 size_t ndr_size_dom_sid0(const struct dom_sid *sid, libndr_flags flags);
 620 void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid);
 621 void ndr_print_sockaddr_storage(struct ndr_print *ndr, const char *name, const struct sockaddr_storage *ss);
 622 void ndr_zero_memory(void *ptr, size_t len);
 623 bool ndr_syntax_id_equal(const struct ndr_syntax_id *i1, const struct ndr_syntax_id *i2);
 624
 625 struct ndr_syntax_id_buf { char buf[39 /*GUID*/ + 3 /* "/0x" */ + 8]; };
 626 char *ndr_syntax_id_buf_string(
 627         const struct ndr_syntax_id *id, struct ndr_syntax_id_buf *buf);
 628 char *ndr_syntax_id_to_string(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *id);
 629
 630 bool ndr_syntax_id_from_string(const char *s, struct ndr_syntax_id *id);
 631 enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p, ndr_push_flags_fn_t fn);
 632 enum ndr_err_code ndr_push_struct_into_fixed_blob(DATA_BLOB *blob,
 633                                                   const void *p,
 634                                                   ndr_push_flags_fn_t fn);
 635 enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, uint32_t level, ndr_push_flags_fn_t fn);
 636 size_t ndr_size_struct(const void *p, libndr_flags flags, ndr_push_flags_fn_t push);
 637 size_t ndr_size_union(const void *p, libndr_flags flags, uint32_t level, ndr_push_flags_fn_t push);
 638 uint32_t ndr_push_get_relative_base_offset(struct ndr_push *ndr);
 639 void ndr_push_restore_relative_base_offset(struct ndr_push *ndr, uint32_t offset);
 640 enum ndr_err_code ndr_push_setup_relative_base_offset1(struct ndr_push *ndr, const void *p, uint32_t offset);
 641 enum ndr_err_code ndr_push_setup_relative_base_offset2(struct ndr_push *ndr, const void *p);
 642 enum ndr_err_code ndr_push_relative_ptr1(struct ndr_push *ndr, const void *p);
 643 enum ndr_err_code ndr_push_short_relative_ptr1(struct ndr_push *ndr, const void *p);
 644 enum ndr_err_code ndr_push_relative_ptr2_start(struct ndr_push *ndr, const void *p);
 645 enum ndr_err_code ndr_push_relative_ptr2_end(struct ndr_push *ndr, const void *p);
 646 enum ndr_err_code ndr_push_short_relative_ptr2(struct ndr_push *ndr, const void *p);
 647 uint32_t ndr_pull_get_relative_base_offset(struct ndr_pull *ndr);
 648 void ndr_pull_restore_relative_base_offset(struct ndr_pull *ndr, uint32_t offset);
 649 enum ndr_err_code ndr_pull_setup_relative_base_offset1(struct ndr_pull *ndr, const void *p, uint32_t offset);
 650 enum ndr_err_code ndr_pull_setup_relative_base_offset2(struct ndr_pull *ndr, const void *p);
 651 enum ndr_err_code ndr_pull_relative_ptr1(struct ndr_pull *ndr, const void *p, uint32_t rel_offset);
 652 enum ndr_err_code ndr_pull_relative_ptr2(struct ndr_pull *ndr, const void *p);
 653 enum ndr_err_code ndr_pull_relative_ptr_short(struct ndr_pull *ndr, uint16_t *v);
 654 size_t ndr_align_size(uint32_t offset, size_t n);
 655 struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
 656 enum ndr_err_code ndr_pull_append(struct ndr_pull *ndr, DATA_BLOB *blob);
 657 enum ndr_err_code ndr_pull_pop(struct ndr_pull *ndr);
 658 enum ndr_err_code ndr_pull_advance(struct ndr_pull *ndr, uint32_t size);
 659 struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx);
 660 DATA_BLOB ndr_push_blob(struct ndr_push *ndr);
 661 enum ndr_err_code ndr_push_expand(struct ndr_push *ndr, uint32_t extra_size);
 662 void ndr_print_debug_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 663 void ndr_print_debugc_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 664 void ndr_print_printf_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 665 void ndr_print_string_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 666 bool ndr_print_debug(int level,
 667                      ndr_print_fn_t fn,
 668                      const char *name,
 669                      const void *ptr,
 670                      const char *location,
 671                      const char *function);
 672 void ndr_print_debugc(int dbgc_class,
 673                       ndr_print_fn_t fn,
 674                       const char *name,
 675                       const void *ptr);
 676 void ndr_print_union_debug(ndr_print_fn_t fn,
 677                            const char *name,
 678                            uint32_t level,
 679                            const void *ptr);
 680 void ndr_print_function_debug(ndr_print_function_t fn,
 681                               const char *name,
 682                               ndr_flags_type flags,
 683                               const void *ptr);
 684 char *ndr_print_struct_string(TALLOC_CTX *mem_ctx,
 685                               ndr_print_fn_t fn,
 686                               const char *name,
 687                               const void *ptr);
 688 char *ndr_print_struct_secret_string(TALLOC_CTX *mem_ctx,
 689                                      ndr_print_fn_t fn,
 690                                      const char *name,
 691                                      const void *ptr);
 692 char *ndr_print_union_string(TALLOC_CTX *mem_ctx,
 693                              ndr_print_fn_t fn,
 694                              const char *name,
 695                              uint32_t level,
 696                              const void *ptr);
 697 char *ndr_print_union_secret_string(TALLOC_CTX *mem_ctx,
 698                                     ndr_print_fn_t fn,
 699                                     const char *name,
 700                                     uint32_t level,
 701                                     const void *ptr);
 702 char *ndr_print_function_string(TALLOC_CTX *mem_ctx,
 703                                 ndr_print_function_t fn,
 704                                 const char *name,
 705                                 ndr_flags_type flags,
 706                                 const void *ptr);
 707 char *ndr_print_function_secret_string(TALLOC_CTX *mem_ctx,
 708                                        ndr_print_function_t fn,
 709                                        const char *name,
 710                                        ndr_flags_type flags,
 711                                        const void *ptr);
 712 void ndr_set_flags(libndr_flags *pflags, libndr_flags new_flags);
 713 enum ndr_err_code _ndr_pull_error(struct ndr_pull *ndr,
 714                                   enum ndr_err_code ndr_err,
 715                                   const char *function,
 716                                   const char *location,
 717                                   const char *format, ...) PRINTF_ATTRIBUTE(5,6);
 718 #define ndr_pull_error(ndr, ndr_err, ...) \
 719         _ndr_pull_error(ndr, \
 720                         ndr_err,      \
 721                         __FUNCTION__, \
 722                         __location__, \
 723                         __VA_ARGS__)
 724 enum ndr_err_code _ndr_push_error(struct ndr_push *ndr,
 725                                   enum ndr_err_code ndr_err,
 726                                   const char *function,
 727                                   const char *location,
 728                                   const char *format, ...)  PRINTF_ATTRIBUTE(5,6);
 729 #define ndr_push_error(ndr, ndr_err, ...) \
 730         _ndr_push_error(ndr, \
 731                         ndr_err, \
 732                         __FUNCTION__, \
 733                         __location__, \
 734                         __VA_ARGS__)
 735 enum ndr_err_code ndr_pull_subcontext_start(struct ndr_pull *ndr,
 736                                    struct ndr_pull **_subndr,
 737                                    size_t header_size,
 738                                    ssize_t size_is);
 739 enum ndr_err_code ndr_pull_subcontext_end(struct ndr_pull *ndr,
 740                                  struct ndr_pull *subndr,
 741                                  size_t header_size,
 742                                  ssize_t size_is);
 743 enum ndr_err_code ndr_push_subcontext_start(struct ndr_push *ndr,
 744                                    struct ndr_push **_subndr,
 745                                    size_t header_size,
 746                                    ssize_t size_is);
 747 enum ndr_err_code ndr_push_subcontext_end(struct ndr_push *ndr,
 748                                  struct ndr_push *subndr,
 749                                  size_t header_size,
 750                                  ssize_t size_is);
 751 enum ndr_err_code ndr_token_store(TALLOC_CTX *mem_ctx,
 752                          struct ndr_token_list *list,
 753                          const void *key,
 754                          uint32_t value);
 755 enum ndr_err_code ndr_token_peek_cmp_fn(struct ndr_token_list *list,
 756                                         const void *key,
 757                                         uint32_t *v,
 758                                         int (*_cmp_fn)(const void *,
 759                                                        const void *));
 760 enum ndr_err_code ndr_token_retrieve(struct ndr_token_list *list, const void *key, uint32_t *v);
 761 enum ndr_err_code ndr_token_peek(struct ndr_token_list *list, const void *key, uint32_t *v);
 762 enum ndr_err_code ndr_pull_array_size(struct ndr_pull *ndr, const void *p);
 763 enum ndr_err_code ndr_get_array_size(struct ndr_pull *ndr, const void *p, uint32_t *size);
 764 enum ndr_err_code ndr_steal_array_size(struct ndr_pull *ndr, const void *p, uint32_t *size);
 765 enum ndr_err_code ndr_check_array_size(struct ndr_pull *ndr, const void *p, uint32_t size);
 766 enum ndr_err_code ndr_check_steal_array_size(struct ndr_pull *ndr, const void *p, uint32_t size);
 767 enum ndr_err_code ndr_pull_array_length(struct ndr_pull *ndr, const void *p);
 768 enum ndr_err_code ndr_get_array_length(struct ndr_pull *ndr, const void *p, uint32_t *length);
 769 enum ndr_err_code ndr_steal_array_length(struct ndr_pull *ndr, const void *p, uint32_t *length);
 770 enum ndr_err_code ndr_check_array_length(struct ndr_pull *ndr, const void *p, uint32_t length);
 771 enum ndr_err_code ndr_check_steal_array_length(struct ndr_pull *ndr, const void *p, uint32_t length);
 772 enum ndr_err_code ndr_push_pipe_chunk_trailer(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t count);
 773 enum ndr_err_code ndr_check_pipe_chunk_trailer(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t count);
 774 enum ndr_err_code ndr_push_set_switch_value(struct ndr_push *ndr, const void *p, uint32_t val);
 775 enum ndr_err_code ndr_pull_set_switch_value(struct ndr_pull *ndr, const void *p, uint32_t val);
 776 enum ndr_err_code ndr_print_set_switch_value(struct ndr_print *ndr, const void *p, uint32_t val);
 777 /* retrieve a switch value (for push) and remove it from the list */
 778 enum ndr_err_code ndr_push_steal_switch_value(struct ndr_push *ndr,
 779                                               const void *p,
 780                                               uint32_t *v);
 781 /* retrieve a switch value and remove it from the list */
 782 uint32_t ndr_print_steal_switch_value(struct ndr_print *ndr, const void *p);
 783 /* retrieve a switch value and remove it from the list */
 784 enum ndr_err_code ndr_pull_steal_switch_value(struct ndr_pull *ndr,
 785                                               const void *p,
 786                                               uint32_t *v);
 787 enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, ndr_pull_flags_fn_t fn);
 788 enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, ndr_pull_flags_fn_t fn);
 789 _PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_noalloc(const uint8_t *buf,
 790                                                         size_t buflen,
 791                                                         void *p,
 792                                                         ndr_pull_flags_fn_t fn,
 793                                                         size_t *consumed);
 794 enum ndr_err_code ndr_pull_struct_blob_all_noalloc(const DATA_BLOB *blob,
 795                                                    void *p, ndr_pull_flags_fn_t fn);
 796 enum ndr_err_code ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, uint32_t level, ndr_pull_flags_fn_t fn);
 797 enum ndr_err_code ndr_pull_union_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, uint32_t level, ndr_pull_flags_fn_t fn);
 798
 799 enum ndr_err_code _ndr_deepcopy_struct(ndr_push_flags_fn_t push_fn,
 800                                        const void *src,
 801                                        ndr_pull_flags_fn_t pull_fn,
 802                                        TALLOC_CTX *dst_mem, void *dst);
 803 #define ndr_deepcopy_struct(type, src, dst_mem, dst) \
 804         _ndr_deepcopy_struct((ndr_push_flags_fn_t)ndr_push_ ## type, \
 805                              src, \
 806                              (ndr_pull_flags_fn_t)ndr_pull_ ## type, \
 807                              dst_mem, dst)
 808
 809 /* from libndr_basic.h */
 810 #define NDR_SCALAR_PROTO(name, type) \
 811 enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, ndr_flags_type ndr_flags, type v); \
 812 enum ndr_err_code ndr_pull_ ## name(struct ndr_pull *ndr, ndr_flags_type ndr_flags, type *v); \
 813 void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, type v);
 814
 815 #define NDR_SCALAR_PTR_PROTO(name, type) \
 816 enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, ndr_flags_type ndr_flags, const type *v); \
 817 enum ndr_err_code ndr_pull_ ## name(struct ndr_pull *ndr, ndr_flags_type ndr_flags, type **v); \
 818 void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, const type *v);
 819
 820 #define NDR_BUFFER_PROTO(name, type) \
 821 enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, ndr_flags_type ndr_flags, const type *v); \
 822 enum ndr_err_code ndr_pull_ ## name(struct ndr_pull *ndr, ndr_flags_type ndr_flags, type *v); \
 823 void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, const type *v);
 824
 825 NDR_SCALAR_PROTO(uint8, uint8_t)
 826 NDR_SCALAR_PROTO(int8, int8_t)
 827 NDR_SCALAR_PROTO(uint16, uint16_t)
 828 NDR_SCALAR_PROTO(int16, int16_t)
 829 NDR_SCALAR_PROTO(uint1632, uint16_t)
 830 NDR_SCALAR_PROTO(uint32, uint32_t)
 831 NDR_SCALAR_PROTO(uint3264, uint32_t)
 832 NDR_SCALAR_PROTO(int32, int32_t)
 833 NDR_SCALAR_PROTO(int3264, int32_t)
 834 NDR_SCALAR_PROTO(udlong, uint64_t)
 835 NDR_SCALAR_PROTO(udlongr, uint64_t)
 836 NDR_SCALAR_PROTO(dlong, int64_t)
 837 NDR_SCALAR_PROTO(hyper, uint64_t)
 838 NDR_SCALAR_PROTO(int64, int64_t)
 839 NDR_SCALAR_PROTO(pointer, void *)
 840 NDR_SCALAR_PROTO(time_t, time_t)
 841 NDR_SCALAR_PROTO(uid_t, uid_t)
 842 NDR_SCALAR_PROTO(gid_t, gid_t)
 843 NDR_SCALAR_PROTO(NTSTATUS, NTSTATUS)
 844 NDR_SCALAR_PROTO(WERROR, WERROR)
 845 NDR_SCALAR_PROTO(HRESULT, HRESULT)
 846 NDR_SCALAR_PROTO(NTTIME, NTTIME)
 847 NDR_SCALAR_PROTO(NTTIME_1sec, NTTIME)
 848 NDR_SCALAR_PROTO(NTTIME_hyper, NTTIME)
 849 NDR_SCALAR_PROTO(DATA_BLOB, DATA_BLOB)
 850 NDR_SCALAR_PROTO(ipv4address, const char *)
 851 NDR_SCALAR_PROTO(ipv6address, const char *)
 852 NDR_SCALAR_PROTO(string, const char *)
 853 NDR_SCALAR_PROTO(u16string, const unsigned char *)
 854 NDR_SCALAR_PROTO(double, double)
 855
 856 enum ndr_err_code ndr_pull_policy_handle(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct policy_handle *r);
 857 enum ndr_err_code ndr_push_policy_handle(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct policy_handle *r);
 858 void ndr_print_policy_handle(struct ndr_print *ndr, const char *name, const struct policy_handle *r);
 859 bool ndr_policy_handle_empty(const struct policy_handle *h);
 860 #define is_valid_policy_hnd(hnd) (!ndr_policy_handle_empty(hnd))
 861 bool ndr_policy_handle_equal(const struct policy_handle *hnd1,
 862                          const struct policy_handle *hnd2);
 863
 864 void ndr_check_padding(struct ndr_pull *ndr, size_t n);
 865 enum ndr_err_code ndr_pull_generic_ptr(struct ndr_pull *ndr, uint32_t *v);
 866 enum ndr_err_code ndr_pull_ref_ptr(struct ndr_pull *ndr, uint32_t *v);
 867 enum ndr_err_code ndr_pull_bytes(struct ndr_pull *ndr, uint8_t *data, uint32_t n);
 868 enum ndr_err_code ndr_pull_array_uint8(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *data, uint32_t n);
 869 enum ndr_err_code ndr_push_align(struct ndr_push *ndr, size_t size);
 870 enum ndr_err_code ndr_pull_align(struct ndr_pull *ndr, size_t size);
 871 enum ndr_err_code ndr_push_union_align(struct ndr_push *ndr, size_t size);
 872 enum ndr_err_code ndr_pull_union_align(struct ndr_pull *ndr, size_t size);
 873 enum ndr_err_code ndr_push_trailer_align(struct ndr_push *ndr, size_t size);
 874 enum ndr_err_code ndr_pull_trailer_align(struct ndr_pull *ndr, size_t size);
 875 enum ndr_err_code ndr_push_bytes(struct ndr_push *ndr, const uint8_t *data, uint32_t n);
 876 enum ndr_err_code ndr_push_zero(struct ndr_push *ndr, uint32_t n);
 877 enum ndr_err_code ndr_push_array_uint8(struct ndr_push *ndr, ndr_flags_type ndr_flags, const uint8_t *data, uint32_t n);
 878 enum ndr_err_code ndr_push_unique_ptr(struct ndr_push *ndr, const void *p);
 879 enum ndr_err_code ndr_push_full_ptr(struct ndr_push *ndr, const void *p);
 880 enum ndr_err_code ndr_push_ref_ptr(struct ndr_push *ndr);
 881 void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type);
 882 void ndr_print_null(struct ndr_print *ndr);
 883 void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type, const char *val, uint32_t value);
 884 void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint64_t flag, uint64_t value);
 885 void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p);
 886 void ndr_print_union(struct ndr_print *ndr, const char *name, int level, const char *type);
 887 void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level);
 888 void ndr_print_array_uint8(struct ndr_print *ndr, const char *name, const uint8_t *data, uint32_t count);
 889 uint32_t ndr_size_DATA_BLOB(int ret, const DATA_BLOB *data, ndr_flags_type flags);
 890
 891 /* strings */
 892 uint32_t ndr_charset_length(const void *var, charset_t chset);
 893 size_t ndr_string_array_size(struct ndr_push *ndr, const char *s);
 894 uint32_t ndr_size_string(int ret, const char * const* string, ndr_flags_type flags);
 895 enum ndr_err_code ndr_pull_string_array(struct ndr_pull *ndr, ndr_flags_type ndr_flags, const char ***_a);
 896 enum ndr_err_code ndr_push_string_array(struct ndr_push *ndr, ndr_flags_type ndr_flags, const char **a);
 897 void ndr_print_string_array(struct ndr_print *ndr, const char *name, const char **a);
 898 size_t ndr_size_string_array(const char **a, uint32_t count, libndr_flags flags);
 899 uint32_t ndr_string_length(const void *_var, uint32_t element_size);
 900 enum ndr_err_code ndr_check_string_terminator(struct ndr_pull *ndr, uint32_t count, uint32_t element_size);
 901 enum ndr_err_code ndr_pull_charset(struct ndr_pull *ndr, ndr_flags_type ndr_flags, const char **var, uint32_t length, uint8_t byte_mul, charset_t chset);
 902 enum ndr_err_code ndr_pull_charset_to_null(struct ndr_pull *ndr, ndr_flags_type ndr_flags, const char **var, uint32_t length, uint8_t byte_mul, charset_t chset);
 903 enum ndr_err_code ndr_push_charset(struct ndr_push *ndr, ndr_flags_type ndr_flags, const char *var, uint32_t length, uint8_t byte_mul, charset_t chset);
 904 enum ndr_err_code ndr_push_charset_to_null(struct ndr_push *ndr, ndr_flags_type ndr_flags, const char *var, uint32_t length, uint8_t byte_mul, charset_t chset);
 905
 906 /* GUIDs */
 907 bool GUID_equal(const struct GUID *u1, const struct GUID *u2);
 908 struct GUID_ndr_buf { uint8_t buf[16]; };
 909 void GUID_to_ndr_buf(const struct GUID *guid, struct GUID_ndr_buf *buf);
 910 NTSTATUS GUID_to_ndr_blob(const struct GUID *guid, TALLOC_CTX *mem_ctx, DATA_BLOB *b);
 911 NTSTATUS GUID_from_ndr_blob(const DATA_BLOB *b, struct GUID *guid);
 912 NTSTATUS GUID_from_data_blob(const DATA_BLOB *s, struct GUID *guid);
 913 NTSTATUS GUID_from_string(const char *s, struct GUID *guid);
 914 struct GUID GUID_zero(void);
 915 bool GUID_all_zero(const struct GUID *u);
 916 int GUID_compare(const struct GUID *u1, const struct GUID *u2);
 917 char *GUID_string(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 918 char *GUID_string2(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 919 char *GUID_hexstring(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 920 struct GUID GUID_random(void);
 921
 922 /* Format is "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" */
 923  /* 32 chars + 4 ' ' + \0 + 2 for adding {}  */
 924 struct GUID_txt_buf { char buf[39]; };
 925 _PUBLIC_ char* GUID_buf_string(const struct GUID *guid,
 926                                struct GUID_txt_buf *dst);
 927
 928 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *v);
 929 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *v);
 930 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint32(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *v);
 931 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint1632(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *v);
 932 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint8(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint8_t v);
 933 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint16(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t v);
 934 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t v);
 935 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint1632(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t v);
 936
 937 _PUBLIC_ void ndr_print_bool(struct ndr_print *ndr, const char *name, const bool b);
 938
 939 _PUBLIC_ enum ndr_err_code ndr_push_timespec(struct ndr_push *ndr,
 940                                              ndr_flags_type ndr_flags,
 941                                              const struct timespec *t);
 942 _PUBLIC_ enum ndr_err_code ndr_pull_timespec(struct ndr_pull *ndr,
 943                                              ndr_flags_type ndr_flags,
 944                                              struct timespec *t);
 945 _PUBLIC_ void ndr_print_timespec(struct ndr_print *ndr, const char *name,
 946                                  const struct timespec *t);
 947
 948 _PUBLIC_ enum ndr_err_code ndr_push_timeval(struct ndr_push *ndr,
 949                                             ndr_flags_type ndr_flags,
 950                                             const struct timeval *t);
 951 _PUBLIC_ enum ndr_err_code ndr_pull_timeval(struct ndr_pull *ndr,
 952                                             ndr_flags_type ndr_flags,
 953                                             struct timeval *t);
 954 _PUBLIC_ void ndr_print_timeval(struct ndr_print *ndr, const char *name,
 955                                 const struct timeval *t);
 956
 957 _PUBLIC_ void ndr_print_libndr_flags(struct ndr_print *ndr, const char *name,
 958                                        libndr_flags flags);
 959
 960
 961 #endif /* __LIBNDR_H__ */