librpc/ndr/ndr_basic.c

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