librpc/ndr/ndr_basic.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    routines for marshalling/unmarshalling basic types
   5
   6    Copyright (C) Andrew Tridgell 2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "replace.h"
  23 #include "system/network.h"
  24 #include "librpc/ndr/libndr.h"
  25 #include "lib/util/util_net.h"
  26 #include "lib/util/debug.h"
  27 #include "lib/util/util.h"
  28 #include "lib/util/bytearray.h"
  29
  30 #define NDR_PULL_U16(ndr, ofs) \
  31         (NDR_BE(ndr) ? PULL_BE_U16(ndr->data,ofs) : PULL_LE_U16(ndr->data,ofs))
  32
  33 #define NDR_PULL_U32(ndr, ofs) \
  34         (NDR_BE(ndr) ? PULL_BE_U32(ndr->data,ofs) : PULL_LE_U32(ndr->data,ofs))
  35
  36 #define NDR_PULL_I32(ndr, ofs) \
  37         (int32_t)(NDR_BE(ndr) ? PULL_BE_U32(ndr->data,ofs) : PULL_LE_U32(ndr->data,ofs))
  38
  39 #define NDR_PUSH_U16(ndr, ofs, v) \
  40         do { \
  41                 if (NDR_BE(ndr)) { \
  42                         PUSH_BE_U16(ndr->data, ofs, v); \
  43                 } else { \
  44                         PUSH_LE_U16(ndr->data, ofs, v); \
  45                 } \
  46         } while (0)
  47
  48 #define NDR_PUSH_U32(ndr, ofs, v) \
  49         do { \
  50                 if (NDR_BE(ndr)) { \
  51                         PUSH_BE_U32(ndr->data, ofs, v); \
  52                 } else { \
  53                         PUSH_LE_U32(ndr->data, ofs, v); \
  54                 } \
  55         } while (0)
  56
  57 #define NDR_PUSH_I32(ndr, ofs, v) \
  58         do { \
  59                 if (NDR_BE(ndr)) { \
  60                         PUSH_BE_U32(ndr->data, ofs, v); \
  61                 } else { \
  62                         PUSH_LE_U32(ndr->data, ofs, v); \
  63                 } \
  64         } while (0)
  65
  66 static void ndr_dump_data(struct ndr_print *ndr, const uint8_t *buf, int len);
  67
  68 /*
  69   check for data leaks from the server by looking for non-zero pad bytes
  70   these could also indicate that real structure elements have been
  71   mistaken for padding in the IDL
  72 */
  73 _PUBLIC_ void ndr_check_padding(struct ndr_pull *ndr, size_t n)
  74 {
  75         size_t ofs2 = (ndr->offset + (n-1)) & ~(n-1);
  76         size_t i;
  77         for (i=ndr->offset;i<ofs2;i++) {
  78                 if (ndr->data[i] != 0) {
  79                         break;
  80                 }
  81         }
  82         if (i<ofs2) {
  83                 DEBUG(0,("WARNING: Non-zero padding to %d: ", (int)n));
  84                 for (i=ndr->offset;i<ofs2;i++) {
  85                         DEBUG(0,("%02x ", ndr->data[i]));
  86                 }
  87                 DEBUG(0,("\n"));
  88         }
  89
  90 }
  91
  92 /*
  93   parse a int8_t
  94 */
  95 _PUBLIC_ enum ndr_err_code ndr_pull_int8(struct ndr_pull *ndr, int ndr_flags, int8_t *v)
  96 {
  97         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
  98         NDR_PULL_NEED_BYTES(ndr, 1);
  99         *v = (int8_t)PULL_BE_U8(ndr->data, ndr->offset);
 100         ndr->offset += 1;
 101         return NDR_ERR_SUCCESS;
 102 }
 103
 104 /*
 105   parse a uint8_t
 106 */
 107 _PUBLIC_ enum ndr_err_code ndr_pull_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
 108 {
 109         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 110         NDR_PULL_NEED_BYTES(ndr, 1);
 111         *v = PULL_BE_U8(ndr->data, ndr->offset);
 112         ndr->offset += 1;
 113         return NDR_ERR_SUCCESS;
 114 }
 115
 116 /*
 117   parse a int16_t
 118 */
 119 _PUBLIC_ enum ndr_err_code ndr_pull_int16(struct ndr_pull *ndr, int ndr_flags, int16_t *v)
 120 {
 121         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 122         NDR_PULL_ALIGN(ndr, 2);
 123         NDR_PULL_NEED_BYTES(ndr, 2);
 124         *v = (uint16_t)NDR_PULL_U16(ndr, ndr->offset);
 125         ndr->offset += 2;
 126         return NDR_ERR_SUCCESS;
 127 }
 128
 129 /*
 130   parse a uint16_t
 131 */
 132 _PUBLIC_ enum ndr_err_code ndr_pull_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
 133 {
 134         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 135         NDR_PULL_ALIGN(ndr, 2);
 136         NDR_PULL_NEED_BYTES(ndr, 2);
 137         *v = NDR_PULL_U16(ndr, ndr->offset);
 138         ndr->offset += 2;
 139         return NDR_ERR_SUCCESS;
 140 }
 141
 142 /*
 143   parse a uint1632_t
 144 */
 145 _PUBLIC_ enum ndr_err_code ndr_pull_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
 146 {
 147         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 148         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 149                 uint32_t v32 = 0;
 150                 enum ndr_err_code err = ndr_pull_uint32(ndr, ndr_flags, &v32);
 151                 *v = v32;
 152                 if (unlikely(v32 != *v)) {
 153                         DEBUG(0,(__location__ ": non-zero upper 16 bits 0x%08x\n", (unsigned)v32));
 154                         return NDR_ERR_NDR64;
 155                 }
 156                 return err;
 157         }
 158         return ndr_pull_uint16(ndr, ndr_flags, v);
 159 }
 160
 161 /*
 162   parse a int32_t
 163 */
 164 _PUBLIC_ enum ndr_err_code ndr_pull_int32(struct ndr_pull *ndr, int ndr_flags, int32_t *v)
 165 {
 166         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 167         NDR_PULL_ALIGN(ndr, 4);
 168         NDR_PULL_NEED_BYTES(ndr, 4);
 169         *v = NDR_PULL_I32(ndr, ndr->offset);
 170         ndr->offset += 4;
 171         return NDR_ERR_SUCCESS;
 172 }
 173
 174 /*
 175   parse a uint32_t
 176 */
 177 _PUBLIC_ enum ndr_err_code ndr_pull_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
 178 {
 179         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 180         NDR_PULL_ALIGN(ndr, 4);
 181         NDR_PULL_NEED_BYTES(ndr, 4);
 182         *v = NDR_PULL_U32(ndr, ndr->offset);
 183         ndr->offset += 4;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 /*
 188   parse a arch dependent uint32/uint64
 189 */
 190 _PUBLIC_ enum ndr_err_code ndr_pull_uint3264(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
 191 {
 192         uint64_t v64 = 0;
 193         enum ndr_err_code err;
 194         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 195         if (likely(!(ndr->flags & LIBNDR_FLAG_NDR64))) {
 196                 return ndr_pull_uint32(ndr, ndr_flags, v);
 197         }
 198         err = ndr_pull_hyper(ndr, ndr_flags, &v64);
 199         if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
 200                 return err;
 201         }
 202         *v = (uint32_t)v64;
 203         if (unlikely(v64 != *v)) {
 204                 DEBUG(0,(__location__ ": non-zero upper 32 bits 0x%016llx\n",
 205                          (unsigned long long)v64));
 206                 return ndr_pull_error(ndr, NDR_ERR_NDR64, __location__ ": non-zero upper 32 bits 0x%016llx\n",
 207                          (unsigned long long)v64);
 208         }
 209         return err;
 210 }
 211
 212 /*
 213   parse a double
 214 */
 215 _PUBLIC_ enum ndr_err_code ndr_pull_double(struct ndr_pull *ndr, int ndr_flags, double *v)
 216 {
 217         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 218         NDR_PULL_ALIGN(ndr, 8);
 219         NDR_PULL_NEED_BYTES(ndr, 8);
 220         memcpy(v, ndr->data+ndr->offset, 8);
 221         ndr->offset += 8;
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 /*
 226   parse a pointer referent identifier stored in 2 bytes
 227 */
 228 _PUBLIC_ enum ndr_err_code ndr_pull_relative_ptr_short(struct ndr_pull *ndr, uint16_t *v)
 229 {
 230         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, v));
 231         if (*v != 0) {
 232                 ndr->ptr_count++;
 233         }
 234         *(v) -= ndr->relative_rap_convert;
 235         return NDR_ERR_SUCCESS;
 236 }
 237
 238 /*
 239   parse a pointer referent identifier
 240 */
 241 _PUBLIC_ enum ndr_err_code ndr_pull_generic_ptr(struct ndr_pull *ndr, uint32_t *v)
 242 {
 243         NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, v));
 244         if (*v != 0) {
 245                 ndr->ptr_count++;
 246         }
 247         return NDR_ERR_SUCCESS;
 248 }
 249
 250 /*
 251   parse a ref pointer referent identifier
 252 */
 253 _PUBLIC_ enum ndr_err_code ndr_pull_ref_ptr(struct ndr_pull *ndr, uint32_t *v)
 254 {
 255         NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, v));
 256         /* ref pointers always point to data */
 257         *v = 1;
 258         return NDR_ERR_SUCCESS;
 259 }
 260
 261 /*
 262   parse a udlong
 263 */
 264 _PUBLIC_ enum ndr_err_code ndr_pull_udlong(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
 265 {
 266         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 267         NDR_PULL_ALIGN(ndr, 4);
 268         NDR_PULL_NEED_BYTES(ndr, 8);
 269         *v = NDR_PULL_U32(ndr, ndr->offset);
 270         *v |= (uint64_t)(NDR_PULL_U32(ndr, ndr->offset+4)) << 32;
 271         ndr->offset += 8;
 272         return NDR_ERR_SUCCESS;
 273 }
 274
 275 /*
 276   parse a udlongr
 277 */
 278 _PUBLIC_ enum ndr_err_code ndr_pull_udlongr(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
 279 {
 280         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 281         NDR_PULL_ALIGN(ndr, 4);
 282         NDR_PULL_NEED_BYTES(ndr, 8);
 283         *v = ((uint64_t)NDR_PULL_U32(ndr, ndr->offset)) << 32;
 284         *v |= NDR_PULL_U32(ndr, ndr->offset+4);
 285         ndr->offset += 8;
 286         return NDR_ERR_SUCCESS;
 287 }
 288
 289 /*
 290   parse a dlong
 291 */
 292 _PUBLIC_ enum ndr_err_code ndr_pull_dlong(struct ndr_pull *ndr, int ndr_flags, int64_t *v)
 293 {
 294         return ndr_pull_udlong(ndr, ndr_flags, (uint64_t *)v);
 295 }
 296
 297 /*
 298   parse a hyper
 299 */
 300 _PUBLIC_ enum ndr_err_code ndr_pull_hyper(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
 301 {
 302         NDR_PULL_ALIGN(ndr, 8);
 303         if (NDR_BE(ndr)) {
 304                 return ndr_pull_udlongr(ndr, ndr_flags, v);
 305         }
 306         return ndr_pull_udlong(ndr, ndr_flags, v);
 307 }
 308
 309 /*
 310   parse a pointer
 311 */
 312 _PUBLIC_ enum ndr_err_code ndr_pull_pointer(struct ndr_pull *ndr, int ndr_flags, void* *v)
 313 {
 314         uintptr_t h;
 315         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 316         NDR_PULL_ALIGN(ndr, sizeof(h));
 317         NDR_PULL_NEED_BYTES(ndr, sizeof(h));
 318         memcpy(&h, ndr->data+ndr->offset, sizeof(h));
 319         ndr->offset += sizeof(h);
 320         *v = (void *)h;
 321         return NDR_ERR_SUCCESS;
 322 }
 323
 324 /*
 325   pull a NTSTATUS
 326 */
 327 _PUBLIC_ enum ndr_err_code ndr_pull_NTSTATUS(struct ndr_pull *ndr, int ndr_flags, NTSTATUS *status)
 328 {
 329         uint32_t v;
 330         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 331         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 332         *status = NT_STATUS(v);
 333         return NDR_ERR_SUCCESS;
 334 }
 335
 336 /*
 337   push a NTSTATUS
 338 */
 339 _PUBLIC_ enum ndr_err_code ndr_push_NTSTATUS(struct ndr_push *ndr, int ndr_flags, NTSTATUS status)
 340 {
 341         return ndr_push_uint32(ndr, ndr_flags, NT_STATUS_V(status));
 342 }
 343
 344 _PUBLIC_ void ndr_print_NTSTATUS(struct ndr_print *ndr, const char *name, NTSTATUS r)
 345 {
 346         ndr->print(ndr, "%-25s: %s", name, nt_errstr(r));
 347 }
 348
 349 /*
 350   pull a WERROR
 351 */
 352 _PUBLIC_ enum ndr_err_code ndr_pull_WERROR(struct ndr_pull *ndr, int ndr_flags, WERROR *status)
 353 {
 354         uint32_t v;
 355         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 356         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 357         *status = W_ERROR(v);
 358         return NDR_ERR_SUCCESS;
 359 }
 360
 361 /*
 362   pull a HRESULT
 363 */
 364 _PUBLIC_ enum ndr_err_code ndr_pull_HRESULT(struct ndr_pull *ndr, int ndr_flags, HRESULT *status)
 365 {
 366         uint32_t v;
 367         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 368         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 369         *status = HRES_ERROR(v);
 370         return NDR_ERR_SUCCESS;
 371 }
 372
 373 /*
 374   parse a uint8_t enum
 375 */
 376 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
 377 {
 378         return ndr_pull_uint8(ndr, ndr_flags, v);
 379 }
 380
 381 /*
 382   parse a uint16_t enum
 383 */
 384 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
 385 {
 386         return ndr_pull_uint16(ndr, ndr_flags, v);
 387 }
 388
 389 /*
 390   parse a uint1632_t enum (uint32_t on NDR64)
 391 */
 392 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
 393 {
 394         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 395                 uint32_t v32;
 396                 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &v32));
 397                 *v = v32;
 398                 if (v32 != *v) {
 399                         DEBUG(0,(__location__ ": non-zero upper 16 bits 0x%08x\n", (unsigned)v32));
 400                         return NDR_ERR_NDR64;
 401                 }
 402                 return NDR_ERR_SUCCESS;
 403         }
 404         return ndr_pull_uint16(ndr, ndr_flags, v);
 405 }
 406
 407 /*
 408   parse a uint32_t enum
 409 */
 410 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
 411 {
 412         return ndr_pull_uint32(ndr, ndr_flags, v);
 413 }
 414
 415 /*
 416   push a uint8_t enum
 417 */
 418 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
 419 {
 420         return ndr_push_uint8(ndr, ndr_flags, v);
 421 }
 422
 423 /*
 424   push a uint16_t enum
 425 */
 426 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
 427 {
 428         return ndr_push_uint16(ndr, ndr_flags, v);
 429 }
 430
 431 /*
 432   push a uint32_t enum
 433 */
 434 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
 435 {
 436         return ndr_push_uint32(ndr, ndr_flags, v);
 437 }
 438
 439 /*
 440   push a uint1632_t enum
 441 */
 442 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint1632(struct ndr_push *ndr, int ndr_flags, uint16_t v)
 443 {
 444         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 445                 return ndr_push_uint32(ndr, ndr_flags, v);
 446         }
 447         return ndr_push_uint16(ndr, ndr_flags, v);
 448 }
 449
 450 /*
 451   push a WERROR
 452 */
 453 _PUBLIC_ enum ndr_err_code ndr_push_WERROR(struct ndr_push *ndr, int ndr_flags, WERROR status)
 454 {
 455         return ndr_push_uint32(ndr, NDR_SCALARS, W_ERROR_V(status));
 456 }
 457
 458 _PUBLIC_ void ndr_print_WERROR(struct ndr_print *ndr, const char *name, WERROR r)
 459 {
 460         ndr->print(ndr, "%-25s: %s", name, win_errstr(r));
 461 }
 462
 463 /*
 464   push a HRESULT
 465 */
 466 _PUBLIC_ enum ndr_err_code ndr_push_HRESULT(struct ndr_push *ndr, int ndr_flags, HRESULT status)
 467 {
 468         return ndr_push_uint32(ndr, NDR_SCALARS, HRES_ERROR_V(status));
 469 }
 470
 471 _PUBLIC_ void ndr_print_HRESULT(struct ndr_print *ndr, const char *name, HRESULT r)
 472 {
 473         ndr->print(ndr, "%-25s: %s", name, hresult_errstr(r));
 474 }
 475
 476
 477 /*
 478   parse a set of bytes
 479 */
 480 _PUBLIC_ enum ndr_err_code ndr_pull_bytes(struct ndr_pull *ndr, uint8_t *data, uint32_t n)
 481 {
 482         NDR_PULL_NEED_BYTES(ndr, n);
 483         memcpy(data, ndr->data + ndr->offset, n);
 484         ndr->offset += n;
 485         return NDR_ERR_SUCCESS;
 486 }
 487
 488 /*
 489   pull an array of uint8
 490 */
 491 _PUBLIC_ enum ndr_err_code ndr_pull_array_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *data, uint32_t n)
 492 {
 493         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 494         if (!(ndr_flags & NDR_SCALARS)) {
 495                 return NDR_ERR_SUCCESS;
 496         }
 497         return ndr_pull_bytes(ndr, data, n);
 498 }
 499
 500 /*
 501   push a int8_t
 502 */
 503 _PUBLIC_ enum ndr_err_code ndr_push_int8(struct ndr_push *ndr, int ndr_flags, int8_t v)
 504 {
 505         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 506         NDR_PUSH_NEED_BYTES(ndr, 1);
 507         PUSH_BE_U8(ndr->data, ndr->offset, (uint8_t)v);
 508         ndr->offset += 1;
 509         return NDR_ERR_SUCCESS;
 510 }
 511
 512 /*
 513   push a uint8_t
 514 */
 515 _PUBLIC_ enum ndr_err_code ndr_push_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
 516 {
 517         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 518         NDR_PUSH_NEED_BYTES(ndr, 1);
 519         PUSH_BE_U8(ndr->data, ndr->offset, v);
 520         ndr->offset += 1;
 521         return NDR_ERR_SUCCESS;
 522 }
 523
 524 /*
 525   push a int16_t
 526 */
 527 _PUBLIC_ enum ndr_err_code ndr_push_int16(struct ndr_push *ndr, int ndr_flags, int16_t v)
 528 {
 529         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 530         NDR_PUSH_ALIGN(ndr, 2);
 531         NDR_PUSH_NEED_BYTES(ndr, 2);
 532         NDR_PUSH_U16(ndr, ndr->offset, (uint16_t)v);
 533         ndr->offset += 2;
 534         return NDR_ERR_SUCCESS;
 535 }
 536
 537 /*
 538   push a uint16_t
 539 */
 540 _PUBLIC_ enum ndr_err_code ndr_push_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
 541 {
 542         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 543         NDR_PUSH_ALIGN(ndr, 2);
 544         NDR_PUSH_NEED_BYTES(ndr, 2);
 545         NDR_PUSH_U16(ndr, ndr->offset, v);
 546         ndr->offset += 2;
 547         return NDR_ERR_SUCCESS;
 548 }
 549
 550 /*
 551   push a uint1632
 552 */
 553 _PUBLIC_ enum ndr_err_code ndr_push_uint1632(struct ndr_push *ndr, int ndr_flags, uint16_t v)
 554 {
 555         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 556                 return ndr_push_uint32(ndr, ndr_flags, v);
 557         }
 558         return ndr_push_uint16(ndr, ndr_flags, v);
 559 }
 560
 561 /*
 562   push a int32_t
 563 */
 564 _PUBLIC_ enum ndr_err_code ndr_push_int32(struct ndr_push *ndr, int ndr_flags, int32_t v)
 565 {
 566         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 567         NDR_PUSH_ALIGN(ndr, 4);
 568         NDR_PUSH_NEED_BYTES(ndr, 4);
 569         NDR_PUSH_I32(ndr, ndr->offset, v);
 570         ndr->offset += 4;
 571         return NDR_ERR_SUCCESS;
 572 }
 573
 574 /*
 575   push a uint32_t
 576 */
 577 _PUBLIC_ enum ndr_err_code ndr_push_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
 578 {
 579         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 580         NDR_PUSH_ALIGN(ndr, 4);
 581         NDR_PUSH_NEED_BYTES(ndr, 4);
 582         NDR_PUSH_U32(ndr, ndr->offset, v);
 583         ndr->offset += 4;
 584         return NDR_ERR_SUCCESS;
 585 }
 586
 587 /*
 588   push a uint3264
 589 */
 590 _PUBLIC_ enum ndr_err_code ndr_push_uint3264(struct ndr_push *ndr, int ndr_flags, uint32_t v)
 591 {
 592         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 593                 return ndr_push_hyper(ndr, ndr_flags, v);
 594         }
 595         return ndr_push_uint32(ndr, ndr_flags, v);
 596 }
 597
 598 /*
 599   push a udlong
 600 */
 601 _PUBLIC_ enum ndr_err_code ndr_push_udlong(struct ndr_push *ndr, int ndr_flags, uint64_t v)
 602 {
 603         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 604         NDR_PUSH_ALIGN(ndr, 4);
 605         NDR_PUSH_NEED_BYTES(ndr, 8);
 606         NDR_PUSH_U32(ndr, ndr->offset, (v & 0xFFFFFFFF));
 607         NDR_PUSH_U32(ndr, ndr->offset+4, (v>>32));
 608         ndr->offset += 8;
 609         return NDR_ERR_SUCCESS;
 610 }
 611
 612 /*
 613   push a udlongr
 614 */
 615 _PUBLIC_ enum ndr_err_code ndr_push_udlongr(struct ndr_push *ndr, int ndr_flags, uint64_t v)
 616 {
 617         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 618         NDR_PUSH_ALIGN(ndr, 4);
 619         NDR_PUSH_NEED_BYTES(ndr, 8);
 620         NDR_PUSH_U32(ndr, ndr->offset, (v>>32));
 621         NDR_PUSH_U32(ndr, ndr->offset+4, (v & 0xFFFFFFFF));
 622         ndr->offset += 8;
 623         return NDR_ERR_SUCCESS;
 624 }
 625
 626 /*
 627   push a dlong
 628 */
 629 _PUBLIC_ enum ndr_err_code ndr_push_dlong(struct ndr_push *ndr, int ndr_flags, int64_t v)
 630 {
 631         return ndr_push_udlong(ndr, NDR_SCALARS, (uint64_t)v);
 632 }
 633
 634 /*
 635   push a hyper
 636 */
 637 _PUBLIC_ enum ndr_err_code ndr_push_hyper(struct ndr_push *ndr, int ndr_flags, uint64_t v)
 638 {
 639         NDR_PUSH_ALIGN(ndr, 8);
 640         if (NDR_BE(ndr)) {
 641                 return ndr_push_udlongr(ndr, NDR_SCALARS, v);
 642         }
 643         return ndr_push_udlong(ndr, NDR_SCALARS, v);
 644 }
 645
 646 /*
 647   push a double
 648 */
 649 _PUBLIC_ enum ndr_err_code ndr_push_double(struct ndr_push *ndr, int ndr_flags, double v)
 650 {
 651         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 652         NDR_PUSH_ALIGN(ndr, 8);
 653         NDR_PUSH_NEED_BYTES(ndr, 8);
 654         memcpy(ndr->data+ndr->offset, &v, 8);
 655         ndr->offset += 8;
 656         return NDR_ERR_SUCCESS;
 657 }
 658
 659 /*
 660   push a pointer
 661 */
 662 _PUBLIC_ enum ndr_err_code ndr_push_pointer(struct ndr_push *ndr, int ndr_flags, void* v)
 663 {
 664         uintptr_t h = (intptr_t)v;
 665         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 666         NDR_PUSH_ALIGN(ndr, sizeof(h));
 667         NDR_PUSH_NEED_BYTES(ndr, sizeof(h));
 668         memcpy(ndr->data+ndr->offset, &h, sizeof(h));
 669         ndr->offset += sizeof(h);
 670         return NDR_ERR_SUCCESS;
 671 }
 672
 673 _PUBLIC_ enum ndr_err_code ndr_push_align(struct ndr_push *ndr, size_t size)
 674 {
 675         /* this is a nasty hack to make pidl work with NDR64 */
 676         if (size == 5) {
 677                 if (ndr->flags & LIBNDR_FLAG_NDR64) {
 678                         size = 8;
 679                 } else {
 680                         size = 4;
 681                 }
 682         } else if (size == 3) {
 683                 if (ndr->flags & LIBNDR_FLAG_NDR64) {
 684                         size = 4;
 685                 } else {
 686                         size = 2;
 687                 }
 688         }
 689         NDR_PUSH_ALIGN(ndr, size);
 690         return NDR_ERR_SUCCESS;
 691 }
 692
 693 _PUBLIC_ enum ndr_err_code ndr_pull_align(struct ndr_pull *ndr, size_t size)
 694 {
 695         /* this is a nasty hack to make pidl work with NDR64 */
 696         if (size == 5) {
 697                 if (ndr->flags & LIBNDR_FLAG_NDR64) {
 698                         size = 8;
 699                 } else {
 700                         size = 4;
 701                 }
 702         } else if (size == 3) {
 703                 if (ndr->flags & LIBNDR_FLAG_NDR64) {
 704                         size = 4;
 705                 } else {
 706                         size = 2;
 707                 }
 708         }
 709         NDR_PULL_ALIGN(ndr, size);
 710         return NDR_ERR_SUCCESS;
 711 }
 712
 713 _PUBLIC_ enum ndr_err_code ndr_push_union_align(struct ndr_push *ndr, size_t size)
 714 {
 715         /* MS-RPCE section 2.2.5.3.4.4 */
 716         if (ndr->flags & LIBNDR_FLAG_NDR64) {
 717                 return ndr_push_align(ndr, size);
 718         }
 719         return NDR_ERR_SUCCESS;
 720 }
 721
 722 _PUBLIC_ enum ndr_err_code ndr_pull_union_align(struct ndr_pull *ndr, size_t size)
 723 {
 724         /* MS-RPCE section 2.2.5.3.4.4 */
 725         if (ndr->flags & LIBNDR_FLAG_NDR64) {
 726                 return ndr_pull_align(ndr, size);
 727         }
 728         return NDR_ERR_SUCCESS;
 729 }
 730
 731 _PUBLIC_ enum ndr_err_code ndr_push_trailer_align(struct ndr_push *ndr, size_t size)
 732 {
 733         /* MS-RPCE section 2.2.5.3.4.1 */
 734         if (ndr->flags & LIBNDR_FLAG_NDR64) {
 735                 return ndr_push_align(ndr, size);
 736         }
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 _PUBLIC_ enum ndr_err_code ndr_pull_trailer_align(struct ndr_pull *ndr, size_t size)
 741 {
 742         /* MS-RPCE section 2.2.5.3.4.1 */
 743         if (ndr->flags & LIBNDR_FLAG_NDR64) {
 744                 return ndr_pull_align(ndr, size);
 745         }
 746         return NDR_ERR_SUCCESS;
 747 }
 748
 749 /*
 750   push some bytes
 751 */
 752 _PUBLIC_ enum ndr_err_code ndr_push_bytes(struct ndr_push *ndr, const uint8_t *data, uint32_t n)
 753 {
 754         if (unlikely(n == 0)) {
 755                 return NDR_ERR_SUCCESS;
 756         }
 757         if (unlikely(data == NULL)) {
 758                 return NDR_ERR_INVALID_POINTER;
 759         }
 760         NDR_PUSH_NEED_BYTES(ndr, n);
 761         memcpy(ndr->data + ndr->offset, data, n);
 762         ndr->offset += n;
 763         return NDR_ERR_SUCCESS;
 764 }
 765
 766 /*
 767   push some zero bytes
 768 */
 769 _PUBLIC_ enum ndr_err_code ndr_push_zero(struct ndr_push *ndr, uint32_t n)
 770 {
 771         NDR_PUSH_NEED_BYTES(ndr, n);
 772         memset(ndr->data + ndr->offset, 0, n);
 773         ndr->offset += n;
 774         return NDR_ERR_SUCCESS;
 775 }
 776
 777 /*
 778   push an array of uint8
 779 */
 780 _PUBLIC_ enum ndr_err_code ndr_push_array_uint8(struct ndr_push *ndr, int ndr_flags, const uint8_t *data, uint32_t n)
 781 {
 782         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 783         if (!(ndr_flags & NDR_SCALARS)) {
 784                 return NDR_ERR_SUCCESS;
 785         }
 786         return ndr_push_bytes(ndr, data, n);
 787 }
 788
 789 /*
 790   push a unique non-zero value if a pointer is non-NULL, otherwise 0
 791 */
 792 _PUBLIC_ enum ndr_err_code ndr_push_unique_ptr(struct ndr_push *ndr, const void *p)
 793 {
 794         uint32_t ptr = 0;
 795         if (p) {
 796                 ptr = ndr->ptr_count * 4;
 797                 ptr |= 0x00020000;
 798                 ndr->ptr_count++;
 799         }
 800         return ndr_push_uint3264(ndr, NDR_SCALARS, ptr);
 801 }
 802
 803 /*
 804   push a 'simple' full non-zero value if a pointer is non-NULL, otherwise 0
 805 */
 806 _PUBLIC_ enum ndr_err_code ndr_push_full_ptr(struct ndr_push *ndr, const void *p)
 807 {
 808         uint32_t ptr = 0;
 809         if (p) {
 810                 /* Check if the pointer already exists and has an id */
 811                 ptr = ndr_token_peek(&ndr->full_ptr_list, p);
 812                 if (ptr == 0) {
 813                         enum ndr_err_code ret = NDR_ERR_SUCCESS;
 814                         ndr->ptr_count++;
 815                         ptr = ndr->ptr_count;
 816                         ret = ndr_token_store(ndr, &ndr->full_ptr_list, p, ptr);
 817                         if (ret != NDR_ERR_SUCCESS) {
 818                                 return ret;
 819                         }
 820                 }
 821         }
 822         return ndr_push_uint3264(ndr, NDR_SCALARS, ptr);
 823 }
 824
 825 /*
 826   push always a 0, if a pointer is NULL it's a fatal error
 827 */
 828 _PUBLIC_ enum ndr_err_code ndr_push_ref_ptr(struct ndr_push *ndr)
 829 {
 830         return ndr_push_uint3264(ndr, NDR_SCALARS, 0xAEF1AEF1);
 831 }
 832
 833
 834 /*
 835   push a NTTIME
 836 */
 837 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME(struct ndr_push *ndr, int ndr_flags, NTTIME t)
 838 {
 839         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 840         NDR_CHECK(ndr_push_udlong(ndr, ndr_flags, t));
 841         return NDR_ERR_SUCCESS;
 842 }
 843
 844 /*
 845   pull a NTTIME
 846 */
 847 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
 848 {
 849         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 850         NDR_CHECK(ndr_pull_udlong(ndr, ndr_flags, t));
 851         return NDR_ERR_SUCCESS;
 852 }
 853
 854 /*
 855   push a NTTIME_1sec
 856 */
 857 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME_1sec(struct ndr_push *ndr, int ndr_flags, NTTIME t)
 858 {
 859         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 860         t /= 10000000;
 861         NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
 862         return NDR_ERR_SUCCESS;
 863 }
 864
 865 /*
 866   pull a NTTIME_1sec
 867 */
 868 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_1sec(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
 869 {
 870         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 871         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
 872         (*t) *= 10000000;
 873         return NDR_ERR_SUCCESS;
 874 }
 875
 876 /*
 877   pull a NTTIME_hyper
 878 */
 879 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_hyper(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
 880 {
 881         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
 882         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
 883         return NDR_ERR_SUCCESS;
 884 }
 885
 886 /*
 887   push a NTTIME_hyper
 888 */
 889 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME_hyper(struct ndr_push *ndr, int ndr_flags, NTTIME t)
 890 {
 891         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 892         NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
 893         return NDR_ERR_SUCCESS;
 894 }
 895
 896 /*
 897   push a time_t
 898 */
 899 _PUBLIC_ enum ndr_err_code ndr_push_time_t(struct ndr_push *ndr, int ndr_flags, time_t t)
 900 {
 901         return ndr_push_uint32(ndr, ndr_flags, t);
 902 }
 903
 904 /*
 905   pull a time_t
 906 */
 907 _PUBLIC_ enum ndr_err_code ndr_pull_time_t(struct ndr_pull *ndr, int ndr_flags, time_t *t)
 908 {
 909         uint32_t tt;
 910         NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &tt));
 911         *t = tt;
 912         return NDR_ERR_SUCCESS;
 913 }
 914
 915
 916 /*
 917   push a uid_t
 918 */
 919 _PUBLIC_ enum ndr_err_code ndr_push_uid_t(struct ndr_push *ndr, int ndr_flags, uid_t u)
 920 {
 921         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 922         return ndr_push_hyper(ndr, NDR_SCALARS, (uint64_t)u);
 923 }
 924
 925 /*
 926   pull a uid_t
 927 */
 928 _PUBLIC_ enum ndr_err_code ndr_pull_uid_t(struct ndr_pull *ndr, int ndr_flags, uid_t *u)
 929 {
 930         uint64_t uu = 0;
 931         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &uu));
 932         *u = (uid_t)uu;
 933         if (unlikely(uu != *u)) {
 934                 DEBUG(0,(__location__ ": uid_t pull doesn't fit 0x%016llx\n",
 935                          (unsigned long long)uu));
 936                 return NDR_ERR_NDR64;
 937         }
 938         return NDR_ERR_SUCCESS;
 939 }
 940
 941
 942 /*
 943   push a gid_t
 944 */
 945 _PUBLIC_ enum ndr_err_code ndr_push_gid_t(struct ndr_push *ndr, int ndr_flags, gid_t g)
 946 {
 947         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
 948         return ndr_push_hyper(ndr, NDR_SCALARS, (uint64_t)g);
 949 }
 950
 951 /*
 952   pull a gid_t
 953 */
 954 _PUBLIC_ enum ndr_err_code ndr_pull_gid_t(struct ndr_pull *ndr, int ndr_flags, gid_t *g)
 955 {
 956         uint64_t gg = 0;
 957         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &gg));
 958         *g = (gid_t)gg;
 959         if (unlikely(gg != *g)) {
 960                 DEBUG(0,(__location__ ": gid_t pull doesn't fit 0x%016llx\n",
 961                          (unsigned long long)gg));
 962                 return NDR_ERR_NDR64;
 963         }
 964         return NDR_ERR_SUCCESS;
 965 }
 966
 967
 968 /*
 969   pull a ipv4address
 970 */
 971 _PUBLIC_ enum ndr_err_code ndr_pull_ipv4address(struct ndr_pull *ndr, int ndr_flags, const char **address)
 972 {
 973         uint32_t addr;
 974         struct in_addr in;
 975         NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &addr));
 976         in.s_addr = htonl(addr);
 977         *address = talloc_strdup(ndr->current_mem_ctx, inet_ntoa(in));
 978         NDR_ERR_HAVE_NO_MEMORY(*address);
 979         return NDR_ERR_SUCCESS;
 980 }
 981
 982 /*
 983   push a ipv4address
 984 */
 985 _PUBLIC_ enum ndr_err_code ndr_push_ipv4address(struct ndr_push *ndr, int ndr_flags, const char *address)
 986 {
 987         uint32_t addr;
 988         if (!is_ipaddress(address)) {
 989                 return ndr_push_error(ndr, NDR_ERR_IPV4ADDRESS,
 990                                       "Invalid IPv4 address: '%s'",
 991                                       address);
 992         }
 993         addr = inet_addr(address);
 994         NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, htonl(addr)));
 995         return NDR_ERR_SUCCESS;
 996 }
 997
 998 /*
 999   print a ipv4address
1000 */
1001 _PUBLIC_ void ndr_print_ipv4address(struct ndr_print *ndr, const char *name,
1002                            const char *address)
1003 {
1004         ndr->print(ndr, "%-25s: %s", name, address);
1005 }
1006
1007 /*
1008   pull a ipv6address
1009 */
1010 #define IPV6_BYTES 16
1011 #define IPV6_ADDR_STR_LEN 39
1012 _PUBLIC_ enum ndr_err_code ndr_pull_ipv6address(struct ndr_pull *ndr, int ndr_flags, const char **address)
1013 {
1014         uint8_t addr[IPV6_BYTES];
1015         char *addr_str = talloc_strdup(ndr->current_mem_ctx, "");
1016         int i;
1017         NDR_CHECK(ndr_pull_array_uint8(ndr, ndr_flags, addr, IPV6_BYTES));
1018         for (i = 0; i < IPV6_BYTES; ++i) {
1019                 addr_str = talloc_asprintf_append(addr_str, "%02x", addr[i]);
1020                 /* We need a ':' every second byte but the last one */
1021                 if (i%2 == 1 && i != (IPV6_BYTES - 1)) {
1022                         addr_str = talloc_strdup_append(addr_str, ":");
1023                 }
1024         }
1025         *address = addr_str;
1026         NDR_ERR_HAVE_NO_MEMORY(*address);
1027         return NDR_ERR_SUCCESS;
1028 }
1029
1030 /*
1031   push a ipv6address
1032 */
1033 _PUBLIC_ enum ndr_err_code ndr_push_ipv6address(struct ndr_push *ndr, int ndr_flags, const char *address)
1034 {
1035 #ifdef AF_INET6
1036         uint8_t addr[IPV6_BYTES];
1037         int ret;
1038
1039         if (!is_ipaddress(address)) {
1040                 return ndr_push_error(ndr, NDR_ERR_IPV6ADDRESS,
1041                                       "Invalid IPv6 address: '%s'",
1042                                       address);
1043         }
1044         ret = inet_pton(AF_INET6, address, addr);
1045         if (ret <= 0) {
1046                 return NDR_ERR_IPV6ADDRESS;
1047         }
1048
1049         NDR_CHECK(ndr_push_array_uint8(ndr, ndr_flags, addr, IPV6_BYTES));
1050
1051         return NDR_ERR_SUCCESS;
1052 #else
1053         return NDR_ERR_IPV6ADDRESS;
1054 #endif
1055 }
1056
1057 /*
1058   print a ipv6address
1059 */
1060 _PUBLIC_ void ndr_print_ipv6address(struct ndr_print *ndr, const char *name,
1061                            const char *address)
1062 {
1063         ndr->print(ndr, "%-25s: %s", name, address);
1064 }
1065 #undef IPV6_BYTES
1066
1067 _PUBLIC_ void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type)
1068 {
1069         ndr->print(ndr, "%s: struct %s", name, type);
1070 }
1071
1072 _PUBLIC_ void ndr_print_null(struct ndr_print *ndr)
1073 {
1074         ndr->print(ndr, "UNEXPECTED NULL POINTER");
1075 }
1076
1077 _PUBLIC_ void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type,
1078                     const char *val, uint32_t value)
1079 {
1080         if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
1081                 ndr->print(ndr, "%-25s: %s (0x%X)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
1082         } else {
1083                 ndr->print(ndr, "%-25s: %s (%d)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
1084         }
1085 }
1086
1087 _PUBLIC_ void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint32_t flag, uint32_t value)
1088 {
1089         if (flag == 0) {
1090                 return;
1091         }
1092
1093         /* this is an attempt to support multi-bit bitmap masks */
1094         value &= flag;
1095
1096         while (!(flag & 1)) {
1097                 flag >>= 1;
1098                 value >>= 1;
1099         }
1100         if (flag == 1) {
1101                 ndr->print(ndr, "   %d: %-25s", value, flag_name);
1102         } else {
1103                 ndr->print(ndr, "0x%02x: %-25s (%d)", value, flag_name, value);
1104         }
1105 }
1106
1107 _PUBLIC_ void ndr_print_int8(struct ndr_print *ndr, const char *name, int8_t v)
1108 {
1109         if (NDR_HIDE_SECRET(ndr)) {
1110                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1111                 return;
1112         }
1113         ndr->print(ndr, "%-25s: %d", name, v);
1114 }
1115
1116 _PUBLIC_ void ndr_print_uint8(struct ndr_print *ndr, const char *name, uint8_t v)
1117 {
1118         if (NDR_HIDE_SECRET(ndr)) {
1119                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1120                 return;
1121         }
1122         ndr->print(ndr, "%-25s: 0x%02x (%u)", name, v, v);
1123 }
1124
1125 _PUBLIC_ void ndr_print_int16(struct ndr_print *ndr, const char *name, int16_t v)
1126 {
1127         if (NDR_HIDE_SECRET(ndr)) {
1128                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1129                 return;
1130         }
1131         ndr->print(ndr, "%-25s: %d", name, v);
1132 }
1133
1134 _PUBLIC_ void ndr_print_uint16(struct ndr_print *ndr, const char *name, uint16_t v)
1135 {
1136         if (NDR_HIDE_SECRET(ndr)) {
1137                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1138                 return;
1139         }
1140         ndr->print(ndr, "%-25s: 0x%04x (%u)", name, v, v);
1141 }
1142
1143 _PUBLIC_ void ndr_print_int32(struct ndr_print *ndr, const char *name, int32_t v)
1144 {
1145         if (NDR_HIDE_SECRET(ndr)) {
1146                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1147                 return;
1148         }
1149         ndr->print(ndr, "%-25s: %d", name, v);
1150 }
1151
1152 _PUBLIC_ void ndr_print_uint32(struct ndr_print *ndr, const char *name, uint32_t v)
1153 {
1154         if (NDR_HIDE_SECRET(ndr)) {
1155                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1156                 return;
1157         }
1158         ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
1159 }
1160
1161 _PUBLIC_ void ndr_print_int3264(struct ndr_print *ndr, const char *name, int32_t v)
1162 {
1163         if (NDR_HIDE_SECRET(ndr)) {
1164                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1165                 return;
1166         }
1167         ndr->print(ndr, "%-25s: %d", name, v);
1168 }
1169
1170 _PUBLIC_ void ndr_print_uint3264(struct ndr_print *ndr, const char *name, uint32_t v)
1171 {
1172         if (NDR_HIDE_SECRET(ndr)) {
1173                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1174                 return;
1175         }
1176         ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
1177 }
1178
1179 _PUBLIC_ void ndr_print_udlong(struct ndr_print *ndr, const char *name, uint64_t v)
1180 {
1181         ndr->print(ndr, "%-25s: 0x%016llx (%llu)", name, (unsigned long long)v, (unsigned long long)v);
1182 }
1183
1184 _PUBLIC_ void ndr_print_udlongr(struct ndr_print *ndr, const char *name, uint64_t v)
1185 {
1186         ndr_print_udlong(ndr, name, v);
1187 }
1188
1189 _PUBLIC_ void ndr_print_dlong(struct ndr_print *ndr, const char *name, int64_t v)
1190 {
1191         if (NDR_HIDE_SECRET(ndr)) {
1192                 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1193                 return;
1194         }
1195         ndr->print(ndr, "%-25s: 0x%016llx (%lld)", name, (unsigned long long)v, (long long)v);
1196 }
1197
1198 _PUBLIC_ void ndr_print_double(struct ndr_print *ndr, const char *name, double v)
1199 {
1200         ndr->print(ndr, "%-25s: %f", name, v);
1201 }
1202
1203 _PUBLIC_ void ndr_print_hyper(struct ndr_print *ndr, const char *name, uint64_t v)
1204 {
1205         ndr_print_dlong(ndr, name, v);
1206 }
1207
1208 _PUBLIC_ void ndr_print_pointer(struct ndr_print *ndr, const char *name, void *v)
1209 {
1210         ndr->print(ndr, "%-25s: %p", name, v);
1211 }
1212
1213 _PUBLIC_ void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p)
1214 {
1215         if (p) {
1216                 ndr->print(ndr, "%-25s: *", name);
1217         } else {
1218                 ndr->print(ndr, "%-25s: NULL", name);
1219         }
1220 }
1221
1222 _PUBLIC_ void ndr_print_NTTIME(struct ndr_print *ndr, const char *name, NTTIME t)
1223 {
1224         ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr, t));
1225 }
1226
1227 _PUBLIC_ void ndr_print_NTTIME_1sec(struct ndr_print *ndr, const char *name, NTTIME t)
1228 {
1229         /* this is a standard NTTIME here
1230          * as it's already converted in the pull/push code
1231          */
1232         ndr_print_NTTIME(ndr, name, t);
1233 }
1234
1235 _PUBLIC_ void ndr_print_NTTIME_hyper(struct ndr_print *ndr, const char *name, NTTIME t)
1236 {
1237         ndr_print_NTTIME(ndr, name, t);
1238 }
1239
1240 _PUBLIC_ void ndr_print_time_t(struct ndr_print *ndr, const char *name, time_t t)
1241 {
1242         if (t == (time_t)-1 || t == 0) {
1243                 ndr->print(ndr, "%-25s: (time_t)%d", name, (int)t);
1244         } else {
1245                 ndr->print(ndr, "%-25s: %s", name, timestring(ndr, t));
1246         }
1247 }
1248
1249 _PUBLIC_ void ndr_print_uid_t(struct ndr_print *ndr, const char *name, uid_t u)
1250 {
1251         ndr_print_dlong(ndr, name, u);
1252 }
1253
1254 _PUBLIC_ void ndr_print_gid_t(struct ndr_print *ndr, const char *name, gid_t g)
1255 {
1256         ndr_print_dlong(ndr, name, g);
1257 }
1258
1259 _PUBLIC_ void ndr_print_union(struct ndr_print *ndr, const char *name, int level, const char *type)
1260 {
1261         if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
1262                 ndr->print(ndr, "%-25s: union %s(case 0x%X)", name, type, level);
1263         } else {
1264                 ndr->print(ndr, "%-25s: union %s(case %d)", name, type, level);
1265         }
1266 }
1267
1268 _PUBLIC_ void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level)
1269 {
1270         ndr->print(ndr, "UNKNOWN LEVEL %u", level);
1271 }
1272
1273 _PUBLIC_ void ndr_print_array_uint8(struct ndr_print *ndr, const char *name,
1274                            const uint8_t *data, uint32_t count)
1275 {
1276         int i;
1277 #define _ONELINE_LIMIT 32
1278
1279         if (data == NULL) {
1280                 ndr->print(ndr, "%s: ARRAY(%d) : NULL", name, count);
1281                 return;
1282         }
1283
1284         if (NDR_HIDE_SECRET(ndr)) {
1285                 ndr->print(ndr, "%s: ARRAY(%d): <REDACTED SECRET VALUES>", name, count);
1286                 return;
1287         }
1288
1289         if (count <= _ONELINE_LIMIT && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
1290                 char s[(_ONELINE_LIMIT + 1) * 2];
1291                 for (i=0;i<count;i++) {
1292                         snprintf(&s[i*2], 3, "%02x", data[i]);
1293                 }
1294                 s[i*2] = 0;
1295                 ndr->print(ndr, "%-25s: %s", name, s);
1296                 return;
1297         }
1298
1299         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
1300         if (count > _ONELINE_LIMIT && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
1301                 ndr_dump_data(ndr, data, count);
1302                 return;
1303         }
1304
1305         ndr->depth++;
1306         for (i=0;i<count;i++) {
1307                 char *idx=NULL;
1308                 if (asprintf(&idx, "[%d]", i) != -1) {
1309                         ndr_print_uint8(ndr, idx, data[i]);
1310                         free(idx);
1311                 }
1312         }
1313         ndr->depth--;
1314 #undef _ONELINE_LIMIT
1315 }
1316
1317 static void ndr_print_dump_data_cb(const char *buf, void *private_data)
1318 {
1319         struct ndr_print *ndr = (struct ndr_print *)private_data;
1320
1321         ndr->print(ndr, "%s", buf);
1322 }
1323
1324 /*
1325   ndr_print version of dump_data()
1326  */
1327 static void ndr_dump_data(struct ndr_print *ndr, const uint8_t *buf, int len)
1328 {
1329         if (NDR_HIDE_SECRET(ndr)) {
1330                 return;
1331         }
1332         ndr->no_newline = true;
1333         dump_data_cb(buf, len, true, ndr_print_dump_data_cb, ndr);
1334         ndr->no_newline = false;
1335 }
1336
1337
1338 _PUBLIC_ void ndr_print_DATA_BLOB(struct ndr_print *ndr, const char *name, DATA_BLOB r)
1339 {
1340         ndr->print(ndr, "%-25s: DATA_BLOB length=%u", name, (unsigned)r.length);
1341         if (r.length) {
1342                 ndr_dump_data(ndr, r.data, r.length);
1343         }
1344 }
1345
1346
1347 /*
1348  * Push a DATA_BLOB onto the wire.
1349  * 1) When called with LIBNDR_FLAG_ALIGN* alignment flags set, push padding
1350  *    bytes _only_. The length is determined by the alignment required and the
1351  *    current ndr offset.
1352  * 2) When called with the LIBNDR_FLAG_REMAINING flag, push the byte array to
1353  *    the ndr buffer.
1354  * 3) Otherwise, push a uint3264 length _and_ a corresponding byte array to the
1355  *    ndr buffer.
1356  */
1357 _PUBLIC_ enum ndr_err_code ndr_push_DATA_BLOB(struct ndr_push *ndr, int ndr_flags, DATA_BLOB blob)
1358 {
1359         if (ndr->flags & LIBNDR_FLAG_REMAINING) {
1360                 /* nothing to do */
1361         } else if (ndr->flags & (LIBNDR_ALIGN_FLAGS & ~LIBNDR_FLAG_NOALIGN)) {
1362                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1363                         blob.length = NDR_ALIGN(ndr, 2);
1364                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1365                         blob.length = NDR_ALIGN(ndr, 4);
1366                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1367                         blob.length = NDR_ALIGN(ndr, 8);
1368                 }
1369                 NDR_PUSH_ALLOC_SIZE(ndr, blob.data, blob.length);
1370                 data_blob_clear(&blob);
1371         } else {
1372                 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, blob.length));
1373         }
1374         NDR_CHECK(ndr_push_bytes(ndr, blob.data, blob.length));
1375         return NDR_ERR_SUCCESS;
1376 }
1377
1378 /*
1379  * Pull a DATA_BLOB from the wire.
1380  * 1) when called with LIBNDR_FLAG_ALIGN* alignment flags set, pull padding
1381  *    bytes _only_. The length is determined by the alignment required and the
1382  *    current ndr offset.
1383  * 2) When called with the LIBNDR_FLAG_REMAINING flag, pull all remaining bytes
1384  *    from the ndr buffer.
1385  * 3) Otherwise, pull a uint3264 length _and_ a corresponding byte array from the
1386  *    ndr buffer.
1387  */
1388 _PUBLIC_ enum ndr_err_code ndr_pull_DATA_BLOB(struct ndr_pull *ndr, int ndr_flags, DATA_BLOB *blob)
1389 {
1390         uint32_t length = 0;
1391
1392         if (ndr->flags & LIBNDR_FLAG_REMAINING) {
1393                 length = ndr->data_size - ndr->offset;
1394         } else if (ndr->flags & (LIBNDR_ALIGN_FLAGS & ~LIBNDR_FLAG_NOALIGN)) {
1395                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1396                         length = NDR_ALIGN(ndr, 2);
1397                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1398                         length = NDR_ALIGN(ndr, 4);
1399                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1400                         length = NDR_ALIGN(ndr, 8);
1401                 }
1402                 if (ndr->data_size - ndr->offset < length) {
1403                         length = ndr->data_size - ndr->offset;
1404                 }
1405         } else {
1406                 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &length));
1407         }
1408         NDR_PULL_NEED_BYTES(ndr, length);
1409         *blob = data_blob_talloc(ndr->current_mem_ctx, ndr->data+ndr->offset, length);
1410         ndr->offset += length;
1411         return NDR_ERR_SUCCESS;
1412 }
1413
1414 _PUBLIC_ uint32_t ndr_size_DATA_BLOB(int ret, const DATA_BLOB *data, int flags)
1415 {
1416         if (!data) return ret;
1417         return ret + data->length;
1418 }
1419
1420 _PUBLIC_ void ndr_print_bool(struct ndr_print *ndr, const char *name, const bool b)
1421 {
1422         ndr->print(ndr, "%-25s: %s", name, b?"true":"false");
1423 }
1424
1425 _PUBLIC_ NTSTATUS ndr_map_error2ntstatus(enum ndr_err_code ndr_err)
1426 {
1427         switch (ndr_err) {
1428         case NDR_ERR_SUCCESS:
1429                 return NT_STATUS_OK;
1430         case NDR_ERR_BUFSIZE:
1431                 return NT_STATUS_BUFFER_TOO_SMALL;
1432         case NDR_ERR_TOKEN:
1433                 return NT_STATUS_INTERNAL_ERROR;
1434         case NDR_ERR_ALLOC:
1435                 return NT_STATUS_NO_MEMORY;
1436         case NDR_ERR_ARRAY_SIZE:
1437                 return NT_STATUS_ARRAY_BOUNDS_EXCEEDED;
1438         case NDR_ERR_INVALID_POINTER:
1439                 return NT_STATUS_INVALID_PARAMETER_MIX;
1440         case NDR_ERR_UNREAD_BYTES:
1441                 return NT_STATUS_PORT_MESSAGE_TOO_LONG;
1442         default:
1443                 break;
1444         }
1445
1446         /* we should map all error codes to different status codes */
1447         return NT_STATUS_INVALID_PARAMETER;
1448 }
1449
1450 _PUBLIC_ int ndr_map_error2errno(enum ndr_err_code ndr_err)
1451 {
1452         switch (ndr_err) {
1453         case NDR_ERR_SUCCESS:
1454                 return 0;
1455         case NDR_ERR_BUFSIZE:
1456                 return ENOSPC;
1457         case NDR_ERR_TOKEN:
1458                 return EINVAL;
1459         case NDR_ERR_ALLOC:
1460                 return ENOMEM;
1461         case NDR_ERR_ARRAY_SIZE:
1462                 return EMSGSIZE;
1463         case NDR_ERR_INVALID_POINTER:
1464                 return EINVAL;
1465         case NDR_ERR_UNREAD_BYTES:
1466                 return EOVERFLOW;
1467         default:
1468                 break;
1469         }
1470
1471         /* we should map all error codes to different status codes */
1472         return EINVAL;
1473 }
1474
1475 _PUBLIC_ enum ndr_err_code ndr_push_timespec(struct ndr_push *ndr,
1476                                              int ndr_flags,
1477                                              const struct timespec *t)
1478 {
1479         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1480         NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t->tv_sec));
1481         NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, t->tv_nsec));
1482         return NDR_ERR_SUCCESS;
1483 }
1484
1485 _PUBLIC_ enum ndr_err_code ndr_pull_timespec(struct ndr_pull *ndr,
1486                                              int ndr_flags,
1487                                              struct timespec *t)
1488 {
1489         uint64_t secs = 0;
1490         uint32_t nsecs = 0;
1491         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1492         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &secs));
1493         NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &nsecs));
1494         t->tv_sec = secs;
1495         t->tv_nsec = nsecs;
1496         return NDR_ERR_SUCCESS;
1497 }
1498
1499 _PUBLIC_ void ndr_print_timespec(struct ndr_print *ndr, const char *name,
1500                                  const struct timespec *t)
1501 {
1502         char *str = timestring(ndr, t->tv_sec);
1503         ndr->print(ndr, "%-25s: %s.%ld", name, str, t->tv_nsec);
1504         TALLOC_FREE(str);
1505 }
1506
1507 _PUBLIC_ enum ndr_err_code ndr_push_timeval(struct ndr_push *ndr,
1508                                             int ndr_flags,
1509                                             const struct timeval *t)
1510 {
1511         NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1512         NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t->tv_sec));
1513         NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, t->tv_usec));
1514         return NDR_ERR_SUCCESS;
1515 }
1516
1517 _PUBLIC_ enum ndr_err_code ndr_pull_timeval(struct ndr_pull *ndr,
1518                                             int ndr_flags,
1519                                             struct timeval *t)
1520 {
1521         uint64_t secs = 0;
1522         uint32_t usecs = 0;
1523         NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1524         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &secs));
1525         NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &usecs));
1526         t->tv_sec = secs;
1527         t->tv_usec = usecs;
1528         return NDR_ERR_SUCCESS;
1529 }
1530
1531 _PUBLIC_ void ndr_print_timeval(struct ndr_print *ndr, const char *name,
1532                                 const struct timeval *t)
1533 {
1534         ndr->print(ndr, "%-25s: %s.%ld", name, timestring(ndr, t->tv_sec),
1535                    (long)t->tv_usec);
1536 }