2 Unix SMB/CIFS implementation.
4 routines for marshalling/unmarshalling string types
6 Copyright (C) Andrew Tridgell 2003
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "librpc/ndr/libndr.h"
26 pull a general string from the wire
28 _PUBLIC_ enum ndr_err_code ndr_pull_string(struct ndr_pull *ndr, int ndr_flags, const char **s)
31 uint32_t len1, ofs, len2;
33 size_t converted_size;
35 unsigned byte_mul = 2;
36 unsigned flags = ndr->flags;
37 unsigned c_len_term = 0;
39 if (!(ndr_flags & NDR_SCALARS)) {
40 return NDR_ERR_SUCCESS;
47 if (flags & LIBNDR_FLAG_STR_ASCII) {
50 flags &= ~LIBNDR_FLAG_STR_ASCII;
53 if (flags & LIBNDR_FLAG_STR_UTF8) {
56 flags &= ~LIBNDR_FLAG_STR_UTF8;
59 flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
60 if (flags & LIBNDR_FLAG_STR_CHARLEN) {
62 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
65 switch (flags & LIBNDR_STRING_FLAGS) {
66 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
67 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
68 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
69 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &ofs));
71 return ndr_pull_error(ndr, NDR_ERR_STRING, "non-zero array offset with string flags 0x%x\n",
72 ndr->flags & LIBNDR_STRING_FLAGS);
74 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len2));
76 return ndr_pull_error(ndr, NDR_ERR_STRING,
77 "Bad string lengths len1=%u ofs=%u len2=%u\n",
80 NDR_PULL_NEED_BYTES(ndr, (len2 + c_len_term)*byte_mul);
82 as = talloc_strdup(ndr->current_mem_ctx, "");
84 if (!convert_string_talloc(ndr->current_mem_ctx, chset,
86 ndr->data+ndr->offset,
87 (len2 + c_len_term)*byte_mul,
89 &converted_size, false))
91 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
92 "Bad character conversion with flags 0x%x", flags);
95 NDR_CHECK(ndr_pull_advance(ndr, (len2 + c_len_term)*byte_mul));
98 DEBUG(6,("len1[%u] != len2[%u] '%s'\n", len1, len2, as));
101 /* this is a way of detecting if a string is sent with the wrong
103 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
104 if (strlen(as) < (len2 + c_len_term)) {
105 DEBUG(6,("short string '%s'\n", as));
108 if (strlen(as) == (len2 + c_len_term)) {
109 DEBUG(6,("long string '%s'\n", as));
115 case LIBNDR_FLAG_STR_SIZE4:
116 case LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
117 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
118 NDR_PULL_NEED_BYTES(ndr, (len1 + c_len_term)*byte_mul);
120 as = talloc_strdup(ndr->current_mem_ctx, "");
122 if (!convert_string_talloc(ndr->current_mem_ctx, chset,
124 ndr->data+ndr->offset,
125 (len1 + c_len_term)*byte_mul,
126 (void **)(void *)&as,
127 &converted_size, false))
129 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
130 "Bad character conversion with flags 0x%x", flags);
133 NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
135 /* this is a way of detecting if a string is sent with the wrong
137 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
138 if (strlen(as) < (len1 + c_len_term)) {
139 DEBUG(6,("short string '%s'\n", as));
142 if (strlen(as) == (len1 + c_len_term)) {
143 DEBUG(6,("long string '%s'\n", as));
149 case LIBNDR_FLAG_STR_LEN4:
150 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_NOTERM:
151 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &ofs));
153 return ndr_pull_error(ndr, NDR_ERR_STRING, "non-zero array offset with string flags 0x%x\n",
154 ndr->flags & LIBNDR_STRING_FLAGS);
156 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
157 NDR_PULL_NEED_BYTES(ndr, (len1 + c_len_term)*byte_mul);
159 as = talloc_strdup(ndr->current_mem_ctx, "");
161 if (!convert_string_talloc(ndr->current_mem_ctx, chset,
163 ndr->data+ndr->offset,
164 (len1 + c_len_term)*byte_mul,
165 (void **)(void *)&as,
166 &converted_size, false))
168 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
169 "Bad character conversion with flags 0x%x", flags);
172 NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
174 /* this is a way of detecting if a string is sent with the wrong
176 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
177 if (strlen(as) < (len1 + c_len_term)) {
178 DEBUG(6,("short string '%s'\n", as));
181 if (strlen(as) == (len1 + c_len_term)) {
182 DEBUG(6,("long string '%s'\n", as));
189 case LIBNDR_FLAG_STR_SIZE2:
190 case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM:
191 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
192 NDR_PULL_NEED_BYTES(ndr, (len3 + c_len_term)*byte_mul);
194 as = talloc_strdup(ndr->current_mem_ctx, "");
196 if (!convert_string_talloc(ndr->current_mem_ctx, chset,
198 ndr->data+ndr->offset,
199 (len3 + c_len_term)*byte_mul,
200 (void **)(void *)&as,
201 &converted_size, false))
203 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
204 "Bad character conversion with flags 0x%x", flags);
207 NDR_CHECK(ndr_pull_advance(ndr, (len3 + c_len_term)*byte_mul));
209 /* this is a way of detecting if a string is sent with the wrong
211 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
212 if (strlen(as) < (len3 + c_len_term)) {
213 DEBUG(6,("short string '%s'\n", as));
216 if (strlen(as) == (len3 + c_len_term)) {
217 DEBUG(6,("long string '%s'\n", as));
223 case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_BYTESIZE:
224 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
225 NDR_PULL_NEED_BYTES(ndr, len3);
227 as = talloc_strdup(ndr->current_mem_ctx, "");
229 if (!convert_string_talloc(ndr->current_mem_ctx, chset,
231 ndr->data+ndr->offset, len3,
232 (void **)(void *)&as,
233 &converted_size, false))
235 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
236 "Bad character conversion with flags 0x%x", flags);
239 NDR_CHECK(ndr_pull_advance(ndr, len3));
243 case LIBNDR_FLAG_STR_NULLTERM:
245 len1 = ascii_len_n((const char *)(ndr->data+ndr->offset), ndr->data_size - ndr->offset);
247 len1 = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
249 if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
250 ndr->data+ndr->offset, len1,
251 (void **)(void *)&as,
252 &converted_size, false))
254 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
255 "Bad character conversion with flags 0x%x", flags);
257 NDR_CHECK(ndr_pull_advance(ndr, len1));
261 case LIBNDR_FLAG_STR_NOTERM:
262 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
263 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
264 ndr->flags & LIBNDR_STRING_FLAGS);
267 len1 = ndr->data_size - ndr->offset;
269 NDR_PULL_NEED_BYTES(ndr, len1);
271 as = talloc_strdup(ndr->current_mem_ctx, "");
273 if (!convert_string_talloc(ndr->current_mem_ctx, chset,
275 ndr->data+ndr->offset, len1,
276 (void **)(void *)&as,
277 &converted_size, false))
279 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
280 "Bad character conversion with flags 0x%x", flags);
283 NDR_CHECK(ndr_pull_advance(ndr, len1));
289 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
290 ndr->flags & LIBNDR_STRING_FLAGS);
293 return NDR_ERR_SUCCESS;
298 push a general string onto the wire
300 _PUBLIC_ enum ndr_err_code ndr_push_string(struct ndr_push *ndr, int ndr_flags, const char *s)
302 ssize_t s_len, c_len;
304 int chset = CH_UTF16;
305 unsigned flags = ndr->flags;
306 unsigned byte_mul = 2;
307 uint8_t *dest = NULL;
309 if (!(ndr_flags & NDR_SCALARS)) {
310 return NDR_ERR_SUCCESS;
317 s_len = s?strlen(s):0;
319 if (flags & LIBNDR_FLAG_STR_ASCII) {
322 flags &= ~LIBNDR_FLAG_STR_ASCII;
325 if (flags & LIBNDR_FLAG_STR_UTF8) {
328 flags &= ~LIBNDR_FLAG_STR_UTF8;
331 flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
333 if (!(flags & LIBNDR_FLAG_STR_NOTERM)) {
336 if (!convert_string_talloc(ndr, CH_UNIX, chset, s, s_len,
337 (void **)(void *)&dest, &d_len, false))
339 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
340 "Bad character push conversion with flags 0x%x", flags);
343 if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
345 flags &= ~LIBNDR_FLAG_STR_BYTESIZE;
346 } else if (flags & LIBNDR_FLAG_STR_CHARLEN) {
347 c_len = (d_len / byte_mul)-1;
348 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
350 c_len = d_len / byte_mul;
353 switch ((flags & LIBNDR_STRING_FLAGS) & ~LIBNDR_FLAG_STR_NOTERM) {
354 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
355 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
356 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
357 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
358 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
361 case LIBNDR_FLAG_STR_LEN4:
362 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
363 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
364 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
367 case LIBNDR_FLAG_STR_SIZE4:
368 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
369 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
372 case LIBNDR_FLAG_STR_SIZE2:
373 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, c_len));
374 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
377 case LIBNDR_FLAG_STR_NULLTERM:
378 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
382 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
383 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
387 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
388 ndr->flags & LIBNDR_STRING_FLAGS);
393 return NDR_ERR_SUCCESS;
397 push a general string onto the wire
399 _PUBLIC_ size_t ndr_string_array_size(struct ndr_push *ndr, const char *s)
402 unsigned flags = ndr->flags;
403 unsigned byte_mul = 2;
404 unsigned c_len_term = 1;
406 c_len = s?strlen_m(s):0;
408 if (flags & (LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_UTF8)) {
412 if (flags & LIBNDR_FLAG_STR_NOTERM) {
416 c_len = c_len + c_len_term;
418 if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
419 c_len = c_len * byte_mul;
425 _PUBLIC_ void ndr_print_string(struct ndr_print *ndr, const char *name, const char *s)
428 ndr->print(ndr, "%-25s: '%s'", name, s);
430 ndr->print(ndr, "%-25s: NULL", name);
434 _PUBLIC_ uint32_t ndr_size_string(int ret, const char * const* string, int flags)
436 /* FIXME: Is this correct for all strings ? */
437 if(!(*string)) return ret;
438 return ret+strlen(*string)+1;
442 pull a general string array from the wire
444 _PUBLIC_ enum ndr_err_code ndr_pull_string_array(struct ndr_pull *ndr, int ndr_flags, const char ***_a)
446 const char **a = NULL;
448 unsigned flags = ndr->flags;
449 unsigned saved_flags = ndr->flags;
451 if (!(ndr_flags & NDR_SCALARS)) {
452 return NDR_ERR_SUCCESS;
455 switch (flags & (LIBNDR_FLAG_STR_NULLTERM|LIBNDR_FLAG_STR_NOTERM)) {
456 case LIBNDR_FLAG_STR_NULLTERM:
458 * here the strings are null terminated
459 * but also the array is null terminated if LIBNDR_FLAG_REMAINING
462 for (count = 0;; count++) {
464 const char *s = NULL;
465 a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 2);
466 NDR_ERR_HAVE_NO_MEMORY(a);
470 tmp_ctx = ndr->current_mem_ctx;
471 ndr->current_mem_ctx = a;
472 NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
473 if ((ndr->data_size - ndr->offset) == 0 && ndr->flags & LIBNDR_FLAG_REMAINING)
478 ndr->current_mem_ctx = tmp_ctx;
479 if (strcmp("", s)==0) {
490 case LIBNDR_FLAG_STR_NOTERM:
491 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
492 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
493 ndr->flags & LIBNDR_STRING_FLAGS);
496 * here the strings are not null terminated
497 * but serarated by a null terminator
499 * which means the same as:
500 * Every string is null terminated exept the last
501 * string is terminated by the end of the buffer
503 * as LIBNDR_FLAG_STR_NULLTERM also end at the end
504 * of the buffer, we can pull each string with this flag
506 * The big difference with the case LIBNDR_FLAG_STR_NOTERM +
507 * LIBNDR_FLAG_REMAINING is that the last string will not be null terminated
509 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
510 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
512 for (count = 0; ((ndr->data_size - ndr->offset) > 0); count++) {
514 const char *s = NULL;
515 a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 2);
516 NDR_ERR_HAVE_NO_MEMORY(a);
520 tmp_ctx = ndr->current_mem_ctx;
521 ndr->current_mem_ctx = a;
522 NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
523 ndr->current_mem_ctx = tmp_ctx;
531 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
532 ndr->flags & LIBNDR_STRING_FLAGS);
535 ndr->flags = saved_flags;
536 return NDR_ERR_SUCCESS;
540 push a general string array onto the wire
542 _PUBLIC_ enum ndr_err_code ndr_push_string_array(struct ndr_push *ndr, int ndr_flags, const char **a)
545 unsigned flags = ndr->flags;
546 unsigned saved_flags = ndr->flags;
548 if (!(ndr_flags & NDR_SCALARS)) {
549 return NDR_ERR_SUCCESS;
552 switch (flags & LIBNDR_STRING_FLAGS) {
553 case LIBNDR_FLAG_STR_NULLTERM:
554 for (count = 0; a && a[count]; count++) {
555 NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
557 /* If LIBNDR_FLAG_REMAINING then we do not add a null terminator to the array */
558 if (!(flags & LIBNDR_FLAG_REMAINING))
560 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
564 case LIBNDR_FLAG_STR_NOTERM:
565 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
566 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
567 ndr->flags & LIBNDR_STRING_FLAGS);
570 for (count = 0; a && a[count]; count++) {
572 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
573 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
574 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
575 ndr->flags = saved_flags;
577 NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
583 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
584 ndr->flags & LIBNDR_STRING_FLAGS);
587 ndr->flags = saved_flags;
588 return NDR_ERR_SUCCESS;
591 _PUBLIC_ void ndr_print_string_array(struct ndr_print *ndr, const char *name, const char **a)
596 for (count = 0; a && a[count]; count++) {}
598 ndr->print(ndr, "%s: ARRAY(%d)", name, count);
600 for (i=0;i<count;i++) {
602 if (asprintf(&idx, "[%d]", i) != -1) {
603 ndr_print_string(ndr, idx, a[i]);
610 _PUBLIC_ size_t ndr_size_string_array(const char **a, uint32_t count, int flags)
615 switch (flags & LIBNDR_STRING_FLAGS) {
616 case LIBNDR_FLAG_STR_NULLTERM:
617 for (i = 0; i < count; i++) {
618 size += strlen_m_term(a[i]);
621 case LIBNDR_FLAG_STR_NOTERM:
622 for (i = 0; i < count; i++) {
623 size += strlen_m(a[i]);
634 * Return number of elements in a string including the last (zeroed) element
636 _PUBLIC_ uint32_t ndr_string_length(const void *_var, uint32_t element_size)
639 uint8_t zero[4] = {0,0,0,0};
640 const char *var = (const char *)_var;
642 for (i = 0; memcmp(var+i*element_size,zero,element_size) != 0; i++);
647 _PUBLIC_ enum ndr_err_code ndr_check_string_terminator(struct ndr_pull *ndr, uint32_t count, uint32_t element_size)
650 uint32_t save_offset;
652 save_offset = ndr->offset;
653 ndr_pull_advance(ndr, (count - 1) * element_size);
654 NDR_PULL_NEED_BYTES(ndr, element_size);
656 for (i = 0; i < element_size; i++) {
657 if (ndr->data[ndr->offset+i] != 0) {
658 ndr->offset = save_offset;
660 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "String terminator not present or outside string boundaries");
664 ndr->offset = save_offset;
666 return NDR_ERR_SUCCESS;
669 _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)
671 size_t converted_size;
674 *var = talloc_strdup(ndr->current_mem_ctx, "");
675 return NDR_ERR_SUCCESS;
678 if (NDR_BE(ndr) && chset == CH_UTF16) {
682 NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
684 if (!convert_string_talloc(ndr->current_mem_ctx, chset, CH_UNIX,
685 ndr->data+ndr->offset, length*byte_mul,
686 discard_const_p(void *, var),
687 &converted_size, false))
689 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
690 "Bad character conversion");
692 NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
694 return NDR_ERR_SUCCESS;
697 _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)
699 ssize_t ret, required;
701 if (NDR_BE(ndr) && chset == CH_UTF16) {
705 required = byte_mul * length;
707 NDR_PUSH_NEED_BYTES(ndr, required);
708 ret = convert_string(CH_UNIX, chset,
710 ndr->data+ndr->offset, required, false);
712 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
713 "Bad character conversion");
716 /* Make sure the remaining part of the string is filled with zeroes */
717 if (ret < required) {
718 memset(ndr->data+ndr->offset+ret, 0, required-ret);
721 ndr->offset += required;
723 return NDR_ERR_SUCCESS;
726 /* Return number of elements in a string in the specified charset */
727 _PUBLIC_ uint32_t ndr_charset_length(const void *var, charset_t chset)
730 /* case CH_UTF16: this has the same value as CH_UTF16LE */
734 return strlen_m_term((const char *)var);
739 return strlen((const char *)var)+1;
742 /* Fallback, this should never happen */
743 return strlen((const char *)var)+1;