2 Unix SMB/CIFS implementation.
4 routines for marshalling/unmarshalling basic types
6 Copyright (C) Andrew Tridgell 2003
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.
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.
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/>.
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"
29 #define NDR_SVAL(ndr, ofs) (NDR_BE(ndr)?RSVAL(ndr->data,ofs):SVAL(ndr->data,ofs))
30 #define NDR_IVAL(ndr, ofs) (NDR_BE(ndr)?RIVAL(ndr->data,ofs):IVAL(ndr->data,ofs))
31 #define NDR_IVALS(ndr, ofs) (NDR_BE(ndr)?RIVALS(ndr->data,ofs):IVALS(ndr->data,ofs))
32 #define NDR_SSVAL(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSSVAL(ndr->data,ofs,v); } else SSVAL(ndr->data,ofs,v); } while (0)
33 #define NDR_SIVAL(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSIVAL(ndr->data,ofs,v); } else SIVAL(ndr->data,ofs,v); } while (0)
34 #define NDR_SIVALS(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSIVALS(ndr->data,ofs,v); } else SIVALS(ndr->data,ofs,v); } while (0)
37 static void ndr_dump_data(struct ndr_print *ndr, const uint8_t *buf, int len);
40 check for data leaks from the server by looking for non-zero pad bytes
41 these could also indicate that real structure elements have been
42 mistaken for padding in the IDL
44 _PUBLIC_ void ndr_check_padding(struct ndr_pull *ndr, size_t n)
46 size_t ofs2 = (ndr->offset + (n-1)) & ~(n-1);
48 for (i=ndr->offset;i<ofs2;i++) {
49 if (ndr->data[i] != 0) {
54 DEBUG(0,("WARNING: Non-zero padding to %d: ", (int)n));
55 for (i=ndr->offset;i<ofs2;i++) {
56 DEBUG(0,("%02x ", ndr->data[i]));
66 _PUBLIC_ enum ndr_err_code ndr_pull_int8(struct ndr_pull *ndr, int ndr_flags, int8_t *v)
68 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
69 NDR_PULL_NEED_BYTES(ndr, 1);
70 *v = (int8_t)CVAL(ndr->data, ndr->offset);
72 return NDR_ERR_SUCCESS;
78 _PUBLIC_ enum ndr_err_code ndr_pull_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
80 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
81 NDR_PULL_NEED_BYTES(ndr, 1);
82 *v = CVAL(ndr->data, ndr->offset);
84 return NDR_ERR_SUCCESS;
90 _PUBLIC_ enum ndr_err_code ndr_pull_int16(struct ndr_pull *ndr, int ndr_flags, int16_t *v)
92 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
93 NDR_PULL_ALIGN(ndr, 2);
94 NDR_PULL_NEED_BYTES(ndr, 2);
95 *v = (uint16_t)NDR_SVAL(ndr, ndr->offset);
97 return NDR_ERR_SUCCESS;
103 _PUBLIC_ enum ndr_err_code ndr_pull_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
105 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
106 NDR_PULL_ALIGN(ndr, 2);
107 NDR_PULL_NEED_BYTES(ndr, 2);
108 *v = NDR_SVAL(ndr, ndr->offset);
110 return NDR_ERR_SUCCESS;
116 _PUBLIC_ enum ndr_err_code ndr_pull_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
118 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
119 if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
121 enum ndr_err_code err = ndr_pull_uint32(ndr, ndr_flags, &v32);
123 if (unlikely(v32 != *v)) {
124 DEBUG(0,(__location__ ": non-zero upper 16 bits 0x%08x\n", (unsigned)v32));
125 return NDR_ERR_NDR64;
129 return ndr_pull_uint16(ndr, ndr_flags, v);
135 _PUBLIC_ enum ndr_err_code ndr_pull_int32(struct ndr_pull *ndr, int ndr_flags, int32_t *v)
137 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
138 NDR_PULL_ALIGN(ndr, 4);
139 NDR_PULL_NEED_BYTES(ndr, 4);
140 *v = NDR_IVALS(ndr, ndr->offset);
142 return NDR_ERR_SUCCESS;
148 _PUBLIC_ enum ndr_err_code ndr_pull_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
150 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
151 NDR_PULL_ALIGN(ndr, 4);
152 NDR_PULL_NEED_BYTES(ndr, 4);
153 *v = NDR_IVAL(ndr, ndr->offset);
155 return NDR_ERR_SUCCESS;
159 parse a arch dependent uint32/uint64
161 _PUBLIC_ enum ndr_err_code ndr_pull_uint3264(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
164 enum ndr_err_code err;
165 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
166 if (likely(!(ndr->flags & LIBNDR_FLAG_NDR64))) {
167 return ndr_pull_uint32(ndr, ndr_flags, v);
169 err = ndr_pull_hyper(ndr, ndr_flags, &v64);
171 if (unlikely(v64 != *v)) {
172 DEBUG(0,(__location__ ": non-zero upper 32 bits 0x%016llx\n",
173 (unsigned long long)v64));
174 return ndr_pull_error(ndr, NDR_ERR_NDR64, __location__ ": non-zero upper 32 bits 0x%016llx\n",
175 (unsigned long long)v64);
183 _PUBLIC_ enum ndr_err_code ndr_pull_double(struct ndr_pull *ndr, int ndr_flags, double *v)
185 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
186 NDR_PULL_ALIGN(ndr, 8);
187 NDR_PULL_NEED_BYTES(ndr, 8);
188 memcpy(v, ndr->data+ndr->offset, 8);
190 return NDR_ERR_SUCCESS;
194 parse a pointer referent identifier stored in 2 bytes
196 _PUBLIC_ enum ndr_err_code ndr_pull_relative_ptr_short(struct ndr_pull *ndr, uint16_t *v)
198 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, v));
202 *(v) -= ndr->relative_rap_convert;
203 return NDR_ERR_SUCCESS;
207 parse a pointer referent identifier
209 _PUBLIC_ enum ndr_err_code ndr_pull_generic_ptr(struct ndr_pull *ndr, uint32_t *v)
211 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, v));
215 return NDR_ERR_SUCCESS;
219 parse a ref pointer referent identifier
221 _PUBLIC_ enum ndr_err_code ndr_pull_ref_ptr(struct ndr_pull *ndr, uint32_t *v)
223 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, v));
224 /* ref pointers always point to data */
226 return NDR_ERR_SUCCESS;
232 _PUBLIC_ enum ndr_err_code ndr_pull_udlong(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
234 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
235 NDR_PULL_ALIGN(ndr, 4);
236 NDR_PULL_NEED_BYTES(ndr, 8);
237 *v = NDR_IVAL(ndr, ndr->offset);
238 *v |= (uint64_t)(NDR_IVAL(ndr, ndr->offset+4)) << 32;
240 return NDR_ERR_SUCCESS;
246 _PUBLIC_ enum ndr_err_code ndr_pull_udlongr(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
248 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
249 NDR_PULL_ALIGN(ndr, 4);
250 NDR_PULL_NEED_BYTES(ndr, 8);
251 *v = ((uint64_t)NDR_IVAL(ndr, ndr->offset)) << 32;
252 *v |= NDR_IVAL(ndr, ndr->offset+4);
254 return NDR_ERR_SUCCESS;
260 _PUBLIC_ enum ndr_err_code ndr_pull_dlong(struct ndr_pull *ndr, int ndr_flags, int64_t *v)
262 return ndr_pull_udlong(ndr, ndr_flags, (uint64_t *)v);
268 _PUBLIC_ enum ndr_err_code ndr_pull_hyper(struct ndr_pull *ndr, int ndr_flags, uint64_t *v)
270 NDR_PULL_ALIGN(ndr, 8);
272 return ndr_pull_udlongr(ndr, ndr_flags, v);
274 return ndr_pull_udlong(ndr, ndr_flags, v);
280 _PUBLIC_ enum ndr_err_code ndr_pull_pointer(struct ndr_pull *ndr, int ndr_flags, void* *v)
283 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
284 NDR_PULL_ALIGN(ndr, sizeof(h));
285 NDR_PULL_NEED_BYTES(ndr, sizeof(h));
286 memcpy(&h, ndr->data+ndr->offset, sizeof(h));
287 ndr->offset += sizeof(h);
289 return NDR_ERR_SUCCESS;
295 _PUBLIC_ enum ndr_err_code ndr_pull_NTSTATUS(struct ndr_pull *ndr, int ndr_flags, NTSTATUS *status)
298 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
299 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
300 *status = NT_STATUS(v);
301 return NDR_ERR_SUCCESS;
307 _PUBLIC_ enum ndr_err_code ndr_push_NTSTATUS(struct ndr_push *ndr, int ndr_flags, NTSTATUS status)
309 return ndr_push_uint32(ndr, ndr_flags, NT_STATUS_V(status));
312 _PUBLIC_ void ndr_print_NTSTATUS(struct ndr_print *ndr, const char *name, NTSTATUS r)
314 ndr->print(ndr, "%-25s: %s", name, nt_errstr(r));
320 _PUBLIC_ enum ndr_err_code ndr_pull_WERROR(struct ndr_pull *ndr, int ndr_flags, WERROR *status)
323 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
324 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
325 *status = W_ERROR(v);
326 return NDR_ERR_SUCCESS;
332 _PUBLIC_ enum ndr_err_code ndr_pull_HRESULT(struct ndr_pull *ndr, int ndr_flags, HRESULT *status)
335 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
336 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
337 *status = HRES_ERROR(v);
338 return NDR_ERR_SUCCESS;
344 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *v)
346 return ndr_pull_uint8(ndr, ndr_flags, v);
350 parse a uint16_t enum
352 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint16(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
354 return ndr_pull_uint16(ndr, ndr_flags, v);
358 parse a uint1632_t enum (uint32_t on NDR64)
360 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint1632(struct ndr_pull *ndr, int ndr_flags, uint16_t *v)
362 if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
364 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &v32));
367 DEBUG(0,(__location__ ": non-zero upper 16 bits 0x%08x\n", (unsigned)v32));
368 return NDR_ERR_NDR64;
370 return NDR_ERR_SUCCESS;
372 return ndr_pull_uint16(ndr, ndr_flags, v);
376 parse a uint32_t enum
378 _PUBLIC_ enum ndr_err_code ndr_pull_enum_uint32(struct ndr_pull *ndr, int ndr_flags, uint32_t *v)
380 return ndr_pull_uint32(ndr, ndr_flags, v);
386 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
388 return ndr_push_uint8(ndr, ndr_flags, v);
394 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
396 return ndr_push_uint16(ndr, ndr_flags, v);
402 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
404 return ndr_push_uint32(ndr, ndr_flags, v);
408 push a uint1632_t enum
410 _PUBLIC_ enum ndr_err_code ndr_push_enum_uint1632(struct ndr_push *ndr, int ndr_flags, uint16_t v)
412 if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
413 return ndr_push_uint32(ndr, ndr_flags, v);
415 return ndr_push_uint16(ndr, ndr_flags, v);
421 _PUBLIC_ enum ndr_err_code ndr_push_WERROR(struct ndr_push *ndr, int ndr_flags, WERROR status)
423 return ndr_push_uint32(ndr, NDR_SCALARS, W_ERROR_V(status));
426 _PUBLIC_ void ndr_print_WERROR(struct ndr_print *ndr, const char *name, WERROR r)
428 ndr->print(ndr, "%-25s: %s", name, win_errstr(r));
434 _PUBLIC_ enum ndr_err_code ndr_push_HRESULT(struct ndr_push *ndr, int ndr_flags, HRESULT status)
436 return ndr_push_uint32(ndr, NDR_SCALARS, HRES_ERROR_V(status));
439 _PUBLIC_ void ndr_print_HRESULT(struct ndr_print *ndr, const char *name, HRESULT r)
441 ndr->print(ndr, "%-25s: %s", name, hresult_errstr(r));
448 _PUBLIC_ enum ndr_err_code ndr_pull_bytes(struct ndr_pull *ndr, uint8_t *data, uint32_t n)
450 NDR_PULL_NEED_BYTES(ndr, n);
451 memcpy(data, ndr->data + ndr->offset, n);
453 return NDR_ERR_SUCCESS;
457 pull an array of uint8
459 _PUBLIC_ enum ndr_err_code ndr_pull_array_uint8(struct ndr_pull *ndr, int ndr_flags, uint8_t *data, uint32_t n)
461 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
462 if (!(ndr_flags & NDR_SCALARS)) {
463 return NDR_ERR_SUCCESS;
465 return ndr_pull_bytes(ndr, data, n);
471 _PUBLIC_ enum ndr_err_code ndr_push_int8(struct ndr_push *ndr, int ndr_flags, int8_t v)
473 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
474 NDR_PUSH_NEED_BYTES(ndr, 1);
475 SCVAL(ndr->data, ndr->offset, (uint8_t)v);
477 return NDR_ERR_SUCCESS;
483 _PUBLIC_ enum ndr_err_code ndr_push_uint8(struct ndr_push *ndr, int ndr_flags, uint8_t v)
485 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
486 NDR_PUSH_NEED_BYTES(ndr, 1);
487 SCVAL(ndr->data, ndr->offset, v);
489 return NDR_ERR_SUCCESS;
495 _PUBLIC_ enum ndr_err_code ndr_push_int16(struct ndr_push *ndr, int ndr_flags, int16_t v)
497 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
498 NDR_PUSH_ALIGN(ndr, 2);
499 NDR_PUSH_NEED_BYTES(ndr, 2);
500 NDR_SSVAL(ndr, ndr->offset, (uint16_t)v);
502 return NDR_ERR_SUCCESS;
508 _PUBLIC_ enum ndr_err_code ndr_push_uint16(struct ndr_push *ndr, int ndr_flags, uint16_t v)
510 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
511 NDR_PUSH_ALIGN(ndr, 2);
512 NDR_PUSH_NEED_BYTES(ndr, 2);
513 NDR_SSVAL(ndr, ndr->offset, v);
515 return NDR_ERR_SUCCESS;
521 _PUBLIC_ enum ndr_err_code ndr_push_uint1632(struct ndr_push *ndr, int ndr_flags, uint16_t v)
523 if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
524 return ndr_push_uint32(ndr, ndr_flags, v);
526 return ndr_push_uint16(ndr, ndr_flags, v);
532 _PUBLIC_ enum ndr_err_code ndr_push_int32(struct ndr_push *ndr, int ndr_flags, int32_t v)
534 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
535 NDR_PUSH_ALIGN(ndr, 4);
536 NDR_PUSH_NEED_BYTES(ndr, 4);
537 NDR_SIVALS(ndr, ndr->offset, v);
539 return NDR_ERR_SUCCESS;
545 _PUBLIC_ enum ndr_err_code ndr_push_uint32(struct ndr_push *ndr, int ndr_flags, uint32_t v)
547 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
548 NDR_PUSH_ALIGN(ndr, 4);
549 NDR_PUSH_NEED_BYTES(ndr, 4);
550 NDR_SIVAL(ndr, ndr->offset, v);
552 return NDR_ERR_SUCCESS;
558 _PUBLIC_ enum ndr_err_code ndr_push_uint3264(struct ndr_push *ndr, int ndr_flags, uint32_t v)
560 if (unlikely(ndr->flags & LIBNDR_FLAG_NDR64)) {
561 return ndr_push_hyper(ndr, ndr_flags, v);
563 return ndr_push_uint32(ndr, ndr_flags, v);
569 _PUBLIC_ enum ndr_err_code ndr_push_udlong(struct ndr_push *ndr, int ndr_flags, uint64_t v)
571 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
572 NDR_PUSH_ALIGN(ndr, 4);
573 NDR_PUSH_NEED_BYTES(ndr, 8);
574 NDR_SIVAL(ndr, ndr->offset, (v & 0xFFFFFFFF));
575 NDR_SIVAL(ndr, ndr->offset+4, (v>>32));
577 return NDR_ERR_SUCCESS;
583 _PUBLIC_ enum ndr_err_code ndr_push_udlongr(struct ndr_push *ndr, int ndr_flags, uint64_t v)
585 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
586 NDR_PUSH_ALIGN(ndr, 4);
587 NDR_PUSH_NEED_BYTES(ndr, 8);
588 NDR_SIVAL(ndr, ndr->offset, (v>>32));
589 NDR_SIVAL(ndr, ndr->offset+4, (v & 0xFFFFFFFF));
591 return NDR_ERR_SUCCESS;
597 _PUBLIC_ enum ndr_err_code ndr_push_dlong(struct ndr_push *ndr, int ndr_flags, int64_t v)
599 return ndr_push_udlong(ndr, NDR_SCALARS, (uint64_t)v);
605 _PUBLIC_ enum ndr_err_code ndr_push_hyper(struct ndr_push *ndr, int ndr_flags, uint64_t v)
607 NDR_PUSH_ALIGN(ndr, 8);
609 return ndr_push_udlongr(ndr, NDR_SCALARS, v);
611 return ndr_push_udlong(ndr, NDR_SCALARS, v);
617 _PUBLIC_ enum ndr_err_code ndr_push_double(struct ndr_push *ndr, int ndr_flags, double v)
619 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
620 NDR_PUSH_ALIGN(ndr, 8);
621 NDR_PUSH_NEED_BYTES(ndr, 8);
622 memcpy(ndr->data+ndr->offset, &v, 8);
624 return NDR_ERR_SUCCESS;
630 _PUBLIC_ enum ndr_err_code ndr_push_pointer(struct ndr_push *ndr, int ndr_flags, void* v)
632 uintptr_t h = (intptr_t)v;
633 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
634 NDR_PUSH_ALIGN(ndr, sizeof(h));
635 NDR_PUSH_NEED_BYTES(ndr, sizeof(h));
636 memcpy(ndr->data+ndr->offset, &h, sizeof(h));
637 ndr->offset += sizeof(h);
638 return NDR_ERR_SUCCESS;
641 _PUBLIC_ enum ndr_err_code ndr_push_align(struct ndr_push *ndr, size_t size)
643 /* this is a nasty hack to make pidl work with NDR64 */
645 if (ndr->flags & LIBNDR_FLAG_NDR64) {
650 } else if (size == 3) {
651 if (ndr->flags & LIBNDR_FLAG_NDR64) {
657 NDR_PUSH_ALIGN(ndr, size);
658 return NDR_ERR_SUCCESS;
661 _PUBLIC_ enum ndr_err_code ndr_pull_align(struct ndr_pull *ndr, size_t size)
663 /* this is a nasty hack to make pidl work with NDR64 */
665 if (ndr->flags & LIBNDR_FLAG_NDR64) {
670 } else if (size == 3) {
671 if (ndr->flags & LIBNDR_FLAG_NDR64) {
677 NDR_PULL_ALIGN(ndr, size);
678 return NDR_ERR_SUCCESS;
681 _PUBLIC_ enum ndr_err_code ndr_push_union_align(struct ndr_push *ndr, size_t size)
683 /* MS-RPCE section 2.2.5.3.4.4 */
684 if (ndr->flags & LIBNDR_FLAG_NDR64) {
685 return ndr_push_align(ndr, size);
687 return NDR_ERR_SUCCESS;
690 _PUBLIC_ enum ndr_err_code ndr_pull_union_align(struct ndr_pull *ndr, size_t size)
692 /* MS-RPCE section 2.2.5.3.4.4 */
693 if (ndr->flags & LIBNDR_FLAG_NDR64) {
694 return ndr_pull_align(ndr, size);
696 return NDR_ERR_SUCCESS;
699 _PUBLIC_ enum ndr_err_code ndr_push_trailer_align(struct ndr_push *ndr, size_t size)
701 /* MS-RPCE section 2.2.5.3.4.1 */
702 if (ndr->flags & LIBNDR_FLAG_NDR64) {
703 return ndr_push_align(ndr, size);
705 return NDR_ERR_SUCCESS;
708 _PUBLIC_ enum ndr_err_code ndr_pull_trailer_align(struct ndr_pull *ndr, size_t size)
710 /* MS-RPCE section 2.2.5.3.4.1 */
711 if (ndr->flags & LIBNDR_FLAG_NDR64) {
712 return ndr_pull_align(ndr, size);
714 return NDR_ERR_SUCCESS;
720 _PUBLIC_ enum ndr_err_code ndr_push_bytes(struct ndr_push *ndr, const uint8_t *data, uint32_t n)
722 if (unlikely(n == 0)) {
723 return NDR_ERR_SUCCESS;
725 if (unlikely(data == NULL)) {
726 return NDR_ERR_INVALID_POINTER;
728 NDR_PUSH_NEED_BYTES(ndr, n);
729 memcpy(ndr->data + ndr->offset, data, n);
731 return NDR_ERR_SUCCESS;
737 _PUBLIC_ enum ndr_err_code ndr_push_zero(struct ndr_push *ndr, uint32_t n)
739 NDR_PUSH_NEED_BYTES(ndr, n);
740 memset(ndr->data + ndr->offset, 0, n);
742 return NDR_ERR_SUCCESS;
746 push an array of uint8
748 _PUBLIC_ enum ndr_err_code ndr_push_array_uint8(struct ndr_push *ndr, int ndr_flags, const uint8_t *data, uint32_t n)
750 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
751 if (!(ndr_flags & NDR_SCALARS)) {
752 return NDR_ERR_SUCCESS;
754 return ndr_push_bytes(ndr, data, n);
758 push a unique non-zero value if a pointer is non-NULL, otherwise 0
760 _PUBLIC_ enum ndr_err_code ndr_push_unique_ptr(struct ndr_push *ndr, const void *p)
764 ptr = ndr->ptr_count * 4;
768 return ndr_push_uint3264(ndr, NDR_SCALARS, ptr);
772 push a 'simple' full non-zero value if a pointer is non-NULL, otherwise 0
774 _PUBLIC_ enum ndr_err_code ndr_push_full_ptr(struct ndr_push *ndr, const void *p)
778 /* Check if the pointer already exists and has an id */
779 ptr = ndr_token_peek(&ndr->full_ptr_list, p);
782 ptr = ndr->ptr_count;
783 ndr_token_store(ndr, &ndr->full_ptr_list, p, ptr);
786 return ndr_push_uint3264(ndr, NDR_SCALARS, ptr);
790 push always a 0, if a pointer is NULL it's a fatal error
792 _PUBLIC_ enum ndr_err_code ndr_push_ref_ptr(struct ndr_push *ndr)
794 return ndr_push_uint3264(ndr, NDR_SCALARS, 0xAEF1AEF1);
801 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME(struct ndr_push *ndr, int ndr_flags, NTTIME t)
803 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
804 NDR_CHECK(ndr_push_udlong(ndr, ndr_flags, t));
805 return NDR_ERR_SUCCESS;
811 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
813 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
814 NDR_CHECK(ndr_pull_udlong(ndr, ndr_flags, t));
815 return NDR_ERR_SUCCESS;
821 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME_1sec(struct ndr_push *ndr, int ndr_flags, NTTIME t)
823 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
825 NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
826 return NDR_ERR_SUCCESS;
832 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_1sec(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
834 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
835 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
837 return NDR_ERR_SUCCESS;
843 _PUBLIC_ enum ndr_err_code ndr_pull_NTTIME_hyper(struct ndr_pull *ndr, int ndr_flags, NTTIME *t)
845 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
846 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, t));
847 return NDR_ERR_SUCCESS;
853 _PUBLIC_ enum ndr_err_code ndr_push_NTTIME_hyper(struct ndr_push *ndr, int ndr_flags, NTTIME t)
855 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
856 NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t));
857 return NDR_ERR_SUCCESS;
863 _PUBLIC_ enum ndr_err_code ndr_push_time_t(struct ndr_push *ndr, int ndr_flags, time_t t)
865 return ndr_push_uint32(ndr, ndr_flags, t);
871 _PUBLIC_ enum ndr_err_code ndr_pull_time_t(struct ndr_pull *ndr, int ndr_flags, time_t *t)
874 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &tt));
876 return NDR_ERR_SUCCESS;
883 _PUBLIC_ enum ndr_err_code ndr_push_uid_t(struct ndr_push *ndr, int ndr_flags, uid_t u)
885 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
886 return ndr_push_hyper(ndr, NDR_SCALARS, (uint64_t)u);
892 _PUBLIC_ enum ndr_err_code ndr_pull_uid_t(struct ndr_pull *ndr, int ndr_flags, uid_t *u)
895 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &uu));
897 if (unlikely(uu != *u)) {
898 DEBUG(0,(__location__ ": uid_t pull doesn't fit 0x%016llx\n",
899 (unsigned long long)uu));
900 return NDR_ERR_NDR64;
902 return NDR_ERR_SUCCESS;
909 _PUBLIC_ enum ndr_err_code ndr_push_gid_t(struct ndr_push *ndr, int ndr_flags, gid_t g)
911 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
912 return ndr_push_hyper(ndr, NDR_SCALARS, (uint64_t)g);
918 _PUBLIC_ enum ndr_err_code ndr_pull_gid_t(struct ndr_pull *ndr, int ndr_flags, gid_t *g)
921 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &gg));
923 if (unlikely(gg != *g)) {
924 DEBUG(0,(__location__ ": gid_t pull doesn't fit 0x%016llx\n",
925 (unsigned long long)gg));
926 return NDR_ERR_NDR64;
928 return NDR_ERR_SUCCESS;
935 _PUBLIC_ enum ndr_err_code ndr_pull_ipv4address(struct ndr_pull *ndr, int ndr_flags, const char **address)
939 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &addr));
940 in.s_addr = htonl(addr);
941 *address = talloc_strdup(ndr->current_mem_ctx, inet_ntoa(in));
942 NDR_ERR_HAVE_NO_MEMORY(*address);
943 return NDR_ERR_SUCCESS;
949 _PUBLIC_ enum ndr_err_code ndr_push_ipv4address(struct ndr_push *ndr, int ndr_flags, const char *address)
952 if (!is_ipaddress(address)) {
953 return ndr_push_error(ndr, NDR_ERR_IPV4ADDRESS,
954 "Invalid IPv4 address: '%s'",
957 addr = inet_addr(address);
958 NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, htonl(addr)));
959 return NDR_ERR_SUCCESS;
965 _PUBLIC_ void ndr_print_ipv4address(struct ndr_print *ndr, const char *name,
968 ndr->print(ndr, "%-25s: %s", name, address);
974 #define IPV6_BYTES 16
975 #define IPV6_ADDR_STR_LEN 39
976 _PUBLIC_ enum ndr_err_code ndr_pull_ipv6address(struct ndr_pull *ndr, int ndr_flags, const char **address)
978 uint8_t addr[IPV6_BYTES];
979 char *addr_str = talloc_strdup(ndr->current_mem_ctx, "");
981 NDR_CHECK(ndr_pull_array_uint8(ndr, ndr_flags, addr, IPV6_BYTES));
982 for (i = 0; i < IPV6_BYTES; ++i) {
983 addr_str = talloc_asprintf_append(addr_str, "%02x", addr[i]);
984 /* We need a ':' every second byte but the last one */
985 if (i%2 == 1 && i != (IPV6_BYTES - 1)) {
986 addr_str = talloc_strdup_append(addr_str, ":");
990 NDR_ERR_HAVE_NO_MEMORY(*address);
991 return NDR_ERR_SUCCESS;
997 _PUBLIC_ enum ndr_err_code ndr_push_ipv6address(struct ndr_push *ndr, int ndr_flags, const char *address)
1000 uint8_t addr[IPV6_BYTES];
1003 if (!is_ipaddress(address)) {
1004 return ndr_push_error(ndr, NDR_ERR_IPV6ADDRESS,
1005 "Invalid IPv6 address: '%s'",
1008 ret = inet_pton(AF_INET6, address, addr);
1010 return NDR_ERR_IPV6ADDRESS;
1013 NDR_CHECK(ndr_push_array_uint8(ndr, ndr_flags, addr, IPV6_BYTES));
1015 return NDR_ERR_SUCCESS;
1017 return NDR_ERR_IPV6ADDRESS;
1024 _PUBLIC_ void ndr_print_ipv6address(struct ndr_print *ndr, const char *name,
1025 const char *address)
1027 ndr->print(ndr, "%-25s: %s", name, address);
1031 _PUBLIC_ void ndr_print_struct(struct ndr_print *ndr, const char *name, const char *type)
1033 ndr->print(ndr, "%s: struct %s", name, type);
1036 _PUBLIC_ void ndr_print_null(struct ndr_print *ndr)
1038 ndr->print(ndr, "UNEXPECTED NULL POINTER");
1041 _PUBLIC_ void ndr_print_enum(struct ndr_print *ndr, const char *name, const char *type,
1042 const char *val, uint32_t value)
1044 if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
1045 ndr->print(ndr, "%-25s: %s (0x%X)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
1047 ndr->print(ndr, "%-25s: %s (%d)", name, val?val:"UNKNOWN_ENUM_VALUE", value);
1051 _PUBLIC_ void ndr_print_bitmap_flag(struct ndr_print *ndr, size_t size, const char *flag_name, uint32_t flag, uint32_t value)
1057 /* this is an attempt to support multi-bit bitmap masks */
1060 while (!(flag & 1)) {
1065 ndr->print(ndr, " %d: %-25s", value, flag_name);
1067 ndr->print(ndr, "0x%02x: %-25s (%d)", value, flag_name, value);
1071 _PUBLIC_ void ndr_print_int8(struct ndr_print *ndr, const char *name, int8_t v)
1073 if (NDR_HIDE_SECRET(ndr)) {
1074 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1077 ndr->print(ndr, "%-25s: %d", name, v);
1080 _PUBLIC_ void ndr_print_uint8(struct ndr_print *ndr, const char *name, uint8_t v)
1082 if (NDR_HIDE_SECRET(ndr)) {
1083 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1086 ndr->print(ndr, "%-25s: 0x%02x (%u)", name, v, v);
1089 _PUBLIC_ void ndr_print_int16(struct ndr_print *ndr, const char *name, int16_t v)
1091 if (NDR_HIDE_SECRET(ndr)) {
1092 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1095 ndr->print(ndr, "%-25s: %d", name, v);
1098 _PUBLIC_ void ndr_print_uint16(struct ndr_print *ndr, const char *name, uint16_t v)
1100 if (NDR_HIDE_SECRET(ndr)) {
1101 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1104 ndr->print(ndr, "%-25s: 0x%04x (%u)", name, v, v);
1107 _PUBLIC_ void ndr_print_int32(struct ndr_print *ndr, const char *name, int32_t v)
1109 if (NDR_HIDE_SECRET(ndr)) {
1110 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1113 ndr->print(ndr, "%-25s: %d", name, v);
1116 _PUBLIC_ void ndr_print_uint32(struct ndr_print *ndr, const char *name, uint32_t v)
1118 if (NDR_HIDE_SECRET(ndr)) {
1119 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1122 ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
1125 _PUBLIC_ void ndr_print_int3264(struct ndr_print *ndr, const char *name, int32_t v)
1127 if (NDR_HIDE_SECRET(ndr)) {
1128 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1131 ndr->print(ndr, "%-25s: %d", name, v);
1134 _PUBLIC_ void ndr_print_uint3264(struct ndr_print *ndr, const char *name, uint32_t v)
1136 if (NDR_HIDE_SECRET(ndr)) {
1137 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1140 ndr->print(ndr, "%-25s: 0x%08x (%u)", name, v, v);
1143 _PUBLIC_ void ndr_print_udlong(struct ndr_print *ndr, const char *name, uint64_t v)
1145 ndr->print(ndr, "%-25s: 0x%016llx (%llu)", name, (unsigned long long)v, (unsigned long long)v);
1148 _PUBLIC_ void ndr_print_udlongr(struct ndr_print *ndr, const char *name, uint64_t v)
1150 ndr_print_udlong(ndr, name, v);
1153 _PUBLIC_ void ndr_print_dlong(struct ndr_print *ndr, const char *name, int64_t v)
1155 if (NDR_HIDE_SECRET(ndr)) {
1156 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
1159 ndr->print(ndr, "%-25s: 0x%016llx (%lld)", name, (unsigned long long)v, (long long)v);
1162 _PUBLIC_ void ndr_print_double(struct ndr_print *ndr, const char *name, double v)
1164 ndr->print(ndr, "%-25s: %f", name, v);
1167 _PUBLIC_ void ndr_print_hyper(struct ndr_print *ndr, const char *name, uint64_t v)
1169 ndr_print_dlong(ndr, name, v);
1172 _PUBLIC_ void ndr_print_pointer(struct ndr_print *ndr, const char *name, void *v)
1174 ndr->print(ndr, "%-25s: %p", name, v);
1177 _PUBLIC_ void ndr_print_ptr(struct ndr_print *ndr, const char *name, const void *p)
1180 ndr->print(ndr, "%-25s: *", name);
1182 ndr->print(ndr, "%-25s: NULL", name);
1186 _PUBLIC_ void ndr_print_NTTIME(struct ndr_print *ndr, const char *name, NTTIME t)
1188 ndr->print(ndr, "%-25s: %s", name, nt_time_string(ndr, t));
1191 _PUBLIC_ void ndr_print_NTTIME_1sec(struct ndr_print *ndr, const char *name, NTTIME t)
1193 /* this is a standard NTTIME here
1194 * as it's already converted in the pull/push code
1196 ndr_print_NTTIME(ndr, name, t);
1199 _PUBLIC_ void ndr_print_NTTIME_hyper(struct ndr_print *ndr, const char *name, NTTIME t)
1201 ndr_print_NTTIME(ndr, name, t);
1204 _PUBLIC_ void ndr_print_time_t(struct ndr_print *ndr, const char *name, time_t t)
1206 if (t == (time_t)-1 || t == 0) {
1207 ndr->print(ndr, "%-25s: (time_t)%d", name, (int)t);
1209 ndr->print(ndr, "%-25s: %s", name, timestring(ndr, t));
1213 _PUBLIC_ void ndr_print_uid_t(struct ndr_print *ndr, const char *name, uid_t u)
1215 ndr_print_dlong(ndr, name, u);
1218 _PUBLIC_ void ndr_print_gid_t(struct ndr_print *ndr, const char *name, gid_t g)
1220 ndr_print_dlong(ndr, name, g);
1223 _PUBLIC_ void ndr_print_union(struct ndr_print *ndr, const char *name, int level, const char *type)
1225 if (ndr->flags & LIBNDR_PRINT_ARRAY_HEX) {
1226 ndr->print(ndr, "%-25s: union %s(case 0x%X)", name, type, level);
1228 ndr->print(ndr, "%-25s: union %s(case %d)", name, type, level);
1232 _PUBLIC_ void ndr_print_bad_level(struct ndr_print *ndr, const char *name, uint16_t level)
1234 ndr->print(ndr, "UNKNOWN LEVEL %u", level);
1237 _PUBLIC_ void ndr_print_array_uint8(struct ndr_print *ndr, const char *name,
1238 const uint8_t *data, uint32_t count)
1241 #define _ONELINE_LIMIT 32
1244 ndr->print(ndr, "%s: ARRAY(%d) : NULL", name, count);
1248 if (NDR_HIDE_SECRET(ndr)) {
1249 ndr->print(ndr, "%s: ARRAY(%d): <REDACTED SECRET VALUES>", name, count);
1253 if (count <= _ONELINE_LIMIT && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
1254 char s[(_ONELINE_LIMIT + 1) * 2];
1255 for (i=0;i<count;i++) {
1256 snprintf(&s[i*2], 3, "%02x", data[i]);
1259 ndr->print(ndr, "%-25s: %s", name, s);
1263 ndr->print(ndr, "%s: ARRAY(%d)", name, count);
1264 if (count > _ONELINE_LIMIT && (ndr->flags & LIBNDR_PRINT_ARRAY_HEX)) {
1265 ndr_dump_data(ndr, data, count);
1270 for (i=0;i<count;i++) {
1272 if (asprintf(&idx, "[%d]", i) != -1) {
1273 ndr_print_uint8(ndr, idx, data[i]);
1278 #undef _ONELINE_LIMIT
1281 static void ndr_print_dump_data_cb(const char *buf, void *private_data)
1283 struct ndr_print *ndr = (struct ndr_print *)private_data;
1285 ndr->print(ndr, "%s", buf);
1289 ndr_print version of dump_data()
1291 static void ndr_dump_data(struct ndr_print *ndr, const uint8_t *buf, int len)
1293 if (NDR_HIDE_SECRET(ndr)) {
1296 ndr->no_newline = true;
1297 dump_data_cb(buf, len, true, ndr_print_dump_data_cb, ndr);
1298 ndr->no_newline = false;
1302 _PUBLIC_ void ndr_print_DATA_BLOB(struct ndr_print *ndr, const char *name, DATA_BLOB r)
1304 ndr->print(ndr, "%-25s: DATA_BLOB length=%u", name, (unsigned)r.length);
1306 ndr_dump_data(ndr, r.data, r.length);
1312 * Push a DATA_BLOB onto the wire.
1313 * 1) When called with LIBNDR_FLAG_ALIGN* alignment flags set, push padding
1314 * bytes _only_. The length is determined by the alignment required and the
1315 * current ndr offset.
1316 * 2) When called with the LIBNDR_FLAG_REMAINING flag, push the byte array to
1318 * 3) Otherwise, push a uint3264 length _and_ a corresponding byte array to the
1321 _PUBLIC_ enum ndr_err_code ndr_push_DATA_BLOB(struct ndr_push *ndr, int ndr_flags, DATA_BLOB blob)
1323 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
1325 } else if (ndr->flags & (LIBNDR_ALIGN_FLAGS & ~LIBNDR_FLAG_NOALIGN)) {
1326 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1327 blob.length = NDR_ALIGN(ndr, 2);
1328 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1329 blob.length = NDR_ALIGN(ndr, 4);
1330 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1331 blob.length = NDR_ALIGN(ndr, 8);
1333 NDR_PUSH_ALLOC_SIZE(ndr, blob.data, blob.length);
1334 data_blob_clear(&blob);
1336 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, blob.length));
1338 NDR_CHECK(ndr_push_bytes(ndr, blob.data, blob.length));
1339 return NDR_ERR_SUCCESS;
1343 * Pull a DATA_BLOB from the wire.
1344 * 1) when called with LIBNDR_FLAG_ALIGN* alignment flags set, pull padding
1345 * bytes _only_. The length is determined by the alignment required and the
1346 * current ndr offset.
1347 * 2) When called with the LIBNDR_FLAG_REMAINING flag, pull all remaining bytes
1348 * from the ndr buffer.
1349 * 3) Otherwise, pull a uint3264 length _and_ a corresponding byte array from the
1352 _PUBLIC_ enum ndr_err_code ndr_pull_DATA_BLOB(struct ndr_pull *ndr, int ndr_flags, DATA_BLOB *blob)
1354 uint32_t length = 0;
1356 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
1357 length = ndr->data_size - ndr->offset;
1358 } else if (ndr->flags & (LIBNDR_ALIGN_FLAGS & ~LIBNDR_FLAG_NOALIGN)) {
1359 if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1360 length = NDR_ALIGN(ndr, 2);
1361 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1362 length = NDR_ALIGN(ndr, 4);
1363 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1364 length = NDR_ALIGN(ndr, 8);
1366 if (ndr->data_size - ndr->offset < length) {
1367 length = ndr->data_size - ndr->offset;
1370 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &length));
1372 NDR_PULL_NEED_BYTES(ndr, length);
1373 *blob = data_blob_talloc(ndr->current_mem_ctx, ndr->data+ndr->offset, length);
1374 ndr->offset += length;
1375 return NDR_ERR_SUCCESS;
1378 _PUBLIC_ uint32_t ndr_size_DATA_BLOB(int ret, const DATA_BLOB *data, int flags)
1380 if (!data) return ret;
1381 return ret + data->length;
1384 _PUBLIC_ void ndr_print_bool(struct ndr_print *ndr, const char *name, const bool b)
1386 ndr->print(ndr, "%-25s: %s", name, b?"true":"false");
1389 _PUBLIC_ NTSTATUS ndr_map_error2ntstatus(enum ndr_err_code ndr_err)
1392 case NDR_ERR_SUCCESS:
1393 return NT_STATUS_OK;
1394 case NDR_ERR_BUFSIZE:
1395 return NT_STATUS_BUFFER_TOO_SMALL;
1397 return NT_STATUS_INTERNAL_ERROR;
1399 return NT_STATUS_NO_MEMORY;
1400 case NDR_ERR_ARRAY_SIZE:
1401 return NT_STATUS_ARRAY_BOUNDS_EXCEEDED;
1402 case NDR_ERR_INVALID_POINTER:
1403 return NT_STATUS_INVALID_PARAMETER_MIX;
1404 case NDR_ERR_UNREAD_BYTES:
1405 return NT_STATUS_PORT_MESSAGE_TOO_LONG;
1410 /* we should map all error codes to different status codes */
1411 return NT_STATUS_INVALID_PARAMETER;
1414 _PUBLIC_ int ndr_map_error2errno(enum ndr_err_code ndr_err)
1417 case NDR_ERR_SUCCESS:
1419 case NDR_ERR_BUFSIZE:
1425 case NDR_ERR_ARRAY_SIZE:
1427 case NDR_ERR_INVALID_POINTER:
1429 case NDR_ERR_UNREAD_BYTES:
1435 /* we should map all error codes to different status codes */
1439 _PUBLIC_ enum ndr_err_code ndr_push_timespec(struct ndr_push *ndr,
1441 const struct timespec *t)
1443 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1444 NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t->tv_sec));
1445 NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, t->tv_nsec));
1446 return NDR_ERR_SUCCESS;
1449 _PUBLIC_ enum ndr_err_code ndr_pull_timespec(struct ndr_pull *ndr,
1455 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1456 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &secs));
1457 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &nsecs));
1460 return NDR_ERR_SUCCESS;
1463 _PUBLIC_ void ndr_print_timespec(struct ndr_print *ndr, const char *name,
1464 const struct timespec *t)
1466 ndr->print(ndr, "%-25s: %s.%ld", name, timestring(ndr, t->tv_sec),
1470 _PUBLIC_ enum ndr_err_code ndr_push_timeval(struct ndr_push *ndr,
1472 const struct timeval *t)
1474 NDR_PUSH_CHECK_FLAGS(ndr, ndr_flags);
1475 NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, t->tv_sec));
1476 NDR_CHECK(ndr_push_uint32(ndr, ndr_flags, t->tv_usec));
1477 return NDR_ERR_SUCCESS;
1480 _PUBLIC_ enum ndr_err_code ndr_pull_timeval(struct ndr_pull *ndr,
1486 NDR_PULL_CHECK_FLAGS(ndr, ndr_flags);
1487 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &secs));
1488 NDR_CHECK(ndr_pull_uint32(ndr, ndr_flags, &usecs));
1491 return NDR_ERR_SUCCESS;
1494 _PUBLIC_ void ndr_print_timeval(struct ndr_print *ndr, const char *name,
1495 const struct timeval *t)
1497 ndr->print(ndr, "%-25s: %s.%ld", name, timestring(ndr, t->tv_sec),