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, int len)
366 hdr->uni_str_len = 2 * len;
367 hdr->uni_max_len = 2 * len;
368 hdr->buffer = 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, int len)
487 init_uni_hdr(&hdr->unihdr, len);
488 hdr->buffer = (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, int 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("undoc ", ps, depth, &buf2->undoc))
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)
770 init_unistr2(str, buf, strlen(buf)+1);
775 init_unistr2(str, "", 0);
780 /*******************************************************************
781 Copies a UNISTR2 structure.
782 ********************************************************************/
784 void copy_unistr2(UNISTR2 *str, const UNISTR2 *from)
787 /* set up string lengths. add one if string is not null-terminated */
788 str->uni_max_len = from->uni_max_len;
789 str->undoc = from->undoc;
790 str->uni_str_len = from->uni_str_len;
792 if (from->buffer == NULL)
795 /* the string buffer is allocated to the maximum size
796 (the the length of the source string) to prevent
797 reallocation of memory. */
798 if (str->buffer == NULL) {
799 size_t len = from->uni_max_len * sizeof(uint16);
801 if (len < MAX_UNISTRLEN)
803 len *= sizeof(uint16);
805 str->buffer = (uint16 *)talloc_zero(get_talloc_ctx(), len);
806 if ((str->buffer == NULL) && (len > 0 ))
808 smb_panic("copy_unistr2: talloc fail\n");
813 /* copy the string */
814 memcpy(str->buffer, from->buffer, from->uni_max_len*sizeof(uint16));
817 /*******************************************************************
818 Creates a STRING2 structure.
819 ********************************************************************/
821 void init_string2(STRING2 *str, const char *buf, int max_len, int str_len)
825 /* set up string lengths. */
826 str->str_max_len = max_len;
828 str->str_str_len = str_len;
830 /* store the string */
832 if (str_len < MAX_STRINGLEN)
833 alloc_len = MAX_STRINGLEN;
834 str->buffer = talloc_zero(get_talloc_ctx(), alloc_len);
835 if (str->buffer == NULL)
836 smb_panic("init_string2: malloc fail\n");
837 memcpy(str->buffer, buf, str_len);
841 /*******************************************************************
842 Reads or writes a STRING2 structure.
843 XXXX NOTE: STRING2 structures need NOT be null-terminated.
844 the str_str_len member tells you how long the string is;
845 the str_max_len member tells you how large the buffer is.
846 ********************************************************************/
848 BOOL smb_io_string2(const char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
855 prs_debug(ps, depth, desc, "smb_io_string2");
861 if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len))
863 if(!prs_uint32("undoc ", ps, depth, &str2->undoc))
865 if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len))
868 /* buffer advanced by indicated length of string
869 NOT by searching for null-termination */
870 if(!prs_string2(True, "buffer ", ps, depth, str2))
875 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
877 memset((char *)str2, '\0', sizeof(*str2));
884 /*******************************************************************
885 Inits a UNISTR2 structure.
886 ********************************************************************/
888 void init_unistr2(UNISTR2 *str, const char *buf, size_t len)
892 /* set up string lengths. */
893 str->uni_max_len = (uint32)len;
895 str->uni_str_len = (uint32)len;
897 if (len < MAX_UNISTRLEN)
899 len *= sizeof(uint16);
901 str->buffer = (uint16 *)talloc_zero(get_talloc_ctx(), len);
902 if ((str->buffer == NULL) && (len > 0))
904 smb_panic("init_unistr2: malloc fail\n");
909 * don't move this test above ! The UNISTR2 must be initialized !!!
915 rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE);
919 * Inits a UNISTR2 structure.
920 * @param ctx talloc context to allocate string on
921 * @param str pointer to string to create
922 * @param buf UCS2 null-terminated buffer to init from
925 void init_unistr2_w(TALLOC_CTX *ctx, UNISTR2 *str, const smb_ucs2_t *buf)
927 uint32 len = strlen_w(buf);
928 uint32 max_len = len;
933 /* set up string lengths. */
934 str->uni_max_len = len;
936 str->uni_str_len = len;
938 if (max_len < MAX_UNISTRLEN)
939 max_len = MAX_UNISTRLEN;
941 alloc_len = (max_len + 1) * sizeof(uint16);
943 str->buffer = (uint16 *)talloc_zero(ctx, alloc_len);
944 if ((str->buffer == NULL) && (alloc_len > 0))
946 smb_panic("init_unistr2_w: malloc fail\n");
951 * don't move this test above ! The UNISTR2 must be initialized !!!
957 /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
958 long as the buffer above is talloc()ed correctly then this
959 is the correct thing to do */
960 strncpy_w(str->buffer, buf, len + 1);
963 /*******************************************************************
964 Inits a UNISTR2 structure from a UNISTR
965 ********************************************************************/
966 void init_unistr2_from_unistr (UNISTR2 *to, const UNISTR *from)
971 /* the destination UNISTR2 should never be NULL.
972 if it is it is a programming error */
974 /* if the source UNISTR is NULL, then zero out
975 the destination string and return */
977 if ((from == NULL) || (from->buffer == NULL))
980 /* get the length; UNISTR must be NULL terminated */
982 while ((from->buffer)[i]!='\0')
984 i++; /* one more to catch the terminating NULL */
985 /* is this necessary -- jerry? I need to think */
987 /* set up string lengths; uni_max_len is set to i+1
988 because we need to account for the final NULL termination */
993 /* allocate the space and copy the string buffer */
994 to->buffer = (uint16 *)talloc_zero(get_talloc_ctx(), sizeof(uint16)*(to->uni_str_len));
995 if (to->buffer == NULL)
996 smb_panic("init_unistr2_from_unistr: malloc fail\n");
997 memcpy(to->buffer, from->buffer, to->uni_max_len*sizeof(uint16));
1003 /*******************************************************************
1004 Reads or writes a UNISTR2 structure.
1005 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
1006 the uni_str_len member tells you how long the string is;
1007 the uni_max_len member tells you how large the buffer is.
1008 ********************************************************************/
1010 BOOL smb_io_unistr2(const char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
1017 prs_debug(ps, depth, desc, "smb_io_unistr2");
1023 if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len))
1025 if(!prs_uint32("undoc ", ps, depth, &uni2->undoc))
1027 if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len))
1030 /* buffer advanced by indicated length of string
1031 NOT by searching for null-termination */
1032 if(!prs_unistr2(True, "buffer ", ps, depth, uni2))
1037 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
1039 memset((char *)uni2, '\0', sizeof(*uni2));
1048 initialise a UNISTR_ARRAY from a char**
1050 BOOL init_unistr2_array(UNISTR2_ARRAY *array,
1051 uint32 count, const char **strings)
1055 array->count = count;
1056 array->ref_id = count?1:0;
1057 if (array->count == 0) {
1061 array->strings = (UNISTR2_ARRAY_EL *)talloc_zero(get_talloc_ctx(), count * sizeof(UNISTR2_ARRAY_EL));
1062 if (!array->strings) {
1066 for (i=0;i<count;i++) {
1067 init_unistr2(&array->strings[i].string, strings[i], strlen(strings[i]));
1068 array->strings[i].size = array->strings[i].string.uni_max_len*2;
1069 array->strings[i].length = array->strings[i].size;
1070 array->strings[i].ref_id = 1;
1076 /*******************************************************************
1077 Reads or writes a UNISTR2_ARRAY structure.
1078 ********************************************************************/
1079 BOOL smb_io_unistr2_array(const char *desc, UNISTR2_ARRAY *array, prs_struct *ps, int depth)
1083 prs_debug(ps, depth, desc, "smb_io_unistr2_array");
1086 if(!prs_uint32("ref_id", ps, depth, &array->ref_id))
1089 if (! array->ref_id) {
1093 if(!prs_uint32("count", ps, depth, &array->count))
1096 if (array->count == 0) {
1100 if (UNMARSHALLING(ps)) {
1101 array->strings = talloc_zero(get_talloc_ctx(), array->count * sizeof(array->strings[0]));
1103 if (! array->strings) {
1107 for (i=0;i<array->count;i++) {
1108 if(!prs_uint16("length", ps, depth, &array->strings[i].length))
1110 if(!prs_uint16("size", ps, depth, &array->strings[i].size))
1112 if(!prs_uint32("ref_id", ps, depth, &array->strings[i].ref_id))
1116 for (i=0;i<array->count;i++) {
1117 if (! smb_io_unistr2("string", &array->strings[i].string, array->strings[i].ref_id, ps, depth))
1125 /*******************************************************************
1126 Reads or writes a SID_ARRAY structure.
1127 ********************************************************************/
1128 BOOL smb_io_sid_array(const char *desc, SID_ARRAY *array, prs_struct *ps, int depth)
1132 prs_debug(ps, depth, desc, "smb_io_sid_array");
1135 if(!prs_uint32("ref_id", ps, depth, &array->ref_id))
1138 if (! array->ref_id) {
1142 if(!prs_uint32("count", ps, depth, &array->count))
1145 if (array->count == 0) {
1149 if (UNMARSHALLING(ps)) {
1150 array->sids = talloc_zero(get_talloc_ctx(), array->count * sizeof(array->sids[0]));
1152 if (! array->sids) {
1156 for (i=0;i<array->count;i++) {
1157 if(!prs_uint32("ref_id", ps, depth, &array->sids[i].ref_id))
1161 for (i=0;i<array->count;i++) {
1162 if (!smb_io_dom_sid2("sid", &array->sids[i].sid, ps, depth))
1170 /*******************************************************************
1171 Inits a DOM_RID2 structure.
1172 ********************************************************************/
1174 void init_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx)
1178 rid2->rid_idx = idx;
1181 /*******************************************************************
1182 Reads or writes a DOM_RID2 structure.
1183 ********************************************************************/
1185 BOOL smb_io_dom_rid2(const char *desc, DOM_RID2 *rid2, prs_struct *ps, int depth)
1190 prs_debug(ps, depth, desc, "smb_io_dom_rid2");
1196 if(!prs_uint8("type ", ps, depth, &rid2->type))
1200 if(!prs_uint32("rid ", ps, depth, &rid2->rid))
1202 if(!prs_uint32("rid_idx", ps, depth, &rid2->rid_idx))
1208 /*******************************************************************
1209 creates a DOM_RID3 structure.
1210 ********************************************************************/
1212 void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
1216 rid3->ptr_type = 0x1; /* non-zero, basically. */
1221 /*******************************************************************
1222 reads or writes a DOM_RID3 structure.
1223 ********************************************************************/
1225 BOOL smb_io_dom_rid3(const char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth)
1230 prs_debug(ps, depth, desc, "smb_io_dom_rid3");
1236 if(!prs_uint32("rid ", ps, depth, &rid3->rid))
1238 if(!prs_uint32("type1 ", ps, depth, &rid3->type1))
1240 if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type))
1242 if(!prs_uint32("type2 ", ps, depth, &rid3->type2))
1244 if(!prs_uint32("unk ", ps, depth, &rid3->unk))
1250 /*******************************************************************
1251 Inits a DOM_RID4 structure.
1252 ********************************************************************/
1254 void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
1256 rid4->unknown = unknown;
1261 /*******************************************************************
1262 Inits a DOM_CLNT_SRV structure.
1263 ********************************************************************/
1265 static void init_clnt_srv(DOM_CLNT_SRV *log, const char *logon_srv, const char *comp_name)
1267 DEBUG(5,("init_clnt_srv: %d\n", __LINE__));
1269 if (logon_srv != NULL) {
1270 log->undoc_buffer = 1;
1271 init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
1273 log->undoc_buffer = 0;
1276 if (comp_name != NULL) {
1277 log->undoc_buffer2 = 1;
1278 init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
1280 log->undoc_buffer2 = 0;
1284 /*******************************************************************
1285 Inits or writes a DOM_CLNT_SRV structure.
1286 ********************************************************************/
1288 static BOOL smb_io_clnt_srv(const char *desc, DOM_CLNT_SRV *log, prs_struct *ps, int depth)
1293 prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1299 if(!prs_uint32("undoc_buffer ", ps, depth, &log->undoc_buffer))
1302 if (log->undoc_buffer != 0) {
1303 if(!smb_io_unistr2("unistr2", &log->uni_logon_srv, log->undoc_buffer, ps, depth))
1310 if(!prs_uint32("undoc_buffer2", ps, depth, &log->undoc_buffer2))
1313 if (log->undoc_buffer2 != 0) {
1314 if(!smb_io_unistr2("unistr2", &log->uni_comp_name, log->undoc_buffer2, ps, depth))
1321 /*******************************************************************
1322 Inits a DOM_LOG_INFO structure.
1323 ********************************************************************/
1325 void init_log_info(DOM_LOG_INFO *log, const char *logon_srv, const char *acct_name,
1326 uint16 sec_chan, const char *comp_name)
1328 DEBUG(5,("make_log_info %d\n", __LINE__));
1330 log->undoc_buffer = 1;
1332 init_unistr2(&log->uni_logon_srv, logon_srv, strlen(logon_srv)+1);
1333 init_unistr2(&log->uni_acct_name, acct_name, strlen(acct_name)+1);
1335 log->sec_chan = sec_chan;
1337 init_unistr2(&log->uni_comp_name, comp_name, strlen(comp_name)+1);
1340 /*******************************************************************
1341 Reads or writes a DOM_LOG_INFO structure.
1342 ********************************************************************/
1344 BOOL smb_io_log_info(const char *desc, DOM_LOG_INFO *log, prs_struct *ps, int depth)
1349 prs_debug(ps, depth, desc, "smb_io_log_info");
1355 if(!prs_uint32("undoc_buffer", ps, depth, &log->undoc_buffer))
1358 if(!smb_io_unistr2("unistr2", &log->uni_logon_srv, True, ps, depth))
1360 if(!smb_io_unistr2("unistr2", &log->uni_acct_name, True, ps, depth))
1363 if(!prs_uint16("sec_chan", ps, depth, &log->sec_chan))
1366 if(!smb_io_unistr2("unistr2", &log->uni_comp_name, True, ps, depth))
1372 /*******************************************************************
1373 Reads or writes a DOM_CHAL structure.
1374 ********************************************************************/
1376 BOOL smb_io_chal(const char *desc, DOM_CHAL *chal, prs_struct *ps, int depth)
1381 prs_debug(ps, depth, desc, "smb_io_chal");
1384 if(!prs_uint8s (False, "data", ps, depth, chal->data, 8))
1390 /*******************************************************************
1391 Reads or writes a DOM_CRED structure.
1392 ********************************************************************/
1394 BOOL smb_io_cred(const char *desc, DOM_CRED *cred, prs_struct *ps, int depth)
1399 prs_debug(ps, depth, desc, "smb_io_cred");
1405 if(!smb_io_chal ("", &cred->challenge, ps, depth))
1408 if(!smb_io_utime("", &cred->timestamp, ps, depth))
1414 /*******************************************************************
1415 Inits a DOM_CLNT_INFO2 structure.
1416 ********************************************************************/
1418 void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1419 const char *logon_srv, const char *comp_name,
1420 const DOM_CRED *clnt_cred)
1422 DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1424 init_clnt_srv(&clnt->login, logon_srv, comp_name);
1426 if (clnt_cred != NULL) {
1428 memcpy(&clnt->cred, clnt_cred, sizeof(clnt->cred));
1434 /*******************************************************************
1435 Reads or writes a DOM_CLNT_INFO2 structure.
1436 ********************************************************************/
1438 BOOL smb_io_clnt_info2(const char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1443 prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1449 if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1455 if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1457 if(!smb_io_cred("", &clnt->cred, ps, depth))
1463 /*******************************************************************
1464 Inits a DOM_CLNT_INFO structure.
1465 ********************************************************************/
1467 void init_clnt_info(DOM_CLNT_INFO *clnt,
1468 const char *logon_srv, const char *acct_name,
1469 uint16 sec_chan, const char *comp_name,
1470 const DOM_CRED *cred)
1472 DEBUG(5,("make_clnt_info\n"));
1474 init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1475 memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1478 /*******************************************************************
1479 Reads or writes a DOM_CLNT_INFO structure.
1480 ********************************************************************/
1482 BOOL smb_io_clnt_info(const char *desc, DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1487 prs_debug(ps, depth, desc, "smb_io_clnt_info");
1493 if(!smb_io_log_info("", &clnt->login, ps, depth))
1495 if(!smb_io_cred("", &clnt->cred, ps, depth))
1501 /*******************************************************************
1502 Inits a DOM_LOGON_ID structure.
1503 ********************************************************************/
1505 void init_logon_id(DOM_LOGON_ID *log, uint32 log_id_low, uint32 log_id_high)
1507 DEBUG(5,("make_logon_id: %d\n", __LINE__));
1509 log->low = log_id_low;
1510 log->high = log_id_high;
1513 /*******************************************************************
1514 Reads or writes a DOM_LOGON_ID structure.
1515 ********************************************************************/
1517 BOOL smb_io_logon_id(const char *desc, DOM_LOGON_ID *log, prs_struct *ps, int depth)
1522 prs_debug(ps, depth, desc, "smb_io_logon_id");
1528 if(!prs_uint32("low ", ps, depth, &log->low ))
1530 if(!prs_uint32("high", ps, depth, &log->high))
1536 /*******************************************************************
1537 Inits an OWF_INFO structure.
1538 ********************************************************************/
1540 void init_owf_info(OWF_INFO *hash, const uint8 data[16])
1542 DEBUG(5,("init_owf_info: %d\n", __LINE__));
1545 memcpy(hash->data, data, sizeof(hash->data));
1547 memset((char *)hash->data, '\0', sizeof(hash->data));
1550 /*******************************************************************
1551 Reads or writes an OWF_INFO structure.
1552 ********************************************************************/
1554 BOOL smb_io_owf_info(const char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1559 prs_debug(ps, depth, desc, "smb_io_owf_info");
1565 if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1571 /*******************************************************************
1572 Reads or writes a DOM_GID structure.
1573 ********************************************************************/
1575 BOOL smb_io_gid(const char *desc, DOM_GID *gid, prs_struct *ps, int depth)
1580 prs_debug(ps, depth, desc, "smb_io_gid");
1586 if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1588 if(!prs_uint32("attr ", ps, depth, &gid->attr))
1594 /*******************************************************************
1595 Reads or writes an POLICY_HND structure.
1596 ********************************************************************/
1598 BOOL smb_io_pol_hnd(const char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1603 prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1609 if(UNMARSHALLING(ps))
1612 if (!prs_uint32("data1", ps, depth, &pol->data1))
1614 if (!prs_uint32("data2", ps, depth, &pol->data2))
1616 if (!prs_uint16("data3", ps, depth, &pol->data3))
1618 if (!prs_uint16("data4", ps, depth, &pol->data4))
1620 if(!prs_uint8s (False, "data5", ps, depth, pol->data5, sizeof(pol->data5)))
1626 /*******************************************************************
1628 ********************************************************************/
1630 void init_unistr3(UNISTR3 *str, const char *buf)
1636 str->str.buffer = NULL;
1640 len = strlen(buf) + 1;
1642 str->uni_str_len=len;
1644 if (len < MAX_UNISTRLEN)
1645 len = MAX_UNISTRLEN;
1647 len *= sizeof(uint16);
1649 str->str.buffer = (uint16 *)talloc_zero(get_talloc_ctx(), len);
1650 if (str->str.buffer == NULL)
1651 smb_panic("init_unistr3: malloc fail\n");
1653 rpcstr_push((char *)str->str.buffer, buf, len, STR_TERMINATE);
1656 /*******************************************************************
1657 Reads or writes a UNISTR3 structure.
1658 ********************************************************************/
1660 BOOL smb_io_unistr3(const char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1665 prs_debug(ps, depth, desc, "smb_io_unistr3");
1671 if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1674 /* don't know if len is specified by uni_str_len member... */
1675 /* assume unicode string is unicode-null-terminated, instead */
1677 if(!prs_unistr3(True, "unistr", name, ps, depth))
1684 /*******************************************************************
1685 Stream a uint64_struct
1686 ********************************************************************/
1687 BOOL prs_uint64(const char *name, prs_struct *ps, int depth, UINT64_S *data64)
1689 return prs_uint32(name, ps, depth+1, &data64->low) &&
1690 prs_uint32(name, ps, depth+1, &data64->high);
1693 /*******************************************************************
1694 reads or writes a BUFHDR2 structure.
1695 ********************************************************************/
1696 BOOL smb_io_bufhdr2(const char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth)
1698 prs_debug(ps, depth, desc, "smb_io_bufhdr2");
1702 prs_uint32("info_level", ps, depth, &(hdr->info_level));
1703 prs_uint32("length ", ps, depth, &(hdr->length ));
1704 prs_uint32("buffer ", ps, depth, &(hdr->buffer ));
1709 /*******************************************************************
1710 reads or writes a BUFFER4 structure.
1711 ********************************************************************/
1712 BOOL smb_io_buffer4(const char *desc, BUFFER4 *buf4, uint32 buffer, prs_struct *ps, int depth)
1714 prs_debug(ps, depth, desc, "smb_io_buffer4");
1718 prs_uint32("buf_len", ps, depth, &(buf4->buf_len));
1720 if (buf4->buf_len > MAX_BUFFERLEN)
1722 buf4->buf_len = MAX_BUFFERLEN;
1725 prs_uint8s(True, "buffer", ps, depth, buf4->buffer, buf4->buf_len);
1730 /*******************************************************************
1731 creates a UNIHDR structure.
1732 ********************************************************************/
1734 BOOL make_uni_hdr(UNIHDR *hdr, int len)
1740 hdr->uni_str_len = 2 * len;
1741 hdr->uni_max_len = 2 * len;
1742 hdr->buffer = len != 0 ? 1 : 0;
1747 /*******************************************************************
1748 creates a BUFHDR2 structure.
1749 ********************************************************************/
1750 BOOL make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer)
1752 hdr->info_level = info_level;
1753 hdr->length = length;
1754 hdr->buffer = buffer;