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 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 creates a STRHDR structure.
327 ********************************************************************/
329 void init_str_hdr(STRHDR
*hdr
, int max_len
, int len
, uint32 buffer
)
331 hdr
->str_max_len
= max_len
;
332 hdr
->str_str_len
= len
;
333 hdr
->buffer
= buffer
;
336 /*******************************************************************
337 Reads or writes a STRHDR structure.
338 ********************************************************************/
340 BOOL
smb_io_strhdr(const char *desc
, STRHDR
*hdr
, prs_struct
*ps
, int depth
)
345 prs_debug(ps
, depth
, desc
, "smb_io_strhdr");
350 if(!prs_uint16("str_str_len", ps
, depth
, &hdr
->str_str_len
))
352 if(!prs_uint16("str_max_len", ps
, depth
, &hdr
->str_max_len
))
354 if(!prs_uint32("buffer ", ps
, depth
, &hdr
->buffer
))
360 /*******************************************************************
361 Inits a UNIHDR structure.
362 ********************************************************************/
364 void init_uni_hdr(UNIHDR
*hdr
, UNISTR2
*str2
)
366 hdr
->uni_str_len
= 2 * (str2
->uni_str_len
);
367 hdr
->uni_max_len
= 2 * (str2
->uni_max_len
);
368 hdr
->buffer
= (str2
->uni_str_len
!= 0) ? 1 : 0;
371 /*******************************************************************
372 Reads or writes a UNIHDR structure.
373 ********************************************************************/
375 BOOL
smb_io_unihdr(const char *desc
, UNIHDR
*hdr
, prs_struct
*ps
, int depth
)
380 prs_debug(ps
, depth
, desc
, "smb_io_unihdr");
386 if(!prs_uint16("uni_str_len", ps
, depth
, &hdr
->uni_str_len
))
388 if(!prs_uint16("uni_max_len", ps
, depth
, &hdr
->uni_max_len
))
390 if(!prs_uint32("buffer ", ps
, depth
, &hdr
->buffer
))
396 /*******************************************************************
397 Inits a BUFHDR structure.
398 ********************************************************************/
400 void init_buf_hdr(BUFHDR
*hdr
, int max_len
, int len
)
402 hdr
->buf_max_len
= max_len
;
406 /*******************************************************************
407 prs_uint16 wrapper. Call this and it sets up a pointer to where the
408 uint16 should be stored, or gets the size if reading.
409 ********************************************************************/
411 BOOL
smb_io_hdrbuf_pre(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
, uint32
*offset
)
413 (*offset
) = prs_offset(ps
);
418 if(!smb_io_hdrbuf(desc
, hdr
, ps
, depth
))
425 if(!prs_set_offset(ps
, prs_offset(ps
) + (sizeof(uint32
) * 2)))
432 /*******************************************************************
433 smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
434 Does nothing on reading, as that is already handled by ...._pre()
435 ********************************************************************/
437 BOOL
smb_io_hdrbuf_post(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
,
438 uint32 ptr_hdrbuf
, uint32 max_len
, uint32 len
)
441 /* writing: go back and do a retrospective job. i hate this */
443 uint32 old_offset
= prs_offset(ps
);
445 init_buf_hdr(hdr
, max_len
, len
);
446 if(!prs_set_offset(ps
, ptr_hdrbuf
))
448 if(!smb_io_hdrbuf(desc
, hdr
, ps
, depth
))
451 if(!prs_set_offset(ps
, old_offset
))
458 /*******************************************************************
459 Reads or writes a BUFHDR structure.
460 ********************************************************************/
462 BOOL
smb_io_hdrbuf(const char *desc
, BUFHDR
*hdr
, prs_struct
*ps
, int depth
)
467 prs_debug(ps
, depth
, desc
, "smb_io_hdrbuf");
473 if(!prs_uint32("buf_max_len", ps
, depth
, &hdr
->buf_max_len
))
475 if(!prs_uint32("buf_len ", ps
, depth
, &hdr
->buf_len
))
481 /*******************************************************************
482 creates a UNIHDR2 structure.
483 ********************************************************************/
485 void init_uni_hdr2(UNIHDR2
*hdr
, UNISTR2
*str2
)
487 init_uni_hdr(&hdr
->unihdr
, str2
);
488 hdr
->buffer
= (str2
->uni_str_len
> 0) ? 1 : 0;
491 /*******************************************************************
492 Reads or writes a UNIHDR2 structure.
493 ********************************************************************/
495 BOOL
smb_io_unihdr2(const char *desc
, UNIHDR2
*hdr2
, prs_struct
*ps
, int depth
)
500 prs_debug(ps
, depth
, desc
, "smb_io_unihdr2");
506 if(!smb_io_unihdr("hdr", &hdr2
->unihdr
, ps
, depth
))
508 if(!prs_uint32("buffer", ps
, depth
, &hdr2
->buffer
))
514 /*******************************************************************
515 Inits a UNISTR structure.
516 ********************************************************************/
518 void init_unistr(UNISTR
*str
, const char *buf
)
528 len
= strlen(buf
) + 1;
530 if (len
< MAX_UNISTRLEN
)
532 len
*= sizeof(uint16
);
534 str
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
535 if (str
->buffer
== NULL
)
536 smb_panic("init_unistr: malloc fail\n");
538 rpcstr_push(str
->buffer
, buf
, len
, STR_TERMINATE
);
541 /*******************************************************************
542 reads or writes a UNISTR structure.
543 XXXX NOTE: UNISTR structures NEED to be null-terminated.
544 ********************************************************************/
546 BOOL
smb_io_unistr(const char *desc
, UNISTR
*uni
, prs_struct
*ps
, int depth
)
551 prs_debug(ps
, depth
, desc
, "smb_io_unistr");
554 if(!prs_unistr("unistr", ps
, depth
, uni
))
560 /*******************************************************************
561 Allocate the BUFFER3 memory.
562 ********************************************************************/
564 static void create_buffer3(BUFFER3
*str
, size_t len
)
566 if (len
< MAX_BUFFERLEN
)
569 str
->buffer
= talloc_zero(get_talloc_ctx(), len
);
570 if (str
->buffer
== NULL
)
571 smb_panic("create_buffer3: talloc fail\n");
575 /*******************************************************************
576 Inits a BUFFER3 structure from a uint32
577 ********************************************************************/
579 void init_buffer3_uint32(BUFFER3
*str
, uint32 val
)
583 /* set up string lengths. */
584 str
->buf_max_len
= sizeof(uint32
);
585 str
->buf_len
= sizeof(uint32
);
587 create_buffer3(str
, sizeof(uint32
));
588 SIVAL(str
->buffer
, 0, val
);
591 /*******************************************************************
592 Inits a BUFFER3 structure.
593 ********************************************************************/
595 void init_buffer3_str(BUFFER3
*str
, const char *buf
, int len
)
599 /* set up string lengths. */
600 str
->buf_max_len
= len
* 2;
601 str
->buf_len
= len
* 2;
603 create_buffer3(str
, str
->buf_max_len
);
605 rpcstr_push(str
->buffer
, buf
, str
->buf_max_len
, STR_TERMINATE
);
609 /*******************************************************************
610 Inits a BUFFER3 structure from a hex string.
611 ********************************************************************/
613 void init_buffer3_hex(BUFFER3
*str
, const char *buf
)
616 create_buffer3(str
, strlen(buf
));
617 str
->buf_max_len
= str
->buf_len
= strhex_to_str((char *)str
->buffer
, sizeof(str
->buffer
), buf
);
620 /*******************************************************************
621 Inits a BUFFER3 structure.
622 ********************************************************************/
624 void init_buffer3_bytes(BUFFER3
*str
, uint8
*buf
, int len
)
628 /* max buffer size (allocated size) */
629 str
->buf_max_len
= len
;
631 create_buffer3(str
, len
);
632 memcpy(str
->buffer
, buf
, len
);
634 str
->buf_len
= buf
!= NULL
? len
: 0;
637 /*******************************************************************
638 Reads or writes a BUFFER3 structure.
639 the uni_max_len member tells you how large the buffer is.
640 the uni_str_len member tells you how much of the buffer is really used.
641 ********************************************************************/
643 BOOL
smb_io_buffer3(const char *desc
, BUFFER3
*buf3
, prs_struct
*ps
, int depth
)
648 prs_debug(ps
, depth
, desc
, "smb_io_buffer3");
654 if(!prs_uint32("uni_max_len", ps
, depth
, &buf3
->buf_max_len
))
657 if (UNMARSHALLING(ps
)) {
658 buf3
->buffer
= (unsigned char *)prs_alloc_mem(ps
, buf3
->buf_max_len
);
659 if (buf3
->buffer
== NULL
)
663 if(!prs_uint8s(True
, "buffer ", ps
, depth
, buf3
->buffer
, buf3
->buf_max_len
))
666 if(!prs_uint32("buf_len ", ps
, depth
, &buf3
->buf_len
))
672 /*******************************************************************
673 reads or writes a BUFFER5 structure.
674 the buf_len member tells you how large the buffer is.
675 ********************************************************************/
676 BOOL
smb_io_buffer5(const char *desc
, BUFFER5
*buf5
, prs_struct
*ps
, int depth
)
678 prs_debug(ps
, depth
, desc
, "smb_io_buffer5");
681 if (buf5
== NULL
) return False
;
685 if(!prs_uint32("buf_len", ps
, depth
, &buf5
->buf_len
))
689 if(!prs_buffer5(True
, "buffer" , ps
, depth
, buf5
))
696 /*******************************************************************
697 Inits a BUFFER2 structure.
698 ********************************************************************/
700 void init_buffer2(BUFFER2
*str
, const uint8
*buf
, size_t len
)
704 /* max buffer size (allocated size) */
705 str
->buf_max_len
= len
;
707 str
->buf_len
= buf
!= NULL
? len
: 0;
710 if (len
< MAX_BUFFERLEN
)
712 str
->buffer
= talloc_zero(get_talloc_ctx(), len
);
713 if (str
->buffer
== NULL
)
714 smb_panic("init_buffer2: talloc fail\n");
715 memcpy(str
->buffer
, buf
, MIN(str
->buf_len
, len
));
719 /*******************************************************************
720 Reads or writes a BUFFER2 structure.
721 the uni_max_len member tells you how large the buffer is.
722 the uni_str_len member tells you how much of the buffer is really used.
723 ********************************************************************/
725 BOOL
smb_io_buffer2(const char *desc
, BUFFER2
*buf2
, uint32 buffer
, prs_struct
*ps
, int depth
)
732 prs_debug(ps
, depth
, desc
, "smb_io_buffer2");
738 if(!prs_uint32("uni_max_len", ps
, depth
, &buf2
->buf_max_len
))
740 if(!prs_uint32("offset ", ps
, depth
, &buf2
->offset
))
742 if(!prs_uint32("buf_len ", ps
, depth
, &buf2
->buf_len
))
745 /* buffer advanced by indicated length of string
746 NOT by searching for null-termination */
748 if(!prs_buffer2(True
, "buffer ", ps
, depth
, buf2
))
753 prs_debug(ps
, depth
, desc
, "smb_io_buffer2 - NULL");
755 memset((char *)buf2
, '\0', sizeof(*buf2
));
761 /*******************************************************************
762 creates a UNISTR2 structure: sets up the buffer, too
763 ********************************************************************/
765 void init_buf_unistr2(UNISTR2
*str
, uint32
*ptr
, const char *buf
)
769 init_unistr2(str
, buf
, UNI_STR_TERMINATE
);
772 init_unistr2(str
, NULL
, UNI_FLAGS_NONE
);
777 /*******************************************************************
778 Copies a UNISTR2 structure.
779 ********************************************************************/
781 void copy_unistr2(UNISTR2
*str
, const UNISTR2
*from
)
783 str
->uni_max_len
= from
->uni_max_len
;
784 str
->offset
= from
->offset
;
785 str
->uni_str_len
= from
->uni_str_len
;
787 if (from
->buffer
== NULL
)
790 /* the string buffer is allocated to the maximum size
791 (the the length of the source string) to prevent
792 reallocation of memory. */
793 if (str
->buffer
== NULL
) {
794 size_t len
= from
->uni_max_len
* sizeof(uint16
);
796 if (len
< MAX_UNISTRLEN
)
798 len
*= sizeof(uint16
);
800 str
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
801 if ((str
->buffer
== NULL
) && (len
> 0 )) {
802 smb_panic("copy_unistr2: talloc fail\n");
807 /* copy the string */
808 memcpy(str
->buffer
, from
->buffer
, from
->uni_max_len
*sizeof(uint16
));
811 /*******************************************************************
812 Creates a STRING2 structure.
813 ********************************************************************/
815 void init_string2(STRING2
*str
, const char *buf
, int max_len
, int str_len
)
819 /* set up string lengths. */
820 str
->str_max_len
= max_len
;
822 str
->str_str_len
= str_len
;
824 /* store the string */
826 if (str_len
< MAX_STRINGLEN
)
827 alloc_len
= MAX_STRINGLEN
;
828 str
->buffer
= talloc_zero(get_talloc_ctx(), alloc_len
);
829 if (str
->buffer
== NULL
)
830 smb_panic("init_string2: malloc fail\n");
831 memcpy(str
->buffer
, buf
, str_len
);
835 /*******************************************************************
836 Reads or writes a STRING2 structure.
837 XXXX NOTE: STRING2 structures need NOT be null-terminated.
838 the str_str_len member tells you how long the string is;
839 the str_max_len member tells you how large the buffer is.
840 ********************************************************************/
842 BOOL
smb_io_string2(const char *desc
, STRING2
*str2
, uint32 buffer
, prs_struct
*ps
, int depth
)
849 prs_debug(ps
, depth
, desc
, "smb_io_string2");
855 if(!prs_uint32("str_max_len", ps
, depth
, &str2
->str_max_len
))
857 if(!prs_uint32("offset ", ps
, depth
, &str2
->offset
))
859 if(!prs_uint32("str_str_len", ps
, depth
, &str2
->str_str_len
))
862 /* buffer advanced by indicated length of string
863 NOT by searching for null-termination */
864 if(!prs_string2(True
, "buffer ", ps
, depth
, str2
))
869 prs_debug(ps
, depth
, desc
, "smb_io_string2 - NULL");
871 memset((char *)str2
, '\0', sizeof(*str2
));
878 /*******************************************************************
879 Inits a UNISTR2 structure.
880 ********************************************************************/
882 void init_unistr2(UNISTR2
*str
, const char *buf
, enum unistr2_term_codes flags
)
885 uint32 num_chars
= 0;
888 /* We always null terminate the copy. */
889 len
= strlen(buf
) + 1;
892 if (len
< MAX_UNISTRLEN
)
894 len
*= sizeof(uint16
);
896 str
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
897 if ((str
->buffer
== NULL
) && (len
> 0)) {
898 smb_panic("init_unistr2: malloc fail\n");
903 * The UNISTR2 must be initialized !!!
907 rpcstr_push((char *)str
->buffer
, buf
, len
, STR_TERMINATE
);
908 num_chars
= strlen_w(str
->buffer
);
909 if (flags
== STR_TERMINATE
|| flags
== UNI_MAXLEN_TERMINATE
) {
914 str
->uni_max_len
= num_chars
;
916 str
->uni_str_len
= num_chars
;
917 if (num_chars
&& (flags
== UNI_MAXLEN_TERMINATE
))
922 * Inits a UNISTR2 structure.
923 * @param ctx talloc context to allocate string on
924 * @param str pointer to string to create
925 * @param buf UCS2 null-terminated buffer to init from
928 void init_unistr2_w(TALLOC_CTX
*ctx
, UNISTR2
*str
, const smb_ucs2_t
*buf
)
930 uint32 len
= strlen_w(buf
);
931 uint32 max_len
= len
;
936 /* set up string lengths. */
937 str
->uni_max_len
= len
;
939 str
->uni_str_len
= len
;
941 if (max_len
< MAX_UNISTRLEN
)
942 max_len
= MAX_UNISTRLEN
;
944 alloc_len
= (max_len
+ 1) * sizeof(uint16
);
946 str
->buffer
= (uint16
*)talloc_zero(ctx
, alloc_len
);
947 if ((str
->buffer
== NULL
) && (alloc_len
> 0)) {
948 smb_panic("init_unistr2_w: malloc fail\n");
953 * don't move this test above ! The UNISTR2 must be initialized !!!
959 /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
960 long as the buffer above is talloc()ed correctly then this
961 is the correct thing to do */
962 strncpy_w(str
->buffer
, buf
, len
+ 1);
965 /*******************************************************************
966 Inits a UNISTR2 structure from a UNISTR
967 ********************************************************************/
969 void init_unistr2_from_unistr(UNISTR2
*to
, const UNISTR
*from
)
973 /* the destination UNISTR2 should never be NULL.
974 if it is it is a programming error */
976 /* if the source UNISTR is NULL, then zero out
977 the destination string and return */
979 if ((from
== NULL
) || (from
->buffer
== NULL
))
982 /* get the length; UNISTR must be NULL terminated */
984 while ((from
->buffer
)[i
]!='\0')
986 i
++; /* one more to catch the terminating NULL */
987 /* is this necessary -- jerry? I need to think */
989 /* set up string lengths; uni_max_len is set to i+1
990 because we need to account for the final NULL termination */
995 /* allocate the space and copy the string buffer */
996 to
->buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), sizeof(uint16
)*(to
->uni_str_len
));
997 if (to
->buffer
== NULL
)
998 smb_panic("init_unistr2_from_unistr: malloc fail\n");
999 memcpy(to
->buffer
, from
->buffer
, to
->uni_max_len
*sizeof(uint16
));
1003 /*******************************************************************
1004 Inits a UNISTR2 structure from a DATA_BLOB.
1005 The length of the data_blob must count the bytes of the buffer.
1006 Copies the blob data.
1007 ********************************************************************/
1009 void init_unistr2_from_datablob(UNISTR2
*str
, DATA_BLOB
*blob
)
1011 /* Allocs the unistring */
1012 init_unistr2(str
, NULL
, UNI_FLAGS_NONE
);
1014 /* Sets the values */
1015 str
->uni_str_len
= blob
->length
/ sizeof(uint16
);
1016 str
->uni_max_len
= str
->uni_str_len
;
1018 str
->buffer
= (uint16
*) memdup(blob
->data
, blob
->length
);
1020 smb_panic("init_unistr2_from_datablob: malloc fail\n");
1024 /*******************************************************************
1025 Reads or writes a UNISTR2 structure.
1026 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
1027 the uni_str_len member tells you how long the string is;
1028 the uni_max_len member tells you how large the buffer is.
1029 ********************************************************************/
1031 BOOL
smb_io_unistr2(const char *desc
, UNISTR2
*uni2
, uint32 buffer
, prs_struct
*ps
, int depth
)
1038 prs_debug(ps
, depth
, desc
, "smb_io_unistr2");
1044 if(!prs_uint32("uni_max_len", ps
, depth
, &uni2
->uni_max_len
))
1046 if(!prs_uint32("offset ", ps
, depth
, &uni2
->offset
))
1048 if(!prs_uint32("uni_str_len", ps
, depth
, &uni2
->uni_str_len
))
1051 /* buffer advanced by indicated length of string
1052 NOT by searching for null-termination */
1053 if(!prs_unistr2(True
, "buffer ", ps
, depth
, uni2
))
1058 prs_debug(ps
, depth
, desc
, "smb_io_unistr2 - NULL");
1060 memset((char *)uni2
, '\0', sizeof(*uni2
));
1069 initialise a UNISTR_ARRAY from a char**
1071 BOOL
init_unistr2_array(UNISTR2_ARRAY
*array
,
1072 uint32 count
, const char **strings
)
1076 array
->count
= count
;
1077 array
->ref_id
= count
?1:0;
1078 if (array
->count
== 0) {
1082 array
->strings
= (UNISTR2_ARRAY_EL
*)talloc_zero(get_talloc_ctx(), count
* sizeof(UNISTR2_ARRAY_EL
));
1083 if (!array
->strings
) {
1087 for (i
=0;i
<count
;i
++) {
1088 init_unistr2(&array
->strings
[i
].string
, strings
[i
], UNI_FLAGS_NONE
);
1089 array
->strings
[i
].size
= array
->strings
[i
].string
.uni_max_len
*2;
1090 array
->strings
[i
].length
= array
->strings
[i
].size
;
1091 array
->strings
[i
].ref_id
= 1;
1097 /*******************************************************************
1098 Reads or writes a UNISTR2_ARRAY structure.
1099 ********************************************************************/
1100 BOOL
smb_io_unistr2_array(const char *desc
, UNISTR2_ARRAY
*array
, prs_struct
*ps
, int depth
)
1104 prs_debug(ps
, depth
, desc
, "smb_io_unistr2_array");
1107 if(!prs_uint32("ref_id", ps
, depth
, &array
->ref_id
))
1110 if (! array
->ref_id
) {
1114 if(!prs_uint32("count", ps
, depth
, &array
->count
))
1117 if (array
->count
== 0) {
1121 if (UNMARSHALLING(ps
)) {
1122 array
->strings
= talloc_zero(get_talloc_ctx(), array
->count
* sizeof(array
->strings
[0]));
1124 if (! array
->strings
) {
1128 for (i
=0;i
<array
->count
;i
++) {
1129 if(!prs_uint16("length", ps
, depth
, &array
->strings
[i
].length
))
1131 if(!prs_uint16("size", ps
, depth
, &array
->strings
[i
].size
))
1133 if(!prs_uint32("ref_id", ps
, depth
, &array
->strings
[i
].ref_id
))
1137 for (i
=0;i
<array
->count
;i
++) {
1138 if (! smb_io_unistr2("string", &array
->strings
[i
].string
, array
->strings
[i
].ref_id
, ps
, depth
))
1146 /*******************************************************************
1147 Inits a DOM_RID2 structure.
1148 ********************************************************************/
1150 void init_dom_rid2(DOM_RID2
*rid2
, uint32 rid
, uint8 type
, uint32 idx
)
1154 rid2
->rid_idx
= idx
;
1157 /*******************************************************************
1158 Reads or writes a DOM_RID2 structure.
1159 ********************************************************************/
1161 BOOL
smb_io_dom_rid2(const char *desc
, DOM_RID2
*rid2
, prs_struct
*ps
, int depth
)
1166 prs_debug(ps
, depth
, desc
, "smb_io_dom_rid2");
1172 if(!prs_uint8("type ", ps
, depth
, &rid2
->type
))
1176 if(!prs_uint32("rid ", ps
, depth
, &rid2
->rid
))
1178 if(!prs_uint32("rid_idx", ps
, depth
, &rid2
->rid_idx
))
1184 /*******************************************************************
1185 creates a DOM_RID3 structure.
1186 ********************************************************************/
1188 void init_dom_rid3(DOM_RID3
*rid3
, uint32 rid
, uint8 type
)
1192 rid3
->ptr_type
= 0x1; /* non-zero, basically. */
1197 /*******************************************************************
1198 reads or writes a DOM_RID3 structure.
1199 ********************************************************************/
1201 BOOL
smb_io_dom_rid3(const char *desc
, DOM_RID3
*rid3
, prs_struct
*ps
, int depth
)
1206 prs_debug(ps
, depth
, desc
, "smb_io_dom_rid3");
1212 if(!prs_uint32("rid ", ps
, depth
, &rid3
->rid
))
1214 if(!prs_uint32("type1 ", ps
, depth
, &rid3
->type1
))
1216 if(!prs_uint32("ptr_type", ps
, depth
, &rid3
->ptr_type
))
1218 if(!prs_uint32("type2 ", ps
, depth
, &rid3
->type2
))
1220 if(!prs_uint32("unk ", ps
, depth
, &rid3
->unk
))
1226 /*******************************************************************
1227 Inits a DOM_RID4 structure.
1228 ********************************************************************/
1230 void init_dom_rid4(DOM_RID4
*rid4
, uint16 unknown
, uint16 attr
, uint32 rid
)
1232 rid4
->unknown
= unknown
;
1237 /*******************************************************************
1238 Inits a DOM_CLNT_SRV structure.
1239 ********************************************************************/
1241 static void init_clnt_srv(DOM_CLNT_SRV
*logcln
, const char *logon_srv
, const char *comp_name
)
1243 DEBUG(5,("init_clnt_srv: %d\n", __LINE__
));
1245 if (logon_srv
!= NULL
) {
1246 logcln
->undoc_buffer
= 1;
1247 init_unistr2(&logcln
->uni_logon_srv
, logon_srv
, UNI_STR_TERMINATE
);
1249 logcln
->undoc_buffer
= 0;
1252 if (comp_name
!= NULL
) {
1253 logcln
->undoc_buffer2
= 1;
1254 init_unistr2(&logcln
->uni_comp_name
, comp_name
, UNI_STR_TERMINATE
);
1256 logcln
->undoc_buffer2
= 0;
1260 /*******************************************************************
1261 Inits or writes a DOM_CLNT_SRV structure.
1262 ********************************************************************/
1264 static BOOL
smb_io_clnt_srv(const char *desc
, DOM_CLNT_SRV
*logcln
, prs_struct
*ps
, int depth
)
1269 prs_debug(ps
, depth
, desc
, "smb_io_clnt_srv");
1275 if(!prs_uint32("undoc_buffer ", ps
, depth
, &logcln
->undoc_buffer
))
1278 if (logcln
->undoc_buffer
!= 0) {
1279 if(!smb_io_unistr2("unistr2", &logcln
->uni_logon_srv
, logcln
->undoc_buffer
, ps
, depth
))
1286 if(!prs_uint32("undoc_buffer2", ps
, depth
, &logcln
->undoc_buffer2
))
1289 if (logcln
->undoc_buffer2
!= 0) {
1290 if(!smb_io_unistr2("unistr2", &logcln
->uni_comp_name
, logcln
->undoc_buffer2
, ps
, depth
))
1297 /*******************************************************************
1298 Inits a DOM_LOG_INFO structure.
1299 ********************************************************************/
1301 void init_log_info(DOM_LOG_INFO
*loginfo
, const char *logon_srv
, const char *acct_name
,
1302 uint16 sec_chan
, const char *comp_name
)
1304 DEBUG(5,("make_log_info %d\n", __LINE__
));
1306 loginfo
->undoc_buffer
= 1;
1308 init_unistr2(&loginfo
->uni_logon_srv
, logon_srv
, UNI_STR_TERMINATE
);
1309 init_unistr2(&loginfo
->uni_acct_name
, acct_name
, UNI_STR_TERMINATE
);
1311 loginfo
->sec_chan
= sec_chan
;
1313 init_unistr2(&loginfo
->uni_comp_name
, comp_name
, UNI_STR_TERMINATE
);
1316 /*******************************************************************
1317 Reads or writes a DOM_LOG_INFO structure.
1318 ********************************************************************/
1320 BOOL
smb_io_log_info(const char *desc
, DOM_LOG_INFO
*loginfo
, prs_struct
*ps
, int depth
)
1322 if (loginfo
== NULL
)
1325 prs_debug(ps
, depth
, desc
, "smb_io_log_info");
1331 if(!prs_uint32("undoc_buffer", ps
, depth
, &loginfo
->undoc_buffer
))
1334 if(!smb_io_unistr2("unistr2", &loginfo
->uni_logon_srv
, True
, ps
, depth
))
1336 if(!smb_io_unistr2("unistr2", &loginfo
->uni_acct_name
, True
, ps
, depth
))
1339 if(!prs_uint16("sec_chan", ps
, depth
, &loginfo
->sec_chan
))
1342 if(!smb_io_unistr2("unistr2", &loginfo
->uni_comp_name
, True
, ps
, depth
))
1348 /*******************************************************************
1349 Reads or writes a DOM_CHAL structure.
1350 ********************************************************************/
1352 BOOL
smb_io_chal(const char *desc
, DOM_CHAL
*chal
, prs_struct
*ps
, int depth
)
1357 prs_debug(ps
, depth
, desc
, "smb_io_chal");
1360 if(!prs_uint8s (False
, "data", ps
, depth
, chal
->data
, 8))
1366 /*******************************************************************
1367 Reads or writes a DOM_CRED structure.
1368 ********************************************************************/
1370 BOOL
smb_io_cred(const char *desc
, DOM_CRED
*cred
, prs_struct
*ps
, int depth
)
1375 prs_debug(ps
, depth
, desc
, "smb_io_cred");
1381 if(!smb_io_chal ("", &cred
->challenge
, ps
, depth
))
1384 if(!smb_io_utime("", &cred
->timestamp
, ps
, depth
))
1390 /*******************************************************************
1391 Inits a DOM_CLNT_INFO2 structure.
1392 ********************************************************************/
1394 void init_clnt_info2(DOM_CLNT_INFO2
*clnt
,
1395 const char *logon_srv
, const char *comp_name
,
1396 const DOM_CRED
*clnt_cred
)
1398 DEBUG(5,("make_clnt_info: %d\n", __LINE__
));
1400 init_clnt_srv(&clnt
->login
, logon_srv
, comp_name
);
1402 if (clnt_cred
!= NULL
) {
1404 memcpy(&clnt
->cred
, clnt_cred
, sizeof(clnt
->cred
));
1410 /*******************************************************************
1411 Reads or writes a DOM_CLNT_INFO2 structure.
1412 ********************************************************************/
1414 BOOL
smb_io_clnt_info2(const char *desc
, DOM_CLNT_INFO2
*clnt
, prs_struct
*ps
, int depth
)
1419 prs_debug(ps
, depth
, desc
, "smb_io_clnt_info2");
1425 if(!smb_io_clnt_srv("", &clnt
->login
, ps
, depth
))
1431 if(!prs_uint32("ptr_cred", ps
, depth
, &clnt
->ptr_cred
))
1433 if(!smb_io_cred("", &clnt
->cred
, ps
, depth
))
1439 /*******************************************************************
1440 Inits a DOM_CLNT_INFO structure.
1441 ********************************************************************/
1443 void init_clnt_info(DOM_CLNT_INFO
*clnt
,
1444 const char *logon_srv
, const char *acct_name
,
1445 uint16 sec_chan
, const char *comp_name
,
1446 const DOM_CRED
*cred
)
1448 DEBUG(5,("make_clnt_info\n"));
1450 init_log_info(&clnt
->login
, logon_srv
, acct_name
, sec_chan
, comp_name
);
1451 memcpy(&clnt
->cred
, cred
, sizeof(clnt
->cred
));
1454 /*******************************************************************
1455 Reads or writes a DOM_CLNT_INFO structure.
1456 ********************************************************************/
1458 BOOL
smb_io_clnt_info(const char *desc
, DOM_CLNT_INFO
*clnt
, prs_struct
*ps
, int depth
)
1463 prs_debug(ps
, depth
, desc
, "smb_io_clnt_info");
1469 if(!smb_io_log_info("", &clnt
->login
, ps
, depth
))
1471 if(!smb_io_cred("", &clnt
->cred
, ps
, depth
))
1477 /*******************************************************************
1478 Inits a DOM_LOGON_ID structure.
1479 ********************************************************************/
1481 void init_logon_id(DOM_LOGON_ID
*logonid
, uint32 log_id_low
, uint32 log_id_high
)
1483 DEBUG(5,("make_logon_id: %d\n", __LINE__
));
1485 logonid
->low
= log_id_low
;
1486 logonid
->high
= log_id_high
;
1489 /*******************************************************************
1490 Reads or writes a DOM_LOGON_ID structure.
1491 ********************************************************************/
1493 BOOL
smb_io_logon_id(const char *desc
, DOM_LOGON_ID
*logonid
, prs_struct
*ps
, int depth
)
1495 if (logonid
== NULL
)
1498 prs_debug(ps
, depth
, desc
, "smb_io_logon_id");
1504 if(!prs_uint32("low ", ps
, depth
, &logonid
->low
))
1506 if(!prs_uint32("high", ps
, depth
, &logonid
->high
))
1512 /*******************************************************************
1513 Inits an OWF_INFO structure.
1514 ********************************************************************/
1516 void init_owf_info(OWF_INFO
*hash
, const uint8 data
[16])
1518 DEBUG(5,("init_owf_info: %d\n", __LINE__
));
1521 memcpy(hash
->data
, data
, sizeof(hash
->data
));
1523 memset((char *)hash
->data
, '\0', sizeof(hash
->data
));
1526 /*******************************************************************
1527 Reads or writes an OWF_INFO structure.
1528 ********************************************************************/
1530 BOOL
smb_io_owf_info(const char *desc
, OWF_INFO
*hash
, prs_struct
*ps
, int depth
)
1535 prs_debug(ps
, depth
, desc
, "smb_io_owf_info");
1541 if(!prs_uint8s (False
, "data", ps
, depth
, hash
->data
, 16))
1547 /*******************************************************************
1548 Reads or writes a DOM_GID structure.
1549 ********************************************************************/
1551 BOOL
smb_io_gid(const char *desc
, DOM_GID
*gid
, prs_struct
*ps
, int depth
)
1556 prs_debug(ps
, depth
, desc
, "smb_io_gid");
1562 if(!prs_uint32("g_rid", ps
, depth
, &gid
->g_rid
))
1564 if(!prs_uint32("attr ", ps
, depth
, &gid
->attr
))
1570 /*******************************************************************
1571 Reads or writes an POLICY_HND structure.
1572 ********************************************************************/
1574 BOOL
smb_io_pol_hnd(const char *desc
, POLICY_HND
*pol
, prs_struct
*ps
, int depth
)
1579 prs_debug(ps
, depth
, desc
, "smb_io_pol_hnd");
1585 if(UNMARSHALLING(ps
))
1588 if (!prs_uint32("data1", ps
, depth
, &pol
->data1
))
1590 if (!prs_uint32("data2", ps
, depth
, &pol
->data2
))
1592 if (!prs_uint16("data3", ps
, depth
, &pol
->data3
))
1594 if (!prs_uint16("data4", ps
, depth
, &pol
->data4
))
1596 if(!prs_uint8s (False
, "data5", ps
, depth
, pol
->data5
, sizeof(pol
->data5
)))
1602 /*******************************************************************
1604 ********************************************************************/
1606 void init_unistr3(UNISTR3
*str
, const char *buf
)
1612 str
->str
.buffer
= NULL
;
1616 len
= strlen(buf
) + 1;
1618 str
->uni_str_len
=len
;
1620 if (len
< MAX_UNISTRLEN
)
1621 len
= MAX_UNISTRLEN
;
1623 len
*= sizeof(uint16
);
1625 str
->str
.buffer
= (uint16
*)talloc_zero(get_talloc_ctx(), len
);
1626 if (str
->str
.buffer
== NULL
)
1627 smb_panic("init_unistr3: malloc fail\n");
1629 rpcstr_push((char *)str
->str
.buffer
, buf
, len
, STR_TERMINATE
);
1632 /*******************************************************************
1633 Reads or writes a UNISTR3 structure.
1634 ********************************************************************/
1636 BOOL
smb_io_unistr3(const char *desc
, UNISTR3
*name
, prs_struct
*ps
, int depth
)
1641 prs_debug(ps
, depth
, desc
, "smb_io_unistr3");
1647 if(!prs_uint32("uni_str_len", ps
, depth
, &name
->uni_str_len
))
1650 /* don't know if len is specified by uni_str_len member... */
1651 /* assume unicode string is unicode-null-terminated, instead */
1653 if(!prs_unistr3(True
, "unistr", name
, ps
, depth
))
1660 /*******************************************************************
1661 Stream a uint64_struct
1662 ********************************************************************/
1663 BOOL
prs_uint64(const char *name
, prs_struct
*ps
, int depth
, UINT64_S
*data64
)
1665 return prs_uint32(name
, ps
, depth
+1, &data64
->low
) &&
1666 prs_uint32(name
, ps
, depth
+1, &data64
->high
);
1669 /*******************************************************************
1670 reads or writes a BUFHDR2 structure.
1671 ********************************************************************/
1672 BOOL
smb_io_bufhdr2(const char *desc
, BUFHDR2
*hdr
, prs_struct
*ps
, int depth
)
1674 prs_debug(ps
, depth
, desc
, "smb_io_bufhdr2");
1678 prs_uint32("info_level", ps
, depth
, &(hdr
->info_level
));
1679 prs_uint32("length ", ps
, depth
, &(hdr
->length
));
1680 prs_uint32("buffer ", ps
, depth
, &(hdr
->buffer
));
1685 /*******************************************************************
1686 reads or writes a BUFFER4 structure.
1687 ********************************************************************/
1688 BOOL
smb_io_buffer4(const char *desc
, BUFFER4
*buf4
, uint32 buffer
, prs_struct
*ps
, int depth
)
1690 prs_debug(ps
, depth
, desc
, "smb_io_buffer4");
1694 prs_uint32("buf_len", ps
, depth
, &(buf4
->buf_len
));
1696 if (buf4
->buf_len
> MAX_BUFFERLEN
)
1698 buf4
->buf_len
= MAX_BUFFERLEN
;
1701 prs_uint8s(True
, "buffer", ps
, depth
, buf4
->buffer
, buf4
->buf_len
);
1706 /*******************************************************************
1707 creates a UNIHDR structure.
1708 ********************************************************************/
1710 BOOL
make_uni_hdr(UNIHDR
*hdr
, int len
)
1716 hdr
->uni_str_len
= 2 * len
;
1717 hdr
->uni_max_len
= 2 * len
;
1718 hdr
->buffer
= len
!= 0 ? 1 : 0;
1723 /*******************************************************************
1724 creates a BUFHDR2 structure.
1725 ********************************************************************/
1726 BOOL
make_bufhdr2(BUFHDR2
*hdr
, uint32 info_level
, uint32 length
, uint32 buffer
)
1728 hdr
->info_level
= info_level
;
1729 hdr
->length
= length
;
1730 hdr
->buffer
= buffer
;