2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6 * Copyright (C) Paul Ashton 1997.
7 * Copyright (C) Gerald (Jerry) Carter 2005
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #define DBGC_CLASS DBGC_RPC_PARSE
29 /****************************************************************************
30 A temporary TALLOC context for things like unistrs, that is valid for
31 the life of a complete RPC call.
32 ****************************************************************************/
34 static TALLOC_CTX
*current_rpc_talloc
= NULL
;
36 static TALLOC_CTX
*get_current_rpc_talloc(void)
38 return current_rpc_talloc
;
41 void set_current_rpc_talloc( TALLOC_CTX
*ctx
)
43 current_rpc_talloc
= ctx
;
46 static TALLOC_CTX
*main_loop_talloc
= NULL
;
48 /*******************************************************************
49 free up temporary memory - called from the main loop
50 ********************************************************************/
52 void main_loop_TALLOC_FREE(void)
54 if (!main_loop_talloc
)
56 talloc_destroy(main_loop_talloc
);
57 main_loop_talloc
= NULL
;
60 /*******************************************************************
61 Get a talloc context that is freed in the main loop...
62 ********************************************************************/
64 TALLOC_CTX
*main_loop_talloc_get(void)
66 if (!main_loop_talloc
) {
67 main_loop_talloc
= talloc_init("main loop talloc (mainly parse_misc)");
68 if (!main_loop_talloc
)
69 smb_panic("main_loop_talloc: malloc fail\n");
72 return main_loop_talloc
;
75 /*******************************************************************
76 Try and get a talloc context. Get the rpc one if possible, else
77 get the main loop one. The main loop one is more dangerous as it
78 goes away between packets, the rpc one will stay around for as long
79 as a current RPC lasts.
80 ********************************************************************/
82 TALLOC_CTX
*get_talloc_ctx(void)
84 TALLOC_CTX
*tc
= get_current_rpc_talloc();
88 return main_loop_talloc_get();
91 /*******************************************************************
92 Reads or writes a UTIME type.
93 ********************************************************************/
95 static BOOL
smb_io_utime(const char *desc
, UTIME
*t
, prs_struct
*ps
, int depth
)
100 prs_debug(ps
, depth
, desc
, "smb_io_utime");
106 if(!prs_uint32 ("time", ps
, depth
, &t
->time
))
112 /*******************************************************************
113 Reads or writes an NTTIME structure.
114 ********************************************************************/
116 BOOL
smb_io_time(const char *desc
, NTTIME
*nttime
, prs_struct
*ps
, int depth
)
122 prs_debug(ps
, depth
, desc
, "smb_io_time");
128 if (MARSHALLING(ps
)) {
129 low
= *nttime
& 0xFFFFFFFF;
130 high
= *nttime
>> 32;
133 if(!prs_uint32("low ", ps
, depth
, &low
)) /* low part */
135 if(!prs_uint32("high", ps
, depth
, &high
)) /* high part */
138 if (UNMARSHALLING(ps
)) {
139 *nttime
= (((uint64_t)high
<< 32) + low
);
145 /*******************************************************************
146 Reads or writes an NTTIME structure.
147 ********************************************************************/
149 BOOL
smb_io_nttime(const char *desc
, prs_struct
*ps
, int depth
, NTTIME
*nttime
)
151 return smb_io_time( desc
, nttime
, ps
, depth
);
154 /*******************************************************************
155 Gets an enumeration handle from an ENUM_HND structure.
156 ********************************************************************/
158 uint32
get_enum_hnd(ENUM_HND
*enh
)
160 return (enh
&& enh
->ptr_hnd
!= 0) ? enh
->handle
: 0;
163 /*******************************************************************
164 Inits an ENUM_HND structure.
165 ********************************************************************/
167 void init_enum_hnd(ENUM_HND
*enh
, uint32 hnd
)
169 DEBUG(5,("smb_io_enum_hnd\n"));
171 enh
->ptr_hnd
= (hnd
!= 0) ? 1 : 0;
175 /*******************************************************************
176 Reads or writes an ENUM_HND structure.
177 ********************************************************************/
179 BOOL
smb_io_enum_hnd(const char *desc
, ENUM_HND
*hnd
, prs_struct
*ps
, int depth
)
184 prs_debug(ps
, depth
, desc
, "smb_io_enum_hnd");
190 if(!prs_uint32("ptr_hnd", ps
, depth
, &hnd
->ptr_hnd
)) /* pointer */
193 if (hnd
->ptr_hnd
!= 0) {
194 if(!prs_uint32("handle ", ps
, depth
, &hnd
->handle
)) /* enum handle */
201 /*******************************************************************
202 Reads or writes a DOM_SID structure.
203 ********************************************************************/
205 BOOL
smb_io_dom_sid(const char *desc
, DOM_SID
*sid
, prs_struct
*ps
, int depth
)
212 prs_debug(ps
, depth
, desc
, "smb_io_dom_sid");
215 if(!prs_uint8 ("sid_rev_num", ps
, depth
, &sid
->sid_rev_num
))
218 if(!prs_uint8 ("num_auths ", ps
, depth
, &sid
->num_auths
))
221 for (i
= 0; i
< 6; i
++)
224 slprintf(tmp
, sizeof(tmp
) - 1, "id_auth[%d] ", i
);
225 if(!prs_uint8 (tmp
, ps
, depth
, &sid
->id_auth
[i
]))
229 /* oops! XXXX should really issue a warning here... */
230 if (sid
->num_auths
> MAXSUBAUTHS
)
231 sid
->num_auths
= MAXSUBAUTHS
;
233 if(!prs_uint32s(False
, "sub_auths ", ps
, depth
, sid
->sub_auths
, sid
->num_auths
))
239 /*******************************************************************
240 Inits a DOM_SID2 structure.
241 ********************************************************************/
243 void init_dom_sid2(DOM_SID2
*sid2
, const DOM_SID
*sid
)
246 sid2
->num_auths
= sid2
->sid
.num_auths
;
249 /*******************************************************************
250 Reads or writes a DOM_SID2 structure.
251 ********************************************************************/
253 BOOL
smb_io_dom_sid2_p(const char *desc
, prs_struct
*ps
, int depth
, DOM_SID2
**sid2
)
257 /* caputure the pointer value to stream */
259 data_p
= *sid2
? 0xf000baaa : 0;
261 if ( !prs_uint32("dom_sid2_p", ps
, depth
, &data_p
))
264 /* we're done if there is no data */
269 if (UNMARSHALLING(ps
)) {
270 if ( !(*sid2
= PRS_ALLOC_MEM(ps
, DOM_SID2
, 1)) )
276 /*******************************************************************
277 Reads or writes a DOM_SID2 structure.
278 ********************************************************************/
280 BOOL
smb_io_dom_sid2(const char *desc
, DOM_SID2
*sid
, prs_struct
*ps
, int depth
)
285 prs_debug(ps
, depth
, desc
, "smb_io_dom_sid2");
291 if(!prs_uint32("num_auths", ps
, depth
, &sid
->num_auths
))
294 if(!smb_io_dom_sid("sid", &sid
->sid
, ps
, depth
))
300 /*******************************************************************
301 Reads or writes a struct GUID
302 ********************************************************************/
304 BOOL
smb_io_uuid(const char *desc
, struct GUID
*uuid
,
305 prs_struct
*ps
, int depth
)
310 prs_debug(ps
, depth
, desc
, "smb_io_uuid");
313 if(!prs_uint32 ("data ", ps
, depth
, &uuid
->time_low
))
315 if(!prs_uint16 ("data ", ps
, depth
, &uuid
->time_mid
))
317 if(!prs_uint16 ("data ", ps
, depth
, &uuid
->time_hi_and_version
))
320 if(!prs_uint8s (False
, "data ", ps
, depth
, uuid
->clock_seq
, sizeof(uuid
->clock_seq
)))
322 if(!prs_uint8s (False
, "data ", ps
, depth
, uuid
->node
, sizeof(uuid
->node
)))
328 /*******************************************************************
329 creates a STRHDR structure.
330 ********************************************************************/
332 void init_str_hdr(STRHDR
*hdr
, int max_len
, int len
, uint32 buffer
)
334 hdr
->str_max_len
= max_len
;
335 hdr
->str_str_len
= len
;
336 hdr
->buffer
= buffer
;
339 /*******************************************************************
340 Reads or writes a STRHDR structure.
341 ********************************************************************/
343 BOOL
smb_io_strhdr(const char *desc
, STRHDR
*hdr
, prs_struct
*ps
, int depth
)
348 prs_debug(ps
, depth
, desc
, "smb_io_strhdr");
353 if(!prs_uint16("str_str_len", ps
, depth
, &hdr
->str_str_len
))
355 if(!prs_uint16("str_max_len", ps
, depth
, &hdr
->str_max_len
))
357 if(!prs_uint32("buffer ", ps
, depth
, &hdr
->buffer
))
363 /*******************************************************************
364 Inits a UNIHDR structure.
365 ********************************************************************/
367 void init_uni_hdr(UNIHDR
*hdr
, UNISTR2
*str2
)
369 hdr
->uni_str_len
= 2 * (str2
->uni_str_len
);
370 hdr
->uni_max_len
= 2 * (str2
->uni_max_len
);
371 hdr
->buffer
= (str2
->uni_str_len
!= 0) ? 1 : 0;
374 /*******************************************************************
375 Reads or writes a UNIHDR structure.
376 ********************************************************************/
378 BOOL
smb_io_unihdr(const char *desc
, UNIHDR
*hdr
, prs_struct
*ps
, int depth
)
383 prs_debug(ps
, depth
, desc
, "smb_io_unihdr");
389 if(!prs_uint16("uni_str_len", ps
, depth
, &hdr
->uni_str_len
))
391 if(!prs_uint16("uni_max_len", ps
, depth
, &hdr
->uni_max_len
))
393 if(!prs_uint32("buffer ", ps
, depth
, &hdr
->buffer
))
399 /*******************************************************************
400 Inits a BUFHDR structure.
401 ********************************************************************/
403 void init_buf_hdr(BUFHDR
*hdr
, int max_len
, int len
)
405 hdr
->buf_max_len
= max_len
;
409 /*******************************************************************
410 prs_uint16 wrapper. Call this and it sets up a pointer to where the
411 uint16 should be stored, or gets the size if reading.
412 ********************************************************************/
414 BOOL
smb_io_hdrbuf_pre(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
, uint32
*offset
)
416 (*offset
) = prs_offset(ps
);
421 if(!smb_io_hdrbuf(desc
, hdr
, ps
, depth
))
428 if(!prs_set_offset(ps
, prs_offset(ps
) + (sizeof(uint32
) * 2)))
435 /*******************************************************************
436 smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
437 Does nothing on reading, as that is already handled by ...._pre()
438 ********************************************************************/
440 BOOL
smb_io_hdrbuf_post(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
,
441 uint32 ptr_hdrbuf
, uint32 max_len
, uint32 len
)
444 /* writing: go back and do a retrospective job. i hate this */
446 uint32 old_offset
= prs_offset(ps
);
448 init_buf_hdr(hdr
, max_len
, len
);
449 if(!prs_set_offset(ps
, ptr_hdrbuf
))
451 if(!smb_io_hdrbuf(desc
, hdr
, ps
, depth
))
454 if(!prs_set_offset(ps
, old_offset
))
461 /*******************************************************************
462 Reads or writes a BUFHDR structure.
463 ********************************************************************/
465 BOOL
smb_io_hdrbuf(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
)
470 prs_debug(ps
, depth
, desc
, "smb_io_hdrbuf");
476 if(!prs_uint32("buf_max_len", ps
, depth
, &hdr
->buf_max_len
))
478 if(!prs_uint32("buf_len ", ps
, depth
, &hdr
->buf_len
))
484 /*******************************************************************
485 Inits a UNISTR structure.
486 ********************************************************************/
488 void init_unistr(UNISTR
*str
, const char *buf
)
497 len
= strlen(buf
) + 1;
499 str
->buffer
= TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16
, len
);
500 if (str
->buffer
== NULL
)
501 smb_panic("init_unistr: malloc fail\n");
503 rpcstr_push(str
->buffer
, buf
, len
*sizeof(uint16
), STR_TERMINATE
);
506 /*******************************************************************
507 reads or writes a UNISTR structure.
508 XXXX NOTE: UNISTR structures NEED to be null-terminated.
509 ********************************************************************/
511 BOOL
smb_io_unistr(const char *desc
, UNISTR
*uni
, prs_struct
*ps
, int depth
)
516 prs_debug(ps
, depth
, desc
, "smb_io_unistr");
519 if(!prs_unistr("unistr", ps
, depth
, uni
))
525 /*******************************************************************
526 Allocate the RPC_DATA_BLOB memory.
527 ********************************************************************/
529 size_t create_rpc_blob(RPC_DATA_BLOB
*str
, size_t len
)
531 str
->buffer
= (uint8
*)TALLOC_ZERO(get_talloc_ctx(), len
);
532 if (str
->buffer
== NULL
)
533 smb_panic("create_rpc_blob: talloc fail\n");
537 /*******************************************************************
538 Inits a RPC_DATA_BLOB structure from a uint32
539 ********************************************************************/
541 void init_rpc_blob_uint32(RPC_DATA_BLOB
*str
, uint32 val
)
545 /* set up string lengths. */
546 str
->buf_len
= create_rpc_blob(str
, sizeof(uint32
));
547 SIVAL(str
->buffer
, 0, val
);
550 /*******************************************************************
551 Inits a RPC_DATA_BLOB structure.
552 ********************************************************************/
554 void init_rpc_blob_str(RPC_DATA_BLOB
*str
, const char *buf
, int len
)
558 /* set up string lengths. */
559 str
->buf_len
= create_rpc_blob(str
, len
*2);
560 rpcstr_push(str
->buffer
, buf
, (size_t)str
->buf_len
, STR_TERMINATE
);
564 /*******************************************************************
565 Inits a RPC_DATA_BLOB structure from a hex string.
566 ********************************************************************/
568 void init_rpc_blob_hex(RPC_DATA_BLOB
*str
, const char *buf
)
571 str
->buf_len
= create_rpc_blob(str
, strlen(buf
));
572 str
->buf_len
= strhex_to_str((char *)str
->buffer
, str
->buf_len
, buf
);
575 /*******************************************************************
576 Inits a RPC_DATA_BLOB structure.
577 ********************************************************************/
579 void init_rpc_blob_bytes(RPC_DATA_BLOB
*str
, uint8
*buf
, size_t len
)
583 /* max buffer size (allocated size) */
585 len
= create_rpc_blob(str
, len
);
586 memcpy(str
->buffer
, buf
, len
);
591 /*******************************************************************
592 reads or writes a BUFFER5 structure.
593 the buf_len member tells you how large the buffer is.
594 ********************************************************************/
595 BOOL
smb_io_buffer5(const char *desc
, BUFFER5
*buf5
, prs_struct
*ps
, int depth
)
597 prs_debug(ps
, depth
, desc
, "smb_io_buffer5");
600 if (buf5
== NULL
) return False
;
604 if(!prs_uint32("buf_len", ps
, depth
, &buf5
->buf_len
))
608 if(!prs_buffer5(True
, "buffer" , ps
, depth
, buf5
))
615 /*******************************************************************
616 Inits a REGVAL_BUFFER structure.
617 ********************************************************************/
619 void init_regval_buffer(REGVAL_BUFFER
*str
, const uint8
*buf
, size_t len
)
623 /* max buffer size (allocated size) */
624 str
->buf_max_len
= len
;
626 str
->buf_len
= buf
!= NULL
? len
: 0;
629 SMB_ASSERT(str
->buf_max_len
>= str
->buf_len
);
630 str
->buffer
= (uint16
*)TALLOC_ZERO(get_talloc_ctx(),
632 if (str
->buffer
== NULL
)
633 smb_panic("init_regval_buffer: talloc fail\n");
634 memcpy(str
->buffer
, buf
, str
->buf_len
);
638 /*******************************************************************
639 Reads or writes a REGVAL_BUFFER structure.
640 the uni_max_len member tells you how large the buffer is.
641 the uni_str_len member tells you how much of the buffer is really used.
642 ********************************************************************/
644 BOOL
smb_io_regval_buffer(const char *desc
, prs_struct
*ps
, int depth
, REGVAL_BUFFER
*buf2
)
647 prs_debug(ps
, depth
, desc
, "smb_io_regval_buffer");
653 if(!prs_uint32("buf_max_len", ps
, depth
, &buf2
->buf_max_len
))
655 if(!prs_uint32("offset ", ps
, depth
, &buf2
->offset
))
657 if(!prs_uint32("buf_len ", ps
, depth
, &buf2
->buf_len
))
660 /* buffer advanced by indicated length of string
661 NOT by searching for null-termination */
663 if(!prs_regval_buffer(True
, "buffer ", ps
, depth
, buf2
))
669 /*******************************************************************
670 creates a UNISTR2 structure: sets up the buffer, too
671 ********************************************************************/
673 void init_buf_unistr2(UNISTR2
*str
, uint32
*ptr
, const char *buf
)
677 init_unistr2(str
, buf
, UNI_STR_TERMINATE
);
680 init_unistr2(str
, NULL
, UNI_FLAGS_NONE
);
685 /*******************************************************************
686 Copies a UNISTR2 structure.
687 ********************************************************************/
689 void copy_unistr2(UNISTR2
*str
, const UNISTR2
*from
)
691 if (from
->buffer
== NULL
) {
696 SMB_ASSERT(from
->uni_max_len
>= from
->uni_str_len
);
698 str
->uni_max_len
= from
->uni_max_len
;
699 str
->offset
= from
->offset
;
700 str
->uni_str_len
= from
->uni_str_len
;
702 /* the string buffer is allocated to the maximum size
703 (the the length of the source string) to prevent
704 reallocation of memory. */
705 if (str
->buffer
== NULL
) {
706 str
->buffer
= (uint16
*)TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16
, str
->uni_max_len
);
707 if ((str
->buffer
== NULL
)) {
708 smb_panic("copy_unistr2: talloc fail\n");
713 /* copy the string */
714 memcpy(str
->buffer
, from
->buffer
, str
->uni_max_len
*sizeof(uint16
));
717 /*******************************************************************
718 Creates a STRING2 structure.
719 ********************************************************************/
721 void init_string2(STRING2
*str
, const char *buf
, size_t max_len
, size_t str_len
)
723 /* set up string lengths. */
724 SMB_ASSERT(max_len
>= str_len
);
726 /* Ensure buf is valid if str_len was set. Coverity check. */
727 if (str_len
&& !buf
) {
731 str
->str_max_len
= max_len
;
733 str
->str_str_len
= str_len
;
735 /* store the string */
737 str
->buffer
= (uint8
*)TALLOC_ZERO(get_talloc_ctx(),
739 if (str
->buffer
== NULL
)
740 smb_panic("init_string2: malloc fail\n");
741 memcpy(str
->buffer
, buf
, str_len
);
745 /*******************************************************************
746 Reads or writes a STRING2 structure.
747 XXXX NOTE: STRING2 structures need NOT be null-terminated.
748 the str_str_len member tells you how long the string is;
749 the str_max_len member tells you how large the buffer is.
750 ********************************************************************/
752 BOOL
smb_io_string2(const char *desc
, STRING2
*str2
, uint32 buffer
, prs_struct
*ps
, int depth
)
759 prs_debug(ps
, depth
, desc
, "smb_io_string2");
765 if(!prs_uint32("str_max_len", ps
, depth
, &str2
->str_max_len
))
767 if(!prs_uint32("offset ", ps
, depth
, &str2
->offset
))
769 if(!prs_uint32("str_str_len", ps
, depth
, &str2
->str_str_len
))
772 /* buffer advanced by indicated length of string
773 NOT by searching for null-termination */
774 if(!prs_string2(True
, "buffer ", ps
, depth
, str2
))
779 prs_debug(ps
, depth
, desc
, "smb_io_string2 - NULL");
781 memset((char *)str2
, '\0', sizeof(*str2
));
788 /*******************************************************************
789 Inits a UNISTR2 structure.
790 ********************************************************************/
792 void init_unistr2(UNISTR2
*str
, const char *buf
, enum unistr2_term_codes flags
)
795 uint32 num_chars
= 0;
798 /* We always null terminate the copy. */
799 len
= strlen(buf
) + 1;
800 if ( flags
== UNI_STR_DBLTERMINATE
)
803 /* no buffer -- nothing to do */
804 str
->uni_max_len
= 0;
806 str
->uni_str_len
= 0;
812 str
->buffer
= TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16
, len
);
813 if (str
->buffer
== NULL
) {
814 smb_panic("init_unistr2: malloc fail\n");
818 /* Ensure len is the length in *bytes* */
819 len
*= sizeof(uint16
);
822 * The UNISTR2 must be initialized !!!
826 rpcstr_push((char *)str
->buffer
, buf
, len
, STR_TERMINATE
);
827 num_chars
= strlen_w(str
->buffer
);
828 if (flags
== UNI_STR_TERMINATE
|| flags
== UNI_MAXLEN_TERMINATE
) {
831 if ( flags
== UNI_STR_DBLTERMINATE
)
835 str
->uni_max_len
= num_chars
;
837 str
->uni_str_len
= num_chars
;
838 if ( num_chars
&& ((flags
== UNI_MAXLEN_TERMINATE
) || (flags
== UNI_BROKEN_NON_NULL
)) )
842 /*******************************************************************
843 Inits a UNISTR4 structure.
844 ********************************************************************/
846 void init_unistr4(UNISTR4
*uni4
, const char *buf
, enum unistr2_term_codes flags
)
848 uni4
->string
= TALLOC_P( get_talloc_ctx(), UNISTR2
);
850 smb_panic("init_unistr4: talloc fail\n");
853 init_unistr2( uni4
->string
, buf
, flags
);
855 uni4
->length
= 2 * (uni4
->string
->uni_str_len
);
856 uni4
->size
= 2 * (uni4
->string
->uni_max_len
);
859 void init_unistr4_w( TALLOC_CTX
*ctx
, UNISTR4
*uni4
, const smb_ucs2_t
*buf
)
861 uni4
->string
= TALLOC_P( ctx
, UNISTR2
);
863 smb_panic("init_unistr4_w: talloc fail\n");
866 init_unistr2_w( ctx
, uni4
->string
, buf
);
868 uni4
->length
= 2 * (uni4
->string
->uni_str_len
);
869 uni4
->size
= 2 * (uni4
->string
->uni_max_len
);
873 * Inits a UNISTR2 structure.
874 * @param ctx talloc context to allocate string on
875 * @param str pointer to string to create
876 * @param buf UCS2 null-terminated buffer to init from
879 void init_unistr2_w(TALLOC_CTX
*ctx
, UNISTR2
*str
, const smb_ucs2_t
*buf
)
881 uint32 len
= buf
? strlen_w(buf
) : 0;
885 /* set up string lengths. */
886 str
->uni_max_len
= len
;
888 str
->uni_str_len
= len
;
890 str
->buffer
= TALLOC_ZERO_ARRAY(ctx
, uint16
, len
+ 1);
891 if (str
->buffer
== NULL
) {
892 smb_panic("init_unistr2_w: talloc fail\n");
897 * don't move this test above ! The UNISTR2 must be initialized !!!
903 /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
904 long as the buffer above is talloc()ed correctly then this
905 is the correct thing to do */
906 strncpy_w(str
->buffer
, buf
, len
+ 1);
909 /*******************************************************************
910 Inits a UNISTR2 structure from a UNISTR
911 ********************************************************************/
913 void init_unistr2_from_unistr(UNISTR2
*to
, const UNISTR
*from
)
917 /* the destination UNISTR2 should never be NULL.
918 if it is it is a programming error */
920 /* if the source UNISTR is NULL, then zero out
921 the destination string and return */
923 if ((from
== NULL
) || (from
->buffer
== NULL
))
926 /* get the length; UNISTR must be NULL terminated */
928 while ((from
->buffer
)[i
]!='\0')
930 i
++; /* one more to catch the terminating NULL */
931 /* is this necessary -- jerry? I need to think */
933 /* set up string lengths; uni_max_len is set to i+1
934 because we need to account for the final NULL termination */
939 /* allocate the space and copy the string buffer */
940 to
->buffer
= TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16
, i
);
941 if (to
->buffer
== NULL
)
942 smb_panic("init_unistr2_from_unistr: malloc fail\n");
943 memcpy(to
->buffer
, from
->buffer
, i
*sizeof(uint16
));
947 /*******************************************************************
948 Inits a UNISTR2 structure from a DATA_BLOB.
949 The length of the data_blob must count the bytes of the buffer.
950 Copies the blob data.
951 ********************************************************************/
953 void init_unistr2_from_datablob(UNISTR2
*str
, DATA_BLOB
*blob
)
955 /* Allocs the unistring */
956 init_unistr2(str
, NULL
, UNI_FLAGS_NONE
);
958 /* Sets the values */
959 str
->uni_str_len
= blob
->length
/ sizeof(uint16
);
960 str
->uni_max_len
= str
->uni_str_len
;
963 str
->buffer
= (uint16
*) memdup(blob
->data
, blob
->length
);
967 if ((str
->buffer
== NULL
) && (blob
->length
> 0)) {
968 smb_panic("init_unistr2_from_datablob: malloc fail\n");
972 /*******************************************************************
973 UNISTR2* are a little different in that the pointer and the UNISTR2
974 are not necessarily read/written back to back. So we break it up
975 into 2 separate functions.
976 See SPOOL_USER_1 in include/rpc_spoolss.h for an example.
977 ********************************************************************/
979 BOOL
prs_io_unistr2_p(const char *desc
, prs_struct
*ps
, int depth
, UNISTR2
**uni2
)
983 /* caputure the pointer value to stream */
985 data_p
= *uni2
? 0xf000baaa : 0;
987 if ( !prs_uint32("ptr", ps
, depth
, &data_p
))
990 /* we're done if there is no data */
995 if (UNMARSHALLING(ps
)) {
996 if ( !(*uni2
= PRS_ALLOC_MEM(ps
, UNISTR2
, 1)) )
1003 /*******************************************************************
1004 now read/write the actual UNISTR2. Memory for the UNISTR2 (but
1005 not UNISTR2.buffer) has been allocated previously by prs_unistr2_p()
1006 ********************************************************************/
1008 BOOL
prs_io_unistr2(const char *desc
, prs_struct
*ps
, int depth
, UNISTR2
*uni2
)
1010 /* just return true if there is no pointer to deal with.
1011 the memory must have been previously allocated on unmarshalling
1012 by prs_unistr2_p() */
1017 /* just pass off to smb_io_unstr2() passing the uni2 address as
1018 the pointer (like you would expect) */
1020 return smb_io_unistr2( desc
, uni2
, uni2
? 1 : 0, ps
, depth
);
1023 /*******************************************************************
1024 Reads or writes a UNISTR2 structure.
1025 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
1026 the uni_str_len member tells you how long the string is;
1027 the uni_max_len member tells you how large the buffer is.
1028 ********************************************************************/
1030 BOOL
smb_io_unistr2(const char *desc
, UNISTR2
*uni2
, uint32 buffer
, prs_struct
*ps
, int depth
)
1037 prs_debug(ps
, depth
, desc
, "smb_io_unistr2");
1043 if(!prs_uint32("uni_max_len", ps
, depth
, &uni2
->uni_max_len
))
1045 if(!prs_uint32("offset ", ps
, depth
, &uni2
->offset
))
1047 if(!prs_uint32("uni_str_len", ps
, depth
, &uni2
->uni_str_len
))
1050 /* buffer advanced by indicated length of string
1051 NOT by searching for null-termination */
1052 if(!prs_unistr2(True
, "buffer ", ps
, depth
, uni2
))
1057 prs_debug(ps
, depth
, desc
, "smb_io_unistr2 - NULL");
1059 memset((char *)uni2
, '\0', sizeof(*uni2
));
1066 /*******************************************************************
1067 now read/write UNISTR4
1068 ********************************************************************/
1070 BOOL
prs_unistr4(const char *desc
, prs_struct
*ps
, int depth
, UNISTR4
*uni4
)
1073 prs_debug(ps
, depth
, desc
, "prs_unistr4");
1076 if ( !prs_uint16("length", ps
, depth
, &uni4
->length
))
1078 if ( !prs_uint16("size", ps
, depth
, &uni4
->size
))
1083 if ( !prs_pointer( desc
, ps
, depth
, &ptr
, sizeof(UNISTR2
), (PRS_POINTER_CAST
)prs_io_unistr2
) )
1086 uni4
->string
= (UNISTR2
*)ptr
;
1091 /*******************************************************************
1092 now read/write UNISTR4 header
1093 ********************************************************************/
1095 BOOL
prs_unistr4_hdr(const char *desc
, prs_struct
*ps
, int depth
, UNISTR4
*uni4
)
1097 prs_debug(ps
, depth
, desc
, "prs_unistr4_hdr");
1100 if ( !prs_uint16("length", ps
, depth
, &uni4
->length
) )
1102 if ( !prs_uint16("size", ps
, depth
, &uni4
->size
) )
1104 if ( !prs_io_unistr2_p(desc
, ps
, depth
, &uni4
->string
) )
1110 /*******************************************************************
1111 now read/write UNISTR4 string
1112 ********************************************************************/
1114 BOOL
prs_unistr4_str(const char *desc
, prs_struct
*ps
, int depth
, UNISTR4
*uni4
)
1116 prs_debug(ps
, depth
, desc
, "prs_unistr4_str");
1119 if ( !prs_io_unistr2(desc
, ps
, depth
, uni4
->string
) )
1125 /*******************************************************************
1126 Reads or writes a UNISTR4_ARRAY structure.
1127 ********************************************************************/
1129 BOOL
prs_unistr4_array(const char *desc
, prs_struct
*ps
, int depth
, UNISTR4_ARRAY
*array
)
1133 prs_debug(ps
, depth
, desc
, "prs_unistr4_array");
1136 if(!prs_uint32("count", ps
, depth
, &array
->count
))
1139 if ( array
->count
== 0 )
1142 if (UNMARSHALLING(ps
)) {
1143 if ( !(array
->strings
= TALLOC_ZERO_ARRAY( get_talloc_ctx(), UNISTR4
, array
->count
)) )
1147 /* write the headers and then the actual string buffer */
1149 for ( i
=0; i
<array
->count
; i
++ ) {
1150 if ( !prs_unistr4_hdr( "string", ps
, depth
, &array
->strings
[i
]) )
1154 for (i
=0;i
<array
->count
;i
++) {
1155 if ( !prs_unistr4_str("string", ps
, depth
, &array
->strings
[i
]) )
1162 /********************************************************************
1163 initialise a UNISTR_ARRAY from a char**
1164 ********************************************************************/
1166 BOOL
init_unistr4_array( UNISTR4_ARRAY
*array
, uint32 count
, const char **strings
)
1170 array
->count
= count
;
1172 if ( array
->count
== 0 )
1175 /* allocate memory for the array of UNISTR4 objects */
1177 if ( !(array
->strings
= TALLOC_ZERO_ARRAY(get_talloc_ctx(), UNISTR4
, count
)) )
1180 for ( i
=0; i
<count
; i
++ )
1181 init_unistr4( &array
->strings
[i
], strings
[i
], UNI_STR_TERMINATE
);
1186 BOOL
smb_io_lockout_string_hdr(const char *desc
, HDR_LOCKOUT_STRING
*hdr_account_lockout
, prs_struct
*ps
, int depth
)
1188 prs_debug(ps
, depth
, desc
, "smb_io_lockout_string_hdr");
1194 if(!prs_uint16("size", ps
, depth
, &hdr_account_lockout
->size
))
1196 if(!prs_uint16("length", ps
, depth
, &hdr_account_lockout
->length
))
1198 if(!prs_uint32("buffer", ps
, depth
, &hdr_account_lockout
->buffer
))
1204 BOOL
smb_io_account_lockout_str(const char *desc
, LOCKOUT_STRING
*account_lockout
, uint32 buffer
, prs_struct
*ps
, int depth
)
1206 prs_debug(ps
, depth
, desc
, "smb_io_account_lockout_string");
1209 if(!prs_uint32("array_size", ps
, depth
, &account_lockout
->array_size
))
1212 if(!prs_uint32("offset", ps
, depth
, &account_lockout
->offset
))
1214 if(!prs_uint32("length", ps
, depth
, &account_lockout
->length
))
1217 if (!prs_uint64("lockout_duration", ps
, depth
, &account_lockout
->lockout_duration
))
1219 if (!prs_uint64("reset_count", ps
, depth
, &account_lockout
->reset_count
))
1221 if (!prs_uint32("bad_attempt_lockout", ps
, depth
, &account_lockout
->bad_attempt_lockout
))
1223 if (!prs_uint32("dummy", ps
, depth
, &account_lockout
->dummy
))
1226 if(!prs_uint16s (False
, "bindata", ps
, depth
, &account_lockout
->bindata
, length
))
1233 /*******************************************************************
1234 Inits a DOM_RID structure.
1235 ********************************************************************/
1237 void init_dom_rid(DOM_RID
*prid
, uint32 rid
, uint16 type
, uint32 idx
)
1241 prid
->rid_idx
= idx
;
1244 /*******************************************************************
1245 Reads or writes a DOM_RID structure.
1246 ********************************************************************/
1248 BOOL
smb_io_dom_rid(const char *desc
, DOM_RID
*rid
, prs_struct
*ps
, int depth
)
1253 prs_debug(ps
, depth
, desc
, "smb_io_dom_rid");
1259 if(!prs_uint16("type ", ps
, depth
, &rid
->type
))
1263 if(!prs_uint32("rid ", ps
, depth
, &rid
->rid
))
1265 if(!prs_uint32("rid_idx", ps
, depth
, &rid
->rid_idx
))
1271 /*******************************************************************
1272 Reads or writes a DOM_RID2 structure.
1273 ********************************************************************/
1275 BOOL
smb_io_dom_rid2(const char *desc
, DOM_RID2
*rid
, prs_struct
*ps
, int depth
)
1280 prs_debug(ps
, depth
, desc
, "smb_io_dom_rid2");
1286 if(!prs_uint16("type ", ps
, depth
, &rid
->type
))
1290 if(!prs_uint32("rid ", ps
, depth
, &rid
->rid
))
1292 if(!prs_uint32("rid_idx", ps
, depth
, &rid
->rid_idx
))
1294 if(!prs_uint32("unknown", ps
, depth
, &rid
->unknown
))
1301 /*******************************************************************
1302 creates a DOM_RID3 structure.
1303 ********************************************************************/
1305 void init_dom_rid3(DOM_RID3
*rid3
, uint32 rid
, uint8 type
)
1309 rid3
->ptr_type
= 0x1; /* non-zero, basically. */
1314 /*******************************************************************
1315 reads or writes a DOM_RID3 structure.
1316 ********************************************************************/
1318 BOOL
smb_io_dom_rid3(const char *desc
, DOM_RID3
*rid3
, prs_struct
*ps
, int depth
)
1323 prs_debug(ps
, depth
, desc
, "smb_io_dom_rid3");
1329 if(!prs_uint32("rid ", ps
, depth
, &rid3
->rid
))
1331 if(!prs_uint32("type1 ", ps
, depth
, &rid3
->type1
))
1333 if(!prs_uint32("ptr_type", ps
, depth
, &rid3
->ptr_type
))
1335 if(!prs_uint32("type2 ", ps
, depth
, &rid3
->type2
))
1337 if(!prs_uint32("unk ", ps
, depth
, &rid3
->unk
))
1343 /*******************************************************************
1344 Inits a DOM_RID4 structure.
1345 ********************************************************************/
1347 void init_dom_rid4(DOM_RID4
*rid4
, uint16 unknown
, uint16 attr
, uint32 rid
)
1349 rid4
->unknown
= unknown
;
1354 /*******************************************************************
1355 Inits a DOM_CLNT_SRV structure.
1356 ********************************************************************/
1358 static void init_clnt_srv(DOM_CLNT_SRV
*logcln
, const char *logon_srv
, const char *comp_name
)
1360 DEBUG(5,("init_clnt_srv: %d\n", __LINE__
));
1362 if (logon_srv
!= NULL
) {
1363 logcln
->undoc_buffer
= 1;
1364 init_unistr2(&logcln
->uni_logon_srv
, logon_srv
, UNI_STR_TERMINATE
);
1366 logcln
->undoc_buffer
= 0;
1369 if (comp_name
!= NULL
) {
1370 logcln
->undoc_buffer2
= 1;
1371 init_unistr2(&logcln
->uni_comp_name
, comp_name
, UNI_STR_TERMINATE
);
1373 logcln
->undoc_buffer2
= 0;
1377 /*******************************************************************
1378 Inits or writes a DOM_CLNT_SRV structure.
1379 ********************************************************************/
1381 BOOL
smb_io_clnt_srv(const char *desc
, DOM_CLNT_SRV
*logcln
, prs_struct
*ps
, int depth
)
1386 prs_debug(ps
, depth
, desc
, "smb_io_clnt_srv");
1392 if(!prs_uint32("undoc_buffer ", ps
, depth
, &logcln
->undoc_buffer
))
1395 if (logcln
->undoc_buffer
!= 0) {
1396 if(!smb_io_unistr2("unistr2", &logcln
->uni_logon_srv
, logcln
->undoc_buffer
, ps
, depth
))
1403 if(!prs_uint32("undoc_buffer2", ps
, depth
, &logcln
->undoc_buffer2
))
1406 if (logcln
->undoc_buffer2
!= 0) {
1407 if(!smb_io_unistr2("unistr2", &logcln
->uni_comp_name
, logcln
->undoc_buffer2
, ps
, depth
))
1414 /*******************************************************************
1415 Inits a DOM_LOG_INFO structure.
1416 ********************************************************************/
1418 void init_log_info(DOM_LOG_INFO
*loginfo
, const char *logon_srv
, const char *acct_name
,
1419 uint16 sec_chan
, const char *comp_name
)
1421 DEBUG(5,("make_log_info %d\n", __LINE__
));
1423 loginfo
->undoc_buffer
= 1;
1425 init_unistr2(&loginfo
->uni_logon_srv
, logon_srv
, UNI_STR_TERMINATE
);
1426 init_unistr2(&loginfo
->uni_acct_name
, acct_name
, UNI_STR_TERMINATE
);
1428 loginfo
->sec_chan
= sec_chan
;
1430 init_unistr2(&loginfo
->uni_comp_name
, comp_name
, UNI_STR_TERMINATE
);
1433 /*******************************************************************
1434 Reads or writes a DOM_LOG_INFO structure.
1435 ********************************************************************/
1437 BOOL
smb_io_log_info(const char *desc
, DOM_LOG_INFO
*loginfo
, prs_struct
*ps
, int depth
)
1439 if (loginfo
== NULL
)
1442 prs_debug(ps
, depth
, desc
, "smb_io_log_info");
1448 if(!prs_uint32("undoc_buffer", ps
, depth
, &loginfo
->undoc_buffer
))
1451 if(!smb_io_unistr2("unistr2", &loginfo
->uni_logon_srv
, True
, ps
, depth
))
1453 if(!smb_io_unistr2("unistr2", &loginfo
->uni_acct_name
, True
, ps
, depth
))
1456 if(!prs_uint16("sec_chan", ps
, depth
, &loginfo
->sec_chan
))
1459 if(!smb_io_unistr2("unistr2", &loginfo
->uni_comp_name
, True
, ps
, depth
))
1465 /*******************************************************************
1466 Reads or writes a DOM_CHAL structure.
1467 ********************************************************************/
1469 BOOL
smb_io_chal(const char *desc
, DOM_CHAL
*chal
, prs_struct
*ps
, int depth
)
1474 prs_debug(ps
, depth
, desc
, "smb_io_chal");
1477 if(!prs_uint8s (False
, "data", ps
, depth
, chal
->data
, 8))
1483 /*******************************************************************
1484 Reads or writes a DOM_CRED structure.
1485 ********************************************************************/
1487 BOOL
smb_io_cred(const char *desc
, DOM_CRED
*cred
, prs_struct
*ps
, int depth
)
1492 prs_debug(ps
, depth
, desc
, "smb_io_cred");
1498 if(!smb_io_chal ("", &cred
->challenge
, ps
, depth
))
1501 if(!smb_io_utime("", &cred
->timestamp
, ps
, depth
))
1507 /*******************************************************************
1508 Inits a DOM_CLNT_INFO2 structure.
1509 ********************************************************************/
1511 void init_clnt_info2(DOM_CLNT_INFO2
*clnt
,
1512 const char *logon_srv
, const char *comp_name
,
1513 const DOM_CRED
*clnt_cred
)
1515 DEBUG(5,("make_clnt_info: %d\n", __LINE__
));
1517 init_clnt_srv(&clnt
->login
, logon_srv
, comp_name
);
1519 if (clnt_cred
!= NULL
) {
1521 memcpy(&clnt
->cred
, clnt_cred
, sizeof(clnt
->cred
));
1527 /*******************************************************************
1528 Reads or writes a DOM_CLNT_INFO2 structure.
1529 ********************************************************************/
1531 BOOL
smb_io_clnt_info2(const char *desc
, DOM_CLNT_INFO2
*clnt
, prs_struct
*ps
, int depth
)
1536 prs_debug(ps
, depth
, desc
, "smb_io_clnt_info2");
1542 if(!smb_io_clnt_srv("", &clnt
->login
, ps
, depth
))
1548 if(!prs_uint32("ptr_cred", ps
, depth
, &clnt
->ptr_cred
))
1550 if(!smb_io_cred("", &clnt
->cred
, ps
, depth
))
1556 /*******************************************************************
1557 Inits a DOM_CLNT_INFO structure.
1558 ********************************************************************/
1560 void init_clnt_info(DOM_CLNT_INFO
*clnt
,
1561 const char *logon_srv
, const char *acct_name
,
1562 uint16 sec_chan
, const char *comp_name
,
1563 const DOM_CRED
*cred
)
1565 DEBUG(5,("make_clnt_info\n"));
1567 init_log_info(&clnt
->login
, logon_srv
, acct_name
, sec_chan
, comp_name
);
1568 memcpy(&clnt
->cred
, cred
, sizeof(clnt
->cred
));
1571 /*******************************************************************
1572 Reads or writes a DOM_CLNT_INFO structure.
1573 ********************************************************************/
1575 BOOL
smb_io_clnt_info(const char *desc
, DOM_CLNT_INFO
*clnt
, prs_struct
*ps
, int depth
)
1580 prs_debug(ps
, depth
, desc
, "smb_io_clnt_info");
1586 if(!smb_io_log_info("", &clnt
->login
, ps
, depth
))
1588 if(!smb_io_cred("", &clnt
->cred
, ps
, depth
))
1594 /*******************************************************************
1595 Inits a DOM_LOGON_ID structure.
1596 ********************************************************************/
1598 void init_logon_id(DOM_LOGON_ID
*logonid
, uint32 log_id_low
, uint32 log_id_high
)
1600 DEBUG(5,("make_logon_id: %d\n", __LINE__
));
1602 logonid
->low
= log_id_low
;
1603 logonid
->high
= log_id_high
;
1606 /*******************************************************************
1607 Reads or writes a DOM_LOGON_ID structure.
1608 ********************************************************************/
1610 BOOL
smb_io_logon_id(const char *desc
, DOM_LOGON_ID
*logonid
, prs_struct
*ps
, int depth
)
1612 if (logonid
== NULL
)
1615 prs_debug(ps
, depth
, desc
, "smb_io_logon_id");
1621 if(!prs_uint32("low ", ps
, depth
, &logonid
->low
))
1623 if(!prs_uint32("high", ps
, depth
, &logonid
->high
))
1629 /*******************************************************************
1630 Inits an OWF_INFO structure.
1631 ********************************************************************/
1633 void init_owf_info(OWF_INFO
*hash
, const uint8 data
[16])
1635 DEBUG(5,("init_owf_info: %d\n", __LINE__
));
1638 memcpy(hash
->data
, data
, sizeof(hash
->data
));
1640 memset((char *)hash
->data
, '\0', sizeof(hash
->data
));
1643 /*******************************************************************
1644 Reads or writes an OWF_INFO structure.
1645 ********************************************************************/
1647 BOOL
smb_io_owf_info(const char *desc
, OWF_INFO
*hash
, prs_struct
*ps
, int depth
)
1652 prs_debug(ps
, depth
, desc
, "smb_io_owf_info");
1658 if(!prs_uint8s (False
, "data", ps
, depth
, hash
->data
, 16))
1664 /*******************************************************************
1665 Reads or writes a DOM_GID structure.
1666 ********************************************************************/
1668 BOOL
smb_io_gid(const char *desc
, DOM_GID
*gid
, prs_struct
*ps
, int depth
)
1673 prs_debug(ps
, depth
, desc
, "smb_io_gid");
1679 if(!prs_uint32("g_rid", ps
, depth
, &gid
->g_rid
))
1681 if(!prs_uint32("attr ", ps
, depth
, &gid
->attr
))
1687 /*******************************************************************
1688 Reads or writes an POLICY_HND structure.
1689 ********************************************************************/
1691 BOOL
smb_io_pol_hnd(const char *desc
, POLICY_HND
*pol
, prs_struct
*ps
, int depth
)
1696 prs_debug(ps
, depth
, desc
, "smb_io_pol_hnd");
1702 if(UNMARSHALLING(ps
))
1705 if (!prs_uint32("handle_type", ps
, depth
, &pol
->handle_type
))
1707 if (!smb_io_uuid("uuid", (struct GUID
*)&pol
->uuid
, ps
, depth
))
1713 /*******************************************************************
1715 ********************************************************************/
1717 void init_unistr3(UNISTR3
*str
, const char *buf
)
1721 str
->str
.buffer
= NULL
;
1725 str
->uni_str_len
= strlen(buf
) + 1;
1727 str
->str
.buffer
= TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16
, str
->uni_str_len
);
1728 if (str
->str
.buffer
== NULL
)
1729 smb_panic("init_unistr3: malloc fail\n");
1731 rpcstr_push((char *)str
->str
.buffer
, buf
, str
->uni_str_len
* sizeof(uint16
), STR_TERMINATE
);
1734 /*******************************************************************
1735 Reads or writes a UNISTR3 structure.
1736 ********************************************************************/
1738 BOOL
smb_io_unistr3(const char *desc
, UNISTR3
*name
, prs_struct
*ps
, int depth
)
1743 prs_debug(ps
, depth
, desc
, "smb_io_unistr3");
1749 if(!prs_uint32("uni_str_len", ps
, depth
, &name
->uni_str_len
))
1752 /* we're done if there is no string */
1754 if ( name
->uni_str_len
== 0 )
1757 /* don't know if len is specified by uni_str_len member... */
1758 /* assume unicode string is unicode-null-terminated, instead */
1760 if(!prs_unistr3(True
, "unistr", name
, ps
, depth
))
1766 /*******************************************************************
1767 Stream a uint64_struct
1768 ********************************************************************/
1769 BOOL
prs_uint64(const char *name
, prs_struct
*ps
, int depth
, uint64
*data64
)
1771 if (UNMARSHALLING(ps
)) {
1774 if (!prs_uint32(name
, ps
, depth
+1, &low
))
1777 if (!prs_uint32(name
, ps
, depth
+1, &high
))
1780 *data64
= ((uint64_t)high
<< 32) + low
;
1784 uint32 high
= (*data64
) >> 32, low
= (*data64
) & 0xFFFFFFFF;
1785 return prs_uint32(name
, ps
, depth
+1, &low
) &&
1786 prs_uint32(name
, ps
, depth
+1, &high
);
1790 /*******************************************************************
1791 reads or writes a BUFHDR2 structure.
1792 ********************************************************************/
1793 BOOL
smb_io_bufhdr2(const char *desc
, BUFHDR2
*hdr
, prs_struct
*ps
, int depth
)
1795 prs_debug(ps
, depth
, desc
, "smb_io_bufhdr2");
1799 prs_uint32("info_level", ps
, depth
, &(hdr
->info_level
));
1800 prs_uint32("length ", ps
, depth
, &(hdr
->length
));
1801 prs_uint32("buffer ", ps
, depth
, &(hdr
->buffer
));
1806 /*******************************************************************
1807 reads or writes a BUFHDR4 structure.
1808 ********************************************************************/
1809 BOOL
smb_io_bufhdr4(const char *desc
, BUFHDR4
*hdr
, prs_struct
*ps
, int depth
)
1811 prs_debug(ps
, depth
, desc
, "smb_io_bufhdr4");
1815 prs_uint32("size", ps
, depth
, &hdr
->size
);
1816 prs_uint32("buffer", ps
, depth
, &hdr
->buffer
);
1821 /*******************************************************************
1822 reads or writes a RPC_DATA_BLOB structure.
1823 ********************************************************************/
1825 BOOL
smb_io_rpc_blob(const char *desc
, RPC_DATA_BLOB
*blob
, prs_struct
*ps
, int depth
)
1827 prs_debug(ps
, depth
, desc
, "smb_io_rpc_blob");
1831 if ( !prs_uint32("buf_len", ps
, depth
, &blob
->buf_len
) )
1834 if ( blob
->buf_len
== 0 )
1837 if (UNMARSHALLING(ps
)) {
1838 blob
->buffer
= PRS_ALLOC_MEM(ps
, uint8
, blob
->buf_len
);
1839 if (!blob
->buffer
) {
1844 if ( !prs_uint8s(True
, "buffer", ps
, depth
, blob
->buffer
, blob
->buf_len
) )
1850 /*******************************************************************
1851 creates a UNIHDR structure.
1852 ********************************************************************/
1854 BOOL
make_uni_hdr(UNIHDR
*hdr
, int len
)
1860 hdr
->uni_str_len
= 2 * len
;
1861 hdr
->uni_max_len
= 2 * len
;
1862 hdr
->buffer
= len
!= 0 ? 1 : 0;
1867 /*******************************************************************
1868 creates a BUFHDR2 structure.
1869 ********************************************************************/
1870 BOOL
make_bufhdr2(BUFHDR2
*hdr
, uint32 info_level
, uint32 length
, uint32 buffer
)
1872 hdr
->info_level
= info_level
;
1873 hdr
->length
= length
;
1874 hdr
->buffer
= buffer
;
1879 /*******************************************************************
1880 return the length of a UNISTR string.
1881 ********************************************************************/
1883 uint32
str_len_uni(UNISTR
*source
)
1887 if (!source
->buffer
)
1890 while (source
->buffer
[i
])