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