2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6 * Copyright (C) Paul Ashton 1997.
7 * Copyright (C) Gerald (Jerry) Carter 2005
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #define DBGC_CLASS DBGC_RPC_PARSE
29 /****************************************************************************
30 A temporary TALLOC context for things like unistrs, that is valid for
31 the life of a complete RPC call.
32 ****************************************************************************/
34 static TALLOC_CTX *current_rpc_talloc = NULL;
36 static TALLOC_CTX *get_current_rpc_talloc(void)
38 return current_rpc_talloc;
41 void set_current_rpc_talloc( TALLOC_CTX *ctx)
43 current_rpc_talloc = ctx;
46 static TALLOC_CTX *main_loop_talloc = NULL;
48 /*******************************************************************
49 free up temporary memory - called from the main loop
50 ********************************************************************/
52 void main_loop_talloc_free(void)
54 if (!main_loop_talloc)
56 talloc_destroy(main_loop_talloc);
57 main_loop_talloc = NULL;
60 /*******************************************************************
61 Get a talloc context that is freed in the main loop...
62 ********************************************************************/
64 TALLOC_CTX *main_loop_talloc_get(void)
66 if (!main_loop_talloc) {
67 main_loop_talloc = talloc_init("main loop talloc (mainly parse_misc)");
68 if (!main_loop_talloc)
69 smb_panic("main_loop_talloc: malloc fail\n");
72 return main_loop_talloc;
75 /*******************************************************************
76 Try and get a talloc context. Get the rpc one if possible, else
77 get the main loop one. The main loop one is more dangerous as it
78 goes away between packets, the rpc one will stay around for as long
79 as a current RPC lasts.
80 ********************************************************************/
82 TALLOC_CTX *get_talloc_ctx(void)
84 TALLOC_CTX *tc = get_current_rpc_talloc();
88 return main_loop_talloc_get();
91 /*******************************************************************
92 Reads or writes a UTIME type.
93 ********************************************************************/
95 static BOOL smb_io_utime(const char *desc, UTIME *t, prs_struct *ps, int depth)
100 prs_debug(ps, depth, desc, "smb_io_utime");
106 if(!prs_uint32 ("time", ps, depth, &t->time))
112 /*******************************************************************
113 Reads or writes an NTTIME structure.
114 ********************************************************************/
116 BOOL smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
121 prs_debug(ps, depth, desc, "smb_io_time");
127 if(!prs_uint32("low ", ps, depth, &nttime->low)) /* low part */
129 if(!prs_uint32("high", ps, depth, &nttime->high)) /* high part */
135 /*******************************************************************
136 Gets an enumeration handle from an ENUM_HND structure.
137 ********************************************************************/
139 uint32 get_enum_hnd(ENUM_HND *enh)
141 return (enh && enh->ptr_hnd != 0) ? enh->handle : 0;
144 /*******************************************************************
145 Inits an ENUM_HND structure.
146 ********************************************************************/
148 void init_enum_hnd(ENUM_HND *enh, uint32 hnd)
150 DEBUG(5,("smb_io_enum_hnd\n"));
152 enh->ptr_hnd = (hnd != 0) ? 1 : 0;
156 /*******************************************************************
157 Reads or writes an ENUM_HND structure.
158 ********************************************************************/
160 BOOL smb_io_enum_hnd(const char *desc, ENUM_HND *hnd, prs_struct *ps, int depth)
165 prs_debug(ps, depth, desc, "smb_io_enum_hnd");
171 if(!prs_uint32("ptr_hnd", ps, depth, &hnd->ptr_hnd)) /* pointer */
174 if (hnd->ptr_hnd != 0) {
175 if(!prs_uint32("handle ", ps, depth, &hnd->handle )) /* enum handle */
182 /*******************************************************************
183 Reads or writes a DOM_SID structure.
184 ********************************************************************/
186 BOOL smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth)
193 prs_debug(ps, depth, desc, "smb_io_dom_sid");
196 if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
199 if(!prs_uint8 ("num_auths ", ps, depth, &sid->num_auths))
202 for (i = 0; i < 6; i++)
205 slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
206 if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
210 /* oops! XXXX should really issue a warning here... */
211 if (sid->num_auths > MAXSUBAUTHS)
212 sid->num_auths = MAXSUBAUTHS;
214 if(!prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
220 /*******************************************************************
221 Inits a DOM_SID structure.
223 BIG NOTE: this function only does SIDS where the identauth is not >= 2^32
224 identauth >= 2^32 can be detected because it will be specified in hex
225 ********************************************************************/
227 void init_dom_sid(DOM_SID *sid, const char *str_sid)
233 if (str_sid == NULL) {
234 DEBUG(4,("netlogon domain SID: none\n"));
235 sid->sid_rev_num = 0;
240 pstrcpy(domsid, str_sid);
242 DEBUG(4,("init_dom_sid %d SID: %s\n", __LINE__, domsid));
244 /* assume, but should check, that domsid starts "S-" */
245 p = strtok(domsid+2,"-");
246 sid->sid_rev_num = atoi(p);
248 /* identauth in decimal should be < 2^32 */
249 /* identauth in hex should be >= 2^32 */
250 identauth = atoi(strtok(0,"-"));
252 DEBUG(4,("netlogon rev %d\n", sid->sid_rev_num));
253 DEBUG(4,("netlogon %s ia %d\n", p, identauth));
257 sid->id_auth[2] = (identauth & 0xff000000) >> 24;
258 sid->id_auth[3] = (identauth & 0x00ff0000) >> 16;
259 sid->id_auth[4] = (identauth & 0x0000ff00) >> 8;
260 sid->id_auth[5] = (identauth & 0x000000ff);
264 while ((p = strtok(0, "-")) != NULL && sid->num_auths < MAXSUBAUTHS)
265 sid->sub_auths[sid->num_auths++] = atoi(p);
267 DEBUG(4,("init_dom_sid: %d SID: %s\n", __LINE__, domsid));
270 /*******************************************************************
271 Inits a DOM_SID2 structure.
272 ********************************************************************/
274 void init_dom_sid2(DOM_SID2 *sid2, const DOM_SID *sid)
277 sid2->num_auths = sid2->sid.num_auths;
280 /*******************************************************************
281 Reads or writes a DOM_SID2 structure.
282 ********************************************************************/
284 BOOL smb_io_dom_sid2_p(const char *desc, prs_struct *ps, int depth, DOM_SID2 **sid2)
288 /* caputure the pointer value to stream */
290 data_p = (uint32) *sid2;
292 if ( !prs_uint32("dom_sid2_p", ps, depth, &data_p ))
295 /* we're done if there is no data */
300 if (UNMARSHALLING(ps)) {
301 if ( !(*sid2 = PRS_ALLOC_MEM(ps, DOM_SID2, 1)) )
307 /*******************************************************************
308 Reads or writes a DOM_SID2 structure.
309 ********************************************************************/
311 BOOL smb_io_dom_sid2(const char *desc, DOM_SID2 *sid, prs_struct *ps, int depth)
316 prs_debug(ps, depth, desc, "smb_io_dom_sid2");
322 if(!prs_uint32("num_auths", ps, depth, &sid->num_auths))
325 if(!smb_io_dom_sid("sid", &sid->sid, ps, depth))
331 /*******************************************************************
332 Reads or writes a struct uuid
333 ********************************************************************/
335 BOOL smb_io_uuid(const char *desc, struct uuid *uuid,
336 prs_struct *ps, int depth)
341 prs_debug(ps, depth, desc, "smb_io_uuid");
344 if(!prs_uint32 ("data ", ps, depth, &uuid->time_low))
346 if(!prs_uint16 ("data ", ps, depth, &uuid->time_mid))
348 if(!prs_uint16 ("data ", ps, depth, &uuid->time_hi_and_version))
351 if(!prs_uint8s (False, "data ", ps, depth, uuid->clock_seq, sizeof(uuid->clock_seq)))
353 if(!prs_uint8s (False, "data ", ps, depth, uuid->node, sizeof(uuid->node)))
359 /*******************************************************************
360 creates a STRHDR structure.
361 ********************************************************************/
363 void init_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
365 hdr->str_max_len = max_len;
366 hdr->str_str_len = len;
367 hdr->buffer = buffer;
370 /*******************************************************************
371 Reads or writes a STRHDR structure.
372 ********************************************************************/
374 BOOL smb_io_strhdr(const char *desc, STRHDR *hdr, prs_struct *ps, int depth)
379 prs_debug(ps, depth, desc, "smb_io_strhdr");
384 if(!prs_uint16("str_str_len", ps, depth, &hdr->str_str_len))
386 if(!prs_uint16("str_max_len", ps, depth, &hdr->str_max_len))
388 if(!prs_uint32("buffer ", ps, depth, &hdr->buffer))
394 /*******************************************************************
395 Inits a UNIHDR structure.
396 ********************************************************************/
398 void init_uni_hdr(UNIHDR *hdr, UNISTR2 *str2)
400 hdr->uni_str_len = 2 * (str2->uni_str_len);
401 hdr->uni_max_len = 2 * (str2->uni_max_len);
402 hdr->buffer = (str2->uni_str_len != 0) ? 1 : 0;
405 /*******************************************************************
406 Reads or writes a UNIHDR structure.
407 ********************************************************************/
409 BOOL smb_io_unihdr(const char *desc, UNIHDR *hdr, prs_struct *ps, int depth)
414 prs_debug(ps, depth, desc, "smb_io_unihdr");
420 if(!prs_uint16("uni_str_len", ps, depth, &hdr->uni_str_len))
422 if(!prs_uint16("uni_max_len", ps, depth, &hdr->uni_max_len))
424 if(!prs_uint32("buffer ", ps, depth, &hdr->buffer))
430 /*******************************************************************
431 Inits a BUFHDR structure.
432 ********************************************************************/
434 void init_buf_hdr(BUFHDR *hdr, int max_len, int len)
436 hdr->buf_max_len = max_len;
440 /*******************************************************************
441 prs_uint16 wrapper. Call this and it sets up a pointer to where the
442 uint16 should be stored, or gets the size if reading.
443 ********************************************************************/
445 BOOL smb_io_hdrbuf_pre(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
447 (*offset) = prs_offset(ps);
452 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
459 if(!prs_set_offset(ps, prs_offset(ps) + (sizeof(uint32) * 2)))
466 /*******************************************************************
467 smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
468 Does nothing on reading, as that is already handled by ...._pre()
469 ********************************************************************/
471 BOOL smb_io_hdrbuf_post(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth,
472 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
475 /* writing: go back and do a retrospective job. i hate this */
477 uint32 old_offset = prs_offset(ps);
479 init_buf_hdr(hdr, max_len, len);
480 if(!prs_set_offset(ps, ptr_hdrbuf))
482 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
485 if(!prs_set_offset(ps, old_offset))
492 /*******************************************************************
493 Reads or writes a BUFHDR structure.
494 ********************************************************************/
496 BOOL smb_io_hdrbuf(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth)
501 prs_debug(ps, depth, desc, "smb_io_hdrbuf");
507 if(!prs_uint32("buf_max_len", ps, depth, &hdr->buf_max_len))
509 if(!prs_uint32("buf_len ", ps, depth, &hdr->buf_len))
515 /*******************************************************************
516 Inits a UNISTR structure.
517 ********************************************************************/
519 void init_unistr(UNISTR *str, const char *buf)
528 len = strlen(buf) + 1;
530 str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
531 if (str->buffer == NULL)
532 smb_panic("init_unistr: malloc fail\n");
534 rpcstr_push(str->buffer, buf, len*sizeof(uint16), STR_TERMINATE);
537 /*******************************************************************
538 reads or writes a UNISTR structure.
539 XXXX NOTE: UNISTR structures NEED to be null-terminated.
540 ********************************************************************/
542 BOOL smb_io_unistr(const char *desc, UNISTR *uni, prs_struct *ps, int depth)
547 prs_debug(ps, depth, desc, "smb_io_unistr");
550 if(!prs_unistr("unistr", ps, depth, uni))
556 /*******************************************************************
557 Allocate the RPC_DATA_BLOB memory.
558 ********************************************************************/
560 static size_t create_rpc_blob(RPC_DATA_BLOB *str, size_t len)
562 str->buffer = TALLOC_ZERO(get_talloc_ctx(), len);
563 if (str->buffer == NULL)
564 smb_panic("create_rpc_blob: talloc fail\n");
568 /*******************************************************************
569 Inits a RPC_DATA_BLOB structure from a uint32
570 ********************************************************************/
572 void init_rpc_blob_uint32(RPC_DATA_BLOB *str, uint32 val)
576 /* set up string lengths. */
577 str->buf_len = create_rpc_blob(str, sizeof(uint32));
578 SIVAL(str->buffer, 0, val);
581 /*******************************************************************
582 Inits a RPC_DATA_BLOB structure.
583 ********************************************************************/
585 void init_rpc_blob_str(RPC_DATA_BLOB *str, const char *buf, int len)
589 /* set up string lengths. */
590 str->buf_len = create_rpc_blob(str, len*2);
591 rpcstr_push(str->buffer, buf, str->buf_len, STR_TERMINATE);
595 /*******************************************************************
596 Inits a RPC_DATA_BLOB structure from a hex string.
597 ********************************************************************/
599 void init_rpc_blob_hex(RPC_DATA_BLOB *str, const char *buf)
602 str->buf_len = create_rpc_blob(str, strlen(buf));
603 str->buf_len = strhex_to_str((char *)str->buffer, str->buf_len, buf);
606 /*******************************************************************
607 Inits a RPC_DATA_BLOB structure.
608 ********************************************************************/
610 void init_rpc_blob_bytes(RPC_DATA_BLOB *str, uint8 *buf, size_t len)
614 /* max buffer size (allocated size) */
616 len = create_rpc_blob(str, len);
617 memcpy(str->buffer, buf, len);
622 /*******************************************************************
623 reads or writes a BUFFER5 structure.
624 the buf_len member tells you how large the buffer is.
625 ********************************************************************/
626 BOOL smb_io_buffer5(const char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
628 prs_debug(ps, depth, desc, "smb_io_buffer5");
631 if (buf5 == NULL) return False;
635 if(!prs_uint32("buf_len", ps, depth, &buf5->buf_len))
639 if(!prs_buffer5(True, "buffer" , ps, depth, buf5))
646 /*******************************************************************
647 Inits a REGVAL_BUFFER structure.
648 ********************************************************************/
650 void init_regval_buffer(REGVAL_BUFFER *str, const uint8 *buf, size_t len)
654 /* max buffer size (allocated size) */
655 str->buf_max_len = len;
657 str->buf_len = buf != NULL ? len : 0;
660 SMB_ASSERT(str->buf_max_len >= str->buf_len);
661 str->buffer = TALLOC_ZERO(get_talloc_ctx(), str->buf_max_len);
662 if (str->buffer == NULL)
663 smb_panic("init_regval_buffer: talloc fail\n");
664 memcpy(str->buffer, buf, str->buf_len);
668 /*******************************************************************
669 Reads or writes a REGVAL_BUFFER structure.
670 the uni_max_len member tells you how large the buffer is.
671 the uni_str_len member tells you how much of the buffer is really used.
672 ********************************************************************/
674 BOOL smb_io_regval_buffer(const char *desc, prs_struct *ps, int depth, REGVAL_BUFFER *buf2)
677 prs_debug(ps, depth, desc, "smb_io_regval_buffer");
683 if(!prs_uint32("uni_max_len", ps, depth, &buf2->buf_max_len))
685 if(!prs_uint32("offset ", ps, depth, &buf2->offset))
687 if(!prs_uint32("buf_len ", ps, depth, &buf2->buf_len))
690 /* buffer advanced by indicated length of string
691 NOT by searching for null-termination */
693 if(!prs_regval_buffer(True, "buffer ", ps, depth, buf2))
699 /*******************************************************************
700 creates a UNISTR2 structure: sets up the buffer, too
701 ********************************************************************/
703 void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf)
707 init_unistr2(str, buf, UNI_STR_TERMINATE);
710 init_unistr2(str, NULL, UNI_FLAGS_NONE);
715 /*******************************************************************
716 Copies a UNISTR2 structure.
717 ********************************************************************/
719 void copy_unistr2(UNISTR2 *str, const UNISTR2 *from)
721 if (from->buffer == NULL) {
726 SMB_ASSERT(from->uni_max_len >= from->uni_str_len);
728 str->uni_max_len = from->uni_max_len;
729 str->offset = from->offset;
730 str->uni_str_len = from->uni_str_len;
732 /* the string buffer is allocated to the maximum size
733 (the the length of the source string) to prevent
734 reallocation of memory. */
735 if (str->buffer == NULL) {
736 str->buffer = (uint16 *)TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_max_len);
737 if ((str->buffer == NULL)) {
738 smb_panic("copy_unistr2: talloc fail\n");
743 /* copy the string */
744 memcpy(str->buffer, from->buffer, str->uni_max_len*sizeof(uint16));
747 /*******************************************************************
748 Creates a STRING2 structure.
749 ********************************************************************/
751 void init_string2(STRING2 *str, const char *buf, size_t max_len, size_t str_len)
753 /* set up string lengths. */
754 SMB_ASSERT(max_len >= str_len);
756 str->str_max_len = max_len;
758 str->str_str_len = str_len;
760 /* store the string */
762 str->buffer = TALLOC_ZERO(get_talloc_ctx(), str->str_max_len);
763 if (str->buffer == NULL)
764 smb_panic("init_string2: malloc fail\n");
765 memcpy(str->buffer, buf, str_len);
769 /*******************************************************************
770 Reads or writes a STRING2 structure.
771 XXXX NOTE: STRING2 structures need NOT be null-terminated.
772 the str_str_len member tells you how long the string is;
773 the str_max_len member tells you how large the buffer is.
774 ********************************************************************/
776 BOOL smb_io_string2(const char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
783 prs_debug(ps, depth, desc, "smb_io_string2");
789 if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len))
791 if(!prs_uint32("offset ", ps, depth, &str2->offset))
793 if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len))
796 /* buffer advanced by indicated length of string
797 NOT by searching for null-termination */
798 if(!prs_string2(True, "buffer ", ps, depth, str2))
803 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
805 memset((char *)str2, '\0', sizeof(*str2));
812 /*******************************************************************
813 Inits a UNISTR2 structure.
814 ********************************************************************/
816 void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags)
819 uint32 num_chars = 0;
822 /* We always null terminate the copy. */
823 len = strlen(buf) + 1;
825 /* no buffer -- nothing to do */
826 str->uni_max_len = 0;
828 str->uni_str_len = 0;
834 str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
835 if (str->buffer == NULL) {
836 smb_panic("init_unistr2: malloc fail\n");
840 /* Ensure len is the length in *bytes* */
841 len *= sizeof(uint16);
844 * The UNISTR2 must be initialized !!!
848 rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE);
849 num_chars = strlen_w(str->buffer);
850 if (flags == UNI_STR_TERMINATE || flags == UNI_MAXLEN_TERMINATE) {
855 str->uni_max_len = num_chars;
857 str->uni_str_len = num_chars;
858 if ( num_chars && ((flags == UNI_MAXLEN_TERMINATE) || (flags == UNI_BROKEN_NON_NULL)) )
862 /*******************************************************************
863 Inits a UNISTR4 structure.
864 ********************************************************************/
866 void init_unistr4(UNISTR4 *uni4, const char *buf, enum unistr2_term_codes flags)
868 uni4->string = TALLOC_P( get_talloc_ctx(), UNISTR2 );
869 init_unistr2( uni4->string, buf, flags );
871 uni4->length = 2 * (uni4->string->uni_str_len);
872 uni4->size = 2 * (uni4->string->uni_max_len);
875 void init_unistr4_w( TALLOC_CTX *ctx, UNISTR4 *uni4, const smb_ucs2_t *buf )
877 uni4->string = TALLOC_P( ctx, UNISTR2 );
878 init_unistr2_w( ctx, uni4->string, buf );
880 uni4->length = 2 * (uni4->string->uni_str_len);
881 uni4->size = 2 * (uni4->string->uni_max_len);
885 * Inits a UNISTR2 structure.
886 * @param ctx talloc context to allocate string on
887 * @param str pointer to string to create
888 * @param buf UCS2 null-terminated buffer to init from
891 void init_unistr2_w(TALLOC_CTX *ctx, UNISTR2 *str, const smb_ucs2_t *buf)
893 uint32 len = strlen_w(buf);
897 /* set up string lengths. */
898 str->uni_max_len = len;
900 str->uni_str_len = len;
902 str->buffer = TALLOC_ZERO_ARRAY(ctx, uint16, len + 1);
903 if (str->buffer == NULL) {
904 smb_panic("init_unistr2_w: malloc fail\n");
909 * don't move this test above ! The UNISTR2 must be initialized !!!
915 /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
916 long as the buffer above is talloc()ed correctly then this
917 is the correct thing to do */
918 strncpy_w(str->buffer, buf, len + 1);
921 /*******************************************************************
922 Inits a UNISTR2 structure from a UNISTR
923 ********************************************************************/
925 void init_unistr2_from_unistr(UNISTR2 *to, const UNISTR *from)
929 /* the destination UNISTR2 should never be NULL.
930 if it is it is a programming error */
932 /* if the source UNISTR is NULL, then zero out
933 the destination string and return */
935 if ((from == NULL) || (from->buffer == NULL))
938 /* get the length; UNISTR must be NULL terminated */
940 while ((from->buffer)[i]!='\0')
942 i++; /* one more to catch the terminating NULL */
943 /* is this necessary -- jerry? I need to think */
945 /* set up string lengths; uni_max_len is set to i+1
946 because we need to account for the final NULL termination */
951 /* allocate the space and copy the string buffer */
952 to->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, i);
953 if (to->buffer == NULL)
954 smb_panic("init_unistr2_from_unistr: malloc fail\n");
955 memcpy(to->buffer, from->buffer, i*sizeof(uint16));
959 /*******************************************************************
960 Inits a UNISTR2 structure from a DATA_BLOB.
961 The length of the data_blob must count the bytes of the buffer.
962 Copies the blob data.
963 ********************************************************************/
965 void init_unistr2_from_datablob(UNISTR2 *str, DATA_BLOB *blob)
967 /* Allocs the unistring */
968 init_unistr2(str, NULL, UNI_FLAGS_NONE);
970 /* Sets the values */
971 str->uni_str_len = blob->length / sizeof(uint16);
972 str->uni_max_len = str->uni_str_len;
975 str->buffer = (uint16 *) memdup(blob->data, blob->length);
979 if ((str->buffer == NULL) && (blob->length > 0)) {
980 smb_panic("init_unistr2_from_datablob: malloc fail\n");
984 /*******************************************************************
985 UNISTR2* are a little different in that the pointer and the UNISTR2
986 are not necessarily read/written back to back. So we break it up
987 into 2 separate functions.
988 See SPOOL_USER_1 in include/rpc_spoolss.h for an example.
989 ********************************************************************/
991 BOOL prs_io_unistr2_p(const char *desc, prs_struct *ps, int depth, UNISTR2 **uni2)
995 /* caputure the pointer value to stream */
997 data_p = (uint32) *uni2;
999 if ( !prs_uint32("ptr", ps, depth, &data_p ))
1002 /* we're done if there is no data */
1007 if (UNMARSHALLING(ps)) {
1008 if ( !(*uni2 = PRS_ALLOC_MEM(ps, UNISTR2, 1)) )
1015 /*******************************************************************
1016 now read/write the actual UNISTR2. Memory for the UNISTR2 (but
1017 not UNISTR2.buffer) has been allocated previously by prs_unistr2_p()
1018 ********************************************************************/
1020 BOOL prs_io_unistr2(const char *desc, prs_struct *ps, int depth, UNISTR2 *uni2 )
1022 /* just return true if there is no pointer to deal with.
1023 the memory must have been previously allocated on unmarshalling
1024 by prs_unistr2_p() */
1029 /* just pass off to smb_io_unstr2() passing the uni2 address as
1030 the pointer (like you would expect) */
1032 return smb_io_unistr2( desc, uni2, (uint32)uni2, ps, depth );
1035 /*******************************************************************
1036 Reads or writes a UNISTR2 structure.
1037 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
1038 the uni_str_len member tells you how long the string is;
1039 the uni_max_len member tells you how large the buffer is.
1040 ********************************************************************/
1042 BOOL smb_io_unistr2(const char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
1049 prs_debug(ps, depth, desc, "smb_io_unistr2");
1055 if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len))
1057 if(!prs_uint32("offset ", ps, depth, &uni2->offset))
1059 if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len))
1062 /* buffer advanced by indicated length of string
1063 NOT by searching for null-termination */
1064 if(!prs_unistr2(True, "buffer ", ps, depth, uni2))
1069 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
1071 memset((char *)uni2, '\0', sizeof(*uni2));
1078 /*******************************************************************
1079 now read/write UNISTR4
1080 ********************************************************************/
1082 BOOL prs_unistr4(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1084 if ( !prs_uint16("length", ps, depth, &uni4->length ))
1086 if ( !prs_uint16("size", ps, depth, &uni4->size ))
1089 if ( !prs_pointer( desc, ps, depth, (void**)&uni4->string, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2 ) )
1095 /*******************************************************************
1096 now read/write UNISTR4 header
1097 ********************************************************************/
1099 BOOL prs_unistr4_hdr(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1101 prs_debug(ps, depth, desc, "prs_unistr4_hdr");
1104 if ( !prs_uint16("length", ps, depth, &uni4->length) )
1106 if ( !prs_uint16("size", ps, depth, &uni4->size) )
1108 if ( !prs_io_unistr2_p(desc, ps, depth, &uni4->string) )
1114 /*******************************************************************
1115 now read/write UNISTR4 string
1116 ********************************************************************/
1118 BOOL prs_unistr4_str(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1120 prs_debug(ps, depth, desc, "prs_unistr4_str");
1123 if ( !prs_io_unistr2(desc, ps, depth, uni4->string) )
1129 /*******************************************************************
1130 Reads or writes a UNISTR2_ARRAY structure.
1131 ********************************************************************/
1133 BOOL prs_unistr4_array(const char *desc, prs_struct *ps, int depth, UNISTR4_ARRAY *array )
1137 prs_debug(ps, depth, desc, "prs_unistr4_array");
1140 if(!prs_uint32("count", ps, depth, &array->count))
1143 if ( array->count == 0 )
1146 if (UNMARSHALLING(ps)) {
1147 if ( !(array->strings = TALLOC_ZERO_ARRAY( get_talloc_ctx(), UNISTR4, array->count)) )
1151 /* write the headers and then the actual string buffer */
1153 for ( i=0; i<array->count; i++ ) {
1154 if ( !prs_unistr4_hdr( "string", ps, depth, &array->strings[i]) )
1158 for (i=0;i<array->count;i++) {
1159 if ( !prs_unistr4_str("string", ps, depth, &array->strings[i]) )
1166 /********************************************************************
1167 initialise a UNISTR_ARRAY from a char**
1168 ********************************************************************/
1170 BOOL init_unistr4_array( UNISTR4_ARRAY *array, uint32 count, const char **strings )
1174 array->count = count;
1176 if ( array->count == 0 )
1179 /* allocate memory for the array of UNISTR4 objects */
1181 if ( !(array->strings = TALLOC_ZERO_ARRAY(get_talloc_ctx(), UNISTR4, count )) )
1184 for ( i=0; i<count; i++ )
1185 init_unistr4( &array->strings[i], strings[i], STR_TERMINATE );
1190 BOOL smb_io_lockout_string_hdr(const char *desc, HDR_LOCKOUT_STRING *hdr_account_lockout, prs_struct *ps, int depth)
1192 prs_debug(ps, depth, desc, "smb_io_lockout_string_hdr");
1198 if(!prs_uint16("size", ps, depth, &hdr_account_lockout->size))
1200 if(!prs_uint16("length", ps, depth, &hdr_account_lockout->length))
1202 if(!prs_uint32("buffer", ps, depth, &hdr_account_lockout->buffer))
1208 BOOL smb_io_account_lockout_str(const char *desc, LOCKOUT_STRING *account_lockout, uint32 buffer, prs_struct *ps, int depth)
1210 prs_debug(ps, depth, desc, "smb_io_account_lockout_string");
1213 if(!prs_uint32("array_size", ps, depth, &account_lockout->array_size))
1216 if(!prs_uint32("offset", ps, depth, &account_lockout->offset))
1218 if(!prs_uint32("length", ps, depth, &account_lockout->length))
1221 if (!prs_uint64("lockout_duration", ps, depth, &account_lockout->lockout_duration))
1223 if (!prs_uint64("reset_count", ps, depth, &account_lockout->reset_count))
1225 if (!prs_uint32("bad_attempt_lockout", ps, depth, &account_lockout->bad_attempt_lockout))
1227 if (!prs_uint32("dummy", ps, depth, &account_lockout->dummy))
1230 if(!prs_uint16s (False, "bindata", ps, depth, &account_lockout->bindata, length))
1237 /*******************************************************************
1238 Inits a DOM_RID2 structure.
1239 ********************************************************************/
1241 void init_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx)
1245 rid2->rid_idx = idx;
1248 /*******************************************************************
1249 Reads or writes a DOM_RID2 structure.
1250 ********************************************************************/
1252 BOOL smb_io_dom_rid2(const char *desc, DOM_RID2 *rid2, prs_struct *ps, int depth)
1257 prs_debug(ps, depth, desc, "smb_io_dom_rid2");
1263 if(!prs_uint8("type ", ps, depth, &rid2->type))
1267 if(!prs_uint32("rid ", ps, depth, &rid2->rid))
1269 if(!prs_uint32("rid_idx", ps, depth, &rid2->rid_idx))
1275 /*******************************************************************
1276 creates a DOM_RID3 structure.
1277 ********************************************************************/
1279 void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
1283 rid3->ptr_type = 0x1; /* non-zero, basically. */
1288 /*******************************************************************
1289 reads or writes a DOM_RID3 structure.
1290 ********************************************************************/
1292 BOOL smb_io_dom_rid3(const char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth)
1297 prs_debug(ps, depth, desc, "smb_io_dom_rid3");
1303 if(!prs_uint32("rid ", ps, depth, &rid3->rid))
1305 if(!prs_uint32("type1 ", ps, depth, &rid3->type1))
1307 if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type))
1309 if(!prs_uint32("type2 ", ps, depth, &rid3->type2))
1311 if(!prs_uint32("unk ", ps, depth, &rid3->unk))
1317 /*******************************************************************
1318 Inits a DOM_RID4 structure.
1319 ********************************************************************/
1321 void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
1323 rid4->unknown = unknown;
1328 /*******************************************************************
1329 Inits a DOM_CLNT_SRV structure.
1330 ********************************************************************/
1332 static void init_clnt_srv(DOM_CLNT_SRV *logcln, const char *logon_srv, const char *comp_name)
1334 DEBUG(5,("init_clnt_srv: %d\n", __LINE__));
1336 if (logon_srv != NULL) {
1337 logcln->undoc_buffer = 1;
1338 init_unistr2(&logcln->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1340 logcln->undoc_buffer = 0;
1343 if (comp_name != NULL) {
1344 logcln->undoc_buffer2 = 1;
1345 init_unistr2(&logcln->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1347 logcln->undoc_buffer2 = 0;
1351 /*******************************************************************
1352 Inits or writes a DOM_CLNT_SRV structure.
1353 ********************************************************************/
1355 static BOOL smb_io_clnt_srv(const char *desc, DOM_CLNT_SRV *logcln, prs_struct *ps, int depth)
1360 prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1366 if(!prs_uint32("undoc_buffer ", ps, depth, &logcln->undoc_buffer))
1369 if (logcln->undoc_buffer != 0) {
1370 if(!smb_io_unistr2("unistr2", &logcln->uni_logon_srv, logcln->undoc_buffer, ps, depth))
1377 if(!prs_uint32("undoc_buffer2", ps, depth, &logcln->undoc_buffer2))
1380 if (logcln->undoc_buffer2 != 0) {
1381 if(!smb_io_unistr2("unistr2", &logcln->uni_comp_name, logcln->undoc_buffer2, ps, depth))
1388 /*******************************************************************
1389 Inits a DOM_LOG_INFO structure.
1390 ********************************************************************/
1392 void init_log_info(DOM_LOG_INFO *loginfo, const char *logon_srv, const char *acct_name,
1393 uint16 sec_chan, const char *comp_name)
1395 DEBUG(5,("make_log_info %d\n", __LINE__));
1397 loginfo->undoc_buffer = 1;
1399 init_unistr2(&loginfo->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1400 init_unistr2(&loginfo->uni_acct_name, acct_name, UNI_STR_TERMINATE);
1402 loginfo->sec_chan = sec_chan;
1404 init_unistr2(&loginfo->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1407 /*******************************************************************
1408 Reads or writes a DOM_LOG_INFO structure.
1409 ********************************************************************/
1411 BOOL smb_io_log_info(const char *desc, DOM_LOG_INFO *loginfo, prs_struct *ps, int depth)
1413 if (loginfo == NULL)
1416 prs_debug(ps, depth, desc, "smb_io_log_info");
1422 if(!prs_uint32("undoc_buffer", ps, depth, &loginfo->undoc_buffer))
1425 if(!smb_io_unistr2("unistr2", &loginfo->uni_logon_srv, True, ps, depth))
1427 if(!smb_io_unistr2("unistr2", &loginfo->uni_acct_name, True, ps, depth))
1430 if(!prs_uint16("sec_chan", ps, depth, &loginfo->sec_chan))
1433 if(!smb_io_unistr2("unistr2", &loginfo->uni_comp_name, True, ps, depth))
1439 /*******************************************************************
1440 Reads or writes a DOM_CHAL structure.
1441 ********************************************************************/
1443 BOOL smb_io_chal(const char *desc, DOM_CHAL *chal, prs_struct *ps, int depth)
1448 prs_debug(ps, depth, desc, "smb_io_chal");
1451 if(!prs_uint8s (False, "data", ps, depth, chal->data, 8))
1457 /*******************************************************************
1458 Reads or writes a DOM_CRED structure.
1459 ********************************************************************/
1461 BOOL smb_io_cred(const char *desc, DOM_CRED *cred, prs_struct *ps, int depth)
1466 prs_debug(ps, depth, desc, "smb_io_cred");
1472 if(!smb_io_chal ("", &cred->challenge, ps, depth))
1475 if(!smb_io_utime("", &cred->timestamp, ps, depth))
1481 /*******************************************************************
1482 Inits a DOM_CLNT_INFO2 structure.
1483 ********************************************************************/
1485 void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1486 const char *logon_srv, const char *comp_name,
1487 const DOM_CRED *clnt_cred)
1489 DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1491 init_clnt_srv(&clnt->login, logon_srv, comp_name);
1493 if (clnt_cred != NULL) {
1495 memcpy(&clnt->cred, clnt_cred, sizeof(clnt->cred));
1501 /*******************************************************************
1502 Reads or writes a DOM_CLNT_INFO2 structure.
1503 ********************************************************************/
1505 BOOL smb_io_clnt_info2(const char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1510 prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1516 if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1522 if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1524 if(!smb_io_cred("", &clnt->cred, ps, depth))
1530 /*******************************************************************
1531 Inits a DOM_CLNT_INFO structure.
1532 ********************************************************************/
1534 void init_clnt_info(DOM_CLNT_INFO *clnt,
1535 const char *logon_srv, const char *acct_name,
1536 uint16 sec_chan, const char *comp_name,
1537 const DOM_CRED *cred)
1539 DEBUG(5,("make_clnt_info\n"));
1541 init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1542 memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1545 /*******************************************************************
1546 Reads or writes a DOM_CLNT_INFO structure.
1547 ********************************************************************/
1549 BOOL smb_io_clnt_info(const char *desc, DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1554 prs_debug(ps, depth, desc, "smb_io_clnt_info");
1560 if(!smb_io_log_info("", &clnt->login, ps, depth))
1562 if(!smb_io_cred("", &clnt->cred, ps, depth))
1568 /*******************************************************************
1569 Inits a DOM_LOGON_ID structure.
1570 ********************************************************************/
1572 void init_logon_id(DOM_LOGON_ID *logonid, uint32 log_id_low, uint32 log_id_high)
1574 DEBUG(5,("make_logon_id: %d\n", __LINE__));
1576 logonid->low = log_id_low;
1577 logonid->high = log_id_high;
1580 /*******************************************************************
1581 Reads or writes a DOM_LOGON_ID structure.
1582 ********************************************************************/
1584 BOOL smb_io_logon_id(const char *desc, DOM_LOGON_ID *logonid, prs_struct *ps, int depth)
1586 if (logonid == NULL)
1589 prs_debug(ps, depth, desc, "smb_io_logon_id");
1595 if(!prs_uint32("low ", ps, depth, &logonid->low ))
1597 if(!prs_uint32("high", ps, depth, &logonid->high))
1603 /*******************************************************************
1604 Inits an OWF_INFO structure.
1605 ********************************************************************/
1607 void init_owf_info(OWF_INFO *hash, const uint8 data[16])
1609 DEBUG(5,("init_owf_info: %d\n", __LINE__));
1612 memcpy(hash->data, data, sizeof(hash->data));
1614 memset((char *)hash->data, '\0', sizeof(hash->data));
1617 /*******************************************************************
1618 Reads or writes an OWF_INFO structure.
1619 ********************************************************************/
1621 BOOL smb_io_owf_info(const char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1626 prs_debug(ps, depth, desc, "smb_io_owf_info");
1632 if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1638 /*******************************************************************
1639 Reads or writes a DOM_GID structure.
1640 ********************************************************************/
1642 BOOL smb_io_gid(const char *desc, DOM_GID *gid, prs_struct *ps, int depth)
1647 prs_debug(ps, depth, desc, "smb_io_gid");
1653 if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1655 if(!prs_uint32("attr ", ps, depth, &gid->attr))
1661 /*******************************************************************
1662 Reads or writes an POLICY_HND structure.
1663 ********************************************************************/
1665 BOOL smb_io_pol_hnd(const char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1670 prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1676 if(UNMARSHALLING(ps))
1679 if (!prs_uint32("data1", ps, depth, &pol->data1))
1681 if (!prs_uint32("data2", ps, depth, &pol->data2))
1683 if (!prs_uint16("data3", ps, depth, &pol->data3))
1685 if (!prs_uint16("data4", ps, depth, &pol->data4))
1687 if(!prs_uint8s (False, "data5", ps, depth, pol->data5, sizeof(pol->data5)))
1693 /*******************************************************************
1695 ********************************************************************/
1697 void init_unistr3(UNISTR3 *str, const char *buf)
1701 str->str.buffer = NULL;
1705 str->uni_str_len = strlen(buf) + 1;
1707 str->str.buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_str_len);
1708 if (str->str.buffer == NULL)
1709 smb_panic("init_unistr3: malloc fail\n");
1711 rpcstr_push((char *)str->str.buffer, buf, str->uni_str_len * sizeof(uint16), STR_TERMINATE);
1714 /*******************************************************************
1715 Reads or writes a UNISTR3 structure.
1716 ********************************************************************/
1718 BOOL smb_io_unistr3(const char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1723 prs_debug(ps, depth, desc, "smb_io_unistr3");
1729 if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1732 /* don't know if len is specified by uni_str_len member... */
1733 /* assume unicode string is unicode-null-terminated, instead */
1735 if(!prs_unistr3(True, "unistr", name, ps, depth))
1742 /*******************************************************************
1743 Stream a uint64_struct
1744 ********************************************************************/
1745 BOOL prs_uint64(const char *name, prs_struct *ps, int depth, UINT64_S *data64)
1747 return prs_uint32(name, ps, depth+1, &data64->low) &&
1748 prs_uint32(name, ps, depth+1, &data64->high);
1751 /*******************************************************************
1752 reads or writes a BUFHDR2 structure.
1753 ********************************************************************/
1754 BOOL smb_io_bufhdr2(const char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth)
1756 prs_debug(ps, depth, desc, "smb_io_bufhdr2");
1760 prs_uint32("info_level", ps, depth, &(hdr->info_level));
1761 prs_uint32("length ", ps, depth, &(hdr->length ));
1762 prs_uint32("buffer ", ps, depth, &(hdr->buffer ));
1767 /*******************************************************************
1768 reads or writes a BUFHDR4 structure.
1769 ********************************************************************/
1770 BOOL smb_io_bufhdr4(const char *desc, BUFHDR4 *hdr, prs_struct *ps, int depth)
1772 prs_debug(ps, depth, desc, "smb_io_bufhdr4");
1776 prs_uint32("size", ps, depth, &hdr->size);
1777 prs_uint32("buffer", ps, depth, &hdr->buffer);
1782 /*******************************************************************
1783 reads or writes a RPC_DATA_BLOB structure.
1784 ********************************************************************/
1786 BOOL smb_io_rpc_blob(const char *desc, RPC_DATA_BLOB *blob, prs_struct *ps, int depth)
1788 prs_debug(ps, depth, desc, "smb_io_rpc_blob");
1792 if ( !prs_uint32("buf_len", ps, depth, &blob->buf_len) )
1795 if ( blob->buf_len == 0 )
1798 if (UNMARSHALLING(ps)) {
1799 blob->buffer = PRS_ALLOC_MEM(ps, uint8, blob->buf_len);
1800 if (!blob->buffer) {
1805 if ( !prs_uint8s(True, "buffer", ps, depth, blob->buffer, blob->buf_len) )
1811 /*******************************************************************
1812 creates a UNIHDR structure.
1813 ********************************************************************/
1815 BOOL make_uni_hdr(UNIHDR *hdr, int len)
1821 hdr->uni_str_len = 2 * len;
1822 hdr->uni_max_len = 2 * len;
1823 hdr->buffer = len != 0 ? 1 : 0;
1828 /*******************************************************************
1829 creates a BUFHDR2 structure.
1830 ********************************************************************/
1831 BOOL make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer)
1833 hdr->info_level = info_level;
1834 hdr->length = length;
1835 hdr->buffer = buffer;
1840 /*******************************************************************
1841 return the length of a UNISTR string.
1842 ********************************************************************/
1844 uint32 str_len_uni(UNISTR *source)
1848 if (!source->buffer)
1851 while (source->buffer[i])