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