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