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
,
91 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
92 "Bad character conversion");
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 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
124 ndr
->data
+ndr
->offset
,
125 (len1
+ c_len_term
)*byte_mul
,
126 (void **)(void *)&as
,
129 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
130 "Bad character conversion");
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 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
163 ndr
->data
+ndr
->offset
,
164 (len1
+ c_len_term
)*byte_mul
,
165 (void **)(void *)&as
,
168 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
169 "Bad character conversion");
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 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
198 ndr
->data
+ndr
->offset
,
199 (len3
+ c_len_term
)*byte_mul
,
200 (void **)(void *)&as
,
203 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
204 "Bad character conversion");
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 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
231 ndr
->data
+ndr
->offset
,
233 (void **)(void *)&as
,
236 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
237 "Bad character conversion");
240 NDR_CHECK(ndr_pull_advance(ndr
, len3
));
244 case LIBNDR_FLAG_STR_NULLTERM
:
246 len1
= ascii_len_n((const char *)(ndr
->data
+ndr
->offset
), ndr
->data_size
- ndr
->offset
);
248 len1
= utf16_len_n(ndr
->data
+ndr
->offset
, ndr
->data_size
- ndr
->offset
);
250 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
252 ndr
->data
+ndr
->offset
,
254 (void **)(void *)&as
,
257 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
258 "Bad character conversion");
260 NDR_CHECK(ndr_pull_advance(ndr
, len1
));
264 case LIBNDR_FLAG_STR_FIXLEN15
:
265 case LIBNDR_FLAG_STR_FIXLEN32
:
266 len1
= (flags
& LIBNDR_FLAG_STR_FIXLEN32
)?32:15;
267 NDR_PULL_NEED_BYTES(ndr
, len1
*byte_mul
);
268 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
270 ndr
->data
+ndr
->offset
,
272 (void **)(void *)&as
,
275 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
276 "Bad character conversion");
278 NDR_CHECK(ndr_pull_advance(ndr
, len1
*byte_mul
));
282 case LIBNDR_FLAG_STR_NOTERM
:
283 if (!(ndr
->flags
& LIBNDR_FLAG_REMAINING
)) {
284 return ndr_pull_error(ndr
, NDR_ERR_STRING
, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
285 ndr
->flags
& LIBNDR_STRING_FLAGS
);
288 len1
= ndr
->data_size
- ndr
->offset
;
290 NDR_PULL_NEED_BYTES(ndr
, len1
);
292 as
= talloc_strdup(ndr
->current_mem_ctx
, "");
294 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
296 ndr
->data
+ndr
->offset
,
298 (void **)(void *)&as
,
301 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
302 "Bad character conversion");
305 NDR_CHECK(ndr_pull_advance(ndr
, len1
));
311 return ndr_pull_error(ndr
, NDR_ERR_STRING
, "Bad string flags 0x%x\n",
312 ndr
->flags
& LIBNDR_STRING_FLAGS
);
315 return NDR_ERR_SUCCESS
;
320 push a general string onto the wire
322 _PUBLIC_
enum ndr_err_code
ndr_push_string(struct ndr_push
*ndr
, int ndr_flags
, const char *s
)
324 ssize_t s_len
, c_len
, d_len
;
325 int chset
= CH_UTF16
;
326 unsigned flags
= ndr
->flags
;
327 unsigned byte_mul
= 2;
328 uint8_t *dest
= NULL
;
330 if (!(ndr_flags
& NDR_SCALARS
)) {
331 return NDR_ERR_SUCCESS
;
338 s_len
= s
?strlen(s
):0;
340 if (flags
& LIBNDR_FLAG_STR_ASCII
) {
343 flags
&= ~LIBNDR_FLAG_STR_ASCII
;
346 if (flags
& LIBNDR_FLAG_STR_UTF8
) {
349 flags
&= ~LIBNDR_FLAG_STR_UTF8
;
352 flags
&= ~LIBNDR_FLAG_STR_CONFORMANT
;
355 (LIBNDR_FLAG_STR_NOTERM
|
356 LIBNDR_FLAG_STR_FIXLEN15
|
357 LIBNDR_FLAG_STR_FIXLEN32
))) {
360 d_len
= convert_string_talloc(ndr
, CH_UNIX
, chset
, s
, s_len
,
361 (void **)(void *)&dest
, false);
363 return ndr_push_error(ndr
, NDR_ERR_CHARCNV
,
364 "Bad character conversion");
367 if (flags
& LIBNDR_FLAG_STR_BYTESIZE
) {
369 flags
&= ~LIBNDR_FLAG_STR_BYTESIZE
;
370 } else if (flags
& LIBNDR_FLAG_STR_CHARLEN
) {
371 c_len
= (d_len
/ byte_mul
)-1;
372 flags
&= ~LIBNDR_FLAG_STR_CHARLEN
;
374 c_len
= d_len
/ byte_mul
;
377 switch ((flags
& LIBNDR_STRING_FLAGS
) & ~LIBNDR_FLAG_STR_NOTERM
) {
378 case LIBNDR_FLAG_STR_LEN4
|LIBNDR_FLAG_STR_SIZE4
:
379 NDR_CHECK(ndr_push_uint32(ndr
, NDR_SCALARS
, c_len
));
380 NDR_CHECK(ndr_push_uint32(ndr
, NDR_SCALARS
, 0));
381 NDR_CHECK(ndr_push_uint32(ndr
, NDR_SCALARS
, c_len
));
382 NDR_CHECK(ndr_push_bytes(ndr
, dest
, d_len
));
385 case LIBNDR_FLAG_STR_LEN4
:
386 NDR_CHECK(ndr_push_uint32(ndr
, NDR_SCALARS
, 0));
387 NDR_CHECK(ndr_push_uint32(ndr
, NDR_SCALARS
, c_len
));
388 NDR_CHECK(ndr_push_bytes(ndr
, dest
, d_len
));
391 case LIBNDR_FLAG_STR_SIZE4
:
392 NDR_CHECK(ndr_push_uint32(ndr
, NDR_SCALARS
, c_len
));
393 NDR_CHECK(ndr_push_bytes(ndr
, dest
, d_len
));
396 case LIBNDR_FLAG_STR_SIZE2
:
397 NDR_CHECK(ndr_push_uint16(ndr
, NDR_SCALARS
, c_len
));
398 NDR_CHECK(ndr_push_bytes(ndr
, dest
, d_len
));
401 case LIBNDR_FLAG_STR_NULLTERM
:
402 NDR_CHECK(ndr_push_bytes(ndr
, dest
, d_len
));
405 case LIBNDR_FLAG_STR_FIXLEN15
:
406 case LIBNDR_FLAG_STR_FIXLEN32
: {
407 ssize_t fix_len
= (flags
& LIBNDR_FLAG_STR_FIXLEN32
)?32:15;
408 uint32_t pad_len
= fix_len
- d_len
;
409 if (d_len
> fix_len
) {
410 return ndr_push_error(ndr
, NDR_ERR_CHARCNV
,
411 "Bad character conversion");
413 NDR_CHECK(ndr_push_bytes(ndr
, dest
, d_len
));
415 NDR_CHECK(ndr_push_zero(ndr
, pad_len
));
421 if (ndr
->flags
& LIBNDR_FLAG_REMAINING
) {
422 NDR_CHECK(ndr_push_bytes(ndr
, dest
, d_len
));
426 return ndr_push_error(ndr
, NDR_ERR_STRING
, "Bad string flags 0x%x\n",
427 ndr
->flags
& LIBNDR_STRING_FLAGS
);
432 return NDR_ERR_SUCCESS
;
436 push a general string onto the wire
438 _PUBLIC_
size_t ndr_string_array_size(struct ndr_push
*ndr
, const char *s
)
441 unsigned flags
= ndr
->flags
;
442 unsigned byte_mul
= 2;
443 unsigned c_len_term
= 1;
445 if (flags
& LIBNDR_FLAG_STR_FIXLEN32
) {
448 if (flags
& LIBNDR_FLAG_STR_FIXLEN15
) {
452 c_len
= s
?strlen_m(s
):0;
454 if (flags
& (LIBNDR_FLAG_STR_ASCII
|LIBNDR_FLAG_STR_UTF8
)) {
458 if (flags
& LIBNDR_FLAG_STR_NOTERM
) {
462 c_len
= c_len
+ c_len_term
;
464 if (flags
& LIBNDR_FLAG_STR_BYTESIZE
) {
465 c_len
= c_len
* byte_mul
;
471 _PUBLIC_
void ndr_print_string(struct ndr_print
*ndr
, const char *name
, const char *s
)
474 ndr
->print(ndr
, "%-25s: '%s'", name
, s
);
476 ndr
->print(ndr
, "%-25s: NULL", name
);
480 _PUBLIC_
uint32_t ndr_size_string(int ret
, const char * const* string
, int flags
)
482 /* FIXME: Is this correct for all strings ? */
483 if(!(*string
)) return ret
;
484 return ret
+strlen(*string
)+1;
488 pull a general string array from the wire
490 _PUBLIC_
enum ndr_err_code
ndr_pull_string_array(struct ndr_pull
*ndr
, int ndr_flags
, const char ***_a
)
492 const char **a
= *_a
;
494 unsigned flags
= ndr
->flags
;
495 unsigned saved_flags
= ndr
->flags
;
497 if (!(ndr_flags
& NDR_SCALARS
)) {
498 return NDR_ERR_SUCCESS
;
501 switch (flags
& LIBNDR_STRING_FLAGS
) {
502 case LIBNDR_FLAG_STR_NULLTERM
:
504 * here the strings are null terminated
505 * but also the array is null terminated
507 for (count
= 0;; count
++) {
509 const char *s
= NULL
;
510 a
= talloc_realloc(ndr
->current_mem_ctx
, a
, const char *, count
+ 2);
511 NDR_ERR_HAVE_NO_MEMORY(a
);
515 tmp_ctx
= ndr
->current_mem_ctx
;
516 ndr
->current_mem_ctx
= a
;
517 NDR_CHECK(ndr_pull_string(ndr
, ndr_flags
, &s
));
518 ndr
->current_mem_ctx
= tmp_ctx
;
519 if (strcmp("", s
)==0) {
530 case LIBNDR_FLAG_STR_NOTERM
:
531 if (!(ndr
->flags
& LIBNDR_FLAG_REMAINING
)) {
532 return ndr_pull_error(ndr
, NDR_ERR_STRING
, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
533 ndr
->flags
& LIBNDR_STRING_FLAGS
);
536 * here the strings are not null terminated
537 * but serarated by a null terminator
539 * which means the same as:
540 * very string is null terminated exept the last
541 * string is terminated by the end of the buffer
543 * as LIBNDR_FLAG_STR_NULLTERM also end at the end
544 * of the buffer, we can pull each string with this flag
546 ndr
->flags
&= ~(LIBNDR_FLAG_STR_NOTERM
|LIBNDR_FLAG_REMAINING
);
547 ndr
->flags
|= LIBNDR_FLAG_STR_NULLTERM
;
549 for (count
= 0; ((ndr
->data_size
- ndr
->offset
) > 0); count
++) {
551 const char *s
= NULL
;
552 a
= talloc_realloc(ndr
->current_mem_ctx
, a
, const char *, count
+ 2);
553 NDR_ERR_HAVE_NO_MEMORY(a
);
557 tmp_ctx
= ndr
->current_mem_ctx
;
558 ndr
->current_mem_ctx
= a
;
559 NDR_CHECK(ndr_pull_string(ndr
, ndr_flags
, &s
));
560 ndr
->current_mem_ctx
= tmp_ctx
;
568 return ndr_pull_error(ndr
, NDR_ERR_STRING
, "Bad string flags 0x%x\n",
569 ndr
->flags
& LIBNDR_STRING_FLAGS
);
572 ndr
->flags
= saved_flags
;
573 return NDR_ERR_SUCCESS
;
577 push a general string array onto the wire
579 _PUBLIC_
enum ndr_err_code
ndr_push_string_array(struct ndr_push
*ndr
, int ndr_flags
, const char **a
)
582 unsigned flags
= ndr
->flags
;
583 unsigned saved_flags
= ndr
->flags
;
585 if (!(ndr_flags
& NDR_SCALARS
)) {
586 return NDR_ERR_SUCCESS
;
589 switch (flags
& LIBNDR_STRING_FLAGS
) {
590 case LIBNDR_FLAG_STR_NULLTERM
:
591 for (count
= 0; a
&& a
[count
]; count
++) {
592 NDR_CHECK(ndr_push_string(ndr
, ndr_flags
, a
[count
]));
595 NDR_CHECK(ndr_push_string(ndr
, ndr_flags
, ""));
598 case LIBNDR_FLAG_STR_NOTERM
:
599 if (!(ndr
->flags
& LIBNDR_FLAG_REMAINING
)) {
600 return ndr_push_error(ndr
, NDR_ERR_STRING
, "Bad string flags 0x%x (missing NDR_REMAINING)\n",
601 ndr
->flags
& LIBNDR_STRING_FLAGS
);
604 for (count
= 0; a
&& a
[count
]; count
++) {
606 ndr
->flags
&= ~(LIBNDR_FLAG_STR_NOTERM
|LIBNDR_FLAG_REMAINING
);
607 ndr
->flags
|= LIBNDR_FLAG_STR_NULLTERM
;
608 NDR_CHECK(ndr_push_string(ndr
, ndr_flags
, ""));
609 ndr
->flags
= saved_flags
;
611 NDR_CHECK(ndr_push_string(ndr
, ndr_flags
, a
[count
]));
617 return ndr_push_error(ndr
, NDR_ERR_STRING
, "Bad string flags 0x%x\n",
618 ndr
->flags
& LIBNDR_STRING_FLAGS
);
621 ndr
->flags
= saved_flags
;
622 return NDR_ERR_SUCCESS
;
625 _PUBLIC_
void ndr_print_string_array(struct ndr_print
*ndr
, const char *name
, const char **a
)
630 for (count
= 0; a
&& a
[count
]; count
++) {}
632 ndr
->print(ndr
, "%s: ARRAY(%d)", name
, count
);
634 for (i
=0;i
<count
;i
++) {
636 if (asprintf(&idx
, "[%d]", i
) != -1) {
637 ndr_print_string(ndr
, idx
, a
[i
]);
645 * Return number of elements in a string including the last (zeroed) element
647 _PUBLIC_
uint32_t ndr_string_length(const void *_var
, uint32_t element_size
)
650 uint8_t zero
[4] = {0,0,0,0};
651 const char *var
= (const char *)_var
;
653 for (i
= 0; memcmp(var
+i
*element_size
,zero
,element_size
) != 0; i
++);
658 _PUBLIC_
enum ndr_err_code
ndr_check_string_terminator(struct ndr_pull
*ndr
, uint32_t count
, uint32_t element_size
)
661 struct ndr_pull_save save_offset
;
663 ndr_pull_save(ndr
, &save_offset
);
664 ndr_pull_advance(ndr
, (count
- 1) * element_size
);
665 NDR_PULL_NEED_BYTES(ndr
, element_size
);
667 for (i
= 0; i
< element_size
; i
++) {
668 if (ndr
->data
[ndr
->offset
+i
] != 0) {
669 ndr_pull_restore(ndr
, &save_offset
);
671 return ndr_pull_error(ndr
, NDR_ERR_ARRAY_SIZE
, "String terminator not present or outside string boundaries");
675 ndr_pull_restore(ndr
, &save_offset
);
677 return NDR_ERR_SUCCESS
;
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
)
684 *var
= talloc_strdup(ndr
->current_mem_ctx
, "");
685 return NDR_ERR_SUCCESS
;
688 if (NDR_BE(ndr
) && chset
== CH_UTF16
) {
692 NDR_PULL_NEED_BYTES(ndr
, length
*byte_mul
);
694 ret
= convert_string_talloc(ndr
->current_mem_ctx
,
696 ndr
->data
+ndr
->offset
,
698 discard_const_p(void *, var
), false);
700 return ndr_pull_error(ndr
, NDR_ERR_CHARCNV
,
701 "Bad character conversion");
703 NDR_CHECK(ndr_pull_advance(ndr
, length
*byte_mul
));
705 return NDR_ERR_SUCCESS
;
708 _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
)
710 ssize_t ret
, required
;
712 if (NDR_BE(ndr
) && chset
== CH_UTF16
) {
716 required
= byte_mul
* length
;
718 NDR_PUSH_NEED_BYTES(ndr
, required
);
719 ret
= convert_string(CH_UNIX
, chset
,
721 ndr
->data
+ndr
->offset
, required
, false);
723 return ndr_push_error(ndr
, NDR_ERR_CHARCNV
,
724 "Bad character conversion");
727 /* Make sure the remaining part of the string is filled with zeroes */
728 if (ret
< required
) {
729 memset(ndr
->data
+ndr
->offset
+ret
, 0, required
-ret
);
732 ndr
->offset
+= required
;
734 return NDR_ERR_SUCCESS
;
737 /* Return number of elements in a string in the specified charset */
738 _PUBLIC_
uint32_t ndr_charset_length(const void *var
, charset_t chset
)
740 /* FIXME: Treat special chars special here, taking chset into account */
741 /* Also include 0 byte */
742 return strlen((const char *)var
)+1;