?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpo: Test certificate policy without NDES
[Samba.git] / librpc / ndr / ndr_string.c
blobb2f965c9d43ca82c15b1d22c8826b59bb052a991
1 /*
2 Unix SMB/CIFS implementation.
3
4 routines for marshalling/unmarshalling string 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 "librpc/ndr/libndr.h"
24
25 /**
26 pull a general string from the wire
27 */
28 _PUBLIC_ enum ndr_err_code ndr_pull_string(struct ndr_pull *ndr, int ndr_flags, const char **s)
29 {
30 char *as=NULL;
31 uint32_t len1, ofs, len2;
32 uint16_t len3;
33 size_t conv_src_len = 0, converted_size;
34 int do_convert = 1, chset = CH_UTF16;
35 unsigned byte_mul = 2;
36 unsigned flags = ndr->flags;
37 unsigned c_len_term = 0;
38
39 if (!(ndr_flags & NDR_SCALARS)) {
40 return NDR_ERR_SUCCESS;
41 }
42
43 if (NDR_BE(ndr)) {
44 chset = CH_UTF16BE;
45 }
46
47 if (flags & LIBNDR_FLAG_STR_ASCII) {
48 chset = CH_DOS;
49 byte_mul = 1;
50 flags &= ~LIBNDR_FLAG_STR_ASCII;
51 }
52
53 if (flags & LIBNDR_FLAG_STR_UTF8) {
54 chset = CH_UTF8;
55 byte_mul = 1;
56 flags &= ~LIBNDR_FLAG_STR_UTF8;
57 }
58
59 if (flags & LIBNDR_FLAG_STR_RAW8) {
60 do_convert = 0;
61 byte_mul = 1;
62 flags &= ~LIBNDR_FLAG_STR_RAW8;
63 }
64
65 flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
66 if (flags & LIBNDR_FLAG_STR_CHARLEN) {
67 c_len_term = 1;
68 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
69 }
70
71 switch (flags & LIBNDR_STRING_FLAGS) {
72 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
73 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
74 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
75 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &ofs));
76 if (ofs != 0) {
77 return ndr_pull_error(ndr, NDR_ERR_STRING, "non-zero array offset with string flags 0x%x\n",
78 ndr->flags & LIBNDR_STRING_FLAGS);
79 }
80 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len2));
81 if (len2 > len1) {
82 return ndr_pull_error(ndr, NDR_ERR_STRING,
83 "Bad string lengths len1=%u ofs=%u len2=%u\n",
84 len1, ofs, len2);
85 } else if (len1 != len2) {
86 DEBUG(6,("len1[%u] != len2[%u] '%s'\n", len1, len2, as));
87 }
88 conv_src_len = len2 + c_len_term;
89 break;
90
91 case LIBNDR_FLAG_STR_SIZE4:
92 case LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
93 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
94 conv_src_len = len1 + c_len_term;
95 break;
96
97 case LIBNDR_FLAG_STR_LEN4:
98 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_NOTERM:
99 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &ofs));
100 if (ofs != 0) {
101 return ndr_pull_error(ndr, NDR_ERR_STRING, "non-zero array offset with string flags 0x%x\n",
102 ndr->flags & LIBNDR_STRING_FLAGS);
103 }
104 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
105 conv_src_len = len1 + c_len_term;
106 break;
107
108 case LIBNDR_FLAG_STR_SIZE2:
109 case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM:
110 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
111 conv_src_len = len3 + c_len_term;
112 break;
113
114 case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_BYTESIZE:
115 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
116 conv_src_len = len3;
117 byte_mul = 1; /* the length is now absolute */
118 break;
119
120 case LIBNDR_FLAG_STR_NULLTERM:
121 /*
122 * We ensure that conv_str_len cannot return 0 by
123 * requiring that there be enough bytes for at least
124 * the NULL terminator
125 */
126 if (byte_mul == 1) {
127 NDR_PULL_NEED_BYTES(ndr, 1);
128 conv_src_len = ascii_len_n((const char *)(ndr->data+ndr->offset), ndr->data_size - ndr->offset);
129 } else {
130 NDR_PULL_NEED_BYTES(ndr, 2);
131 conv_src_len = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
132 }
133 byte_mul = 1; /* the length is now absolute */
134 break;
135
136 case LIBNDR_FLAG_STR_NOTERM:
137 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
138 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
139 ndr->flags & LIBNDR_STRING_FLAGS);
140 }
141 conv_src_len = ndr->data_size - ndr->offset;
142 byte_mul = 1; /* the length is now absolute */
143 break;
144
145 default:
146 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
147 ndr->flags & LIBNDR_STRING_FLAGS);
148 }
149
150 NDR_PULL_NEED_BYTES(ndr, conv_src_len * byte_mul);
151 if (conv_src_len == 0) {
152 as = talloc_strdup(ndr->current_mem_ctx, "");
153 converted_size = 0;
154 } else {
155 if (!do_convert) {
156 as = talloc_strndup(ndr->current_mem_ctx,
157 (char *)ndr->data + ndr->offset,
158 conv_src_len);
159 if (!as) {
160 return ndr_pull_error(ndr, NDR_ERR_ALLOC,
161 "Failed to talloc_strndup() in RAW8 ndr_string_pull()");
162 }
163 converted_size = MIN(strlen(as)+1, conv_src_len);
164 } else if (!convert_string_talloc(ndr->current_mem_ctx, chset,
165 CH_UNIX, ndr->data + ndr->offset,
166 conv_src_len * byte_mul,
167 (void **)(void *)&as,
168 &converted_size)) {
169 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
170 "Bad character conversion with flags 0x%x", flags);
171 }
172 }
173
174 /* this is a way of detecting if a string is sent with the wrong
175 termination */
176 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
177 if (as && converted_size > 0 && as[converted_size-1] == '\0') {
178 DEBUG(6,("short string '%s', sent with NULL termination despite NOTERM flag in IDL\n", as));
179 }
180 } else {
181 if (as && converted_size > 0 && as[converted_size-1] != '\0') {
182 DEBUG(6,("long string '%s', send without NULL termination (which was expected)\n", as));
183 }
184 }
185
186 NDR_CHECK(ndr_pull_advance(ndr, conv_src_len * byte_mul));
187 *s = as;
188
189 return NDR_ERR_SUCCESS;
190 }
191
192
193 /**
194 push a general string onto the wire
195 */
196 _PUBLIC_ enum ndr_err_code ndr_push_string(struct ndr_push *ndr, int ndr_flags, const char *s)
197 {
198 ssize_t s_len, c_len;
199 size_t d_len;
200 int do_convert = 1, chset = CH_UTF16;
201 unsigned flags = ndr->flags;
202 unsigned byte_mul = 2;
203 uint8_t *dest = NULL;
204
205 if (!(ndr_flags & NDR_SCALARS)) {
206 return NDR_ERR_SUCCESS;
207 }
208
209 if (NDR_BE(ndr)) {
210 chset = CH_UTF16BE;
211 }
212
213 s_len = s?strlen(s):0;
214
215 if (flags & LIBNDR_FLAG_STR_ASCII) {
216 chset = CH_DOS;
217 byte_mul = 1;
218 flags &= ~LIBNDR_FLAG_STR_ASCII;
219 }
220
221 if (flags & LIBNDR_FLAG_STR_UTF8) {
222 chset = CH_UTF8;
223 byte_mul = 1;
224 flags &= ~LIBNDR_FLAG_STR_UTF8;
225 }
226
227 if (flags & LIBNDR_FLAG_STR_RAW8) {
228 do_convert = 0;
229 byte_mul = 1;
230 flags &= ~LIBNDR_FLAG_STR_RAW8;
231 }
232
233 flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
234
235 if (!(flags & LIBNDR_FLAG_STR_NOTERM)) {
236 s_len++;
237 }
238
239 if (s_len == 0) {
240 d_len = 0;
241 dest = (uint8_t *)talloc_strdup(ndr, "");
242 } else if (!do_convert) {
243 d_len = s_len;
244 dest = (uint8_t *)talloc_strndup(ndr, s, s_len);
245 } else if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
246 (void **)(void *)&dest, &d_len))
247 {
248 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
249 "Bad character push conversion with flags 0x%x", flags);
250 }
251
252 if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
253 c_len = d_len;
254 flags &= ~LIBNDR_FLAG_STR_BYTESIZE;
255 } else if (flags & LIBNDR_FLAG_STR_CHARLEN) {
256 c_len = (d_len / byte_mul)-1;
257 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
258 } else {
259 c_len = d_len / byte_mul;
260 }
261
262 switch ((flags & LIBNDR_STRING_FLAGS) & ~LIBNDR_FLAG_STR_NOTERM) {
263 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
264 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
265 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
266 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
267 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
268 break;
269
270 case LIBNDR_FLAG_STR_LEN4:
271 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
272 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
273 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
274 break;
275
276 case LIBNDR_FLAG_STR_SIZE4:
277 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
278 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
279 break;
280
281 case LIBNDR_FLAG_STR_SIZE2:
282 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, c_len));
283 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
284 break;
285
286 case LIBNDR_FLAG_STR_NULLTERM:
287 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
288 break;
289
290 default:
291 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
292 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
293 break;
294 }
295
296 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
297 ndr->flags & LIBNDR_STRING_FLAGS);
298 }
299
300 talloc_free(dest);
301
302 return NDR_ERR_SUCCESS;
303 }
304
305 /**
306 push a general string onto the wire
307 */
308 _PUBLIC_ size_t ndr_string_array_size(struct ndr_push *ndr, const char *s)
309 {
310 size_t c_len;
311 unsigned flags = ndr->flags;
312 unsigned byte_mul = 2;
313 unsigned c_len_term = 1;
314
315 if (flags & LIBNDR_FLAG_STR_RAW8) {
316 c_len = s?strlen(s):0;
317 } else {
318 c_len = s?strlen_m(s):0;
319 }
320
321 if (flags & (LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_RAW8|LIBNDR_FLAG_STR_UTF8)) {
322 byte_mul = 1;
323 }
324
325 if (flags & LIBNDR_FLAG_STR_NOTERM) {
326 c_len_term = 0;
327 }
328
329 c_len = c_len + c_len_term;
330
331 if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
332 c_len = c_len * byte_mul;
333 }
334
335 return c_len;
336 }
337
338 _PUBLIC_ void ndr_print_string(struct ndr_print *ndr, const char *name, const char *s)
339 {
340 if (NDR_HIDE_SECRET(ndr)) {
341 ndr->print(ndr, "%-25s: <REDACTED SECRET VALUE>", name);
342 return;
343 }
344 if (s) {
345 ndr->print(ndr, "%-25s: '%s'", name, s);
346 } else {
347 ndr->print(ndr, "%-25s: NULL", name);
348 }
349 }
350
351 _PUBLIC_ uint32_t ndr_size_string(int ret, const char * const* string, int flags)
352 {
353 /* FIXME: Is this correct for all strings ? */
354 if(!(*string)) return ret;
355 return ret+strlen(*string)+1;
356 }
357
358 static uint32_t guess_string_array_size(struct ndr_pull *ndr, int ndr_flags)
359 {
360 /*
361 * Here we could do something clever like count the number of zeros in
362 * the ndr data, but it is probably sufficient to pick a lowish number
363 * (compared to the overhead of the talloc header) and let the
364 * expontential resizing deal with longer arrays.
365 */
366 return 5;
367 }
368
369 static enum ndr_err_code extend_string_array(struct ndr_pull *ndr,
370 const char ***_a,
371 uint32_t *count)
372 {
373 const char **a = *_a;
374 uint32_t inc = *count / 4 + 3;
375 uint32_t alloc_size = *count + inc;
376
377 if (alloc_size < *count) {
378 /* overflow ! */
379 return NDR_ERR_ALLOC;
380 }
381 /*
382 * We allocate and zero two more bytes than we report back, so that
383 * the string array will always be NULL terminated.
384 */
385 a = talloc_realloc(ndr->current_mem_ctx, a,
386 const char *,
387 alloc_size);
388 NDR_ERR_HAVE_NO_MEMORY(a);
389
390 memset(a + *count, 0, inc * sizeof(a[0]));
391 *_a = a;
392 *count = alloc_size - 2;
393 return NDR_ERR_SUCCESS;
394 }
395
396 /**
397 pull a general string array from the wire
398 */
399 _PUBLIC_ enum ndr_err_code ndr_pull_string_array(struct ndr_pull *ndr, int ndr_flags, const char ***_a)
400 {
401 const char **a = NULL;
402 uint32_t count;
403 unsigned flags = ndr->flags;
404 unsigned saved_flags = ndr->flags;
405 uint32_t alloc_size;
406
407 if (!(ndr_flags & NDR_SCALARS)) {
408 return NDR_ERR_SUCCESS;
409 }
410
411 alloc_size = guess_string_array_size(ndr, ndr_flags);
412 a = talloc_zero_array(ndr->current_mem_ctx, const char *, alloc_size + 2);
413 NDR_ERR_HAVE_NO_MEMORY(a);
414
415 switch (flags & (LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_STR_NOTERM)) {
416 case LIBNDR_FLAG_STR_NULLTERM:
417 /*
418 * here the strings are null terminated
419 * but also the array is null terminated if LIBNDR_FLAG_REMAINING
420 * is specified
421 */
422 for (count = 0;; count++) {
423 TALLOC_CTX *tmp_ctx;
424 const char *s = NULL;
425 if (count == alloc_size) {
426 NDR_CHECK(extend_string_array(ndr,
427 &a,
428 &alloc_size));
429 }
430
431 tmp_ctx = ndr->current_mem_ctx;
432 ndr->current_mem_ctx = a;
433 NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
434 ndr->current_mem_ctx = tmp_ctx;
435 if ((ndr->data_size - ndr->offset) == 0 && ndr->flags & LIBNDR_FLAG_REMAINING)
436 {
437 a[count] = s;
438 break;
439 }
440 if (strcmp("", s)==0) {
441 a[count] = NULL;
442 break;
443 } else {
444 a[count] = s;
445 }
446 }
447
448 *_a =a;
449 break;
450
451 case LIBNDR_FLAG_STR_NOTERM:
452 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
453 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
454 ndr->flags & LIBNDR_STRING_FLAGS);
455 }
456 /*
457 * here the strings are not null terminated
458 * but separated by a null terminator
459 *
460 * which means the same as:
461 * Every string is null terminated except the last
462 * string is terminated by the end of the buffer
463 *
464 * as LIBNDR_FLAG_STR_NULLTERM also end at the end
465 * of the buffer, we can pull each string with this flag
466 *
467 * The big difference with the case LIBNDR_FLAG_STR_NOTERM +
468 * LIBNDR_FLAG_REMAINING is that the last string will not be null terminated
469 */
470 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
471 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
472
473 for (count = 0; ((ndr->data_size - ndr->offset) > 0); count++) {
474 TALLOC_CTX *tmp_ctx;
475 const char *s = NULL;
476 if (count == alloc_size) {
477 NDR_CHECK(extend_string_array(ndr,
478 &a,
479 &alloc_size));
480 }
481
482 tmp_ctx = ndr->current_mem_ctx;
483 ndr->current_mem_ctx = a;
484 NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
485 ndr->current_mem_ctx = tmp_ctx;
486 a[count] = s;
487 }
488
489 a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 1);
490 NDR_ERR_HAVE_NO_MEMORY(a);
491 *_a = a;
492 break;
493
494 default:
495 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
496 ndr->flags & LIBNDR_STRING_FLAGS);
497 }
498
499 ndr->flags = saved_flags;
500 return NDR_ERR_SUCCESS;
501 }
502
503 /**
504 push a general string array onto the wire
505 */
506 _PUBLIC_ enum ndr_err_code ndr_push_string_array(struct ndr_push *ndr, int ndr_flags, const char **a)
507 {
508 uint32_t count;
509 unsigned flags = ndr->flags;
510 unsigned saved_flags = ndr->flags;
511
512 if (!(ndr_flags & NDR_SCALARS)) {
513 return NDR_ERR_SUCCESS;
514 }
515
516 switch (flags & LIBNDR_STRING_FLAGS) {
517 case LIBNDR_FLAG_STR_NULLTERM:
518 for (count = 0; a && a[count]; count++) {
519 NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
520 }
521 /* If LIBNDR_FLAG_REMAINING then we do not add a null terminator to the array */
522 if (!(flags & LIBNDR_FLAG_REMAINING))
523 {
524 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
525 }
526 break;
527
528 case LIBNDR_FLAG_STR_NOTERM:
529 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
530 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
531 ndr->flags & LIBNDR_STRING_FLAGS);
532 }
533
534 for (count = 0; a && a[count]; count++) {
535 if (count > 0) {
536 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
537 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
538 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
539 ndr->flags = saved_flags;
540 }
541 NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
542 }
543
544 break;
545
546 default:
547 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
548 ndr->flags & LIBNDR_STRING_FLAGS);
549 }
550
551 ndr->flags = saved_flags;
552 return NDR_ERR_SUCCESS;
553 }
554
555 _PUBLIC_ void ndr_print_string_array(struct ndr_print *ndr, const char *name, const char **a)
556 {
557 uint32_t count;
558 uint32_t i;
559
560 for (count = 0; a && a[count]; count++) {}
561
562 ndr->print(ndr, "%s: ARRAY(%d)", name, count);
563 ndr->depth++;
564 for (i=0;i<count;i++) {
565 char *idx=NULL;
566 if (asprintf(&idx, "[%d]", i) != -1) {
567 ndr_print_string(ndr, idx, a[i]);
568 free(idx);
569 }
570 }
571 ndr->depth--;
572 }
573
574 _PUBLIC_ size_t ndr_size_string_array(const char **a, uint32_t count, int flags)
575 {
576 uint32_t i;
577 size_t size = 0;
578 int rawbytes = 0;
579
580 if (flags & LIBNDR_FLAG_STR_RAW8) {
581 rawbytes = 1;
582 flags &= ~LIBNDR_FLAG_STR_RAW8;
583 }
584
585 switch (flags & LIBNDR_STRING_FLAGS) {
586 case LIBNDR_FLAG_STR_NULLTERM:
587 for (i = 0; i < count; i++) {
588 size += rawbytes?strlen(a[i]) + 1:strlen_m_term(a[i]);
589 }
590 break;
591 case LIBNDR_FLAG_STR_NOTERM:
592 for (i = 0; i < count; i++) {
593 size += rawbytes?strlen(a[i]):strlen_m(a[i]);
594 }
595 break;
596 default:
597 return 0;
598 }
599
600 return size;
601 }
602
603 /**
604 * Return number of elements in a string including the last (zeroed) element
605 */
606 _PUBLIC_ uint32_t ndr_string_length(const void *_var, uint32_t element_size)
607 {
608 uint32_t i;
609 uint8_t zero[4] = {0,0,0,0};
610 const char *var = (const char *)_var;
611
612 for (i = 0; memcmp(var+i*element_size,zero,element_size) != 0; i++);
613
614 return i+1;
615 }
616
617 /**
618 * @brief Get the string length including the null terminator if available.
619 *
620 * This checks the string length based on the elements. The returned number
621 * includes the terminating null byte(s) if found.
622 *
623 * @param[in] _var The string the calculate the length for.
624 *
625 * @param[in] length The length of the buffer passed by _var.
626 *
627 * @param[in] element_size The element_size of a string char in bytes.
628 *
629 * @return The length of the strings or 0.
630 */
631 static uint32_t ndr_string_n_length(const void *_var,
632 size_t length,
633 uint32_t element_size)
634 {
635 size_t i = 0;
636 uint8_t zero[4] = {0,0,0,0};
637 const char *var = (const char *)_var;
638 int cmp;
639
640 if (element_size > 4) {
641 return 0;
642 }
643
644 for (i = 0; i < length; i++, var += element_size) {
645 cmp = memcmp(var, zero, element_size);
646 if (cmp == 0) {
647 break;
648 }
649 }
650
651 if (i == length) {
652 return length;
653 }
654
655 return i + 1;
656 }
657
658 _PUBLIC_ enum ndr_err_code ndr_check_string_terminator(struct ndr_pull *ndr, uint32_t count, uint32_t element_size)
659 {
660 uint32_t i;
661 uint32_t save_offset;
662
663 save_offset = ndr->offset;
664 NDR_CHECK(ndr_pull_advance(ndr, (count - 1) * element_size));
665 NDR_PULL_NEED_BYTES(ndr, element_size);
666
667 for (i = 0; i < element_size; i++) {
668 if (ndr->data[ndr->offset+i] != 0) {
669 ndr->offset = save_offset;
670
671 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "String terminator not present or outside string boundaries");
672 }
673 }
674
675 ndr->offset = save_offset;
676
677 return NDR_ERR_SUCCESS;
678 }
679
680 _PUBLIC_ enum ndr_err_code ndr_pull_charset(struct ndr_pull *ndr, int ndr_flags, const char **var, uint32_t length, uint8_t byte_mul, charset_t chset)
681 {
682 size_t converted_size;
683
684 if (length == 0) {
685 *var = talloc_strdup(ndr->current_mem_ctx, "");
686 return NDR_ERR_SUCCESS;
687 }
688
689 if (NDR_BE(ndr) && chset == CH_UTF16) {
690 chset = CH_UTF16BE;
691 }
692
693 if ((byte_mul != 0) && (length > UINT32_MAX/byte_mul)) {
694 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE, "length overflow");
695 }
696 NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
697
698 if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
699 ndr->data+ndr->offset, length*byte_mul,
700 discard_const_p(void *, var),
701 &converted_size))
702 {
703 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
704 "Bad character conversion");
705 }
706 NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
707
708 return NDR_ERR_SUCCESS;
709 }
710
711 _PUBLIC_ enum ndr_err_code ndr_pull_charset_to_null(struct ndr_pull *ndr, int ndr_flags, const char **var, uint32_t length, uint8_t byte_mul, charset_t chset)
712 {
713 size_t converted_size;
714 uint32_t str_len;
715
716 if (length == 0) {
717 *var = talloc_strdup(ndr->current_mem_ctx, "");
718 return NDR_ERR_SUCCESS;
719 }
720
721 if (NDR_BE(ndr) && chset == CH_UTF16) {
722 chset = CH_UTF16BE;
723 }
724
725 NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
726
727 str_len = ndr_string_n_length(ndr->data+ndr->offset, length, byte_mul);
728 if (str_len == 0) {
729 return ndr_pull_error(ndr, NDR_ERR_LENGTH,
730 "Invalid length");
731 }
732
733 if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
734 ndr->data+ndr->offset, str_len*byte_mul,
735 discard_const_p(void *, var),
736 &converted_size))
737 {
738 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
739 "Bad character conversion");
740 }
741 NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
742
743 return NDR_ERR_SUCCESS;
744 }
745
746 _PUBLIC_ enum ndr_err_code ndr_push_charset(struct ndr_push *ndr, int ndr_flags, const char *var, uint32_t length, uint8_t byte_mul, charset_t chset)
747 {
748 size_t required;
749
750 if (NDR_BE(ndr) && chset == CH_UTF16) {
751 chset = CH_UTF16BE;
752 }
753
754 if ((byte_mul != 0) && (length > SIZE_MAX/byte_mul)) {
755 return ndr_push_error(ndr, NDR_ERR_LENGTH, "length overflow");
756 }
757 required = byte_mul * length;
758
759 NDR_PUSH_NEED_BYTES(ndr, required);
760
761 if (required) {
762 size_t size = 0;
763
764 if (var == NULL) {
765 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
766 }
767
768 if (!convert_string(CH_UNIX, chset,
769 var, strlen(var),
770 ndr->data+ndr->offset, required, &size)) {
771 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
772 "Bad character conversion");
773 }
774
775 /* Make sure the remaining part of the string is filled with zeroes */
776 if (size < required) {
777 memset(ndr->data+ndr->offset+size, 0, required-size);
778 }
779 }
780
781 ndr->offset += required;
782
783 return NDR_ERR_SUCCESS;
784 }
785
786 _PUBLIC_ enum ndr_err_code ndr_push_charset_to_null(struct ndr_push *ndr, int ndr_flags, const char *var, uint32_t length, uint8_t byte_mul, charset_t chset)
787 {
788 const char *str = var;
789
790 if (str == NULL) {
791 str = "\0"; /* i.e. two zero bytes, for UTF16 null word. */
792 length = 1;
793 }
794
795 return ndr_push_charset(ndr, ndr_flags, str, length, byte_mul, chset);
796 }
797
798 /* Return number of elements in a string in the specified charset */
799 _PUBLIC_ uint32_t ndr_charset_length(const void *var, charset_t chset)
800 {
801 switch (chset) {
802 /* case CH_UTF16: this has the same value as CH_UTF16LE */
803 case CH_UTF16LE:
804 case CH_UTF16BE:
805 case CH_UTF16MUNGED:
806 case CH_UTF8:
807 return strlen_m_ext_term((const char *)var, CH_UNIX, chset);
808 case CH_DOS:
809 case CH_UNIX:
810 return strlen((const char *)var)+1;
811 }
812
813 /* Fallback, this should never happen */
814 return strlen((const char *)var)+1;
815 }
Samba GIT mirror