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
  26 #define NDR_SVAL(ndr, ofs) (NDR_BE(ndr)?RSVAL(ndr->data,ofs):SVAL(ndr->data,ofs))
  27 #define NDR_IVAL(ndr, ofs) (NDR_BE(ndr)?RIVAL(ndr->data,ofs):IVAL(ndr->data,ofs))
  28 #define NDR_IVALS(ndr, ofs) (NDR_BE(ndr)?RIVALS(ndr->data,ofs):IVALS(ndr->data,ofs))
  29 #define NDR_SSVAL(ndr, ofs, v) do { if (NDR_BE(ndr))  { RSSVAL(ndr->data,ofs,v); } else SSVAL(ndr->data,ofs,v); } while (0)
  30 #define NDR_SIVAL(ndr, ofs, v) do { if (NDR_BE(ndr))  { RSIVAL(ndr->data,ofs,v); } else SIVAL(ndr->data,ofs,v); } while (0)
  31 #define NDR_SIVALS(ndr, ofs, v) do { if (NDR_BE(ndr))  { RSIVALS(ndr->data,ofs,v); } else SIVALS(ndr->data,ofs,v); } while (0)
  32
  33
  34 /*
  35   check for data leaks from the server by looking for non-zero pad bytes
  36   these could also indicate that real structure elements have been
  37   mistaken for padding in the IDL
  38 */
  39 _PUBLIC_ void ndr_check_padding(struct ndr_pull *ndr, size_t n)
  40 {
  41         size_t ofs2 = (ndr->offset + (n-1)) & ~(n-1);
  42         int i;
  43         for (i=ndr->offset;i<ofs2;i++) {
  44                 if (ndr->data[i] != 0) {
  45                         break;
  46                 }
  47         }
  48         if (i<ofs2) {
  49                 DEBUG(0,("WARNING: Non-zero padding to %d: ", (int)n));
  50                 for (i=ndr->offset;i<ofs2;i++) {
  51                         DEBUG(0,("%02x ", ndr->data[i]));
  52                 }
  53                 DEBUG(0,("\n"));
  54         }
  55
  56 }
  57
  58 /*
  59   parse a int8_t
  60 */
  61 _PUBLIC_ enum ndr_err_code ndr_pull_int8(struct ndr_pull *ndr, int ndr_flags, int8_t *v)
  62 {
  63         NDR_PULL_NEED_BYTES(ndr, 1);
  64         *v = (int8_t)CVAL(ndr->data, ndr->offset);
  65         ndr->offset += 1;
  66         return NDR_ERR_SUCCESS;
  67 }
  68
  69 /*
  70   parse a uint8_t
  71 */
  72 _PUBLIC_ enum ndr_err_code ndr_pull_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
  73 {
  74         NDR_PULL_NEED_BYTES(ndr, 1);
  75         *v = CVAL(ndr->data, ndr->offset);
  76         ndr->offset += 1;
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 /*
  81   parse a int16_t
  82 */
  83 _PUBLIC_ enum ndr_err_code ndr_pull_int16(struct ndr_pull *ndr, int ndr_flags, int16_t *v)
  84 {
  85         NDR_PULL_ALIGN(ndr, 2);
  86         NDR_PULL_NEED_BYTES(ndr, 2);
  87         *v = (uint16_t)NDR_SVAL(ndr, ndr->offset);
  88         ndr->offset += 2;
  89         return NDR_ERR_SUCCESS;
  90 }
  91
  92 /*
  93   parse a uint16_t
  94 */
  95 _PUBLIC_ enum ndr_err_code ndr_pull_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
  96 {
  97         NDR_PULL_ALIGN(ndr, 2);
  98         NDR_PULL_NEED_BYTES(ndr, 2);
  99         *v = NDR_SVAL(ndr, ndr->offset);
 100         ndr->offset += 2;
 101         return NDR_ERR_SUCCESS;
 102 }
 103
 104 /*
 105   parse a int32_t
 106 */
 107 _PUBLIC_ enum ndr_err_code ndr_pull_int32(struct ndr_pull *ndr, int ndr_flags, int32_t *v)
 108 {
 109         NDR_PULL_ALIGN(ndr, 4);
 110         NDR_PULL_NEED_BYTES(ndr, 4);
 111         *v = NDR_IVALS(ndr, ndr->offset);
 112         ndr->offset += 4;
 113         return NDR_ERR_SUCCESS;
 114 }
 115
 116 /*
 117   parse a uint32_t
 118 */
 119 _PUBLIC_ enum ndr_err_code ndr_pull_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
 120 {
 121         NDR_PULL_ALIGN(ndr, 4);
 122         NDR_PULL_NEED_BYTES(ndr, 4);
 123         *v = NDR_IVAL(ndr, ndr->offset);
 124         ndr->offset += 4;
 125         return NDR_ERR_SUCCESS;
 126 }
 127
 128 /*
 129   parse a arch dependent uint32/uint64
 130 */
 131 _PUBLIC_ enum ndr_err_code ndr_pull_uint3264(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
 132 {
 133         uint64_t v64;
 134         enum ndr_err_code err;
 135         if (likely(!(ndr->flags & LIBNDR_FLAG_NDR64))) {
 136                 return ndr_pull_uint32(ndr, ndr_flags, v);
 137         }
 138         err = ndr_pull_hyper(ndr, ndr_flags, &v64);
 139         *v = (uint32_t)v64;
 140         if (unlikely(v64 != *v)) {
 141                 DEBUG(0,(__location__ ": non-zero upper 32 bits 0x%016llx\n",
 142                          (unsigned long long)v64));
 143                 return NDR_ERR_NDR64;
 144         }
 145         return err;
 146 }
 147
 148 /*
 149   parse a double
 150 */
 151 _PUBLIC_ enum ndr_err_code ndr_pull_double(struct ndr_pull *ndr, int ndr_flags, double *v)
 152 {
 153         NDR_PULL_ALIGN(ndr, 8);
 154         NDR_PULL_NEED_BYTES(ndr, 8);
 155         memcpy(v, ndr->data+ndr->offset, 8);
 156         ndr->offset += 8;
 157         return NDR_ERR_SUCCESS;
 158 }
 159
 160 /*
 161   parse a pointer referent identifier
 162 */
 163 _PUBLIC_ enum ndr_err_code ndr_pull_generic_ptr(struct ndr_pull *ndr, uint32_t *v)
 164 {
 165         NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, v));
 166         if (*v != 0) {
 167                 ndr->ptr_count++;
 168         }
 169         return NDR_ERR_SUCCESS;
 170 }
 171
 172 /*
 173   parse a ref pointer referent identifier
 174 */
 175 _PUBLIC_ enum ndr_err_code ndr_pull_ref_ptr(struct ndr_pull *ndr, uint32_t *v)
 176 {
 177         NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, v));
 178         /* ref pointers always point to data */
 179         *v = 1;
 180         return NDR_ERR_SUCCESS;
 181 }
 182
 183 /*
 184   parse a udlong
 185 */
 186 _PUBLIC_ enum ndr_err_code ndr_pull_udlong(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
 187 {
 188         NDR_PULL_ALIGN(ndr, 4);
 189         NDR_PULL_NEED_BYTES(ndr, 8);
 190         *v = NDR_IVAL(ndr, ndr->offset);
 191         *v |= (uint64_t)(NDR_IVAL(ndr, ndr->offset+4)) << 32;
 192         ndr->offset += 8;
 193         return NDR_ERR_SUCCESS;
 194 }
 195
 196 /*
 197   parse a udlongr
 198 */
 199 _PUBLIC_ enum ndr_err_code ndr_pull_udlongr(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
 200 {
 201         NDR_PULL_ALIGN(ndr, 4);
 202         NDR_PULL_NEED_BYTES(ndr, 8);
 203         *v = ((uint64_t)NDR_IVAL(ndr, ndr->offset)) << 32;
 204         *v |= NDR_IVAL(ndr, ndr->offset+4);
 205         ndr->offset += 8;
 206         return NDR_ERR_SUCCESS;
 207 }
 208
 209 /*
 210   parse a dlong
 211 */
 212 _PUBLIC_ enum ndr_err_code ndr_pull_dlong(struct ndr_pull *ndr, int ndr_flags, int64_t *v)
 213 {
 214         return ndr_pull_udlong(ndr, ndr_flags, (uint64_t *)v);
 215 }
 216
 217 /*
 218   parse a hyper
 219 */
 220 _PUBLIC_ enum ndr_err_code ndr_pull_hyper(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
 221 {
 222         NDR_PULL_ALIGN(ndr, 8);
 223         return ndr_pull_udlong(ndr, ndr_flags, v);
 224 }
 225
 226 /*
 227   parse a pointer
 228 */
 229 _PUBLIC_ enum ndr_err_code ndr_pull_pointer(struct ndr_pull *ndr, int ndr_flags, void* *v)
 230 {
 231         uintptr_t h;
 232         NDR_PULL_ALIGN(ndr, sizeof(h));
 233         NDR_PULL_NEED_BYTES(ndr, sizeof(h));
 234         memcpy(&h, ndr->data+ndr->offset, sizeof(h));
 235         ndr->offset += sizeof(h);
 236         *v = (void *)h;
 237         return NDR_ERR_SUCCESS;
 238 }
 239
 240 /*
 241   pull a NTSTATUS
 242 */
 243 _PUBLIC_ enum ndr_err_code ndr_pull_NTSTATUS(struct ndr_pull *ndr, int ndr_flags, NTSTATUS *status)
 244 {
 245         uint32_t v;
 246         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 247         *status = NT_STATUS(v);
 248         return NDR_ERR_SUCCESS;
 249 }
 250
 251 /*
 252   push a NTSTATUS
 253 */
 254 _PUBLIC_ enum ndr_err_code ndr_push_NTSTATUS(struct ndr_push *ndr, int ndr_flags, NTSTATUS status)
 255 {
 256         return ndr_push_uint32(ndr, ndr_flags, NT_STATUS_V(status));
 257 }
 258
 259 _PUBLIC_ void ndr_print_NTSTATUS(struct ndr_print *ndr, const char *name, NTSTATUS r)
 260 {
 261         ndr->print(ndr, "%-25s: %s", name, nt_errstr(r));
 262 }
 263
 264 /*
 265   pull a WERROR
 266 */
 267 _PUBLIC_ enum ndr_err_code ndr_pull_WERROR(struct ndr_pull *ndr, int ndr_flags, WERROR *status)
 268 {
 269         uint32_t v;
 270         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 271         *status = W_ERROR(v);
 272         return NDR_ERR_SUCCESS;
 273 }
 274
 275
 276 /*
 277   parse a uint8_t enum
 278 */
 279 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
 280 {
 281         return ndr_pull_uint8(ndr, ndr_flags, v);
 282 }
 283
 284 /*
 285   parse a uint16_t enum (uint32_t on NDR64)
 286 */
 287 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
 288 {
 289         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 290                 uint32_t v32;
 291                 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &v32));
 292                 *v = v32;
 293                 if (v32 != *v) {
 294                         DEBUG(0,(__location__ ": non-zero upper 16 bits 0x%08x\n", (unsigned)v32));
 295                         return NDR_ERR_NDR64;
 296                 }
 297                 return NDR_ERR_SUCCESS;
 298         }
 299         NDR_PULL_ALIGN(ndr, 2);
 300         NDR_PULL_NEED_BYTES(ndr, 2);
 301         *v = NDR_SVAL(ndr, ndr->offset);
 302         ndr->offset += 2;
 303         return NDR_ERR_SUCCESS;
 304 }
 305
 306 /*
 307   parse a uint32_t enum
 308 */
 309 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
 310 {
 311         return ndr_pull_uint32(ndr, ndr_flags, v);
 312 }
 313
 314 /*
 315   push a uint8_t enum
 316 */
 317 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
 318 {
 319         return ndr_push_uint8(ndr, ndr_flags, v);
 320 }
 321
 322 /*
 323   push a uint16_t enum (uint32_t on NDR64)
 324 */
 325 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
 326 {
 327         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 328                 return ndr_push_uint32(ndr, ndr_flags, v);
 329         }
 330         return ndr_push_uint16(ndr, ndr_flags, v);
 331 }
 332
 333 /*
 334   push a uint32_t enum
 335 */
 336 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
 337 {
 338         return ndr_push_uint32(ndr, ndr_flags, v);
 339 }
 340
 341
 342 /*
 343   push a WERROR
 344 */
 345 _PUBLIC_ enum ndr_err_code ndr_push_WERROR(struct ndr_push *ndr, int ndr_flags, WERROR status)
 346 {
 347         return ndr_push_uint32(ndr, NDR_SCALARS, W_ERROR_V(status));
 348 }
 349
 350 _PUBLIC_ void ndr_print_WERROR(struct ndr_print *ndr, const char *name, WERROR r)
 351 {
 352         ndr->print(ndr, "%-25s: %s", name, win_errstr(r));
 353 }
 354
 355 /*
 356   parse a set of bytes
 357 */
 358 _PUBLIC_ enum ndr_err_code ndr_pull_bytes(struct ndr_pull *ndr, uint8_t *data, uint32_t n)
 359 {
 360         NDR_PULL_NEED_BYTES(ndr, n);
 361         memcpy(data, ndr->data + ndr->offset, n);
 362         ndr->offset += n;
 363         return NDR_ERR_SUCCESS;
 364 }
 365
 366 /*
 367   pull an array of uint8
 368 */
 369 _PUBLIC_ enum ndr_err_code ndr_pull_array_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *data, uint32_t n)
 370 {
 371         if (!(ndr_flags & NDR_SCALARS)) {
 372                 return NDR_ERR_SUCCESS;
 373         }
 374         return ndr_pull_bytes(ndr, data, n);
 375 }
 376
 377 /*
 378   push a int8_t
 379 */
 380 _PUBLIC_ enum ndr_err_code ndr_push_int8(struct ndr_push *ndr, int ndr_flags, int8_t v)
 381 {
 382         NDR_PUSH_NEED_BYTES(ndr, 1);
 383         SCVAL(ndr->data, ndr->offset, (uint8_t)v);
 384         ndr->offset += 1;
 385         return NDR_ERR_SUCCESS;
 386 }
 387
 388 /*
 389   push a uint8_t
 390 */
 391 _PUBLIC_ enum ndr_err_code ndr_push_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
 392 {
 393         NDR_PUSH_NEED_BYTES(ndr, 1);
 394         SCVAL(ndr->data, ndr->offset, v);
 395         ndr->offset += 1;
 396         return NDR_ERR_SUCCESS;
 397 }
 398
 399 /*
 400   push a int16_t
 401 */
 402 _PUBLIC_ enum ndr_err_code ndr_push_int16(struct ndr_push *ndr, int ndr_flags, int16_t v)
 403 {
 404         NDR_PUSH_ALIGN(ndr, 2);
 405         NDR_PUSH_NEED_BYTES(ndr, 2);
 406         NDR_SSVAL(ndr, ndr->offset, (uint16_t)v);
 407         ndr->offset += 2;
 408         return NDR_ERR_SUCCESS;
 409 }
 410
 411 /*
 412   push a uint16_t
 413 */
 414 _PUBLIC_ enum ndr_err_code ndr_push_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
 415 {
 416         NDR_PUSH_ALIGN(ndr, 2);
 417         NDR_PUSH_NEED_BYTES(ndr, 2);
 418         NDR_SSVAL(ndr, ndr->offset, v);
 419         ndr->offset += 2;
 420         return NDR_ERR_SUCCESS;
 421 }
 422
 423 /*
 424   push a int32_t
 425 */
 426 _PUBLIC_ enum ndr_err_code ndr_push_int32(struct ndr_push *ndr, int ndr_flags, int32_t v)
 427 {
 428         NDR_PUSH_ALIGN(ndr, 4);
 429         NDR_PUSH_NEED_BYTES(ndr, 4);
 430         NDR_SIVALS(ndr, ndr->offset, v);
 431         ndr->offset += 4;
 432         return NDR_ERR_SUCCESS;
 433 }
 434
 435 /*
 436   push a uint32_t
 437 */
 438 _PUBLIC_ enum ndr_err_code ndr_push_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
 439 {
 440         NDR_PUSH_ALIGN(ndr, 4);
 441         NDR_PUSH_NEED_BYTES(ndr, 4);
 442         NDR_SIVAL(ndr, ndr->offset, v);
 443         ndr->offset += 4;
 444         return NDR_ERR_SUCCESS;
 445 }
 446
 447 /*
 448   push a uint3264
 449 */
 450 _PUBLIC_ enum ndr_err_code ndr_push_uint3264(struct ndr_push *ndr, int ndr_flags, uint32_t v)
 451 {
 452         if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
 453                 return ndr_push_hyper(ndr, ndr_flags, v);
 454         }
 455         NDR_PUSH_ALIGN(ndr, 4);
 456         NDR_PUSH_NEED_BYTES(ndr, 4);
 457         NDR_SIVAL(ndr, ndr->offset, v);
 458         ndr->offset += 4;
 459         return NDR_ERR_SUCCESS;
 460 }
 461
 462 /*
 463   push a udlong
 464 */
 465 _PUBLIC_ enum ndr_err_code ndr_push_udlong(struct ndr_push *ndr, int ndr_flags, uint64_t v)
 466 {
 467         NDR_PUSH_ALIGN(ndr, 4);
 468         NDR_PUSH_NEED_BYTES(ndr, 8);
 469         NDR_SIVAL(ndr, ndr->offset, (v & 0xFFFFFFFF));
 470         NDR_SIVAL(ndr, ndr->offset+4, (v>>32));
 471         ndr->offset += 8;
 472         return NDR_ERR_SUCCESS;
 473 }
 474
 475 /*
 476   push a udlongr
 477 */
 478 _PUBLIC_ enum ndr_err_code ndr_push_udlongr(struct ndr_push *ndr, int ndr_flags, uint64_t v)
 479 {
 480         NDR_PUSH_ALIGN(ndr, 4);
 481         NDR_PUSH_NEED_BYTES(ndr, 8);
 482         NDR_SIVAL(ndr, ndr->offset, (v>>32));
 483         NDR_SIVAL(ndr, ndr->offset+4, (v & 0xFFFFFFFF));
 484         ndr->offset += 8;
 485         return NDR_ERR_SUCCESS;
 486 }
 487
 488 /*
 489   push a dlong
 490 */
 491 _PUBLIC_ enum ndr_err_code ndr_push_dlong(struct ndr_push *ndr, int ndr_flags, int64_t v)
 492 {
 493         return ndr_push_udlong(ndr, NDR_SCALARS, (uint64_t)v);
 494 }
 495
 496 /*
 497   push a hyper
 498 */
 499 _PUBLIC_ enum ndr_err_code ndr_push_hyper(struct ndr_push *ndr, int ndr_flags, uint64_t v)
 500 {
 501         NDR_PUSH_ALIGN(ndr, 8);
 502         return ndr_push_udlong(ndr, NDR_SCALARS, v);
 503 }
 504
 505 /*
 506   push a double
 507 */
 508 _PUBLIC_ enum ndr_err_code ndr_push_double(struct ndr_push *ndr, int ndr_flags, double v)
 509 {
 510         NDR_PUSH_ALIGN(ndr, 8);
 511         NDR_PUSH_NEED_BYTES(ndr, 8);
 512         memcpy(ndr->data+ndr->offset, &v, 8);
 513         ndr->offset += 8;
 514         return NDR_ERR_SUCCESS;
 515 }
 516
 517 /*
 518   push a pointer
 519 */
 520 _PUBLIC_ enum ndr_err_code ndr_push_pointer(struct ndr_push *ndr, int ndr_flags, void* v)
 521 {
 522         uintptr_t h = (intptr_t)v;
 523         NDR_PUSH_ALIGN(ndr, sizeof(h));
 524         NDR_PUSH_NEED_BYTES(ndr, sizeof(h));
 525         memcpy(ndr->data+ndr->offset, &h, sizeof(h));
 526         ndr->offset += sizeof(h);
 527         return NDR_ERR_SUCCESS;
 528 }
 529
 530 _PUBLIC_ enum ndr_err_code ndr_push_align(struct ndr_push *ndr, size_t size)
 531 {
 532         /* this is a nasty hack to make pidl work with NDR64 */
 533         if (size == 5) {
 534                 if (ndr->flags & LIBNDR_FLAG_NDR64) {
 535                         size = 8;
 536                 } else {
 537                         size = 4;
 538                 }
 539         }
 540         NDR_PUSH_ALIGN(ndr, size);
 541         return NDR_ERR_SUCCESS;
 542 }
 543
 544 _PUBLIC_ enum ndr_err_code ndr_pull_align(struct ndr_pull *ndr, size_t size)
 545 {
 546         /* this is a nasty hack to make pidl work with NDR64 */
 547         if (size == 5) {
 548                 if (ndr->flags & LIBNDR_FLAG_NDR64) {
 549                         size = 8;
 550                 } else {
 551                         size = 4;
 552                 }
 553         }
 554         NDR_PULL_ALIGN(ndr, size);
 555         return NDR_ERR_SUCCESS;
 556 }
 557
 558 /*
 559   push some bytes
 560 */
 561 _PUBLIC_ enum ndr_err_code ndr_push_bytes(struct ndr_push *ndr, const uint8_t *data, uint32_t n)
 562 {
 563         NDR_PUSH_NEED_BYTES(ndr, n);
 564         memcpy(ndr->data + ndr->offset, data, n);
 565         ndr->offset += n;
 566         return NDR_ERR_SUCCESS;
 567 }
 568
 569 /*
 570   push some zero bytes
 571 */
 572 _PUBLIC_ enum ndr_err_code ndr_push_zero(struct ndr_push *ndr, uint32_t n)
 573 {
 574         NDR_PUSH_NEED_BYTES(ndr, n);
 575         memset(ndr->data + ndr->offset, 0, n);
 576         ndr->offset += n;
 577         return NDR_ERR_SUCCESS;
 578 }
 579
 580 /*
 581   push an array of uint8
 582 */
 583 _PUBLIC_ enum ndr_err_code ndr_push_array_uint8(struct ndr_push *ndr, int ndr_flags, const uint8_t *data, uint32_t n)
 584 {
 585         if (!(ndr_flags & NDR_SCALARS)) {
 586                 return NDR_ERR_SUCCESS;
 587         }
 588         return ndr_push_bytes(ndr, data, n);
 589 }
 590
 591 /*
 592   push a unique non-zero value if a pointer is non-NULL, otherwise 0
 593 */
 594 _PUBLIC_ enum ndr_err_code ndr_push_unique_ptr(struct ndr_push *ndr, const void *p)
 595 {
 596         uint32_t ptr = 0;
 597         if (p) {
 598                 ptr = ndr->ptr_count * 4;
 599                 ptr |= 0x00020000;
 600                 ndr->ptr_count++;
 601         }
 602         return ndr_push_uint3264(ndr, NDR_SCALARS, ptr);
 603 }
 604
 605 /*
 606   push a 'simple' full non-zero value if a pointer is non-NULL, otherwise 0
 607 */
 608 _PUBLIC_ enum ndr_err_code ndr_push_full_ptr(struct ndr_push *ndr, const void *p)
 609 {
 610         uint32_t ptr = 0;
 611         if (p) {
 612                 /* Check if the pointer already exists and has an id */
 613                 ptr = ndr_token_peek(&ndr->full_ptr_list, p);
 614                 if (ptr == 0) {
 615                         ndr->ptr_count++;
 616                         ptr = ndr->ptr_count;
 617                         ndr_token_store(ndr, &ndr->full_ptr_list, p, ptr);
 618                 }
 619         }
 620         return ndr_push_uint3264(ndr, NDR_SCALARS, ptr);
 621 }
 622
 623 /*
 624   push always a 0, if a pointer is NULL it's a fatal error
 625 */
 626 _PUBLIC_ enum ndr_err_code ndr_push_ref_ptr(struct ndr_push *ndr)
 627 {
 628         return ndr_push_uint3264(ndr, NDR_SCALARS, 0xAEF1AEF1);
 629 }
 630
 631
 632 /*
 633   push a NTTIME
 634 */
 635 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME(struct ndr_push *ndr, int ndr_flags, NTTIME t)
 636 {
 637         NDR_CHECK(ndr_push_udlong(ndr, ndr_flags, t));
 638         return NDR_ERR_SUCCESS;
 639 }
 640
 641 /*
 642   pull a NTTIME
 643 */
 644 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
 645 {
 646         NDR_CHECK(ndr_pull_udlong(ndr, ndr_flags, t));
 647         return NDR_ERR_SUCCESS;
 648 }
 649
 650 /*
 651   push a NTTIME_1sec
 652 */
 653 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME_1sec(struct ndr_push *ndr, int ndr_flags, NTTIME t)
 654 {
 655         t /= 10000000;
 656         NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
 657         return NDR_ERR_SUCCESS;
 658 }
 659
 660 /*
 661   pull a NTTIME_1sec
 662 */
 663 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_1sec(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
 664 {
 665         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
 666         (*t) *= 10000000;
 667         return NDR_ERR_SUCCESS;
 668 }
 669
 670 /*
 671   pull a NTTIME_hyper
 672 */
 673 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_hyper(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
 674 {
 675         NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
 676         return NDR_ERR_SUCCESS;
 677 }
 678
 679 /*
 680   push a NTTIME_hyper
 681 */
 682 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME_hyper(struct ndr_push *ndr, int ndr_flags, NTTIME t)
 683 {
 684         NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
 685         return NDR_ERR_SUCCESS;
 686 }
 687
 688 /*
 689   push a time_t
 690 */
 691 _PUBLIC_ enum ndr_err_code ndr_push_time_t(struct ndr_push *ndr, int ndr_flags, time_t t)
 692 {
 693         return ndr_push_uint32(ndr, ndr_flags, t);
 694 }
 695
 696 /*
 697   pull a time_t
 698 */
 699 _PUBLIC_ enum ndr_err_code ndr_pull_time_t(struct ndr_pull *ndr, int ndr_flags, time_t *t)
 700 {
 701         uint32_t tt;
 702         NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &tt));
 703         *t = tt;
 704         return NDR_ERR_SUCCESS;
 705 }
 706
 707
 708 /*
 709   pull a ipv4address
 710 */
 711 _PUBLIC_ enum ndr_err_code ndr_pull_ipv4address(struct ndr_pull *ndr, int ndr_flags, const char **address)
 712 {
 713         uint32_t addr;
 714         struct in_addr in;
 715         NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &addr));
 716         in.s_addr = htonl(addr);
 717         *address = talloc_strdup(ndr->current_mem_ctx, inet_ntoa(in));
 718         NDR_ERR_HAVE_NO_MEMORY(*address);
 719         return NDR_ERR_SUCCESS;
 720 }
 721
 722 /*
 723   push a ipv4address
 724 */
 725 _PUBLIC_ enum ndr_err_code ndr_push_ipv4address(struct ndr_push *ndr, int ndr_flags, const char *address)
 726 {
 727         uint32_t addr;
 728         if (!is_ipaddress(address)) {
 729                 return ndr_push_error(ndr, NDR_ERR_IPV4ADDRESS,
 730                                       "Invalid IPv4 address: '%s'",
 731                                       address);
 732         }
 733         addr = inet_addr(address);
 734         NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, htonl(addr)));
 735         return NDR_ERR_SUCCESS;
 736 }
 737
 738 /*
 739   print a ipv4address
 740 */
 741 _PUBLIC_ void ndr_print_ipv4address(struct ndr_print *ndr, const char *name,
 742                            const char *address)
 743 {
 744         ndr->print(ndr, "%-25s: %s", name, address);
 745 }
 746
 747
 748 _PUBLIC_ void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type)
 749 {
 750         ndr->print(ndr, "%s: struct %s", name, type);
 751 }
 752
 753 _PUBLIC_ void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type,
 754                     const char *val, uint32_t value)
 755 {
 756         if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
 757                 ndr->print(ndr, "%-25s: %s (0x%X)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
 758         } else {
 759                 ndr->print(ndr, "%-25s: %s (%d)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
 760         }
 761 }
 762
 763 _PUBLIC_ void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint32_t flag, uint32_t value)
 764 {
 765         /* this is an attempt to support multi-bit bitmap masks */
 766         value &= flag;
 767
 768         while (!(flag & 1)) {
 769                 flag >>= 1;
 770                 value >>= 1;
 771         }
 772         if (flag == 1) {
 773                 ndr->print(ndr, "   %d: %-25s", value, flag_name);
 774         } else {
 775                 ndr->print(ndr, "0x%02x: %-25s (%d)", value, flag_name, value);
 776         }
 777 }
 778
 779 _PUBLIC_ void ndr_print_int8(struct ndr_print *ndr, const char *name, int8_t v)
 780 {
 781         ndr->print(ndr, "%-25s: %d", name, v);
 782 }
 783
 784 _PUBLIC_ void ndr_print_uint8(struct ndr_print *ndr, const char *name, uint8_t v)
 785 {
 786         ndr->print(ndr, "%-25s: 0x%02x (%u)", name, v, v);
 787 }
 788
 789 _PUBLIC_ void ndr_print_int16(struct ndr_print *ndr, const char *name, int16_t v)
 790 {
 791         ndr->print(ndr, "%-25s: %d", name, v);
 792 }
 793
 794 _PUBLIC_ void ndr_print_uint16(struct ndr_print *ndr, const char *name, uint16_t v)
 795 {
 796         ndr->print(ndr, "%-25s: 0x%04x (%u)", name, v, v);
 797 }
 798
 799 _PUBLIC_ void ndr_print_int32(struct ndr_print *ndr, const char *name, int32_t v)
 800 {
 801         ndr->print(ndr, "%-25s: %d", name, v);
 802 }
 803
 804 _PUBLIC_ void ndr_print_uint32(struct ndr_print *ndr, const char *name, uint32_t v)
 805 {
 806         ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
 807 }
 808
 809 _PUBLIC_ void ndr_print_udlong(struct ndr_print *ndr, const char *name, uint64_t v)
 810 {
 811         ndr->print(ndr, "%-25s: 0x%016llx (%llu)", name, (unsigned long long)v, (unsigned long long)v);
 812 }
 813
 814 _PUBLIC_ void ndr_print_udlongr(struct ndr_print *ndr, const char *name, uint64_t v)
 815 {
 816         ndr_print_udlong(ndr, name, v);
 817 }
 818
 819 _PUBLIC_ void ndr_print_dlong(struct ndr_print *ndr, const char *name, int64_t v)
 820 {
 821         ndr->print(ndr, "%-25s: 0x%016llx (%lld)", name, (unsigned long long)v, (long long)v);
 822 }
 823
 824 _PUBLIC_ void ndr_print_double(struct ndr_print *ndr, const char *name, double v)
 825 {
 826         ndr->print(ndr, "%-25s: %f", name, v);
 827 }
 828
 829 _PUBLIC_ void ndr_print_hyper(struct ndr_print *ndr, const char *name, uint64_t v)
 830 {
 831         ndr_print_dlong(ndr, name, v);
 832 }
 833
 834 _PUBLIC_ void ndr_print_pointer(struct ndr_print *ndr, const char *name, void *v)
 835 {
 836         ndr->print(ndr, "%-25s: %p", name, v);
 837 }
 838
 839 _PUBLIC_ void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p)
 840 {
 841         if (p) {
 842                 ndr->print(ndr, "%-25s: *", name);
 843         } else {
 844                 ndr->print(ndr, "%-25s: NULL", name);
 845         }
 846 }
 847
 848 _PUBLIC_ void ndr_print_NTTIME(struct ndr_print *ndr, const char *name, NTTIME t)
 849 {
 850         ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr, t));
 851 }
 852
 853 _PUBLIC_ void ndr_print_NTTIME_1sec(struct ndr_print *ndr, const char *name, NTTIME t)
 854 {
 855         /* this is a standard NTTIME here
 856          * as it's already converted in the pull/push code
 857          */
 858         ndr_print_NTTIME(ndr, name, t);
 859 }
 860
 861 _PUBLIC_ void ndr_print_NTTIME_hyper(struct ndr_print *ndr, const char *name, NTTIME t)
 862 {
 863         ndr_print_NTTIME(ndr, name, t);
 864 }
 865
 866 _PUBLIC_ void ndr_print_time_t(struct ndr_print *ndr, const char *name, time_t t)
 867 {
 868         if (t == (time_t)-1 || t == 0) {
 869                 ndr->print(ndr, "%-25s: (time_t)%d", name, (int)t);
 870         } else {
 871                 ndr->print(ndr, "%-25s: %s", name, timestring(ndr, t));
 872         }
 873 }
 874
 875 _PUBLIC_ void ndr_print_union(struct ndr_print *ndr, const char *name, int level, const char *type)
 876 {
 877         if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
 878                 ndr->print(ndr, "%-25s: union %s(case 0x%X)", name, type, level);
 879         } else {
 880                 ndr->print(ndr, "%-25s: union %s(case %d)", name, type, level);
 881         }
 882 }
 883
 884 _PUBLIC_ void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level)
 885 {
 886         ndr->print(ndr, "UNKNOWN LEVEL %u", level);
 887 }
 888
 889 _PUBLIC_ void ndr_print_array_uint8(struct ndr_print *ndr, const char *name,
 890                            const uint8_t *data, uint32_t count)
 891 {
 892         int i;
 893
 894         if (count <= 600 && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
 895                 char s[1202];
 896                 for (i=0;i<count;i++) {
 897                         snprintf(&s[i*2], 3, "%02x", data[i]);
 898                 }
 899                 s[i*2] = 0;
 900                 ndr->print(ndr, "%-25s: %s", name, s);
 901                 return;
 902         }
 903
 904         ndr->print(ndr, "%s: ARRAY(%d)", name, count);
 905         ndr->depth++;
 906         for (i=0;i<count;i++) {
 907                 char *idx=NULL;
 908                 if (asprintf(&idx, "[%d]", i) != -1) {
 909                         ndr_print_uint8(ndr, idx, data[i]);
 910                         free(idx);
 911                 }
 912         }
 913         ndr->depth--;
 914 }
 915
 916 _PUBLIC_ void ndr_print_DATA_BLOB(struct ndr_print *ndr, const char *name, DATA_BLOB r)
 917 {
 918         ndr->print(ndr, "%-25s: DATA_BLOB length=%u", name, (unsigned)r.length);
 919         if (r.length) {
 920                 dump_data(10, r.data, r.length);
 921         }
 922 }
 923
 924
 925 /*
 926   push a DATA_BLOB onto the wire.
 927 */
 928 _PUBLIC_ enum ndr_err_code ndr_push_DATA_BLOB(struct ndr_push *ndr, int ndr_flags, DATA_BLOB blob)
 929 {
 930         if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
 931                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
 932                         blob.length = NDR_ALIGN(ndr, 2);
 933                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
 934                         blob.length = NDR_ALIGN(ndr, 4);
 935                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
 936                         blob.length = NDR_ALIGN(ndr, 8);
 937                 }
 938                 NDR_PUSH_ALLOC_SIZE(ndr, blob.data, blob.length);
 939                 data_blob_clear(&blob);
 940         } else if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
 941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, blob.length));
 942         }
 943         NDR_CHECK(ndr_push_bytes(ndr, blob.data, blob.length));
 944         return NDR_ERR_SUCCESS;
 945 }
 946
 947 /*
 948   pull a DATA_BLOB from the wire.
 949 */
 950 _PUBLIC_ enum ndr_err_code ndr_pull_DATA_BLOB(struct ndr_pull *ndr, int ndr_flags, DATA_BLOB *blob)
 951 {
 952         uint32_t length = 0;
 953
 954         if (ndr->flags & LIBNDR_ALIGN_FLAGS) {
 955                 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
 956                         length = NDR_ALIGN(ndr, 2);
 957                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
 958                         length = NDR_ALIGN(ndr, 4);
 959                 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
 960                         length = NDR_ALIGN(ndr, 8);
 961                 }
 962                 if (ndr->data_size - ndr->offset < length) {
 963                         length = ndr->data_size - ndr->offset;
 964                 }
 965         } else if (ndr->flags & LIBNDR_FLAG_REMAINING) {
 966                 length = ndr->data_size - ndr->offset;
 967         } else {
 968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &length));
 969         }
 970         NDR_PULL_NEED_BYTES(ndr, length);
 971         *blob = data_blob_talloc(ndr->current_mem_ctx, ndr->data+ndr->offset, length);
 972         ndr->offset += length;
 973         return NDR_ERR_SUCCESS;
 974 }
 975
 976 _PUBLIC_ uint32_t ndr_size_DATA_BLOB(int ret, const DATA_BLOB *data, int flags)
 977 {
 978         if (!data) return ret;
 979         return ret + data->length;
 980 }