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