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 ((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
 519 #define NDR_PUSH_ALLOC_SIZE(ndr, s, size) do { \
 520        (s) = talloc_array(ndr, uint8_t, size); \
 521        if (unlikely(!(s))) return ndr_push_error(ndr, NDR_ERR_ALLOC, "push alloc %zu failed: %s\n", (size_t)size, __location__); \
 522 } while (0)
 523
 524 #define NDR_PUSH_ALLOC(ndr, s) do { \
 525        (s) = talloc_ptrtype(ndr, (s)); \
 526        if (unlikely(!(s))) return ndr_push_error(ndr, NDR_ERR_ALLOC, "push alloc %s failed: %s\n", # s, __location__); \
 527 } while (0)
 528
 529 #define NDR_ZERO_STRUCT(x) ndr_zero_memory(&(x), sizeof(x))
 530 #define NDR_ZERO_STRUCTP(x) do { \
 531         if ((x) != NULL) { \
 532                 ndr_zero_memory((x), sizeof(*(x))); \
 533         } \
 534 } while(0)
 535
 536 /* these are used when generic fn pointers are needed for ndr push/pull fns */
 537 typedef enum ndr_err_code (*ndr_push_flags_fn_t)(struct ndr_push *, ndr_flags_type ndr_flags, const void *);
 538 typedef enum ndr_err_code (*ndr_pull_flags_fn_t)(struct ndr_pull *, ndr_flags_type ndr_flags, void *);
 539 typedef void (*ndr_print_fn_t)(struct ndr_print *, const char *, const void *);
 540 typedef void (*ndr_print_function_t)(struct ndr_print *, const char *, ndr_flags_type, const void *);
 541
 542 #include "../libcli/util/error.h"
 543 #include "librpc/gen_ndr/misc.h"
 544
 545 extern const struct ndr_syntax_id ndr_transfer_syntax_ndr;
 546 extern const struct ndr_syntax_id ndr_transfer_syntax_ndr64;
 547 extern const struct ndr_syntax_id ndr_syntax_id_null;
 548
 549 struct ndr_interface_call_pipe {
 550         const char *name;
 551         const char *chunk_struct_name;
 552         size_t chunk_struct_size;
 553         ndr_push_flags_fn_t ndr_push;
 554         ndr_pull_flags_fn_t ndr_pull;
 555         ndr_print_fn_t ndr_print;
 556 };
 557
 558 struct ndr_interface_call_pipes {
 559         uint32_t num_pipes;
 560         const struct ndr_interface_call_pipe *pipes;
 561 };
 562
 563 struct ndr_interface_call {
 564         const char *name;
 565         size_t struct_size;
 566         ndr_push_flags_fn_t ndr_push;
 567         ndr_pull_flags_fn_t ndr_pull;
 568         ndr_print_function_t ndr_print;
 569         struct ndr_interface_call_pipes in_pipes;
 570         struct ndr_interface_call_pipes out_pipes;
 571 };
 572
 573 struct ndr_interface_public_struct {
 574         const char *name;
 575         size_t struct_size;
 576         ndr_push_flags_fn_t ndr_push;
 577         ndr_pull_flags_fn_t ndr_pull;
 578         ndr_print_function_t ndr_print;
 579 };
 580
 581 struct ndr_interface_string_array {
 582         uint32_t count;
 583         const char * const *names;
 584 };
 585
 586 struct ndr_interface_table {
 587         const char *name;
 588         struct ndr_syntax_id syntax_id;
 589         const char *helpstring;
 590         uint32_t num_calls;
 591         const struct ndr_interface_call *calls;
 592         uint32_t num_public_structs;
 593         const struct ndr_interface_public_struct *public_structs;
 594         const struct ndr_interface_string_array *endpoints;
 595         const struct ndr_interface_string_array *authservices;
 596 };
 597
 598 struct ndr_interface_list {
 599         struct ndr_interface_list *prev, *next;
 600         const struct ndr_interface_table *table;
 601 };
 602
 603 struct sockaddr_storage;
 604
 605 /*********************************************************************
 606  Map an NT error code from a NDR error code.
 607 *********************************************************************/
 608 NTSTATUS ndr_map_error2ntstatus(enum ndr_err_code ndr_err);
 609 int ndr_map_error2errno(enum ndr_err_code ndr_err);
 610 const char *ndr_map_error2string(enum ndr_err_code ndr_err);
 611 #define ndr_errstr ndr_map_error2string
 612
 613 /* FIXME: Use represent_as instead */
 614 struct dom_sid;
 615 enum ndr_err_code ndr_push_dom_sid2(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dom_sid *sid);
 616 enum ndr_err_code ndr_pull_dom_sid2(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dom_sid *sid);
 617 void ndr_print_dom_sid2(struct ndr_print *ndr, const char *name, const struct dom_sid *sid);
 618 enum ndr_err_code ndr_push_dom_sid28(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dom_sid *sid);
 619 enum ndr_err_code ndr_pull_dom_sid28(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dom_sid *sid);
 620 void ndr_print_dom_sid28(struct ndr_print *ndr, const char *name, const struct dom_sid *sid);
 621 size_t ndr_size_dom_sid28(const struct dom_sid *sid, libndr_flags flags);
 622 enum ndr_err_code ndr_push_dom_sid0(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct dom_sid *sid);
 623 enum ndr_err_code ndr_pull_dom_sid0(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct dom_sid *sid);
 624 void ndr_print_dom_sid0(struct ndr_print *ndr, const char *name, const struct dom_sid *sid);
 625 size_t ndr_size_dom_sid0(const struct dom_sid *sid, libndr_flags flags);
 626 void ndr_print_GUID(struct ndr_print *ndr, const char *name, const struct GUID *guid);
 627 void ndr_print_sockaddr_storage(struct ndr_print *ndr, const char *name, const struct sockaddr_storage *ss);
 628 void ndr_zero_memory(void *ptr, size_t len);
 629 bool ndr_syntax_id_equal(const struct ndr_syntax_id *i1, const struct ndr_syntax_id *i2);
 630
 631 struct ndr_syntax_id_buf { char buf[39 /*GUID*/ + 3 /* "/0x" */ + 8]; };
 632 char *ndr_syntax_id_buf_string(
 633         const struct ndr_syntax_id *id, struct ndr_syntax_id_buf *buf);
 634 char *ndr_syntax_id_to_string(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *id);
 635
 636 bool ndr_syntax_id_from_string(const char *s, struct ndr_syntax_id *id);
 637 enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p, ndr_push_flags_fn_t fn);
 638 enum ndr_err_code ndr_push_struct_into_fixed_blob(DATA_BLOB *blob,
 639                                                   const void *p,
 640                                                   ndr_push_flags_fn_t fn);
 641 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);
 642 size_t ndr_size_struct(const void *p, libndr_flags flags, ndr_push_flags_fn_t push);
 643 size_t ndr_size_union(const void *p, libndr_flags flags, uint32_t level, ndr_push_flags_fn_t push);
 644 uint32_t ndr_push_get_relative_base_offset(struct ndr_push *ndr);
 645 void ndr_push_restore_relative_base_offset(struct ndr_push *ndr, uint32_t offset);
 646 enum ndr_err_code ndr_push_setup_relative_base_offset1(struct ndr_push *ndr, const void *p, uint32_t offset);
 647 enum ndr_err_code ndr_push_setup_relative_base_offset2(struct ndr_push *ndr, const void *p);
 648 enum ndr_err_code ndr_push_relative_ptr1(struct ndr_push *ndr, const void *p);
 649 enum ndr_err_code ndr_push_short_relative_ptr1(struct ndr_push *ndr, const void *p);
 650 enum ndr_err_code ndr_push_relative_ptr2_start(struct ndr_push *ndr, const void *p);
 651 enum ndr_err_code ndr_push_relative_ptr2_end(struct ndr_push *ndr, const void *p);
 652 enum ndr_err_code ndr_push_short_relative_ptr2(struct ndr_push *ndr, const void *p);
 653 uint32_t ndr_pull_get_relative_base_offset(struct ndr_pull *ndr);
 654 void ndr_pull_restore_relative_base_offset(struct ndr_pull *ndr, uint32_t offset);
 655 enum ndr_err_code ndr_pull_setup_relative_base_offset1(struct ndr_pull *ndr, const void *p, uint32_t offset);
 656 enum ndr_err_code ndr_pull_setup_relative_base_offset2(struct ndr_pull *ndr, const void *p);
 657 enum ndr_err_code ndr_pull_relative_ptr1(struct ndr_pull *ndr, const void *p, uint32_t rel_offset);
 658 enum ndr_err_code ndr_pull_relative_ptr2(struct ndr_pull *ndr, const void *p);
 659 enum ndr_err_code ndr_pull_relative_ptr_short(struct ndr_pull *ndr, uint16_t *v);
 660 size_t ndr_align_size(uint32_t offset, size_t n);
 661 struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx);
 662 enum ndr_err_code ndr_pull_append(struct ndr_pull *ndr, DATA_BLOB *blob);
 663 enum ndr_err_code ndr_pull_pop(struct ndr_pull *ndr);
 664 enum ndr_err_code ndr_pull_advance(struct ndr_pull *ndr, uint32_t size);
 665 struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx);
 666 DATA_BLOB ndr_push_blob(struct ndr_push *ndr);
 667 enum ndr_err_code ndr_push_expand(struct ndr_push *ndr, uint32_t extra_size);
 668 void ndr_print_debug_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 669 void ndr_print_debugc_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 670 void ndr_print_printf_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 671 void ndr_print_string_helper(struct ndr_print *ndr, const char *format, ...) PRINTF_ATTRIBUTE(2,3);
 672 bool ndr_print_debug(int level, ndr_print_fn_t fn, const char *name, void *ptr, const char *location, const char *function);
 673 void ndr_print_debugc(int dbgc_class, ndr_print_fn_t fn, const char *name, void *ptr);
 674 void ndr_print_union_debug(ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr);
 675 void ndr_print_function_debug(ndr_print_function_t fn, const char *name, ndr_flags_type flags, void *ptr);
 676 char *ndr_print_struct_string(TALLOC_CTX *mem_ctx, ndr_print_fn_t fn, const char *name, void *ptr);
 677 char *ndr_print_union_string(TALLOC_CTX *mem_ctx, ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr);
 678 char *ndr_print_function_string(TALLOC_CTX *mem_ctx,
 679                                 ndr_print_function_t fn, const char *name,
 680                                 ndr_flags_type flags, void *ptr);
 681 void ndr_set_flags(libndr_flags *pflags, libndr_flags new_flags);
 682 enum ndr_err_code _ndr_pull_error(struct ndr_pull *ndr,
 683                                   enum ndr_err_code ndr_err,
 684                                   const char *function,
 685                                   const char *location,
 686                                   const char *format, ...) PRINTF_ATTRIBUTE(5,6);
 687 #define ndr_pull_error(ndr, ndr_err, ...) \
 688         _ndr_pull_error(ndr, \
 689                         ndr_err,      \
 690                         __FUNCTION__, \
 691                         __location__, \
 692                         __VA_ARGS__)
 693 enum ndr_err_code _ndr_push_error(struct ndr_push *ndr,
 694                                   enum ndr_err_code ndr_err,
 695                                   const char *function,
 696                                   const char *location,
 697                                   const char *format, ...)  PRINTF_ATTRIBUTE(5,6);
 698 #define ndr_push_error(ndr, ndr_err, ...) \
 699         _ndr_push_error(ndr, \
 700                         ndr_err, \
 701                         __FUNCTION__, \
 702                         __location__, \
 703                         __VA_ARGS__)
 704 enum ndr_err_code ndr_pull_subcontext_start(struct ndr_pull *ndr,
 705                                    struct ndr_pull **_subndr,
 706                                    size_t header_size,
 707                                    ssize_t size_is);
 708 enum ndr_err_code ndr_pull_subcontext_end(struct ndr_pull *ndr,
 709                                  struct ndr_pull *subndr,
 710                                  size_t header_size,
 711                                  ssize_t size_is);
 712 enum ndr_err_code ndr_push_subcontext_start(struct ndr_push *ndr,
 713                                    struct ndr_push **_subndr,
 714                                    size_t header_size,
 715                                    ssize_t size_is);
 716 enum ndr_err_code ndr_push_subcontext_end(struct ndr_push *ndr,
 717                                  struct ndr_push *subndr,
 718                                  size_t header_size,
 719                                  ssize_t size_is);
 720 enum ndr_err_code ndr_token_store(TALLOC_CTX *mem_ctx,
 721                          struct ndr_token_list *list,
 722                          const void *key,
 723                          uint32_t value);
 724 enum ndr_err_code ndr_token_retrieve_cmp_fn(struct ndr_token_list *list, const void *key, uint32_t *v,
 725                                             int(*_cmp_fn)(const void*,const void*), bool erase);
 726 enum ndr_err_code ndr_token_retrieve(struct ndr_token_list *list, const void *key, uint32_t *v);
 727 enum ndr_err_code ndr_token_peek(struct ndr_token_list *list, const void *key, uint32_t *v);
 728 enum ndr_err_code ndr_pull_array_size(struct ndr_pull *ndr, const void *p);
 729 enum ndr_err_code ndr_get_array_size(struct ndr_pull *ndr, const void *p, uint32_t *size);
 730 enum ndr_err_code ndr_steal_array_size(struct ndr_pull *ndr, const void *p, uint32_t *size);
 731 enum ndr_err_code ndr_check_array_size(struct ndr_pull *ndr, const void *p, uint32_t size);
 732 enum ndr_err_code ndr_check_steal_array_size(struct ndr_pull *ndr, const void *p, uint32_t size);
 733 enum ndr_err_code ndr_pull_array_length(struct ndr_pull *ndr, const void *p);
 734 enum ndr_err_code ndr_get_array_length(struct ndr_pull *ndr, const void *p, uint32_t *length);
 735 enum ndr_err_code ndr_steal_array_length(struct ndr_pull *ndr, const void *p, uint32_t *length);
 736 enum ndr_err_code ndr_check_array_length(struct ndr_pull *ndr, const void *p, uint32_t length);
 737 enum ndr_err_code ndr_check_steal_array_length(struct ndr_pull *ndr, const void *p, uint32_t length);
 738 enum ndr_err_code ndr_push_pipe_chunk_trailer(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t count);
 739 enum ndr_err_code ndr_check_pipe_chunk_trailer(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t count);
 740 enum ndr_err_code ndr_push_set_switch_value(struct ndr_push *ndr, const void *p, uint32_t val);
 741 enum ndr_err_code ndr_pull_set_switch_value(struct ndr_pull *ndr, const void *p, uint32_t val);
 742 enum ndr_err_code ndr_print_set_switch_value(struct ndr_print *ndr, const void *p, uint32_t val);
 743 /* retrieve a switch value (for push) and remove it from the list */
 744 enum ndr_err_code ndr_push_steal_switch_value(struct ndr_push *ndr,
 745                                               const void *p,
 746                                               uint32_t *v);
 747 /* retrieve a switch value and remove it from the list */
 748 uint32_t ndr_print_steal_switch_value(struct ndr_print *ndr, const void *p);
 749 /* retrieve a switch value and remove it from the list */
 750 enum ndr_err_code ndr_pull_steal_switch_value(struct ndr_pull *ndr,
 751                                               const void *p,
 752                                               uint32_t *v);
 753 enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p, ndr_pull_flags_fn_t fn);
 754 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);
 755 _PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_noalloc(const uint8_t *buf,
 756                                                         size_t buflen,
 757                                                         void *p,
 758                                                         ndr_pull_flags_fn_t fn,
 759                                                         size_t *consumed);
 760 enum ndr_err_code ndr_pull_struct_blob_all_noalloc(const DATA_BLOB *blob,
 761                                                    void *p, ndr_pull_flags_fn_t fn);
 762 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);
 763 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);
 764
 765 /* from libndr_basic.h */
 766 #define NDR_SCALAR_PROTO(name, type) \
 767 enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, ndr_flags_type ndr_flags, type v); \
 768 enum ndr_err_code ndr_pull_ ## name(struct ndr_pull *ndr, ndr_flags_type ndr_flags, type *v); \
 769 void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, type v);
 770
 771 #define NDR_SCALAR_PTR_PROTO(name, type) \
 772 enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, ndr_flags_type ndr_flags, const type *v); \
 773 enum ndr_err_code ndr_pull_ ## name(struct ndr_pull *ndr, ndr_flags_type ndr_flags, type **v); \
 774 void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, const type *v);
 775
 776 #define NDR_BUFFER_PROTO(name, type) \
 777 enum ndr_err_code ndr_push_ ## name(struct ndr_push *ndr, ndr_flags_type ndr_flags, const type *v); \
 778 enum ndr_err_code ndr_pull_ ## name(struct ndr_pull *ndr, ndr_flags_type ndr_flags, type *v); \
 779 void ndr_print_ ## name(struct ndr_print *ndr, const char *var_name, const type *v);
 780
 781 NDR_SCALAR_PROTO(uint8, uint8_t)
 782 NDR_SCALAR_PROTO(int8, int8_t)
 783 NDR_SCALAR_PROTO(uint16, uint16_t)
 784 NDR_SCALAR_PROTO(int16, int16_t)
 785 NDR_SCALAR_PROTO(uint1632, uint16_t)
 786 NDR_SCALAR_PROTO(uint32, uint32_t)
 787 NDR_SCALAR_PROTO(uint3264, uint32_t)
 788 NDR_SCALAR_PROTO(int32, int32_t)
 789 NDR_SCALAR_PROTO(int3264, int32_t)
 790 NDR_SCALAR_PROTO(udlong, uint64_t)
 791 NDR_SCALAR_PROTO(udlongr, uint64_t)
 792 NDR_SCALAR_PROTO(dlong, int64_t)
 793 NDR_SCALAR_PROTO(hyper, uint64_t)
 794 NDR_SCALAR_PROTO(int64, int64_t)
 795 NDR_SCALAR_PROTO(pointer, void *)
 796 NDR_SCALAR_PROTO(time_t, time_t)
 797 NDR_SCALAR_PROTO(uid_t, uid_t)
 798 NDR_SCALAR_PROTO(gid_t, gid_t)
 799 NDR_SCALAR_PROTO(NTSTATUS, NTSTATUS)
 800 NDR_SCALAR_PROTO(WERROR, WERROR)
 801 NDR_SCALAR_PROTO(HRESULT, HRESULT)
 802 NDR_SCALAR_PROTO(NTTIME, NTTIME)
 803 NDR_SCALAR_PROTO(NTTIME_1sec, NTTIME)
 804 NDR_SCALAR_PROTO(NTTIME_hyper, NTTIME)
 805 NDR_SCALAR_PROTO(DATA_BLOB, DATA_BLOB)
 806 NDR_SCALAR_PROTO(ipv4address, const char *)
 807 NDR_SCALAR_PROTO(ipv6address, const char *)
 808 NDR_SCALAR_PROTO(string, const char *)
 809 NDR_SCALAR_PROTO(u16string, const uint16_t *)
 810 NDR_SCALAR_PROTO(double, double)
 811
 812 enum ndr_err_code ndr_pull_policy_handle(struct ndr_pull *ndr, ndr_flags_type ndr_flags, struct policy_handle *r);
 813 enum ndr_err_code ndr_push_policy_handle(struct ndr_push *ndr, ndr_flags_type ndr_flags, const struct policy_handle *r);
 814 void ndr_print_policy_handle(struct ndr_print *ndr, const char *name, const struct policy_handle *r);
 815 bool ndr_policy_handle_empty(const struct policy_handle *h);
 816 #define is_valid_policy_hnd(hnd) (!ndr_policy_handle_empty(hnd))
 817 bool ndr_policy_handle_equal(const struct policy_handle *hnd1,
 818                          const struct policy_handle *hnd2);
 819
 820 void ndr_check_padding(struct ndr_pull *ndr, size_t n);
 821 enum ndr_err_code ndr_pull_generic_ptr(struct ndr_pull *ndr, uint32_t *v);
 822 enum ndr_err_code ndr_pull_ref_ptr(struct ndr_pull *ndr, uint32_t *v);
 823 enum ndr_err_code ndr_pull_bytes(struct ndr_pull *ndr, uint8_t *data, uint32_t n);
 824 enum ndr_err_code ndr_pull_array_uint8(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *data, uint32_t n);
 825 enum ndr_err_code ndr_push_align(struct ndr_push *ndr, size_t size);
 826 enum ndr_err_code ndr_pull_align(struct ndr_pull *ndr, size_t size);
 827 enum ndr_err_code ndr_push_union_align(struct ndr_push *ndr, size_t size);
 828 enum ndr_err_code ndr_pull_union_align(struct ndr_pull *ndr, size_t size);
 829 enum ndr_err_code ndr_push_trailer_align(struct ndr_push *ndr, size_t size);
 830 enum ndr_err_code ndr_pull_trailer_align(struct ndr_pull *ndr, size_t size);
 831 enum ndr_err_code ndr_push_bytes(struct ndr_push *ndr, const uint8_t *data, uint32_t n);
 832 enum ndr_err_code ndr_push_zero(struct ndr_push *ndr, uint32_t n);
 833 enum ndr_err_code ndr_push_array_uint8(struct ndr_push *ndr, ndr_flags_type ndr_flags, const uint8_t *data, uint32_t n);
 834 enum ndr_err_code ndr_push_unique_ptr(struct ndr_push *ndr, const void *p);
 835 enum ndr_err_code ndr_push_full_ptr(struct ndr_push *ndr, const void *p);
 836 enum ndr_err_code ndr_push_ref_ptr(struct ndr_push *ndr);
 837 void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type);
 838 void ndr_print_null(struct ndr_print *ndr);
 839 void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type, const char *val, uint32_t value);
 840 void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint32_t flag, uint32_t value);
 841 void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint32_t flag, uint32_t value);
 842 void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p);
 843 void ndr_print_union(struct ndr_print *ndr, const char *name, int level, const char *type);
 844 void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level);
 845 void ndr_print_array_uint8(struct ndr_print *ndr, const char *name, const uint8_t *data, uint32_t count);
 846 uint32_t ndr_size_DATA_BLOB(int ret, const DATA_BLOB *data, ndr_flags_type flags);
 847
 848 /* strings */
 849 uint32_t ndr_charset_length(const void *var, charset_t chset);
 850 size_t ndr_string_array_size(struct ndr_push *ndr, const char *s);
 851 uint32_t ndr_size_string(int ret, const char * const* string, ndr_flags_type flags);
 852 enum ndr_err_code ndr_pull_string_array(struct ndr_pull *ndr, ndr_flags_type ndr_flags, const char ***_a);
 853 enum ndr_err_code ndr_push_string_array(struct ndr_push *ndr, ndr_flags_type ndr_flags, const char **a);
 854 void ndr_print_string_array(struct ndr_print *ndr, const char *name, const char **a);
 855 size_t ndr_size_string_array(const char **a, uint32_t count, libndr_flags flags);
 856 uint32_t ndr_string_length(const void *_var, uint32_t element_size);
 857 enum ndr_err_code ndr_check_string_terminator(struct ndr_pull *ndr, uint32_t count, uint32_t element_size);
 858 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);
 859 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);
 860 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);
 861 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);
 862
 863 /* GUIDs */
 864 bool GUID_equal(const struct GUID *u1, const struct GUID *u2);
 865 struct GUID_ndr_buf { uint8_t buf[16]; };
 866 NTSTATUS GUID_to_ndr_buf(const struct GUID *guid, struct GUID_ndr_buf *buf);
 867 NTSTATUS GUID_to_ndr_blob(const struct GUID *guid, TALLOC_CTX *mem_ctx, DATA_BLOB *b);
 868 NTSTATUS GUID_from_ndr_blob(const DATA_BLOB *b, struct GUID *guid);
 869 NTSTATUS GUID_from_data_blob(const DATA_BLOB *s, struct GUID *guid);
 870 NTSTATUS GUID_from_string(const char *s, struct GUID *guid);
 871 struct GUID GUID_zero(void);
 872 bool GUID_all_zero(const struct GUID *u);
 873 int GUID_compare(const struct GUID *u1, const struct GUID *u2);
 874 char *GUID_string(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 875 char *GUID_string2(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 876 char *GUID_hexstring(TALLOC_CTX *mem_ctx, const struct GUID *guid);
 877 struct GUID GUID_random(void);
 878
 879 /* Format is "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" */
 880  /* 32 chars + 4 ' ' + \0 + 2 for adding {}  */
 881 struct GUID_txt_buf { char buf[39]; };
 882 _PUBLIC_ char* GUID_buf_string(const struct GUID *guid,
 883                                struct GUID_txt_buf *dst);
 884
 885 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint8_t *v);
 886 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *v);
 887 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint32(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint32_t *v);
 888 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint1632(struct ndr_pull *ndr, ndr_flags_type ndr_flags, uint16_t *v);
 889 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint8(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint8_t v);
 890 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint16(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t v);
 891 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint32_t v);
 892 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint1632(struct ndr_push *ndr, ndr_flags_type ndr_flags, uint16_t v);
 893
 894 _PUBLIC_ void ndr_print_bool(struct ndr_print *ndr, const char *name, const bool b);
 895
 896 _PUBLIC_ enum ndr_err_code ndr_push_timespec(struct ndr_push *ndr,
 897                                              ndr_flags_type ndr_flags,
 898                                              const struct timespec *t);
 899 _PUBLIC_ enum ndr_err_code ndr_pull_timespec(struct ndr_pull *ndr,
 900                                              ndr_flags_type ndr_flags,
 901                                              struct timespec *t);
 902 _PUBLIC_ void ndr_print_timespec(struct ndr_print *ndr, const char *name,
 903                                  const struct timespec *t);
 904
 905 _PUBLIC_ enum ndr_err_code ndr_push_timeval(struct ndr_push *ndr,
 906                                             ndr_flags_type ndr_flags,
 907                                             const struct timeval *t);
 908 _PUBLIC_ enum ndr_err_code ndr_pull_timeval(struct ndr_pull *ndr,
 909                                             ndr_flags_type ndr_flags,
 910                                             struct timeval *t);
 911 _PUBLIC_ void ndr_print_timeval(struct ndr_print *ndr, const char *name,
 912                                 const struct timeval *t);
 913
 914 _PUBLIC_ void ndr_print_libndr_flags(struct ndr_print *ndr, const char *name,
 915                                        libndr_flags flags);
 916
 917
 918 #endif /* __LIBNDR_H__ */