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;
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 ret = convert_string_talloc(ndr->current_mem_ctx,
86 ndr->data+ndr->offset,
87 (len2 + c_len_term)*byte_mul,
90 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
91 "Bad character conversion");
94 NDR_CHECK(ndr_pull_advance(ndr, (len2 + c_len_term)*byte_mul));
97 DEBUG(6,("len1[%u] != len2[%u] '%s'\n", len1, len2, as));
100 /* this is a way of detecting if a string is sent with the wrong
102 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
103 if (strlen(as) < (len2 + c_len_term)) {
104 DEBUG(6,("short string '%s'\n", as));
107 if (strlen(as) == (len2 + c_len_term)) {
108 DEBUG(6,("long string '%s'\n", as));
114 case LIBNDR_FLAG_STR_SIZE4:
115 case LIBNDR_FLAG_STR_SIZE4|LIBNDR_FLAG_STR_NOTERM:
116 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
117 NDR_PULL_NEED_BYTES(ndr, (len1 + c_len_term)*byte_mul);
119 as = talloc_strdup(ndr->current_mem_ctx, "");
121 ret = convert_string_talloc(ndr->current_mem_ctx,
123 ndr->data+ndr->offset,
124 (len1 + c_len_term)*byte_mul,
127 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
128 "Bad character conversion");
131 NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
133 /* this is a way of detecting if a string is sent with the wrong
135 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
136 if (strlen(as) < (len1 + c_len_term)) {
137 DEBUG(6,("short string '%s'\n", as));
140 if (strlen(as) == (len1 + c_len_term)) {
141 DEBUG(6,("long string '%s'\n", as));
147 case LIBNDR_FLAG_STR_LEN4:
148 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_NOTERM:
149 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &ofs));
151 return ndr_pull_error(ndr, NDR_ERR_STRING, "non-zero array offset with string flags 0x%x\n",
152 ndr->flags & LIBNDR_STRING_FLAGS);
154 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &len1));
155 NDR_PULL_NEED_BYTES(ndr, (len1 + c_len_term)*byte_mul);
157 as = talloc_strdup(ndr->current_mem_ctx, "");
159 ret = convert_string_talloc(ndr->current_mem_ctx,
161 ndr->data+ndr->offset,
162 (len1 + c_len_term)*byte_mul,
165 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
166 "Bad character conversion");
169 NDR_CHECK(ndr_pull_advance(ndr, (len1 + c_len_term)*byte_mul));
171 /* this is a way of detecting if a string is sent with the wrong
173 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
174 if (strlen(as) < (len1 + c_len_term)) {
175 DEBUG(6,("short string '%s'\n", as));
178 if (strlen(as) == (len1 + c_len_term)) {
179 DEBUG(6,("long string '%s'\n", as));
186 case LIBNDR_FLAG_STR_SIZE2:
187 case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM:
188 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
189 NDR_PULL_NEED_BYTES(ndr, (len3 + c_len_term)*byte_mul);
191 as = talloc_strdup(ndr->current_mem_ctx, "");
193 ret = convert_string_talloc(ndr->current_mem_ctx,
195 ndr->data+ndr->offset,
196 (len3 + c_len_term)*byte_mul,
199 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
200 "Bad character conversion");
203 NDR_CHECK(ndr_pull_advance(ndr, (len3 + c_len_term)*byte_mul));
205 /* this is a way of detecting if a string is sent with the wrong
207 if (ndr->flags & LIBNDR_FLAG_STR_NOTERM) {
208 if (strlen(as) < (len3 + c_len_term)) {
209 DEBUG(6,("short string '%s'\n", as));
212 if (strlen(as) == (len3 + c_len_term)) {
213 DEBUG(6,("long string '%s'\n", as));
219 case LIBNDR_FLAG_STR_SIZE2|LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_STR_BYTESIZE:
220 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &len3));
221 NDR_PULL_NEED_BYTES(ndr, len3);
223 as = talloc_strdup(ndr->current_mem_ctx, "");
225 ret = convert_string_talloc(ndr->current_mem_ctx,
227 ndr->data+ndr->offset,
231 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
232 "Bad character conversion");
235 NDR_CHECK(ndr_pull_advance(ndr, len3));
239 case LIBNDR_FLAG_STR_NULLTERM:
241 len1 = ascii_len_n((const char *)(ndr->data+ndr->offset), ndr->data_size - ndr->offset);
243 len1 = utf16_len_n(ndr->data+ndr->offset, ndr->data_size - ndr->offset);
245 ret = convert_string_talloc(ndr->current_mem_ctx,
247 ndr->data+ndr->offset,
251 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
252 "Bad character conversion");
254 NDR_CHECK(ndr_pull_advance(ndr, len1));
258 case LIBNDR_FLAG_STR_FIXLEN15:
259 case LIBNDR_FLAG_STR_FIXLEN32:
260 len1 = (flags & LIBNDR_FLAG_STR_FIXLEN32)?32:15;
261 NDR_PULL_NEED_BYTES(ndr, len1*byte_mul);
262 ret = convert_string_talloc(ndr->current_mem_ctx,
264 ndr->data+ndr->offset,
268 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
269 "Bad character conversion");
271 NDR_CHECK(ndr_pull_advance(ndr, len1*byte_mul));
275 case LIBNDR_FLAG_STR_NOTERM:
276 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
277 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
278 ndr->flags & LIBNDR_STRING_FLAGS);
281 len1 = ndr->data_size - ndr->offset;
283 NDR_PULL_NEED_BYTES(ndr, len1);
285 as = talloc_strdup(ndr->current_mem_ctx, "");
287 ret = convert_string_talloc(ndr->current_mem_ctx,
289 ndr->data+ndr->offset,
293 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
294 "Bad character conversion");
297 NDR_CHECK(ndr_pull_advance(ndr, len1));
303 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
304 ndr->flags & LIBNDR_STRING_FLAGS);
307 return NDR_ERR_SUCCESS;
312 push a general string onto the wire
314 _PUBLIC_ enum ndr_err_code ndr_push_string(struct ndr_push *ndr, int ndr_flags, const char *s)
316 ssize_t s_len, c_len, d_len;
317 int chset = CH_UTF16;
318 unsigned flags = ndr->flags;
319 unsigned byte_mul = 2;
320 uint8_t *dest = NULL;
322 if (!(ndr_flags & NDR_SCALARS)) {
323 return NDR_ERR_SUCCESS;
330 s_len = s?strlen(s):0;
332 if (flags & LIBNDR_FLAG_STR_ASCII) {
335 flags &= ~LIBNDR_FLAG_STR_ASCII;
338 if (flags & LIBNDR_FLAG_STR_UTF8) {
341 flags &= ~LIBNDR_FLAG_STR_UTF8;
344 flags &= ~LIBNDR_FLAG_STR_CONFORMANT;
347 (LIBNDR_FLAG_STR_NOTERM |
348 LIBNDR_FLAG_STR_FIXLEN15 |
349 LIBNDR_FLAG_STR_FIXLEN32))) {
352 d_len = convert_string_talloc(ndr, CH_UNIX, chset, s, s_len, (void **)&dest);
354 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
355 "Bad character conversion");
358 if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
360 flags &= ~LIBNDR_FLAG_STR_BYTESIZE;
361 } else if (flags & LIBNDR_FLAG_STR_CHARLEN) {
362 c_len = (d_len / byte_mul)-1;
363 flags &= ~LIBNDR_FLAG_STR_CHARLEN;
365 c_len = d_len / byte_mul;
368 switch ((flags & LIBNDR_STRING_FLAGS) & ~LIBNDR_FLAG_STR_NOTERM) {
369 case LIBNDR_FLAG_STR_LEN4|LIBNDR_FLAG_STR_SIZE4:
370 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
371 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
372 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
373 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
376 case LIBNDR_FLAG_STR_LEN4:
377 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
378 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
379 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
382 case LIBNDR_FLAG_STR_SIZE4:
383 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, c_len));
384 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
387 case LIBNDR_FLAG_STR_SIZE2:
388 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, c_len));
389 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
392 case LIBNDR_FLAG_STR_NULLTERM:
393 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
396 case LIBNDR_FLAG_STR_FIXLEN15:
397 case LIBNDR_FLAG_STR_FIXLEN32: {
398 ssize_t fix_len = (flags & LIBNDR_FLAG_STR_FIXLEN32)?32:15;
399 uint32_t pad_len = fix_len - d_len;
400 if (d_len > fix_len) {
401 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
402 "Bad character conversion");
404 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
406 NDR_CHECK(ndr_push_zero(ndr, pad_len));
412 if (ndr->flags & LIBNDR_FLAG_REMAINING) {
413 NDR_CHECK(ndr_push_bytes(ndr, dest, d_len));
417 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
418 ndr->flags & LIBNDR_STRING_FLAGS);
423 return NDR_ERR_SUCCESS;
427 push a general string onto the wire
429 _PUBLIC_ size_t ndr_string_array_size(struct ndr_push *ndr, const char *s)
432 unsigned flags = ndr->flags;
433 unsigned byte_mul = 2;
434 unsigned c_len_term = 1;
436 if (flags & LIBNDR_FLAG_STR_FIXLEN32) {
439 if (flags & LIBNDR_FLAG_STR_FIXLEN15) {
443 c_len = s?strlen_m(s):0;
445 if (flags & (LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_UTF8)) {
449 if (flags & LIBNDR_FLAG_STR_NOTERM) {
453 c_len = c_len + c_len_term;
455 if (flags & LIBNDR_FLAG_STR_BYTESIZE) {
456 c_len = c_len * byte_mul;
462 _PUBLIC_ void ndr_print_string(struct ndr_print *ndr, const char *name, const char *s)
465 ndr->print(ndr, "%-25s: '%s'", name, s);
467 ndr->print(ndr, "%-25s: NULL", name);
471 _PUBLIC_ uint32_t ndr_size_string(int ret, const char * const* string, int flags)
473 /* FIXME: Is this correct for all strings ? */
474 if(!(*string)) return ret;
475 return ret+strlen(*string)+1;
479 pull a general string array from the wire
481 _PUBLIC_ enum ndr_err_code ndr_pull_string_array(struct ndr_pull *ndr, int ndr_flags, const char ***_a)
483 const char **a = *_a;
485 unsigned flags = ndr->flags;
486 unsigned saved_flags = ndr->flags;
488 if (!(ndr_flags & NDR_SCALARS)) {
489 return NDR_ERR_SUCCESS;
492 switch (flags & LIBNDR_STRING_FLAGS) {
493 case LIBNDR_FLAG_STR_NULLTERM:
495 * here the strings are null terminated
496 * but also the array is null terminated
498 for (count = 0;; count++) {
500 const char *s = NULL;
501 a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 2);
502 NDR_ERR_HAVE_NO_MEMORY(a);
506 tmp_ctx = ndr->current_mem_ctx;
507 ndr->current_mem_ctx = a;
508 NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
509 ndr->current_mem_ctx = tmp_ctx;
510 if (strcmp("", s)==0) {
521 case LIBNDR_FLAG_STR_NOTERM:
522 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
523 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
524 ndr->flags & LIBNDR_STRING_FLAGS);
527 * here the strings are not null terminated
528 * but serarated by a null terminator
530 * which means the same as:
531 * very string is null terminated exept the last
532 * string is terminated by the end of the buffer
534 * as LIBNDR_FLAG_STR_NULLTERM also end at the end
535 * of the buffer, we can pull each string with this flag
537 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
538 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
540 for (count = 0; ((ndr->data_size - ndr->offset) > 0); count++) {
542 const char *s = NULL;
543 a = talloc_realloc(ndr->current_mem_ctx, a, const char *, count + 2);
544 NDR_ERR_HAVE_NO_MEMORY(a);
548 tmp_ctx = ndr->current_mem_ctx;
549 ndr->current_mem_ctx = a;
550 NDR_CHECK(ndr_pull_string(ndr, ndr_flags, &s));
551 ndr->current_mem_ctx = tmp_ctx;
559 return ndr_pull_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
560 ndr->flags & LIBNDR_STRING_FLAGS);
563 ndr->flags = saved_flags;
564 return NDR_ERR_SUCCESS;
568 push a general string array onto the wire
570 _PUBLIC_ enum ndr_err_code ndr_push_string_array(struct ndr_push *ndr, int ndr_flags, const char **a)
573 unsigned flags = ndr->flags;
574 unsigned saved_flags = ndr->flags;
576 if (!(ndr_flags & NDR_SCALARS)) {
577 return NDR_ERR_SUCCESS;
580 switch (flags & LIBNDR_STRING_FLAGS) {
581 case LIBNDR_FLAG_STR_NULLTERM:
582 for (count = 0; a && a[count]; count++) {
583 NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
586 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
589 case LIBNDR_FLAG_STR_NOTERM:
590 if (!(ndr->flags & LIBNDR_FLAG_REMAINING)) {
591 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
592 ndr->flags & LIBNDR_STRING_FLAGS);
595 for (count = 0; a && a[count]; count++) {
597 ndr->flags &= ~(LIBNDR_FLAG_STR_NOTERM|LIBNDR_FLAG_REMAINING);
598 ndr->flags |= LIBNDR_FLAG_STR_NULLTERM;
599 NDR_CHECK(ndr_push_string(ndr, ndr_flags, ""));
600 ndr->flags = saved_flags;
602 NDR_CHECK(ndr_push_string(ndr, ndr_flags, a[count]));
608 return ndr_push_error(ndr, NDR_ERR_STRING, "Bad string flags 0x%x\n",
609 ndr->flags & LIBNDR_STRING_FLAGS);
612 ndr->flags = saved_flags;
613 return NDR_ERR_SUCCESS;
616 _PUBLIC_ void ndr_print_string_array(struct ndr_print *ndr, const char *name, const char **a)
621 for (count = 0; a && a[count]; count++) {}
623 ndr->print(ndr, "%s: ARRAY(%d)", name, count);
625 for (i=0;i<count;i++) {
627 asprintf(&idx, "[%d]", i);
629 ndr_print_string(ndr, idx, a[i]);
637 * Return number of elements in a string including the last (zeroed) element
639 _PUBLIC_ uint32_t ndr_string_length(const void *_var, uint32_t element_size)
642 uint8_t zero[4] = {0,0,0,0};
643 const char *var = (const char *)_var;
645 for (i = 0; memcmp(var+i*element_size,zero,element_size) != 0; i++);
650 _PUBLIC_ enum ndr_err_code ndr_check_string_terminator(struct ndr_pull *ndr, uint32_t count, uint32_t element_size)
653 uint32_t save_offset;
655 save_offset = ndr->offset;
656 ndr_pull_advance(ndr, (count - 1) * element_size);
657 NDR_PULL_NEED_BYTES(ndr, element_size);
659 for (i = 0; i < element_size; i++) {
660 if (ndr->data[ndr->offset+i] != 0) {
661 ndr->offset = save_offset;
663 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "String terminator not present or outside string boundaries");
667 ndr->offset = save_offset;
669 return NDR_ERR_SUCCESS;
672 _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)
676 *var = talloc_strdup(ndr->current_mem_ctx, "");
677 return NDR_ERR_SUCCESS;
680 if (NDR_BE(ndr) && chset == CH_UTF16) {
684 NDR_PULL_NEED_BYTES(ndr, length*byte_mul);
686 ret = convert_string_talloc(ndr->current_mem_ctx,
688 ndr->data+ndr->offset,
690 discard_const_p(void *, var));
692 return ndr_pull_error(ndr, NDR_ERR_CHARCNV,
693 "Bad character conversion");
695 NDR_CHECK(ndr_pull_advance(ndr, length*byte_mul));
697 return NDR_ERR_SUCCESS;
700 _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)
702 ssize_t ret, required;
704 if (NDR_BE(ndr) && chset == CH_UTF16) {
708 required = byte_mul * length;
710 NDR_PUSH_NEED_BYTES(ndr, required);
711 ret = convert_string(CH_UNIX, chset,
713 ndr->data+ndr->offset, required);
715 return ndr_push_error(ndr, NDR_ERR_CHARCNV,
716 "Bad character conversion");
719 /* Make sure the remaining part of the string is filled with zeroes */
720 if (ret < required) {
721 memset(ndr->data+ndr->offset+ret, 0, required-ret);
724 ndr->offset += required;
726 return NDR_ERR_SUCCESS;
729 /* Return number of elements in a string in the specified charset */
730 _PUBLIC_ uint32_t ndr_charset_length(const void *var, charset_t chset)
732 /* FIXME: Treat special chars special here, taking chset into account */
733 /* Also include 0 byte */
734 return strlen((const char *)var)+1;