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.
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 2 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, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #define DBGC_CLASS DBGC_RPC_PARSE
28 /****************************************************************************
29 A temporary TALLOC context for things like unistrs, that is valid for
30 the life of a complete RPC call.
31 ****************************************************************************/
33 static TALLOC_CTX
*current_rpc_talloc
= NULL
;
35 static TALLOC_CTX
*get_current_rpc_talloc(void)
37 return current_rpc_talloc
;
40 void set_current_rpc_talloc( TALLOC_CTX
*ctx
)
42 current_rpc_talloc
= ctx
;
45 static TALLOC_CTX
*main_loop_talloc
= NULL
;
47 /*******************************************************************
48 free up temporary memory - called from the main loop
49 ********************************************************************/
51 void main_loop_talloc_free(void)
53 if (!main_loop_talloc
)
55 talloc_destroy(main_loop_talloc
);
56 main_loop_talloc
= NULL
;
59 /*******************************************************************
60 Get a talloc context that is freed in the main loop...
61 ********************************************************************/
63 TALLOC_CTX
*main_loop_talloc_get(void)
65 if (!main_loop_talloc
) {
66 main_loop_talloc
= talloc_init("main loop talloc (mainly parse_misc)");
67 if (!main_loop_talloc
)
68 smb_panic("main_loop_talloc: malloc fail\n");
71 return main_loop_talloc
;
74 /*******************************************************************
75 Try and get a talloc context. Get the rpc one if possible, else
76 get the main loop one. The main loop one is more dangerous as it
77 goes away between packets, the rpc one will stay around for as long
78 as a current RPC lasts.
79 ********************************************************************/
81 TALLOC_CTX
*get_talloc_ctx(void)
83 TALLOC_CTX
*tc
= get_current_rpc_talloc();
87 return main_loop_talloc_get();
90 /*******************************************************************
91 Reads or writes a UTIME type.
92 ********************************************************************/
94 static BOOL
smb_io_utime(const char *desc
, UTIME
*t
, prs_struct
*ps
, int depth
)
99 prs_debug(ps
, depth
, desc
, "smb_io_utime");
105 if(!prs_uint32 ("time", ps
, depth
, &t
->time
))
111 /*******************************************************************
112 Reads or writes an NTTIME structure.
113 ********************************************************************/
115 BOOL
smb_io_time(const char *desc
, NTTIME
*nttime
, prs_struct
*ps
, int depth
)
120 prs_debug(ps
, depth
, desc
, "smb_io_time");
126 if(!prs_uint32("low ", ps
, depth
, &nttime
->low
)) /* low part */
128 if(!prs_uint32("high", ps
, depth
, &nttime
->high
)) /* high part */
134 /*******************************************************************
135 Reads or writes a LOOKUP_LEVEL structure.
136 ********************************************************************/
138 BOOL
smb_io_lookup_level(const char *desc
, LOOKUP_LEVEL
*level
, prs_struct
*ps
, int depth
)
143 prs_debug(ps
, depth
, desc
, "smb_io_lookup_level");
148 if(!prs_uint16("value", ps
, depth
, &level
->value
))
156 /*******************************************************************
157 Gets an enumeration handle from an ENUM_HND structure.
158 ********************************************************************/
160 uint32
get_enum_hnd(ENUM_HND
*enh
)
162 return (enh
&& enh
->ptr_hnd
!= 0) ? enh
->handle
: 0;
165 /*******************************************************************
166 Inits an ENUM_HND structure.
167 ********************************************************************/
169 void init_enum_hnd(ENUM_HND
*enh
, uint32 hnd
)
171 DEBUG(5,("smb_io_enum_hnd\n"));
173 enh
->ptr_hnd
= (hnd
!= 0) ? 1 : 0;
177 /*******************************************************************
178 Reads or writes an ENUM_HND structure.
179 ********************************************************************/
181 BOOL
smb_io_enum_hnd(const char *desc
, ENUM_HND
*hnd
, prs_struct
*ps
, int depth
)
186 prs_debug(ps
, depth
, desc
, "smb_io_enum_hnd");
192 if(!prs_uint32("ptr_hnd", ps
, depth
, &hnd
->ptr_hnd
)) /* pointer */
195 if (hnd
->ptr_hnd
!= 0) {
196 if(!prs_uint32("handle ", ps
, depth
, &hnd
->handle
)) /* enum handle */
203 /*******************************************************************
204 Reads or writes a DOM_SID structure.
205 ********************************************************************/
207 BOOL
smb_io_dom_sid(const char *desc
, DOM_SID
*sid
, prs_struct
*ps
, int depth
)
214 prs_debug(ps
, depth
, desc
, "smb_io_dom_sid");
217 if(!prs_uint8 ("sid_rev_num", ps
, depth
, &sid
->sid_rev_num
))
220 if(!prs_uint8 ("num_auths ", ps
, depth
, &sid
->num_auths
))
223 for (i
= 0; i
< 6; i
++)
226 slprintf(tmp
, sizeof(tmp
) - 1, "id_auth[%d] ", i
);
227 if(!prs_uint8 (tmp
, ps
, depth
, &sid
->id_auth
[i
]))
231 /* oops! XXXX should really issue a warning here... */
232 if (sid
->num_auths
> MAXSUBAUTHS
)
233 sid
->num_auths
= MAXSUBAUTHS
;
235 if(!prs_uint32s(False
, "sub_auths ", ps
, depth
, sid
->sub_auths
, sid
->num_auths
))
241 /*******************************************************************
242 Inits a DOM_SID structure.
244 BIG NOTE: this function only does SIDS where the identauth is not >= 2^32
245 identauth >= 2^32 can be detected because it will be specified in hex
246 ********************************************************************/
248 void init_dom_sid(DOM_SID
*sid
, const char *str_sid
)
254 if (str_sid
== NULL
) {
255 DEBUG(4,("netlogon domain SID: none\n"));
256 sid
->sid_rev_num
= 0;
261 pstrcpy(domsid
, str_sid
);
263 DEBUG(4,("init_dom_sid %d SID: %s\n", __LINE__
, domsid
));
265 /* assume, but should check, that domsid starts "S-" */
266 p
= strtok(domsid
+2,"-");
267 sid
->sid_rev_num
= atoi(p
);
269 /* identauth in decimal should be < 2^32 */
270 /* identauth in hex should be >= 2^32 */
271 identauth
= atoi(strtok(0,"-"));
273 DEBUG(4,("netlogon rev %d\n", sid
->sid_rev_num
));
274 DEBUG(4,("netlogon %s ia %d\n", p
, identauth
));
278 sid
->id_auth
[2] = (identauth
& 0xff000000) >> 24;
279 sid
->id_auth
[3] = (identauth
& 0x00ff0000) >> 16;
280 sid
->id_auth
[4] = (identauth
& 0x0000ff00) >> 8;
281 sid
->id_auth
[5] = (identauth
& 0x000000ff);
285 while ((p
= strtok(0, "-")) != NULL
&& sid
->num_auths
< MAXSUBAUTHS
)
286 sid
->sub_auths
[sid
->num_auths
++] = atoi(p
);
288 DEBUG(4,("init_dom_sid: %d SID: %s\n", __LINE__
, domsid
));
291 /*******************************************************************
292 Inits a DOM_SID2 structure.
293 ********************************************************************/
295 void init_dom_sid2(DOM_SID2
*sid2
, const DOM_SID
*sid
)
298 sid2
->num_auths
= sid2
->sid
.num_auths
;
301 /*******************************************************************
302 Reads or writes a DOM_SID2 structure.
303 ********************************************************************/
305 BOOL
smb_io_dom_sid2(const char *desc
, DOM_SID2
*sid
, prs_struct
*ps
, int depth
)
310 prs_debug(ps
, depth
, desc
, "smb_io_dom_sid2");
316 if(!prs_uint32("num_auths", ps
, depth
, &sid
->num_auths
))
319 if(!smb_io_dom_sid("sid", &sid
->sid
, ps
, depth
))
325 /*******************************************************************
326 Reads or writes a struct uuid
327 ********************************************************************/
329 BOOL
smb_io_uuid(const char *desc
, struct uuid
*uuid
,
330 prs_struct
*ps
, int depth
)
335 prs_debug(ps
, depth
, desc
, "smb_io_uuid");
338 if(!prs_uint32 ("data ", ps
, depth
, &uuid
->time_low
))
340 if(!prs_uint16 ("data ", ps
, depth
, &uuid
->time_mid
))
342 if(!prs_uint16 ("data ", ps
, depth
, &uuid
->time_hi_and_version
))
345 if(!prs_uint8s (False
, "data ", ps
, depth
, uuid
->clock_seq
, sizeof(uuid
->clock_seq
)))
347 if(!prs_uint8s (False
, "data ", ps
, depth
, uuid
->node
, sizeof(uuid
->node
)))
353 /*******************************************************************
354 creates a STRHDR structure.
355 ********************************************************************/
357 void init_str_hdr(STRHDR
*hdr
, int max_len
, int len
, uint32 buffer
)
359 hdr
->str_max_len
= max_len
;
360 hdr
->str_str_len
= len
;
361 hdr
->buffer
= buffer
;
364 /*******************************************************************
365 Reads or writes a STRHDR structure.
366 ********************************************************************/
368 BOOL
smb_io_strhdr(const char *desc
, STRHDR
*hdr
, prs_struct
*ps
, int depth
)
373 prs_debug(ps
, depth
, desc
, "smb_io_strhdr");
378 if(!prs_uint16("str_str_len", ps
, depth
, &hdr
->str_str_len
))
380 if(!prs_uint16("str_max_len", ps
, depth
, &hdr
->str_max_len
))
382 if(!prs_uint32("buffer ", ps
, depth
, &hdr
->buffer
))
388 /*******************************************************************
389 Inits a UNIHDR structure.
390 ********************************************************************/
392 void init_uni_hdr(UNIHDR
*hdr
, UNISTR2
*str2
)
394 hdr
->uni_str_len
= 2 * (str2
->uni_str_len
);
395 hdr
->uni_max_len
= 2 * (str2
->uni_max_len
);
396 hdr
->buffer
= (str2
->uni_str_len
!= 0) ? 1 : 0;
399 /*******************************************************************
400 Reads or writes a UNIHDR structure.
401 ********************************************************************/
403 BOOL
smb_io_unihdr(const char *desc
, UNIHDR
*hdr
, prs_struct
*ps
, int depth
)
408 prs_debug(ps
, depth
, desc
, "smb_io_unihdr");
414 if(!prs_uint16("uni_str_len", ps
, depth
, &hdr
->uni_str_len
))
416 if(!prs_uint16("uni_max_len", ps
, depth
, &hdr
->uni_max_len
))
418 if(!prs_uint32("buffer ", ps
, depth
, &hdr
->buffer
))
424 /*******************************************************************
425 Inits a BUFHDR structure.
426 ********************************************************************/
428 void init_buf_hdr(BUFHDR
*hdr
, int max_len
, int len
)
430 hdr
->buf_max_len
= max_len
;
434 /*******************************************************************
435 prs_uint16 wrapper. Call this and it sets up a pointer to where the
436 uint16 should be stored, or gets the size if reading.
437 ********************************************************************/
439 BOOL
smb_io_hdrbuf_pre(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
, uint32
*offset
)
441 (*offset
) = prs_offset(ps
);
446 if(!smb_io_hdrbuf(desc
, hdr
, ps
, depth
))
453 if(!prs_set_offset(ps
, prs_offset(ps
) + (sizeof(uint32
) * 2)))
460 /*******************************************************************
461 smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
462 Does nothing on reading, as that is already handled by ...._pre()
463 ********************************************************************/
465 BOOL
smb_io_hdrbuf_post(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
,
466 uint32 ptr_hdrbuf
, uint32 max_len
, uint32 len
)
469 /* writing: go back and do a retrospective job. i hate this */
471 uint32 old_offset
= prs_offset(ps
);
473 init_buf_hdr(hdr
, max_len
, len
);
474 if(!prs_set_offset(ps
, ptr_hdrbuf
))
476 if(!smb_io_hdrbuf(desc
, hdr
, ps
, depth
))
479 if(!prs_set_offset(ps
, old_offset
))
486 /*******************************************************************
487 Reads or writes a BUFHDR structure.
488 ********************************************************************/
490 BOOL
smb_io_hdrbuf(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
)
495 prs_debug(ps
, depth
, desc
, "smb_io_hdrbuf");
501 if(!prs_uint32("buf_max_len", ps
, depth
, &hdr
->buf_max_len
))
503 if(!prs_uint32("buf_len ", ps
, depth
, &hdr
->buf_len
))
509 /*******************************************************************
510 creates a UNIHDR2 structure.
511 ********************************************************************/
513 void init_uni_hdr2(UNIHDR2
*hdr
, UNISTR2
*str2
)
515 init_uni_hdr(&hdr
->unihdr
, str2
);
516 hdr
->buffer
= (str2
->uni_str_len
> 0) ? 1 : 0;
519 /*******************************************************************
520 Reads or writes a UNIHDR2 structure.
521 ********************************************************************/
523 BOOL
smb_io_unihdr2(const char *desc
, UNIHDR2
*hdr2
, prs_struct
*ps
, int depth
)
528 prs_debug(ps
, depth
, desc
, "smb_io_unihdr2");
534 if(!smb_io_unihdr("hdr", &hdr2
->unihdr
, ps
, depth
))
536 if(!prs_uint32("buffer", ps
, depth
, &hdr2
->buffer
))
542 /*******************************************************************
543 Inits a UNISTR structure.
544 ********************************************************************/
546 void init_unistr(UNISTR
*str
, const char *buf
)
556 len
= strlen(buf
) + 1;
558 if (len
< MAX_UNISTRLEN
)
560 len
*= sizeof(uint16
);
562 str
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
563 if (str
->buffer
== NULL
)
564 smb_panic("init_unistr: malloc fail\n");
566 rpcstr_push(str
->buffer
, buf
, len
, STR_TERMINATE
);
569 /*******************************************************************
570 reads or writes a UNISTR structure.
571 XXXX NOTE: UNISTR structures NEED to be null-terminated.
572 ********************************************************************/
574 BOOL
smb_io_unistr(const char *desc
, UNISTR
*uni
, prs_struct
*ps
, int depth
)
579 prs_debug(ps
, depth
, desc
, "smb_io_unistr");
582 if(!prs_unistr("unistr", ps
, depth
, uni
))
588 /*******************************************************************
589 Allocate the BUFFER3 memory.
590 ********************************************************************/
592 static void create_buffer3(BUFFER3
*str
, size_t len
)
594 if (len
< MAX_BUFFERLEN
)
597 str
->buffer
= talloc_zero(get_talloc_ctx(), len
);
598 if (str
->buffer
== NULL
)
599 smb_panic("create_buffer3: talloc fail\n");
603 /*******************************************************************
604 Inits a BUFFER3 structure from a uint32
605 ********************************************************************/
607 void init_buffer3_uint32(BUFFER3
*str
, uint32 val
)
611 /* set up string lengths. */
612 str
->buf_max_len
= sizeof(uint32
);
613 str
->buf_len
= sizeof(uint32
);
615 create_buffer3(str
, sizeof(uint32
));
616 SIVAL(str
->buffer
, 0, val
);
619 /*******************************************************************
620 Inits a BUFFER3 structure.
621 ********************************************************************/
623 void init_buffer3_str(BUFFER3
*str
, const char *buf
, int len
)
627 /* set up string lengths. */
628 str
->buf_max_len
= len
* 2;
629 str
->buf_len
= len
* 2;
631 create_buffer3(str
, str
->buf_max_len
);
633 rpcstr_push(str
->buffer
, buf
, str
->buf_max_len
, STR_TERMINATE
);
637 /*******************************************************************
638 Inits a BUFFER3 structure from a hex string.
639 ********************************************************************/
641 void init_buffer3_hex(BUFFER3
*str
, const char *buf
)
644 create_buffer3(str
, strlen(buf
));
645 str
->buf_max_len
= str
->buf_len
= strhex_to_str((char *)str
->buffer
, sizeof(str
->buffer
), buf
);
648 /*******************************************************************
649 Inits a BUFFER3 structure.
650 ********************************************************************/
652 void init_buffer3_bytes(BUFFER3
*str
, uint8
*buf
, int len
)
656 /* max buffer size (allocated size) */
657 str
->buf_max_len
= len
;
659 create_buffer3(str
, len
);
660 memcpy(str
->buffer
, buf
, len
);
662 str
->buf_len
= buf
!= NULL
? len
: 0;
665 /*******************************************************************
666 Reads or writes a BUFFER3 structure.
667 the uni_max_len member tells you how large the buffer is.
668 the uni_str_len member tells you how much of the buffer is really used.
669 ********************************************************************/
671 BOOL
smb_io_buffer3(const char *desc
, BUFFER3
*buf3
, prs_struct
*ps
, int depth
)
676 prs_debug(ps
, depth
, desc
, "smb_io_buffer3");
682 if(!prs_uint32("uni_max_len", ps
, depth
, &buf3
->buf_max_len
))
685 if (UNMARSHALLING(ps
)) {
686 buf3
->buffer
= (unsigned char *)prs_alloc_mem(ps
, buf3
->buf_max_len
);
687 if (buf3
->buffer
== NULL
)
691 if(!prs_uint8s(True
, "buffer ", ps
, depth
, buf3
->buffer
, buf3
->buf_max_len
))
694 if(!prs_uint32("buf_len ", ps
, depth
, &buf3
->buf_len
))
700 /*******************************************************************
701 reads or writes a BUFFER5 structure.
702 the buf_len member tells you how large the buffer is.
703 ********************************************************************/
704 BOOL
smb_io_buffer5(const char *desc
, BUFFER5
*buf5
, prs_struct
*ps
, int depth
)
706 prs_debug(ps
, depth
, desc
, "smb_io_buffer5");
709 if (buf5
== NULL
) return False
;
713 if(!prs_uint32("buf_len", ps
, depth
, &buf5
->buf_len
))
717 if(!prs_buffer5(True
, "buffer" , ps
, depth
, buf5
))
724 /*******************************************************************
725 Inits a BUFFER2 structure.
726 ********************************************************************/
728 void init_buffer2(BUFFER2
*str
, const uint8
*buf
, size_t len
)
732 /* max buffer size (allocated size) */
733 str
->buf_max_len
= len
;
735 str
->buf_len
= buf
!= NULL
? len
: 0;
738 if (len
< MAX_BUFFERLEN
)
740 str
->buffer
= talloc_zero(get_talloc_ctx(), len
);
741 if (str
->buffer
== NULL
)
742 smb_panic("init_buffer2: talloc fail\n");
743 memcpy(str
->buffer
, buf
, MIN(str
->buf_len
, len
));
747 /*******************************************************************
748 Reads or writes a BUFFER2 structure.
749 the uni_max_len member tells you how large the buffer is.
750 the uni_str_len member tells you how much of the buffer is really used.
751 ********************************************************************/
753 BOOL
smb_io_buffer2(const char *desc
, BUFFER2
*buf2
, uint32 buffer
, prs_struct
*ps
, int depth
)
760 prs_debug(ps
, depth
, desc
, "smb_io_buffer2");
766 if(!prs_uint32("uni_max_len", ps
, depth
, &buf2
->buf_max_len
))
768 if(!prs_uint32("offset ", ps
, depth
, &buf2
->offset
))
770 if(!prs_uint32("buf_len ", ps
, depth
, &buf2
->buf_len
))
773 /* buffer advanced by indicated length of string
774 NOT by searching for null-termination */
776 if(!prs_buffer2(True
, "buffer ", ps
, depth
, buf2
))
781 prs_debug(ps
, depth
, desc
, "smb_io_buffer2 - NULL");
783 memset((char *)buf2
, '\0', sizeof(*buf2
));
789 /*******************************************************************
790 creates a UNISTR2 structure: sets up the buffer, too
791 ********************************************************************/
793 void init_buf_unistr2(UNISTR2
*str
, uint32
*ptr
, const char *buf
)
797 init_unistr2(str
, buf
, UNI_STR_TERMINATE
);
800 init_unistr2(str
, NULL
, UNI_FLAGS_NONE
);
805 /*******************************************************************
806 Copies a UNISTR2 structure.
807 ********************************************************************/
809 void copy_unistr2(UNISTR2
*str
, const UNISTR2
*from
)
811 str
->uni_max_len
= from
->uni_max_len
;
812 str
->offset
= from
->offset
;
813 str
->uni_str_len
= from
->uni_str_len
;
815 if (from
->buffer
== NULL
)
818 /* the string buffer is allocated to the maximum size
819 (the the length of the source string) to prevent
820 reallocation of memory. */
821 if (str
->buffer
== NULL
) {
822 size_t len
= from
->uni_max_len
* sizeof(uint16
);
824 if (len
< MAX_UNISTRLEN
)
826 len
*= sizeof(uint16
);
828 str
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
829 if ((str
->buffer
== NULL
) && (len
> 0 )) {
830 smb_panic("copy_unistr2: talloc fail\n");
835 /* copy the string */
836 memcpy(str
->buffer
, from
->buffer
, from
->uni_max_len
*sizeof(uint16
));
839 /*******************************************************************
840 Creates a STRING2 structure.
841 ********************************************************************/
843 void init_string2(STRING2
*str
, const char *buf
, int max_len
, int str_len
)
847 /* set up string lengths. */
848 str
->str_max_len
= max_len
;
850 str
->str_str_len
= str_len
;
852 /* store the string */
854 if (str_len
< MAX_STRINGLEN
)
855 alloc_len
= MAX_STRINGLEN
;
856 str
->buffer
= talloc_zero(get_talloc_ctx(), alloc_len
);
857 if (str
->buffer
== NULL
)
858 smb_panic("init_string2: malloc fail\n");
859 memcpy(str
->buffer
, buf
, str_len
);
863 /*******************************************************************
864 Reads or writes a STRING2 structure.
865 XXXX NOTE: STRING2 structures need NOT be null-terminated.
866 the str_str_len member tells you how long the string is;
867 the str_max_len member tells you how large the buffer is.
868 ********************************************************************/
870 BOOL
smb_io_string2(const char *desc
, STRING2
*str2
, uint32 buffer
, prs_struct
*ps
, int depth
)
877 prs_debug(ps
, depth
, desc
, "smb_io_string2");
883 if(!prs_uint32("str_max_len", ps
, depth
, &str2
->str_max_len
))
885 if(!prs_uint32("offset ", ps
, depth
, &str2
->offset
))
887 if(!prs_uint32("str_str_len", ps
, depth
, &str2
->str_str_len
))
890 /* buffer advanced by indicated length of string
891 NOT by searching for null-termination */
892 if(!prs_string2(True
, "buffer ", ps
, depth
, str2
))
897 prs_debug(ps
, depth
, desc
, "smb_io_string2 - NULL");
899 memset((char *)str2
, '\0', sizeof(*str2
));
906 /*******************************************************************
907 Inits a UNISTR2 structure.
908 ********************************************************************/
910 void init_unistr2(UNISTR2
*str
, const char *buf
, enum unistr2_term_codes flags
)
913 uint32 num_chars
= 0;
916 /* We always null terminate the copy. */
917 len
= strlen(buf
) + 1;
920 if (len
< MAX_UNISTRLEN
)
922 len
*= sizeof(uint16
);
924 str
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
925 if ((str
->buffer
== NULL
) && (len
> 0)) {
926 smb_panic("init_unistr2: malloc fail\n");
931 * The UNISTR2 must be initialized !!!
935 rpcstr_push((char *)str
->buffer
, buf
, len
, STR_TERMINATE
);
936 num_chars
= strlen_w(str
->buffer
);
937 if (flags
== STR_TERMINATE
|| flags
== UNI_MAXLEN_TERMINATE
) {
942 str
->uni_max_len
= num_chars
;
944 str
->uni_str_len
= num_chars
;
945 if ( num_chars
&& ((flags
== UNI_MAXLEN_TERMINATE
) || (flags
== UNI_BROKEN_NON_NULL
)) )
950 * Inits a UNISTR2 structure.
951 * @param ctx talloc context to allocate string on
952 * @param str pointer to string to create
953 * @param buf UCS2 null-terminated buffer to init from
956 void init_unistr2_w(TALLOC_CTX
*ctx
, UNISTR2
*str
, const smb_ucs2_t
*buf
)
958 uint32 len
= strlen_w(buf
);
959 uint32 max_len
= len
;
964 /* set up string lengths. */
965 str
->uni_max_len
= len
;
967 str
->uni_str_len
= len
;
969 if (max_len
< MAX_UNISTRLEN
)
970 max_len
= MAX_UNISTRLEN
;
972 alloc_len
= (max_len
+ 1) * sizeof(uint16
);
974 str
->buffer
= (uint16
*)talloc_zero(ctx
, alloc_len
);
975 if ((str
->buffer
== NULL
) && (alloc_len
> 0)) {
976 smb_panic("init_unistr2_w: malloc fail\n");
981 * don't move this test above ! The UNISTR2 must be initialized !!!
987 /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
988 long as the buffer above is talloc()ed correctly then this
989 is the correct thing to do */
990 strncpy_w(str
->buffer
, buf
, len
+ 1);
993 /*******************************************************************
994 Inits a UNISTR2 structure from a UNISTR
995 ********************************************************************/
997 void init_unistr2_from_unistr(UNISTR2
*to
, const UNISTR
*from
)
1001 /* the destination UNISTR2 should never be NULL.
1002 if it is it is a programming error */
1004 /* if the source UNISTR is NULL, then zero out
1005 the destination string and return */
1007 if ((from
== NULL
) || (from
->buffer
== NULL
))
1010 /* get the length; UNISTR must be NULL terminated */
1012 while ((from
->buffer
)[i
]!='\0')
1014 i
++; /* one more to catch the terminating NULL */
1015 /* is this necessary -- jerry? I need to think */
1017 /* set up string lengths; uni_max_len is set to i+1
1018 because we need to account for the final NULL termination */
1019 to
->uni_max_len
= i
;
1021 to
->uni_str_len
= i
;
1023 /* allocate the space and copy the string buffer */
1024 to
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), sizeof(uint16
)*(to
->uni_str_len
));
1025 if (to
->buffer
== NULL
)
1026 smb_panic("init_unistr2_from_unistr: malloc fail\n");
1027 memcpy(to
->buffer
, from
->buffer
, to
->uni_max_len
*sizeof(uint16
));
1031 /*******************************************************************
1032 Inits a UNISTR2 structure from a DATA_BLOB.
1033 The length of the data_blob must count the bytes of the buffer.
1034 Copies the blob data.
1035 ********************************************************************/
1037 void init_unistr2_from_datablob(UNISTR2
*str
, DATA_BLOB
*blob
)
1039 /* Allocs the unistring */
1040 init_unistr2(str
, NULL
, UNI_FLAGS_NONE
);
1042 /* Sets the values */
1043 str
->uni_str_len
= blob
->length
/ sizeof(uint16
);
1044 str
->uni_max_len
= str
->uni_str_len
;
1047 str
->buffer
= (uint16
*) memdup(blob
->data
, blob
->length
);
1051 if ((str
->buffer
== NULL
) && (blob
->length
> 0)) {
1052 smb_panic("init_unistr2_from_datablob: malloc fail\n");
1056 /*******************************************************************
1057 Reads or writes a UNISTR2 structure.
1058 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
1059 the uni_str_len member tells you how long the string is;
1060 the uni_max_len member tells you how large the buffer is.
1061 ********************************************************************/
1063 BOOL
smb_io_unistr2(const char *desc
, UNISTR2
*uni2
, uint32 buffer
, prs_struct
*ps
, int depth
)
1070 prs_debug(ps
, depth
, desc
, "smb_io_unistr2");
1076 if(!prs_uint32("uni_max_len", ps
, depth
, &uni2
->uni_max_len
))
1078 if(!prs_uint32("offset ", ps
, depth
, &uni2
->offset
))
1080 if(!prs_uint32("uni_str_len", ps
, depth
, &uni2
->uni_str_len
))
1083 /* buffer advanced by indicated length of string
1084 NOT by searching for null-termination */
1085 if(!prs_unistr2(True
, "buffer ", ps
, depth
, uni2
))
1090 prs_debug(ps
, depth
, desc
, "smb_io_unistr2 - NULL");
1092 memset((char *)uni2
, '\0', sizeof(*uni2
));
1101 initialise a UNISTR_ARRAY from a char**
1103 BOOL
init_unistr2_array(UNISTR2_ARRAY
*array
,
1104 uint32 count
, const char **strings
)
1108 array
->count
= count
;
1109 array
->ref_id
= count
?1:0;
1110 if (array
->count
== 0) {
1114 array
->strings
= (UNISTR2_ARRAY_EL
*)talloc_zero(get_talloc_ctx(), count
* sizeof(UNISTR2_ARRAY_EL
));
1115 if (!array
->strings
) {
1119 for (i
=0;i
<count
;i
++) {
1120 init_unistr2(&array
->strings
[i
].string
, strings
[i
], UNI_FLAGS_NONE
);
1121 array
->strings
[i
].size
= array
->strings
[i
].string
.uni_max_len
*2;
1122 array
->strings
[i
].length
= array
->strings
[i
].size
;
1123 array
->strings
[i
].ref_id
= 1;
1129 /*******************************************************************
1130 Reads or writes a UNISTR2_ARRAY structure.
1131 ********************************************************************/
1132 BOOL
smb_io_unistr2_array(const char *desc
, UNISTR2_ARRAY
*array
, prs_struct
*ps
, int depth
)
1136 prs_debug(ps
, depth
, desc
, "smb_io_unistr2_array");
1139 if(!prs_uint32("ref_id", ps
, depth
, &array
->ref_id
))
1142 if (! array
->ref_id
) {
1146 if(!prs_uint32("count", ps
, depth
, &array
->count
))
1149 if (array
->count
== 0) {
1153 if (UNMARSHALLING(ps
)) {
1154 array
->strings
= talloc_zero(get_talloc_ctx(), array
->count
* sizeof(array
->strings
[0]));
1156 if (! array
->strings
) {
1160 for (i
=0;i
<array
->count
;i
++) {
1161 if(!prs_uint16("length", ps
, depth
, &array
->strings
[i
].length
))
1163 if(!prs_uint16("size", ps
, depth
, &array
->strings
[i
].size
))
1165 if(!prs_uint32("ref_id", ps
, depth
, &array
->strings
[i
].ref_id
))
1169 for (i
=0;i
<array
->count
;i
++) {
1170 if (! smb_io_unistr2("string", &array
->strings
[i
].string
, array
->strings
[i
].ref_id
, ps
, depth
))
1178 /*******************************************************************
1179 Inits a DOM_RID2 structure.
1180 ********************************************************************/
1182 void init_dom_rid2(DOM_RID2
*rid2
, uint32 rid
, uint8 type
, uint32 idx
)
1186 rid2
->rid_idx
= idx
;
1189 /*******************************************************************
1190 Reads or writes a DOM_RID2 structure.
1191 ********************************************************************/
1193 BOOL
smb_io_dom_rid2(const char *desc
, DOM_RID2
*rid2
, prs_struct
*ps
, int depth
)
1198 prs_debug(ps
, depth
, desc
, "smb_io_dom_rid2");
1204 if(!prs_uint8("type ", ps
, depth
, &rid2
->type
))
1208 if(!prs_uint32("rid ", ps
, depth
, &rid2
->rid
))
1210 if(!prs_uint32("rid_idx", ps
, depth
, &rid2
->rid_idx
))
1216 /*******************************************************************
1217 creates a DOM_RID3 structure.
1218 ********************************************************************/
1220 void init_dom_rid3(DOM_RID3
*rid3
, uint32 rid
, uint8 type
)
1224 rid3
->ptr_type
= 0x1; /* non-zero, basically. */
1229 /*******************************************************************
1230 reads or writes a DOM_RID3 structure.
1231 ********************************************************************/
1233 BOOL
smb_io_dom_rid3(const char *desc
, DOM_RID3
*rid3
, prs_struct
*ps
, int depth
)
1238 prs_debug(ps
, depth
, desc
, "smb_io_dom_rid3");
1244 if(!prs_uint32("rid ", ps
, depth
, &rid3
->rid
))
1246 if(!prs_uint32("type1 ", ps
, depth
, &rid3
->type1
))
1248 if(!prs_uint32("ptr_type", ps
, depth
, &rid3
->ptr_type
))
1250 if(!prs_uint32("type2 ", ps
, depth
, &rid3
->type2
))
1252 if(!prs_uint32("unk ", ps
, depth
, &rid3
->unk
))
1258 /*******************************************************************
1259 Inits a DOM_RID4 structure.
1260 ********************************************************************/
1262 void init_dom_rid4(DOM_RID4
*rid4
, uint16 unknown
, uint16 attr
, uint32 rid
)
1264 rid4
->unknown
= unknown
;
1269 /*******************************************************************
1270 Inits a DOM_CLNT_SRV structure.
1271 ********************************************************************/
1273 static void init_clnt_srv(DOM_CLNT_SRV
*logcln
, const char *logon_srv
, const char *comp_name
)
1275 DEBUG(5,("init_clnt_srv: %d\n", __LINE__
));
1277 if (logon_srv
!= NULL
) {
1278 logcln
->undoc_buffer
= 1;
1279 init_unistr2(&logcln
->uni_logon_srv
, logon_srv
, UNI_STR_TERMINATE
);
1281 logcln
->undoc_buffer
= 0;
1284 if (comp_name
!= NULL
) {
1285 logcln
->undoc_buffer2
= 1;
1286 init_unistr2(&logcln
->uni_comp_name
, comp_name
, UNI_STR_TERMINATE
);
1288 logcln
->undoc_buffer2
= 0;
1292 /*******************************************************************
1293 Inits or writes a DOM_CLNT_SRV structure.
1294 ********************************************************************/
1296 static BOOL
smb_io_clnt_srv(const char *desc
, DOM_CLNT_SRV
*logcln
, prs_struct
*ps
, int depth
)
1301 prs_debug(ps
, depth
, desc
, "smb_io_clnt_srv");
1307 if(!prs_uint32("undoc_buffer ", ps
, depth
, &logcln
->undoc_buffer
))
1310 if (logcln
->undoc_buffer
!= 0) {
1311 if(!smb_io_unistr2("unistr2", &logcln
->uni_logon_srv
, logcln
->undoc_buffer
, ps
, depth
))
1318 if(!prs_uint32("undoc_buffer2", ps
, depth
, &logcln
->undoc_buffer2
))
1321 if (logcln
->undoc_buffer2
!= 0) {
1322 if(!smb_io_unistr2("unistr2", &logcln
->uni_comp_name
, logcln
->undoc_buffer2
, ps
, depth
))
1329 /*******************************************************************
1330 Inits a DOM_LOG_INFO structure.
1331 ********************************************************************/
1333 void init_log_info(DOM_LOG_INFO
*loginfo
, const char *logon_srv
, const char *acct_name
,
1334 uint16 sec_chan
, const char *comp_name
)
1336 DEBUG(5,("make_log_info %d\n", __LINE__
));
1338 loginfo
->undoc_buffer
= 1;
1340 init_unistr2(&loginfo
->uni_logon_srv
, logon_srv
, UNI_STR_TERMINATE
);
1341 init_unistr2(&loginfo
->uni_acct_name
, acct_name
, UNI_STR_TERMINATE
);
1343 loginfo
->sec_chan
= sec_chan
;
1345 init_unistr2(&loginfo
->uni_comp_name
, comp_name
, UNI_STR_TERMINATE
);
1348 /*******************************************************************
1349 Reads or writes a DOM_LOG_INFO structure.
1350 ********************************************************************/
1352 BOOL
smb_io_log_info(const char *desc
, DOM_LOG_INFO
*loginfo
, prs_struct
*ps
, int depth
)
1354 if (loginfo
== NULL
)
1357 prs_debug(ps
, depth
, desc
, "smb_io_log_info");
1363 if(!prs_uint32("undoc_buffer", ps
, depth
, &loginfo
->undoc_buffer
))
1366 if(!smb_io_unistr2("unistr2", &loginfo
->uni_logon_srv
, True
, ps
, depth
))
1368 if(!smb_io_unistr2("unistr2", &loginfo
->uni_acct_name
, True
, ps
, depth
))
1371 if(!prs_uint16("sec_chan", ps
, depth
, &loginfo
->sec_chan
))
1374 if(!smb_io_unistr2("unistr2", &loginfo
->uni_comp_name
, True
, ps
, depth
))
1380 /*******************************************************************
1381 Reads or writes a DOM_CHAL structure.
1382 ********************************************************************/
1384 BOOL
smb_io_chal(const char *desc
, DOM_CHAL
*chal
, prs_struct
*ps
, int depth
)
1389 prs_debug(ps
, depth
, desc
, "smb_io_chal");
1392 if(!prs_uint8s (False
, "data", ps
, depth
, chal
->data
, 8))
1398 /*******************************************************************
1399 Reads or writes a DOM_CRED structure.
1400 ********************************************************************/
1402 BOOL
smb_io_cred(const char *desc
, DOM_CRED
*cred
, prs_struct
*ps
, int depth
)
1407 prs_debug(ps
, depth
, desc
, "smb_io_cred");
1413 if(!smb_io_chal ("", &cred
->challenge
, ps
, depth
))
1416 if(!smb_io_utime("", &cred
->timestamp
, ps
, depth
))
1422 /*******************************************************************
1423 Inits a DOM_CLNT_INFO2 structure.
1424 ********************************************************************/
1426 void init_clnt_info2(DOM_CLNT_INFO2
*clnt
,
1427 const char *logon_srv
, const char *comp_name
,
1428 const DOM_CRED
*clnt_cred
)
1430 DEBUG(5,("make_clnt_info: %d\n", __LINE__
));
1432 init_clnt_srv(&clnt
->login
, logon_srv
, comp_name
);
1434 if (clnt_cred
!= NULL
) {
1436 memcpy(&clnt
->cred
, clnt_cred
, sizeof(clnt
->cred
));
1442 /*******************************************************************
1443 Reads or writes a DOM_CLNT_INFO2 structure.
1444 ********************************************************************/
1446 BOOL
smb_io_clnt_info2(const char *desc
, DOM_CLNT_INFO2
*clnt
, prs_struct
*ps
, int depth
)
1451 prs_debug(ps
, depth
, desc
, "smb_io_clnt_info2");
1457 if(!smb_io_clnt_srv("", &clnt
->login
, ps
, depth
))
1463 if(!prs_uint32("ptr_cred", ps
, depth
, &clnt
->ptr_cred
))
1465 if(!smb_io_cred("", &clnt
->cred
, ps
, depth
))
1471 /*******************************************************************
1472 Inits a DOM_CLNT_INFO structure.
1473 ********************************************************************/
1475 void init_clnt_info(DOM_CLNT_INFO
*clnt
,
1476 const char *logon_srv
, const char *acct_name
,
1477 uint16 sec_chan
, const char *comp_name
,
1478 const DOM_CRED
*cred
)
1480 DEBUG(5,("make_clnt_info\n"));
1482 init_log_info(&clnt
->login
, logon_srv
, acct_name
, sec_chan
, comp_name
);
1483 memcpy(&clnt
->cred
, cred
, sizeof(clnt
->cred
));
1486 /*******************************************************************
1487 Reads or writes a DOM_CLNT_INFO structure.
1488 ********************************************************************/
1490 BOOL
smb_io_clnt_info(const char *desc
, DOM_CLNT_INFO
*clnt
, prs_struct
*ps
, int depth
)
1495 prs_debug(ps
, depth
, desc
, "smb_io_clnt_info");
1501 if(!smb_io_log_info("", &clnt
->login
, ps
, depth
))
1503 if(!smb_io_cred("", &clnt
->cred
, ps
, depth
))
1509 /*******************************************************************
1510 Inits a DOM_LOGON_ID structure.
1511 ********************************************************************/
1513 void init_logon_id(DOM_LOGON_ID
*logonid
, uint32 log_id_low
, uint32 log_id_high
)
1515 DEBUG(5,("make_logon_id: %d\n", __LINE__
));
1517 logonid
->low
= log_id_low
;
1518 logonid
->high
= log_id_high
;
1521 /*******************************************************************
1522 Reads or writes a DOM_LOGON_ID structure.
1523 ********************************************************************/
1525 BOOL
smb_io_logon_id(const char *desc
, DOM_LOGON_ID
*logonid
, prs_struct
*ps
, int depth
)
1527 if (logonid
== NULL
)
1530 prs_debug(ps
, depth
, desc
, "smb_io_logon_id");
1536 if(!prs_uint32("low ", ps
, depth
, &logonid
->low
))
1538 if(!prs_uint32("high", ps
, depth
, &logonid
->high
))
1544 /*******************************************************************
1545 Inits an OWF_INFO structure.
1546 ********************************************************************/
1548 void init_owf_info(OWF_INFO
*hash
, const uint8 data
[16])
1550 DEBUG(5,("init_owf_info: %d\n", __LINE__
));
1553 memcpy(hash
->data
, data
, sizeof(hash
->data
));
1555 memset((char *)hash
->data
, '\0', sizeof(hash
->data
));
1558 /*******************************************************************
1559 Reads or writes an OWF_INFO structure.
1560 ********************************************************************/
1562 BOOL
smb_io_owf_info(const char *desc
, OWF_INFO
*hash
, prs_struct
*ps
, int depth
)
1567 prs_debug(ps
, depth
, desc
, "smb_io_owf_info");
1573 if(!prs_uint8s (False
, "data", ps
, depth
, hash
->data
, 16))
1579 /*******************************************************************
1580 Reads or writes a DOM_GID structure.
1581 ********************************************************************/
1583 BOOL
smb_io_gid(const char *desc
, DOM_GID
*gid
, prs_struct
*ps
, int depth
)
1588 prs_debug(ps
, depth
, desc
, "smb_io_gid");
1594 if(!prs_uint32("g_rid", ps
, depth
, &gid
->g_rid
))
1596 if(!prs_uint32("attr ", ps
, depth
, &gid
->attr
))
1602 /*******************************************************************
1603 Reads or writes an POLICY_HND structure.
1604 ********************************************************************/
1606 BOOL
smb_io_pol_hnd(const char *desc
, POLICY_HND
*pol
, prs_struct
*ps
, int depth
)
1611 prs_debug(ps
, depth
, desc
, "smb_io_pol_hnd");
1617 if(UNMARSHALLING(ps
))
1620 if (!prs_uint32("data1", ps
, depth
, &pol
->data1
))
1622 if (!prs_uint32("data2", ps
, depth
, &pol
->data2
))
1624 if (!prs_uint16("data3", ps
, depth
, &pol
->data3
))
1626 if (!prs_uint16("data4", ps
, depth
, &pol
->data4
))
1628 if(!prs_uint8s (False
, "data5", ps
, depth
, pol
->data5
, sizeof(pol
->data5
)))
1634 /*******************************************************************
1636 ********************************************************************/
1638 void init_unistr3(UNISTR3
*str
, const char *buf
)
1644 str
->str
.buffer
= NULL
;
1648 len
= strlen(buf
) + 1;
1650 str
->uni_str_len
=len
;
1652 if (len
< MAX_UNISTRLEN
)
1653 len
= MAX_UNISTRLEN
;
1655 len
*= sizeof(uint16
);
1657 str
->str
.buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
1658 if (str
->str
.buffer
== NULL
)
1659 smb_panic("init_unistr3: malloc fail\n");
1661 rpcstr_push((char *)str
->str
.buffer
, buf
, len
, STR_TERMINATE
);
1664 /*******************************************************************
1665 Reads or writes a UNISTR3 structure.
1666 ********************************************************************/
1668 BOOL
smb_io_unistr3(const char *desc
, UNISTR3
*name
, prs_struct
*ps
, int depth
)
1673 prs_debug(ps
, depth
, desc
, "smb_io_unistr3");
1679 if(!prs_uint32("uni_str_len", ps
, depth
, &name
->uni_str_len
))
1682 /* don't know if len is specified by uni_str_len member... */
1683 /* assume unicode string is unicode-null-terminated, instead */
1685 if(!prs_unistr3(True
, "unistr", name
, ps
, depth
))
1692 /*******************************************************************
1693 Stream a uint64_struct
1694 ********************************************************************/
1695 BOOL
prs_uint64(const char *name
, prs_struct
*ps
, int depth
, UINT64_S
*data64
)
1697 return prs_uint32(name
, ps
, depth
+1, &data64
->low
) &&
1698 prs_uint32(name
, ps
, depth
+1, &data64
->high
);
1701 /*******************************************************************
1702 reads or writes a BUFHDR2 structure.
1703 ********************************************************************/
1704 BOOL
smb_io_bufhdr2(const char *desc
, BUFHDR2
*hdr
, prs_struct
*ps
, int depth
)
1706 prs_debug(ps
, depth
, desc
, "smb_io_bufhdr2");
1710 prs_uint32("info_level", ps
, depth
, &(hdr
->info_level
));
1711 prs_uint32("length ", ps
, depth
, &(hdr
->length
));
1712 prs_uint32("buffer ", ps
, depth
, &(hdr
->buffer
));
1717 /*******************************************************************
1718 reads or writes a BUFFER4 structure.
1719 ********************************************************************/
1720 BOOL
smb_io_buffer4(const char *desc
, BUFFER4
*buf4
, uint32 buffer
, prs_struct
*ps
, int depth
)
1722 prs_debug(ps
, depth
, desc
, "smb_io_buffer4");
1726 prs_uint32("buf_len", ps
, depth
, &(buf4
->buf_len
));
1728 if (buf4
->buf_len
> MAX_BUFFERLEN
)
1730 buf4
->buf_len
= MAX_BUFFERLEN
;
1733 prs_uint8s(True
, "buffer", ps
, depth
, buf4
->buffer
, buf4
->buf_len
);
1738 /*******************************************************************
1739 creates a UNIHDR structure.
1740 ********************************************************************/
1742 BOOL
make_uni_hdr(UNIHDR
*hdr
, int len
)
1748 hdr
->uni_str_len
= 2 * len
;
1749 hdr
->uni_max_len
= 2 * len
;
1750 hdr
->buffer
= len
!= 0 ? 1 : 0;
1755 /*******************************************************************
1756 creates a BUFHDR2 structure.
1757 ********************************************************************/
1758 BOOL
make_bufhdr2(BUFHDR2
*hdr
, uint32 info_level
, uint32 length
, uint32 buffer
)
1760 hdr
->info_level
= info_level
;
1761 hdr
->length
= length
;
1762 hdr
->buffer
= buffer
;