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