?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
librpc: Shorten dcerpc_binding_handle_call a bit
[Samba/gebeck_regimport.git] / librpc / ndr / ndr.c
blobe86cf2f7635119e0e3e40865cc83d75074ec1fa4
1 /*
2 Unix SMB/CIFS implementation.
3
4 libndr interface
5
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Jelmer Vernooij 2005-2008
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 /*
24 this provides the core routines for NDR parsing functions
25
26 see http://www.opengroup.org/onlinepubs/9629399/chap14.htm for details
27 of NDR encoding rules
28 */
29
30 #include "includes.h"
31 #include "librpc/ndr/libndr.h"
32 #include "../lib/util/dlinklist.h"
33
34 #define NDR_BASE_MARSHALL_SIZE 1024
35
36 /* this guid indicates NDR encoding in a protocol tower */
37 const struct ndr_syntax_id ndr_transfer_syntax_ndr = {
38 { 0x8a885d04, 0x1ceb, 0x11c9, {0x9f, 0xe8}, {0x08,0x00,0x2b,0x10,0x48,0x60} },
39 2
40 };
41
42 const struct ndr_syntax_id ndr_transfer_syntax_ndr64 = {
43 { 0x71710533, 0xbeba, 0x4937, {0x83, 0x19}, {0xb5,0xdb,0xef,0x9c,0xcc,0x36} },
44 1
45 };
46
47 const struct ndr_syntax_id ndr_syntax_id_null = {
48 { 0, 0, 0, { 0, 0 }, { 0, 0, 0, 0, 0, 0 } },
49 0
50 };
51
52 /*
53 work out the number of bytes needed to align on a n byte boundary
54 */
55 _PUBLIC_ size_t ndr_align_size(uint32_t offset, size_t n)
56 {
57 if ((offset & (n-1)) == 0) return 0;
58 return n - (offset & (n-1));
59 }
60
61 /*
62 initialise a ndr parse structure from a data blob
63 */
64 _PUBLIC_ struct ndr_pull *ndr_pull_init_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx)
65 {
66 struct ndr_pull *ndr;
67
68 ndr = talloc_zero(mem_ctx, struct ndr_pull);
69 if (!ndr) return NULL;
70 ndr->current_mem_ctx = mem_ctx;
71
72 ndr->data = blob->data;
73 ndr->data_size = blob->length;
74
75 return ndr;
76 }
77
78 /*
79 advance by 'size' bytes
80 */
81 _PUBLIC_ enum ndr_err_code ndr_pull_advance(struct ndr_pull *ndr, uint32_t size)
82 {
83 ndr->offset += size;
84 if (ndr->offset > ndr->data_size) {
85 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
86 "ndr_pull_advance by %u failed",
87 size);
88 }
89 return NDR_ERR_SUCCESS;
90 }
91
92 /*
93 set the parse offset to 'ofs'
94 */
95 static enum ndr_err_code ndr_pull_set_offset(struct ndr_pull *ndr, uint32_t ofs)
96 {
97 ndr->offset = ofs;
98 if (ndr->offset > ndr->data_size) {
99 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
100 "ndr_pull_set_offset %u failed",
101 ofs);
102 }
103 return NDR_ERR_SUCCESS;
104 }
105
106 /* create a ndr_push structure, ready for some marshalling */
107 _PUBLIC_ struct ndr_push *ndr_push_init_ctx(TALLOC_CTX *mem_ctx)
108 {
109 struct ndr_push *ndr;
110
111 ndr = talloc_zero(mem_ctx, struct ndr_push);
112 if (!ndr) {
113 return NULL;
114 }
115
116 ndr->flags = 0;
117 ndr->alloc_size = NDR_BASE_MARSHALL_SIZE;
118 ndr->data = talloc_array(ndr, uint8_t, ndr->alloc_size);
119 if (!ndr->data) {
120 return NULL;
121 }
122
123 return ndr;
124 }
125
126 /* return a DATA_BLOB structure for the current ndr_push marshalled data */
127 _PUBLIC_ DATA_BLOB ndr_push_blob(struct ndr_push *ndr)
128 {
129 DATA_BLOB blob;
130 blob = data_blob_const(ndr->data, ndr->offset);
131 if (ndr->alloc_size > ndr->offset) {
132 ndr->data[ndr->offset] = 0;
133 }
134 return blob;
135 }
136
137
138 /*
139 expand the available space in the buffer to ndr->offset + extra_size
140 */
141 _PUBLIC_ enum ndr_err_code ndr_push_expand(struct ndr_push *ndr, uint32_t extra_size)
142 {
143 uint32_t size = extra_size + ndr->offset;
144
145 if (size < ndr->offset) {
146 /* extra_size overflowed the offset */
147 return ndr_push_error(ndr, NDR_ERR_BUFSIZE, "Overflow in push_expand to %u",
148 size);
149 }
150
151 if (ndr->alloc_size > size) {
152 return NDR_ERR_SUCCESS;
153 }
154
155 ndr->alloc_size += NDR_BASE_MARSHALL_SIZE;
156 if (size+1 > ndr->alloc_size) {
157 ndr->alloc_size = size+1;
158 }
159 ndr->data = talloc_realloc(ndr, ndr->data, uint8_t, ndr->alloc_size);
160 if (!ndr->data) {
161 return ndr_push_error(ndr, NDR_ERR_ALLOC, "Failed to push_expand to %u",
162 ndr->alloc_size);
163 }
164
165 return NDR_ERR_SUCCESS;
166 }
167
168 _PUBLIC_ void ndr_print_debugc_helper(struct ndr_print *ndr, const char *format, ...)
169 {
170 va_list ap;
171 char *s = NULL;
172 uint32_t i;
173 int ret;
174 int dbgc_class;
175
176 va_start(ap, format);
177 ret = vasprintf(&s, format, ap);
178 va_end(ap);
179
180 if (ret == -1) {
181 return;
182 }
183
184 dbgc_class = *(int *)ndr->private_data;
185
186 if (ndr->no_newline) {
187 DEBUGADDC(dbgc_class, 1,("%s", s));
188 free(s);
189 return;
190 }
191
192 for (i=0;i<ndr->depth;i++) {
193 DEBUGADDC(dbgc_class, 1,(" "));
194 }
195
196 DEBUGADDC(dbgc_class, 1,("%s\n", s));
197 free(s);
198 }
199
200 _PUBLIC_ void ndr_print_debug_helper(struct ndr_print *ndr, const char *format, ...)
201 {
202 va_list ap;
203 char *s = NULL;
204 uint32_t i;
205 int ret;
206
207 va_start(ap, format);
208 ret = vasprintf(&s, format, ap);
209 va_end(ap);
210
211 if (ret == -1) {
212 return;
213 }
214
215 if (ndr->no_newline) {
216 DEBUGADD(1,("%s", s));
217 free(s);
218 return;
219 }
220
221 for (i=0;i<ndr->depth;i++) {
222 DEBUGADD(1,(" "));
223 }
224
225 DEBUGADD(1,("%s\n", s));
226 free(s);
227 }
228
229 _PUBLIC_ void ndr_print_printf_helper(struct ndr_print *ndr, const char *format, ...)
230 {
231 va_list ap;
232 uint32_t i;
233
234 if (!ndr->no_newline) {
235 for (i=0;i<ndr->depth;i++) {
236 printf(" ");
237 }
238 }
239
240 va_start(ap, format);
241 vprintf(format, ap);
242 va_end(ap);
243 if (!ndr->no_newline) {
244 printf("\n");
245 }
246 }
247
248 _PUBLIC_ void ndr_print_string_helper(struct ndr_print *ndr, const char *format, ...)
249 {
250 va_list ap;
251 uint32_t i;
252
253 if (!ndr->no_newline) {
254 for (i=0;i<ndr->depth;i++) {
255 ndr->private_data = talloc_asprintf_append_buffer(
256 (char *)ndr->private_data, " ");
257 }
258 }
259
260 va_start(ap, format);
261 ndr->private_data = talloc_vasprintf_append_buffer((char *)ndr->private_data,
262 format, ap);
263 va_end(ap);
264 if (!ndr->no_newline) {
265 ndr->private_data = talloc_asprintf_append_buffer((char *)ndr->private_data,
266 "\n");
267 }
268 }
269
270 /*
271 a useful helper function for printing idl structures via DEBUGC()
272 */
273 _PUBLIC_ void ndr_print_debugc(int dbgc_class, ndr_print_fn_t fn, const char *name, void *ptr)
274 {
275 struct ndr_print *ndr;
276
277 DEBUGC(dbgc_class, 1,(" "));
278
279 ndr = talloc_zero(NULL, struct ndr_print);
280 if (!ndr) return;
281 ndr->private_data = &dbgc_class;
282 ndr->print = ndr_print_debugc_helper;
283 ndr->depth = 1;
284 ndr->flags = 0;
285 fn(ndr, name, ptr);
286 talloc_free(ndr);
287 }
288
289 /*
290 a useful helper function for printing idl structures via DEBUG()
291 */
292 _PUBLIC_ void ndr_print_debug(ndr_print_fn_t fn, const char *name, void *ptr)
293 {
294 struct ndr_print *ndr;
295
296 DEBUG(1,(" "));
297
298 ndr = talloc_zero(NULL, struct ndr_print);
299 if (!ndr) return;
300 ndr->print = ndr_print_debug_helper;
301 ndr->depth = 1;
302 ndr->flags = 0;
303 fn(ndr, name, ptr);
304 talloc_free(ndr);
305 }
306
307 /*
308 a useful helper function for printing idl unions via DEBUG()
309 */
310 _PUBLIC_ void ndr_print_union_debug(ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr)
311 {
312 struct ndr_print *ndr;
313
314 DEBUG(1,(" "));
315
316 ndr = talloc_zero(NULL, struct ndr_print);
317 if (!ndr) return;
318 ndr->print = ndr_print_debug_helper;
319 ndr->depth = 1;
320 ndr->flags = 0;
321 ndr_print_set_switch_value(ndr, ptr, level);
322 fn(ndr, name, ptr);
323 talloc_free(ndr);
324 }
325
326 /*
327 a useful helper function for printing idl function calls via DEBUG()
328 */
329 _PUBLIC_ void ndr_print_function_debug(ndr_print_function_t fn, const char *name, int flags, void *ptr)
330 {
331 struct ndr_print *ndr;
332
333 DEBUG(1,(" "));
334
335 ndr = talloc_zero(NULL, struct ndr_print);
336 if (!ndr) return;
337 ndr->print = ndr_print_debug_helper;
338 ndr->depth = 1;
339 ndr->flags = 0;
340
341 fn(ndr, name, flags, ptr);
342 talloc_free(ndr);
343 }
344
345 /*
346 a useful helper function for printing idl structures to a string
347 */
348 _PUBLIC_ char *ndr_print_struct_string(TALLOC_CTX *mem_ctx, ndr_print_fn_t fn, const char *name, void *ptr)
349 {
350 struct ndr_print *ndr;
351 char *ret = NULL;
352
353 ndr = talloc_zero(mem_ctx, struct ndr_print);
354 if (!ndr) return NULL;
355 ndr->private_data = talloc_strdup(ndr, "");
356 if (!ndr->private_data) {
357 goto failed;
358 }
359 ndr->print = ndr_print_string_helper;
360 ndr->depth = 1;
361 ndr->flags = 0;
362
363 fn(ndr, name, ptr);
364 ret = talloc_steal(mem_ctx, (char *)ndr->private_data);
365 failed:
366 talloc_free(ndr);
367 return ret;
368 }
369
370 /*
371 a useful helper function for printing idl unions to a string
372 */
373 _PUBLIC_ char *ndr_print_union_string(TALLOC_CTX *mem_ctx, ndr_print_fn_t fn, const char *name, uint32_t level, void *ptr)
374 {
375 struct ndr_print *ndr;
376 char *ret = NULL;
377
378 ndr = talloc_zero(mem_ctx, struct ndr_print);
379 if (!ndr) return NULL;
380 ndr->private_data = talloc_strdup(ndr, "");
381 if (!ndr->private_data) {
382 goto failed;
383 }
384 ndr->print = ndr_print_string_helper;
385 ndr->depth = 1;
386 ndr->flags = 0;
387 ndr_print_set_switch_value(ndr, ptr, level);
388 fn(ndr, name, ptr);
389 ret = talloc_steal(mem_ctx, (char *)ndr->private_data);
390 failed:
391 talloc_free(ndr);
392 return ret;
393 }
394
395 /*
396 a useful helper function for printing idl function calls to a string
397 */
398 _PUBLIC_ char *ndr_print_function_string(TALLOC_CTX *mem_ctx,
399 ndr_print_function_t fn, const char *name,
400 int flags, void *ptr)
401 {
402 struct ndr_print *ndr;
403 char *ret = NULL;
404
405 ndr = talloc_zero(mem_ctx, struct ndr_print);
406 if (!ndr) return NULL;
407 ndr->private_data = talloc_strdup(ndr, "");
408 if (!ndr->private_data) {
409 goto failed;
410 }
411 ndr->print = ndr_print_string_helper;
412 ndr->depth = 1;
413 ndr->flags = 0;
414 fn(ndr, name, flags, ptr);
415 ret = talloc_steal(mem_ctx, (char *)ndr->private_data);
416 failed:
417 talloc_free(ndr);
418 return ret;
419 }
420
421 _PUBLIC_ void ndr_set_flags(uint32_t *pflags, uint32_t new_flags)
422 {
423 /* the big/little endian flags are inter-dependent */
424 if (new_flags & LIBNDR_FLAG_LITTLE_ENDIAN) {
425 (*pflags) &= ~LIBNDR_FLAG_BIGENDIAN;
426 (*pflags) &= ~LIBNDR_FLAG_NDR64;
427 }
428 if (new_flags & LIBNDR_FLAG_BIGENDIAN) {
429 (*pflags) &= ~LIBNDR_FLAG_LITTLE_ENDIAN;
430 (*pflags) &= ~LIBNDR_FLAG_NDR64;
431 }
432 if (new_flags & LIBNDR_ALIGN_FLAGS) {
433 /* Ensure we only have the passed-in
434 align flag set in the new_flags,
435 remove any old align flag. */
436 (*pflags) &= ~LIBNDR_ALIGN_FLAGS;
437 }
438 if (new_flags & LIBNDR_FLAG_NO_RELATIVE_REVERSE) {
439 (*pflags) &= ~LIBNDR_FLAG_RELATIVE_REVERSE;
440 }
441 (*pflags) |= new_flags;
442 }
443
444 /*
445 return and possibly log an NDR error
446 */
447 _PUBLIC_ enum ndr_err_code ndr_pull_error(struct ndr_pull *ndr,
448 enum ndr_err_code ndr_err,
449 const char *format, ...)
450 {
451 char *s=NULL;
452 va_list ap;
453 int ret;
454
455 va_start(ap, format);
456 ret = vasprintf(&s, format, ap);
457 va_end(ap);
458
459 if (ret == -1) {
460 return NDR_ERR_ALLOC;
461 }
462
463 DEBUG(1,("ndr_pull_error(%u): %s\n", ndr_err, s));
464
465 free(s);
466
467 return ndr_err;
468 }
469
470 /*
471 return and possibly log an NDR error
472 */
473 _PUBLIC_ enum ndr_err_code ndr_push_error(struct ndr_push *ndr,
474 enum ndr_err_code ndr_err,
475 const char *format, ...)
476 {
477 char *s=NULL;
478 va_list ap;
479 int ret;
480
481 va_start(ap, format);
482 ret = vasprintf(&s, format, ap);
483 va_end(ap);
484
485 if (ret == -1) {
486 return NDR_ERR_ALLOC;
487 }
488
489 DEBUG(1,("ndr_push_error(%u): %s\n", ndr_err, s));
490
491 free(s);
492
493 return ndr_err;
494 }
495
496 /*
497 handle subcontext buffers, which in midl land are user-marshalled, but
498 we use magic in pidl to make them easier to cope with
499 */
500 _PUBLIC_ enum ndr_err_code ndr_pull_subcontext_start(struct ndr_pull *ndr,
501 struct ndr_pull **_subndr,
502 size_t header_size,
503 ssize_t size_is)
504 {
505 struct ndr_pull *subndr;
506 uint32_t r_content_size;
507 bool force_le = false;
508 bool force_be = false;
509
510 switch (header_size) {
511 case 0: {
512 uint32_t content_size = ndr->data_size - ndr->offset;
513 if (size_is >= 0) {
514 content_size = size_is;
515 }
516 r_content_size = content_size;
517 break;
518 }
519
520 case 2: {
521 uint16_t content_size;
522 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &content_size));
523 if (size_is >= 0 && size_is != content_size) {
524 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) size_is(%d) mismatch content_size %d",
525 (int)size_is, (int)content_size);
526 }
527 r_content_size = content_size;
528 break;
529 }
530
531 case 4: {
532 uint32_t content_size;
533 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &content_size));
534 if (size_is >= 0 && size_is != content_size) {
535 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) size_is(%d) mismatch content_size %d",
536 (int)size_is, (int)content_size);
537 }
538 r_content_size = content_size;
539 break;
540 }
541 case 0xFFFFFC01: {
542 /*
543 * Common Type Header for the Serialization Stream
544 * See [MS-RPCE] 2.2.6 Type Serialization Version 1
545 */
546 uint8_t version;
547 uint8_t drep;
548 uint16_t hdrlen;
549 uint32_t filler;
550 uint32_t content_size;
551 uint32_t reserved;
552
553 /* version */
554 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &version));
555
556 if (version != 1) {
557 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT,
558 "Bad subcontext (PULL) Common Type Header version %d != 1",
559 (int)version);
560 }
561
562 /*
563 * 0x10 little endian
564 * 0x00 big endian
565 */
566 NDR_CHECK(ndr_pull_uint8(ndr, NDR_SCALARS, &drep));
567 if (drep == 0x10) {
568 force_le = true;
569 } else if (drep == 0x00) {
570 force_be = true;
571 } else {
572 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT,
573 "Bad subcontext (PULL) Common Type Header invalid drep 0x%02X",
574 (unsigned int)drep);
575 }
576
577 /* length of the "Private Header for Constructed Type" */
578 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &hdrlen));
579 if (hdrlen != 8) {
580 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT,
581 "Bad subcontext (PULL) Common Type Header length %d != 8",
582 (int)hdrlen);
583 }
584
585 /* filler should be ignored */
586 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &filler));
587
588 /*
589 * Private Header for Constructed Type
590 */
591 /* length - will be updated latter */
592 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &content_size));
593 if (size_is >= 0 && size_is != content_size) {
594 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) size_is(%d) mismatch content_size %d",
595 (int)size_is, (int)content_size);
596 }
597 /* the content size must be a multiple of 8 */
598 if ((content_size % 8) != 0) {
599 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT,
600 "Bad subcontext (PULL) size_is(%d) not padded to 8 content_size %d",
601 (int)size_is, (int)content_size);
602 }
603 r_content_size = content_size;
604
605 /* reserved */
606 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &reserved));
607 break;
608 }
609 default:
610 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PULL) header_size %d",
611 (int)header_size);
612 }
613
614 NDR_PULL_NEED_BYTES(ndr, r_content_size);
615
616 subndr = talloc_zero(ndr, struct ndr_pull);
617 NDR_ERR_HAVE_NO_MEMORY(subndr);
618 subndr->flags = ndr->flags & ~LIBNDR_FLAG_NDR64;
619 subndr->current_mem_ctx = ndr->current_mem_ctx;
620
621 subndr->data = ndr->data + ndr->offset;
622 subndr->offset = 0;
623 subndr->data_size = r_content_size;
624
625 if (force_le) {
626 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
627 } else if (force_be) {
628 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
629 }
630
631 *_subndr = subndr;
632 return NDR_ERR_SUCCESS;
633 }
634
635 _PUBLIC_ enum ndr_err_code ndr_pull_subcontext_end(struct ndr_pull *ndr,
636 struct ndr_pull *subndr,
637 size_t header_size,
638 ssize_t size_is)
639 {
640 uint32_t advance;
641 if (size_is >= 0) {
642 advance = size_is;
643 } else if (header_size > 0) {
644 advance = subndr->data_size;
645 } else {
646 advance = subndr->offset;
647 }
648 NDR_CHECK(ndr_pull_advance(ndr, advance));
649 return NDR_ERR_SUCCESS;
650 }
651
652 _PUBLIC_ enum ndr_err_code ndr_push_subcontext_start(struct ndr_push *ndr,
653 struct ndr_push **_subndr,
654 size_t header_size,
655 ssize_t size_is)
656 {
657 struct ndr_push *subndr;
658
659 subndr = ndr_push_init_ctx(ndr);
660 NDR_ERR_HAVE_NO_MEMORY(subndr);
661 subndr->flags = ndr->flags & ~LIBNDR_FLAG_NDR64;
662
663 if (size_is > 0) {
664 NDR_CHECK(ndr_push_zero(subndr, size_is));
665 subndr->offset = 0;
666 subndr->relative_end_offset = size_is;
667 }
668
669 *_subndr = subndr;
670 return NDR_ERR_SUCCESS;
671 }
672
673 /*
674 push a subcontext header
675 */
676 _PUBLIC_ enum ndr_err_code ndr_push_subcontext_end(struct ndr_push *ndr,
677 struct ndr_push *subndr,
678 size_t header_size,
679 ssize_t size_is)
680 {
681 ssize_t padding_len;
682
683 if (size_is >= 0) {
684 padding_len = size_is - subndr->offset;
685 if (padding_len < 0) {
686 return ndr_push_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext (PUSH) content_size %d is larger than size_is(%d)",
687 (int)subndr->offset, (int)size_is);
688 }
689 subndr->offset = size_is;
690 }
691
692 switch (header_size) {
693 case 0:
694 break;
695
696 case 2:
697 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, subndr->offset));
698 break;
699
700 case 4:
701 NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, subndr->offset));
702 break;
703
704 case 0xFFFFFC01:
705 /*
706 * Common Type Header for the Serialization Stream
707 * See [MS-RPCE] 2.2.6 Type Serialization Version 1
708 */
709 padding_len = NDR_ROUND(subndr->offset, 8) - subndr->offset;
710 if (padding_len > 0) {
711 NDR_CHECK(ndr_push_zero(subndr, padding_len));
712 }
713
714 /* version */
715 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, 1));
716
717 /*
718 * 0x10 little endian
719 * 0x00 big endian
720 */
721 NDR_CHECK(ndr_push_uint8(ndr, NDR_SCALARS, NDR_BE(ndr)?0x00:0x10));
722
723 /* length of the "Private Header for Constructed Type" */
724 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 8));
725
726 /* filler */
727 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0xCCCCCCCC));
728
729 /*
730 * Private Header for Constructed Type
731 */
732 /* length - will be updated latter */
733 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, subndr->offset));
734
735 /* reserved */
736 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
737 break;
738
739 default:
740 return ndr_push_error(ndr, NDR_ERR_SUBCONTEXT, "Bad subcontext header size %d",
741 (int)header_size);
742 }
743
744 NDR_CHECK(ndr_push_bytes(ndr, subndr->data, subndr->offset));
745 return NDR_ERR_SUCCESS;
746 }
747
748 /*
749 store a token in the ndr context, for later retrieval
750 */
751 _PUBLIC_ enum ndr_err_code ndr_token_store(TALLOC_CTX *mem_ctx,
752 struct ndr_token_list **list,
753 const void *key,
754 uint32_t value)
755 {
756 struct ndr_token_list *tok;
757 tok = talloc(mem_ctx, struct ndr_token_list);
758 NDR_ERR_HAVE_NO_MEMORY(tok);
759 tok->key = key;
760 tok->value = value;
761 DLIST_ADD((*list), tok);
762 return NDR_ERR_SUCCESS;
763 }
764
765 /*
766 retrieve a token from a ndr context, using cmp_fn to match the tokens
767 */
768 _PUBLIC_ enum ndr_err_code ndr_token_retrieve_cmp_fn(struct ndr_token_list **list, const void *key, uint32_t *v,
769 comparison_fn_t _cmp_fn, bool _remove_tok)
770 {
771 struct ndr_token_list *tok;
772 for (tok=*list;tok;tok=tok->next) {
773 if (_cmp_fn && _cmp_fn(tok->key,key)==0) goto found;
774 else if (!_cmp_fn && tok->key == key) goto found;
775 }
776 return NDR_ERR_TOKEN;
777 found:
778 *v = tok->value;
779 if (_remove_tok) {
780 DLIST_REMOVE((*list), tok);
781 talloc_free(tok);
782 }
783 return NDR_ERR_SUCCESS;
784 }
785
786 /*
787 retrieve a token from a ndr context
788 */
789 _PUBLIC_ enum ndr_err_code ndr_token_retrieve(struct ndr_token_list **list, const void *key, uint32_t *v)
790 {
791 return ndr_token_retrieve_cmp_fn(list, key, v, NULL, true);
792 }
793
794 /*
795 peek at but don't removed a token from a ndr context
796 */
797 _PUBLIC_ uint32_t ndr_token_peek(struct ndr_token_list **list, const void *key)
798 {
799 enum ndr_err_code status;
800 uint32_t v;
801
802 status = ndr_token_retrieve_cmp_fn(list, key, &v, NULL, false);
803 if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
804 return 0;
805 }
806
807 return v;
808 }
809
810 /*
811 pull an array size field and add it to the array_size_list token list
812 */
813 _PUBLIC_ enum ndr_err_code ndr_pull_array_size(struct ndr_pull *ndr, const void *p)
814 {
815 uint32_t size;
816 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &size));
817 return ndr_token_store(ndr, &ndr->array_size_list, p, size);
818 }
819
820 /*
821 get the stored array size field
822 */
823 _PUBLIC_ uint32_t ndr_get_array_size(struct ndr_pull *ndr, const void *p)
824 {
825 return ndr_token_peek(&ndr->array_size_list, p);
826 }
827
828 /*
829 check the stored array size field
830 */
831 _PUBLIC_ enum ndr_err_code ndr_check_array_size(struct ndr_pull *ndr, void *p, uint32_t size)
832 {
833 uint32_t stored;
834 stored = ndr_token_peek(&ndr->array_size_list, p);
835 if (stored != size) {
836 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE,
837 "Bad array size - got %u expected %u\n",
838 stored, size);
839 }
840 return NDR_ERR_SUCCESS;
841 }
842
843 /*
844 pull an array length field and add it to the array_length_list token list
845 */
846 _PUBLIC_ enum ndr_err_code ndr_pull_array_length(struct ndr_pull *ndr, const void *p)
847 {
848 uint32_t length, offset;
849 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &offset));
850 if (offset != 0) {
851 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE,
852 "non-zero array offset %u\n", offset);
853 }
854 NDR_CHECK(ndr_pull_uint3264(ndr, NDR_SCALARS, &length));
855 return ndr_token_store(ndr, &ndr->array_length_list, p, length);
856 }
857
858 /*
859 get the stored array length field
860 */
861 _PUBLIC_ uint32_t ndr_get_array_length(struct ndr_pull *ndr, const void *p)
862 {
863 return ndr_token_peek(&ndr->array_length_list, p);
864 }
865
866 /*
867 check the stored array length field
868 */
869 _PUBLIC_ enum ndr_err_code ndr_check_array_length(struct ndr_pull *ndr, void *p, uint32_t length)
870 {
871 uint32_t stored;
872 stored = ndr_token_peek(&ndr->array_length_list, p);
873 if (stored != length) {
874 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE,
875 "Bad array length - got %u expected %u\n",
876 stored, length);
877 }
878 return NDR_ERR_SUCCESS;
879 }
880
881 _PUBLIC_ enum ndr_err_code ndr_push_pipe_chunk_trailer(struct ndr_push *ndr, int ndr_flags, uint32_t count)
882 {
883 if (ndr->flags & LIBNDR_FLAG_NDR64) {
884 int64_t tmp = 0 - (int64_t)count;
885 uint64_t ncount = tmp;
886
887 NDR_CHECK(ndr_push_hyper(ndr, ndr_flags, ncount));
888 }
889
890 return NDR_ERR_SUCCESS;
891 }
892
893 _PUBLIC_ enum ndr_err_code ndr_check_pipe_chunk_trailer(struct ndr_pull *ndr, int ndr_flags, uint32_t count)
894 {
895 if (ndr->flags & LIBNDR_FLAG_NDR64) {
896 int64_t tmp = 0 - (int64_t)count;
897 uint64_t ncount1 = tmp;
898 uint64_t ncount2;
899
900 NDR_CHECK(ndr_pull_hyper(ndr, ndr_flags, &ncount2));
901 if (ncount1 == ncount2) {
902 return NDR_ERR_SUCCESS;
903 }
904
905 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE,
906 "Bad pipe trailer[%lld should be %lld] size was %lu\"",
907 (unsigned long long)ncount2,
908 (unsigned long long)ncount1,
909 (unsigned long)count);
910 }
911
912 return NDR_ERR_SUCCESS;
913 }
914
915 /*
916 store a switch value
917 */
918 _PUBLIC_ enum ndr_err_code ndr_push_set_switch_value(struct ndr_push *ndr, const void *p, uint32_t val)
919 {
920 return ndr_token_store(ndr, &ndr->switch_list, p, val);
921 }
922
923 _PUBLIC_ enum ndr_err_code ndr_pull_set_switch_value(struct ndr_pull *ndr, const void *p, uint32_t val)
924 {
925 return ndr_token_store(ndr, &ndr->switch_list, p, val);
926 }
927
928 _PUBLIC_ enum ndr_err_code ndr_print_set_switch_value(struct ndr_print *ndr, const void *p, uint32_t val)
929 {
930 return ndr_token_store(ndr, &ndr->switch_list, p, val);
931 }
932
933 /*
934 retrieve a switch value
935 */
936 _PUBLIC_ uint32_t ndr_push_get_switch_value(struct ndr_push *ndr, const void *p)
937 {
938 return ndr_token_peek(&ndr->switch_list, p);
939 }
940
941 _PUBLIC_ uint32_t ndr_pull_get_switch_value(struct ndr_pull *ndr, const void *p)
942 {
943 return ndr_token_peek(&ndr->switch_list, p);
944 }
945
946 _PUBLIC_ uint32_t ndr_print_get_switch_value(struct ndr_print *ndr, const void *p)
947 {
948 return ndr_token_peek(&ndr->switch_list, p);
949 }
950
951 /*
952 pull a struct from a blob using NDR
953 */
954 _PUBLIC_ enum ndr_err_code ndr_pull_struct_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
955 ndr_pull_flags_fn_t fn)
956 {
957 struct ndr_pull *ndr;
958 ndr = ndr_pull_init_blob(blob, mem_ctx);
959 NDR_ERR_HAVE_NO_MEMORY(ndr);
960 NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
961 talloc_free(ndr);
962 return NDR_ERR_SUCCESS;
963 }
964
965 /*
966 pull a struct from a blob using NDR - failing if all bytes are not consumed
967 */
968 _PUBLIC_ enum ndr_err_code ndr_pull_struct_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
969 void *p, ndr_pull_flags_fn_t fn)
970 {
971 struct ndr_pull *ndr;
972 uint32_t highest_ofs;
973 ndr = ndr_pull_init_blob(blob, mem_ctx);
974 NDR_ERR_HAVE_NO_MEMORY(ndr);
975 NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
976 if (ndr->offset > ndr->relative_highest_offset) {
977 highest_ofs = ndr->offset;
978 } else {
979 highest_ofs = ndr->relative_highest_offset;
980 }
981 if (highest_ofs < ndr->data_size) {
982 enum ndr_err_code ret;
983 ret = ndr_pull_error(ndr, NDR_ERR_UNREAD_BYTES,
984 "not all bytes consumed ofs[%u] size[%u]",
985 highest_ofs, ndr->data_size);
986 talloc_free(ndr);
987 return ret;
988 }
989 talloc_free(ndr);
990 return NDR_ERR_SUCCESS;
991 }
992
993 /*
994 pull a union from a blob using NDR, given the union discriminator
995 */
996 _PUBLIC_ enum ndr_err_code ndr_pull_union_blob(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
997 void *p,
998 uint32_t level, ndr_pull_flags_fn_t fn)
999 {
1000 struct ndr_pull *ndr;
1001 ndr = ndr_pull_init_blob(blob, mem_ctx);
1002 NDR_ERR_HAVE_NO_MEMORY(ndr);
1003 NDR_CHECK_FREE(ndr_pull_set_switch_value(ndr, p, level));
1004 NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
1005 talloc_free(ndr);
1006 return NDR_ERR_SUCCESS;
1007 }
1008
1009 /*
1010 pull a union from a blob using NDR, given the union discriminator,
1011 failing if all bytes are not consumed
1012 */
1013 _PUBLIC_ enum ndr_err_code ndr_pull_union_blob_all(const DATA_BLOB *blob, TALLOC_CTX *mem_ctx,
1014 void *p,
1015 uint32_t level, ndr_pull_flags_fn_t fn)
1016 {
1017 struct ndr_pull *ndr;
1018 uint32_t highest_ofs;
1019 ndr = ndr_pull_init_blob(blob, mem_ctx);
1020 NDR_ERR_HAVE_NO_MEMORY(ndr);
1021 NDR_CHECK_FREE(ndr_pull_set_switch_value(ndr, p, level));
1022 NDR_CHECK_FREE(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
1023 if (ndr->offset > ndr->relative_highest_offset) {
1024 highest_ofs = ndr->offset;
1025 } else {
1026 highest_ofs = ndr->relative_highest_offset;
1027 }
1028 if (highest_ofs < ndr->data_size) {
1029 enum ndr_err_code ret;
1030 ret = ndr_pull_error(ndr, NDR_ERR_UNREAD_BYTES,
1031 "not all bytes consumed ofs[%u] size[%u]",
1032 highest_ofs, ndr->data_size);
1033 talloc_free(ndr);
1034 return ret;
1035 }
1036 talloc_free(ndr);
1037 return NDR_ERR_SUCCESS;
1038 }
1039
1040 /*
1041 push a struct to a blob using NDR
1042 */
1043 _PUBLIC_ enum ndr_err_code ndr_push_struct_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, const void *p, ndr_push_flags_fn_t fn)
1044 {
1045 struct ndr_push *ndr;
1046 ndr = ndr_push_init_ctx(mem_ctx);
1047 NDR_ERR_HAVE_NO_MEMORY(ndr);
1048
1049 NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
1050
1051 *blob = ndr_push_blob(ndr);
1052 talloc_steal(mem_ctx, blob->data);
1053 talloc_free(ndr);
1054
1055 return NDR_ERR_SUCCESS;
1056 }
1057
1058 /*
1059 push a union to a blob using NDR
1060 */
1061 _PUBLIC_ enum ndr_err_code ndr_push_union_blob(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, void *p,
1062 uint32_t level, ndr_push_flags_fn_t fn)
1063 {
1064 struct ndr_push *ndr;
1065 ndr = ndr_push_init_ctx(mem_ctx);
1066 NDR_ERR_HAVE_NO_MEMORY(ndr);
1067
1068 NDR_CHECK(ndr_push_set_switch_value(ndr, p, level));
1069 NDR_CHECK(fn(ndr, NDR_SCALARS|NDR_BUFFERS, p));
1070
1071 *blob = ndr_push_blob(ndr);
1072 talloc_steal(mem_ctx, blob->data);
1073 talloc_free(ndr);
1074
1075 return NDR_ERR_SUCCESS;
1076 }
1077
1078 /*
1079 generic ndr_size_*() handler for structures
1080 */
1081 _PUBLIC_ size_t ndr_size_struct(const void *p, int flags, ndr_push_flags_fn_t push)
1082 {
1083 struct ndr_push *ndr;
1084 enum ndr_err_code status;
1085 size_t ret;
1086
1087 /* avoid recursion */
1088 if (flags & LIBNDR_FLAG_NO_NDR_SIZE) return 0;
1089
1090 ndr = ndr_push_init_ctx(NULL);
1091 if (!ndr) return 0;
1092 ndr->flags |= flags | LIBNDR_FLAG_NO_NDR_SIZE;
1093 status = push(ndr, NDR_SCALARS|NDR_BUFFERS, discard_const(p));
1094 if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
1095 talloc_free(ndr);
1096 return 0;
1097 }
1098 ret = ndr->offset;
1099 talloc_free(ndr);
1100 return ret;
1101 }
1102
1103 /*
1104 generic ndr_size_*() handler for unions
1105 */
1106 _PUBLIC_ size_t ndr_size_union(const void *p, int flags, uint32_t level, ndr_push_flags_fn_t push)
1107 {
1108 struct ndr_push *ndr;
1109 enum ndr_err_code status;
1110 size_t ret;
1111
1112 /* avoid recursion */
1113 if (flags & LIBNDR_FLAG_NO_NDR_SIZE) return 0;
1114
1115 ndr = ndr_push_init_ctx(NULL);
1116 if (!ndr) return 0;
1117 ndr->flags |= flags | LIBNDR_FLAG_NO_NDR_SIZE;
1118
1119 status = ndr_push_set_switch_value(ndr, p, level);
1120 if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
1121 talloc_free(ndr);
1122 return 0;
1123 }
1124 status = push(ndr, NDR_SCALARS|NDR_BUFFERS, p);
1125 if (!NDR_ERR_CODE_IS_SUCCESS(status)) {
1126 talloc_free(ndr);
1127 return 0;
1128 }
1129 ret = ndr->offset;
1130 talloc_free(ndr);
1131 return ret;
1132 }
1133
1134 /*
1135 get the current base for relative pointers for the push
1136 */
1137 _PUBLIC_ uint32_t ndr_push_get_relative_base_offset(struct ndr_push *ndr)
1138 {
1139 return ndr->relative_base_offset;
1140 }
1141
1142 /*
1143 restore the old base for relative pointers for the push
1144 */
1145 _PUBLIC_ void ndr_push_restore_relative_base_offset(struct ndr_push *ndr, uint32_t offset)
1146 {
1147 ndr->relative_base_offset = offset;
1148 }
1149
1150 /*
1151 setup the current base for relative pointers for the push
1152 called in the NDR_SCALAR stage
1153 */
1154 _PUBLIC_ enum ndr_err_code ndr_push_setup_relative_base_offset1(struct ndr_push *ndr, const void *p, uint32_t offset)
1155 {
1156 ndr->relative_base_offset = offset;
1157 return ndr_token_store(ndr, &ndr->relative_base_list, p, offset);
1158 }
1159
1160 /*
1161 setup the current base for relative pointers for the push
1162 called in the NDR_BUFFERS stage
1163 */
1164 _PUBLIC_ enum ndr_err_code ndr_push_setup_relative_base_offset2(struct ndr_push *ndr, const void *p)
1165 {
1166 return ndr_token_retrieve(&ndr->relative_base_list, p, &ndr->relative_base_offset);
1167 }
1168
1169 /*
1170 push a relative object - stage1
1171 this is called during SCALARS processing
1172 */
1173 _PUBLIC_ enum ndr_err_code ndr_push_relative_ptr1(struct ndr_push *ndr, const void *p)
1174 {
1175 if (p == NULL) {
1176 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
1177 return NDR_ERR_SUCCESS;
1178 }
1179 NDR_CHECK(ndr_push_align(ndr, 4));
1180 NDR_CHECK(ndr_token_store(ndr, &ndr->relative_list, p, ndr->offset));
1181 return ndr_push_uint32(ndr, NDR_SCALARS, 0xFFFFFFFF);
1182 }
1183
1184 /*
1185 push a short relative object - stage1
1186 this is called during SCALARS processing
1187 */
1188 _PUBLIC_ enum ndr_err_code ndr_push_short_relative_ptr1(struct ndr_push *ndr, const void *p)
1189 {
1190 if (p == NULL) {
1191 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, 0));
1192 return NDR_ERR_SUCCESS;
1193 }
1194 NDR_CHECK(ndr_push_align(ndr, 2));
1195 NDR_CHECK(ndr_token_store(ndr, &ndr->relative_list, p, ndr->offset));
1196 return ndr_push_uint16(ndr, NDR_SCALARS, 0xFFFF);
1197 }
1198 /*
1199 push a relative object - stage2
1200 this is called during buffers processing
1201 */
1202 static enum ndr_err_code ndr_push_relative_ptr2(struct ndr_push *ndr, const void *p)
1203 {
1204 uint32_t save_offset;
1205 uint32_t ptr_offset = 0xFFFFFFFF;
1206 if (p == NULL) {
1207 return NDR_ERR_SUCCESS;
1208 }
1209 save_offset = ndr->offset;
1210 NDR_CHECK(ndr_token_retrieve(&ndr->relative_list, p, &ptr_offset));
1211 if (ptr_offset > ndr->offset) {
1212 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
1213 "ndr_push_relative_ptr2 ptr_offset(%u) > ndr->offset(%u)",
1214 ptr_offset, ndr->offset);
1215 }
1216 ndr->offset = ptr_offset;
1217 if (save_offset < ndr->relative_base_offset) {
1218 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
1219 "ndr_push_relative_ptr2 save_offset(%u) < ndr->relative_base_offset(%u)",
1220 save_offset, ndr->relative_base_offset);
1221 }
1222 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, save_offset - ndr->relative_base_offset));
1223 ndr->offset = save_offset;
1224 return NDR_ERR_SUCCESS;
1225 }
1226 /*
1227 push a short relative object - stage2
1228 this is called during buffers processing
1229 */
1230 _PUBLIC_ enum ndr_err_code ndr_push_short_relative_ptr2(struct ndr_push *ndr, const void *p)
1231 {
1232 uint32_t save_offset;
1233 uint32_t ptr_offset = 0xFFFF;
1234 if (p == NULL) {
1235 return NDR_ERR_SUCCESS;
1236 }
1237 save_offset = ndr->offset;
1238 NDR_CHECK(ndr_token_retrieve(&ndr->relative_list, p, &ptr_offset));
1239 if (ptr_offset > ndr->offset) {
1240 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
1241 "ndr_push_short_relative_ptr2 ptr_offset(%u) > ndr->offset(%u)",
1242 ptr_offset, ndr->offset);
1243 }
1244 ndr->offset = ptr_offset;
1245 if (save_offset < ndr->relative_base_offset) {
1246 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
1247 "ndr_push_relative_ptr2 save_offset(%u) < ndr->relative_base_offset(%u)",
1248 save_offset, ndr->relative_base_offset);
1249 }
1250 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, save_offset - ndr->relative_base_offset));
1251 ndr->offset = save_offset;
1252 return NDR_ERR_SUCCESS;
1253 }
1254
1255 /*
1256 push a relative object - stage2 start
1257 this is called during buffers processing
1258 */
1259 _PUBLIC_ enum ndr_err_code ndr_push_relative_ptr2_start(struct ndr_push *ndr, const void *p)
1260 {
1261 if (p == NULL) {
1262 return NDR_ERR_SUCCESS;
1263 }
1264 if (!(ndr->flags & LIBNDR_FLAG_RELATIVE_REVERSE)) {
1265 uint32_t relative_offset;
1266 size_t pad;
1267 size_t align = 1;
1268
1269 if (ndr->offset < ndr->relative_base_offset) {
1270 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,
1271 "ndr_push_relative_ptr2_start ndr->offset(%u) < ndr->relative_base_offset(%u)",
1272 ndr->offset, ndr->relative_base_offset);
1273 }
1274
1275 relative_offset = ndr->offset - ndr->relative_base_offset;
1276
1277 if (ndr->flags & LIBNDR_FLAG_NOALIGN) {
1278 align = 1;
1279 } else if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1280 align = 2;
1281 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1282 align = 4;
1283 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1284 align = 8;
1285 }
1286
1287 pad = ndr_align_size(relative_offset, align);
1288 if (pad) {
1289 NDR_CHECK(ndr_push_zero(ndr, pad));
1290 }
1291
1292 return ndr_push_relative_ptr2(ndr, p);
1293 }
1294 if (ndr->relative_end_offset == -1) {
1295 return ndr_push_error(ndr, NDR_ERR_RELATIVE,
1296 "ndr_push_relative_ptr2_start RELATIVE_REVERSE flag set and relative_end_offset %d",
1297 ndr->relative_end_offset);
1298 }
1299 NDR_CHECK(ndr_token_store(ndr, &ndr->relative_begin_list, p, ndr->offset));
1300 return NDR_ERR_SUCCESS;
1301 }
1302
1303 /*
1304 push a relative object - stage2 end
1305 this is called during buffers processing
1306 */
1307 _PUBLIC_ enum ndr_err_code ndr_push_relative_ptr2_end(struct ndr_push *ndr, const void *p)
1308 {
1309 uint32_t begin_offset = 0xFFFFFFFF;
1310 ssize_t len;
1311 uint32_t correct_offset = 0;
1312 uint32_t align = 1;
1313 uint32_t pad = 0;
1314
1315 if (p == NULL) {
1316 return NDR_ERR_SUCCESS;
1317 }
1318
1319 if (!(ndr->flags & LIBNDR_FLAG_RELATIVE_REVERSE)) {
1320 return NDR_ERR_SUCCESS;
1321 }
1322
1323 if (ndr->flags & LIBNDR_FLAG_NO_NDR_SIZE) {
1324 /* better say more than calculation a too small buffer */
1325 NDR_PUSH_ALIGN(ndr, 8);
1326 return NDR_ERR_SUCCESS;
1327 }
1328
1329 if (ndr->relative_end_offset < ndr->offset) {
1330 return ndr_push_error(ndr, NDR_ERR_RELATIVE,
1331 "ndr_push_relative_ptr2_end:"
1332 "relative_end_offset %u < offset %u",
1333 ndr->relative_end_offset, ndr->offset);
1334 }
1335
1336 NDR_CHECK(ndr_token_retrieve(&ndr->relative_begin_list, p, &begin_offset));
1337
1338 /* we have marshalled a buffer, see how long it was */
1339 len = ndr->offset - begin_offset;
1340
1341 if (len < 0) {
1342 return ndr_push_error(ndr, NDR_ERR_RELATIVE,
1343 "ndr_push_relative_ptr2_end:"
1344 "offset %u - begin_offset %u < 0",
1345 ndr->offset, begin_offset);
1346 }
1347
1348 if (ndr->relative_end_offset < len) {
1349 return ndr_push_error(ndr, NDR_ERR_RELATIVE,
1350 "ndr_push_relative_ptr2_end:"
1351 "relative_end_offset %u < len %lld",
1352 ndr->offset, (long long)len);
1353 }
1354
1355 /* the reversed offset is at the end of the main buffer */
1356 correct_offset = ndr->relative_end_offset - len;
1357
1358 if (ndr->flags & LIBNDR_FLAG_NOALIGN) {
1359 align = 1;
1360 } else if (ndr->flags & LIBNDR_FLAG_ALIGN2) {
1361 align = 2;
1362 } else if (ndr->flags & LIBNDR_FLAG_ALIGN4) {
1363 align = 4;
1364 } else if (ndr->flags & LIBNDR_FLAG_ALIGN8) {
1365 align = 8;
1366 }
1367
1368 pad = ndr_align_size(correct_offset, align);
1369 if (pad) {
1370 correct_offset += pad;
1371 correct_offset -= align;
1372 }
1373
1374 if (correct_offset < begin_offset) {
1375 return ndr_push_error(ndr, NDR_ERR_RELATIVE,
1376 "ndr_push_relative_ptr2_end: "
1377 "correct_offset %u < begin_offset %u",
1378 correct_offset, begin_offset);
1379 }
1380
1381 if (len > 0) {
1382 uint32_t clear_size = correct_offset - begin_offset;
1383
1384 clear_size = MIN(clear_size, len);
1385
1386 /* now move the marshalled buffer to the end of the main buffer */
1387 memmove(ndr->data + correct_offset, ndr->data + begin_offset, len);
1388
1389 if (clear_size) {
1390 /* and wipe out old buffer within the main buffer */
1391 memset(ndr->data + begin_offset, '\0', clear_size);
1392 }
1393 }
1394
1395 /* and set the end offset for the next buffer */
1396 ndr->relative_end_offset = correct_offset;
1397
1398 /* finally write the offset to the main buffer */
1399 ndr->offset = correct_offset;
1400 NDR_CHECK(ndr_push_relative_ptr2(ndr, p));
1401
1402 /* restore to where we were in the main buffer */
1403 ndr->offset = begin_offset;
1404
1405 return NDR_ERR_SUCCESS;
1406 }
1407
1408 /*
1409 get the current base for relative pointers for the pull
1410 */
1411 _PUBLIC_ uint32_t ndr_pull_get_relative_base_offset(struct ndr_pull *ndr)
1412 {
1413 return ndr->relative_base_offset;
1414 }
1415
1416 /*
1417 restore the old base for relative pointers for the pull
1418 */
1419 _PUBLIC_ void ndr_pull_restore_relative_base_offset(struct ndr_pull *ndr, uint32_t offset)
1420 {
1421 ndr->relative_base_offset = offset;
1422 }
1423
1424 /*
1425 setup the current base for relative pointers for the pull
1426 called in the NDR_SCALAR stage
1427 */
1428 _PUBLIC_ enum ndr_err_code ndr_pull_setup_relative_base_offset1(struct ndr_pull *ndr, const void *p, uint32_t offset)
1429 {
1430 ndr->relative_base_offset = offset;
1431 return ndr_token_store(ndr, &ndr->relative_base_list, p, offset);
1432 }
1433
1434 /*
1435 setup the current base for relative pointers for the pull
1436 called in the NDR_BUFFERS stage
1437 */
1438 _PUBLIC_ enum ndr_err_code ndr_pull_setup_relative_base_offset2(struct ndr_pull *ndr, const void *p)
1439 {
1440 return ndr_token_retrieve(&ndr->relative_base_list, p, &ndr->relative_base_offset);
1441 }
1442
1443 /*
1444 pull a relative object - stage1
1445 called during SCALARS processing
1446 */
1447 _PUBLIC_ enum ndr_err_code ndr_pull_relative_ptr1(struct ndr_pull *ndr, const void *p, uint32_t rel_offset)
1448 {
1449 rel_offset += ndr->relative_base_offset;
1450 if (rel_offset > ndr->data_size) {
1451 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
1452 "ndr_pull_relative_ptr1 rel_offset(%u) > ndr->data_size(%u)",
1453 rel_offset, ndr->data_size);
1454 }
1455 return ndr_token_store(ndr, &ndr->relative_list, p, rel_offset);
1456 }
1457
1458 /*
1459 pull a relative object - stage2
1460 called during BUFFERS processing
1461 */
1462 _PUBLIC_ enum ndr_err_code ndr_pull_relative_ptr2(struct ndr_pull *ndr, const void *p)
1463 {
1464 uint32_t rel_offset;
1465 NDR_CHECK(ndr_token_retrieve(&ndr->relative_list, p, &rel_offset));
1466 return ndr_pull_set_offset(ndr, rel_offset);
1467 }
1468
1469 const static struct {
1470 enum ndr_err_code err;
1471 const char *string;
1472 } ndr_err_code_strings[] = {
1473 { NDR_ERR_SUCCESS, "Success" },
1474 { NDR_ERR_ARRAY_SIZE, "Bad Array Size" },
1475 { NDR_ERR_BAD_SWITCH, "Bad Switch" },
1476 { NDR_ERR_OFFSET, "Offset Error" },
1477 { NDR_ERR_RELATIVE, "Relative Pointer Error" },
1478 { NDR_ERR_CHARCNV, "Character Conversion Error" },
1479 { NDR_ERR_LENGTH, "Length Error" },
1480 { NDR_ERR_SUBCONTEXT, "Subcontext Error" },
1481 { NDR_ERR_COMPRESSION, "Compression Error" },
1482 { NDR_ERR_STRING, "String Error" },
1483 { NDR_ERR_VALIDATE, "Validate Error" },
1484 { NDR_ERR_BUFSIZE, "Buffer Size Error" },
1485 { NDR_ERR_ALLOC, "Allocation Error" },
1486 { NDR_ERR_RANGE, "Range Error" },
1487 { NDR_ERR_TOKEN, "Token Error" },
1488 { NDR_ERR_IPV4ADDRESS, "IPv4 Address Error" },
1489 { NDR_ERR_INVALID_POINTER, "Invalid Pointer" },
1490 { NDR_ERR_UNREAD_BYTES, "Unread Bytes" },
1491 { NDR_ERR_NDR64, "NDR64 assertion error" },
1492 { 0, NULL }
1493 };
1494
1495 _PUBLIC_ const char *ndr_map_error2string(enum ndr_err_code ndr_err)
1496 {
1497 int i;
1498 for (i = 0; ndr_err_code_strings[i].string != NULL; i++) {
1499 if (ndr_err_code_strings[i].err == ndr_err)
1500 return ndr_err_code_strings[i].string;
1501 }
1502 return "Unknown error";
1503 }
reg import