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 Reads or writes an NTTIME structure.
137 ********************************************************************/
139 BOOL smb_io_nttime(const char *desc, prs_struct *ps, int depth, NTTIME *nttime)
141 return smb_io_time( desc, nttime, ps, depth );
144 /*******************************************************************
145 Gets an enumeration handle from an ENUM_HND structure.
146 ********************************************************************/
148 uint32 get_enum_hnd(ENUM_HND *enh)
150 return (enh && enh->ptr_hnd != 0) ? enh->handle : 0;
153 /*******************************************************************
154 Inits an ENUM_HND structure.
155 ********************************************************************/
157 void init_enum_hnd(ENUM_HND *enh, uint32 hnd)
159 DEBUG(5,("smb_io_enum_hnd\n"));
161 enh->ptr_hnd = (hnd != 0) ? 1 : 0;
165 /*******************************************************************
166 Reads or writes an ENUM_HND structure.
167 ********************************************************************/
169 BOOL smb_io_enum_hnd(const char *desc, ENUM_HND *hnd, prs_struct *ps, int depth)
174 prs_debug(ps, depth, desc, "smb_io_enum_hnd");
180 if(!prs_uint32("ptr_hnd", ps, depth, &hnd->ptr_hnd)) /* pointer */
183 if (hnd->ptr_hnd != 0) {
184 if(!prs_uint32("handle ", ps, depth, &hnd->handle )) /* enum handle */
191 /*******************************************************************
192 Reads or writes a DOM_SID structure.
193 ********************************************************************/
195 BOOL smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth)
202 prs_debug(ps, depth, desc, "smb_io_dom_sid");
205 if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
208 if(!prs_uint8 ("num_auths ", ps, depth, &sid->num_auths))
211 for (i = 0; i < 6; i++)
214 slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
215 if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
219 /* oops! XXXX should really issue a warning here... */
220 if (sid->num_auths > MAXSUBAUTHS)
221 sid->num_auths = MAXSUBAUTHS;
223 if(!prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
229 /*******************************************************************
230 Inits a DOM_SID structure.
232 BIG NOTE: this function only does SIDS where the identauth is not >= 2^32
233 identauth >= 2^32 can be detected because it will be specified in hex
234 ********************************************************************/
236 void init_dom_sid(DOM_SID *sid, const char *str_sid)
242 if (str_sid == NULL) {
243 DEBUG(4,("netlogon domain SID: none\n"));
244 sid->sid_rev_num = 0;
249 pstrcpy(domsid, str_sid);
251 DEBUG(4,("init_dom_sid %d SID: %s\n", __LINE__, domsid));
253 /* assume, but should check, that domsid starts "S-" */
254 p = strtok(domsid+2,"-");
255 sid->sid_rev_num = atoi(p);
257 /* identauth in decimal should be < 2^32 */
258 /* identauth in hex should be >= 2^32 */
259 identauth = atoi(strtok(0,"-"));
261 DEBUG(4,("netlogon rev %d\n", sid->sid_rev_num));
262 DEBUG(4,("netlogon %s ia %d\n", p, identauth));
266 sid->id_auth[2] = (identauth & 0xff000000) >> 24;
267 sid->id_auth[3] = (identauth & 0x00ff0000) >> 16;
268 sid->id_auth[4] = (identauth & 0x0000ff00) >> 8;
269 sid->id_auth[5] = (identauth & 0x000000ff);
273 while ((p = strtok(0, "-")) != NULL && sid->num_auths < MAXSUBAUTHS)
274 sid->sub_auths[sid->num_auths++] = atoi(p);
276 DEBUG(4,("init_dom_sid: %d SID: %s\n", __LINE__, domsid));
279 /*******************************************************************
280 Inits a DOM_SID2 structure.
281 ********************************************************************/
283 void init_dom_sid2(DOM_SID2 *sid2, const DOM_SID *sid)
286 sid2->num_auths = sid2->sid.num_auths;
289 /*******************************************************************
290 Reads or writes a DOM_SID2 structure.
291 ********************************************************************/
293 BOOL smb_io_dom_sid2_p(const char *desc, prs_struct *ps, int depth, DOM_SID2 **sid2)
297 /* caputure the pointer value to stream */
299 data_p = *sid2 ? 0xf000baaa : 0;
301 if ( !prs_uint32("dom_sid2_p", ps, depth, &data_p ))
304 /* we're done if there is no data */
309 if (UNMARSHALLING(ps)) {
310 if ( !(*sid2 = PRS_ALLOC_MEM(ps, DOM_SID2, 1)) )
316 /*******************************************************************
317 Reads or writes a DOM_SID2 structure.
318 ********************************************************************/
320 BOOL smb_io_dom_sid2(const char *desc, DOM_SID2 *sid, prs_struct *ps, int depth)
325 prs_debug(ps, depth, desc, "smb_io_dom_sid2");
331 if(!prs_uint32("num_auths", ps, depth, &sid->num_auths))
334 if(!smb_io_dom_sid("sid", &sid->sid, ps, depth))
340 /*******************************************************************
341 Reads or writes a struct uuid
342 ********************************************************************/
344 BOOL smb_io_uuid(const char *desc, struct uuid *uuid,
345 prs_struct *ps, int depth)
350 prs_debug(ps, depth, desc, "smb_io_uuid");
353 if(!prs_uint32 ("data ", ps, depth, &uuid->time_low))
355 if(!prs_uint16 ("data ", ps, depth, &uuid->time_mid))
357 if(!prs_uint16 ("data ", ps, depth, &uuid->time_hi_and_version))
360 if(!prs_uint8s (False, "data ", ps, depth, uuid->clock_seq, sizeof(uuid->clock_seq)))
362 if(!prs_uint8s (False, "data ", ps, depth, uuid->node, sizeof(uuid->node)))
368 /*******************************************************************
369 creates a STRHDR structure.
370 ********************************************************************/
372 void init_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
374 hdr->str_max_len = max_len;
375 hdr->str_str_len = len;
376 hdr->buffer = buffer;
379 /*******************************************************************
380 Reads or writes a STRHDR structure.
381 ********************************************************************/
383 BOOL smb_io_strhdr(const char *desc, STRHDR *hdr, prs_struct *ps, int depth)
388 prs_debug(ps, depth, desc, "smb_io_strhdr");
393 if(!prs_uint16("str_str_len", ps, depth, &hdr->str_str_len))
395 if(!prs_uint16("str_max_len", ps, depth, &hdr->str_max_len))
397 if(!prs_uint32("buffer ", ps, depth, &hdr->buffer))
403 /*******************************************************************
404 Inits a UNIHDR structure.
405 ********************************************************************/
407 void init_uni_hdr(UNIHDR *hdr, UNISTR2 *str2)
409 hdr->uni_str_len = 2 * (str2->uni_str_len);
410 hdr->uni_max_len = 2 * (str2->uni_max_len);
411 hdr->buffer = (str2->uni_str_len != 0) ? 1 : 0;
414 /*******************************************************************
415 Reads or writes a UNIHDR structure.
416 ********************************************************************/
418 BOOL smb_io_unihdr(const char *desc, UNIHDR *hdr, prs_struct *ps, int depth)
423 prs_debug(ps, depth, desc, "smb_io_unihdr");
429 if(!prs_uint16("uni_str_len", ps, depth, &hdr->uni_str_len))
431 if(!prs_uint16("uni_max_len", ps, depth, &hdr->uni_max_len))
433 if(!prs_uint32("buffer ", ps, depth, &hdr->buffer))
439 /*******************************************************************
440 Inits a BUFHDR structure.
441 ********************************************************************/
443 void init_buf_hdr(BUFHDR *hdr, int max_len, int len)
445 hdr->buf_max_len = max_len;
449 /*******************************************************************
450 prs_uint16 wrapper. Call this and it sets up a pointer to where the
451 uint16 should be stored, or gets the size if reading.
452 ********************************************************************/
454 BOOL smb_io_hdrbuf_pre(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
456 (*offset) = prs_offset(ps);
461 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
468 if(!prs_set_offset(ps, prs_offset(ps) + (sizeof(uint32) * 2)))
475 /*******************************************************************
476 smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
477 Does nothing on reading, as that is already handled by ...._pre()
478 ********************************************************************/
480 BOOL smb_io_hdrbuf_post(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth,
481 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
484 /* writing: go back and do a retrospective job. i hate this */
486 uint32 old_offset = prs_offset(ps);
488 init_buf_hdr(hdr, max_len, len);
489 if(!prs_set_offset(ps, ptr_hdrbuf))
491 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
494 if(!prs_set_offset(ps, old_offset))
501 /*******************************************************************
502 Reads or writes a BUFHDR structure.
503 ********************************************************************/
505 BOOL smb_io_hdrbuf(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth)
510 prs_debug(ps, depth, desc, "smb_io_hdrbuf");
516 if(!prs_uint32("buf_max_len", ps, depth, &hdr->buf_max_len))
518 if(!prs_uint32("buf_len ", ps, depth, &hdr->buf_len))
524 /*******************************************************************
525 Inits a UNISTR structure.
526 ********************************************************************/
528 void init_unistr(UNISTR *str, const char *buf)
537 len = strlen(buf) + 1;
539 str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
540 if (str->buffer == NULL)
541 smb_panic("init_unistr: malloc fail\n");
543 rpcstr_push(str->buffer, buf, len*sizeof(uint16), STR_TERMINATE);
546 /*******************************************************************
547 reads or writes a UNISTR structure.
548 XXXX NOTE: UNISTR structures NEED to be null-terminated.
549 ********************************************************************/
551 BOOL smb_io_unistr(const char *desc, UNISTR *uni, prs_struct *ps, int depth)
556 prs_debug(ps, depth, desc, "smb_io_unistr");
559 if(!prs_unistr("unistr", ps, depth, uni))
565 /*******************************************************************
566 Allocate the RPC_DATA_BLOB memory.
567 ********************************************************************/
569 size_t create_rpc_blob(RPC_DATA_BLOB *str, size_t len)
571 str->buffer = TALLOC_ZERO(get_talloc_ctx(), len);
572 if (str->buffer == NULL)
573 smb_panic("create_rpc_blob: talloc fail\n");
577 /*******************************************************************
578 Inits a RPC_DATA_BLOB structure from a uint32
579 ********************************************************************/
581 void init_rpc_blob_uint32(RPC_DATA_BLOB *str, uint32 val)
585 /* set up string lengths. */
586 str->buf_len = create_rpc_blob(str, sizeof(uint32));
587 SIVAL(str->buffer, 0, val);
590 /*******************************************************************
591 Inits a RPC_DATA_BLOB structure.
592 ********************************************************************/
594 void init_rpc_blob_str(RPC_DATA_BLOB *str, const char *buf, int len)
598 /* set up string lengths. */
599 str->buf_len = create_rpc_blob(str, len*2);
600 rpcstr_push(str->buffer, buf, str->buf_len, STR_TERMINATE);
604 /*******************************************************************
605 Inits a RPC_DATA_BLOB structure from a hex string.
606 ********************************************************************/
608 void init_rpc_blob_hex(RPC_DATA_BLOB *str, const char *buf)
611 str->buf_len = create_rpc_blob(str, strlen(buf));
612 str->buf_len = strhex_to_str((char *)str->buffer, str->buf_len, buf);
615 /*******************************************************************
616 Inits a RPC_DATA_BLOB structure.
617 ********************************************************************/
619 void init_rpc_blob_bytes(RPC_DATA_BLOB *str, uint8 *buf, size_t len)
623 /* max buffer size (allocated size) */
625 len = create_rpc_blob(str, len);
626 memcpy(str->buffer, buf, len);
631 /*******************************************************************
632 reads or writes a BUFFER5 structure.
633 the buf_len member tells you how large the buffer is.
634 ********************************************************************/
635 BOOL smb_io_buffer5(const char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
637 prs_debug(ps, depth, desc, "smb_io_buffer5");
640 if (buf5 == NULL) return False;
644 if(!prs_uint32("buf_len", ps, depth, &buf5->buf_len))
648 if(!prs_buffer5(True, "buffer" , ps, depth, buf5))
655 /*******************************************************************
656 Inits a REGVAL_BUFFER structure.
657 ********************************************************************/
659 void init_regval_buffer(REGVAL_BUFFER *str, const uint8 *buf, size_t len)
663 /* max buffer size (allocated size) */
664 str->buf_max_len = len;
666 str->buf_len = buf != NULL ? len : 0;
669 SMB_ASSERT(str->buf_max_len >= str->buf_len);
670 str->buffer = TALLOC_ZERO(get_talloc_ctx(), str->buf_max_len);
671 if (str->buffer == NULL)
672 smb_panic("init_regval_buffer: talloc fail\n");
673 memcpy(str->buffer, buf, str->buf_len);
677 /*******************************************************************
678 Reads or writes a REGVAL_BUFFER structure.
679 the uni_max_len member tells you how large the buffer is.
680 the uni_str_len member tells you how much of the buffer is really used.
681 ********************************************************************/
683 BOOL smb_io_regval_buffer(const char *desc, prs_struct *ps, int depth, REGVAL_BUFFER *buf2)
686 prs_debug(ps, depth, desc, "smb_io_regval_buffer");
692 if(!prs_uint32("buf_max_len", ps, depth, &buf2->buf_max_len))
694 if(!prs_uint32("offset ", ps, depth, &buf2->offset))
696 if(!prs_uint32("buf_len ", ps, depth, &buf2->buf_len))
699 /* buffer advanced by indicated length of string
700 NOT by searching for null-termination */
702 if(!prs_regval_buffer(True, "buffer ", ps, depth, buf2))
708 /*******************************************************************
709 creates a UNISTR2 structure: sets up the buffer, too
710 ********************************************************************/
712 void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf)
716 init_unistr2(str, buf, UNI_STR_TERMINATE);
719 init_unistr2(str, NULL, UNI_FLAGS_NONE);
724 /*******************************************************************
725 Copies a UNISTR2 structure.
726 ********************************************************************/
728 void copy_unistr2(UNISTR2 *str, const UNISTR2 *from)
730 if (from->buffer == NULL) {
735 SMB_ASSERT(from->uni_max_len >= from->uni_str_len);
737 str->uni_max_len = from->uni_max_len;
738 str->offset = from->offset;
739 str->uni_str_len = from->uni_str_len;
741 /* the string buffer is allocated to the maximum size
742 (the the length of the source string) to prevent
743 reallocation of memory. */
744 if (str->buffer == NULL) {
745 str->buffer = (uint16 *)TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_max_len);
746 if ((str->buffer == NULL)) {
747 smb_panic("copy_unistr2: talloc fail\n");
752 /* copy the string */
753 memcpy(str->buffer, from->buffer, str->uni_max_len*sizeof(uint16));
756 /*******************************************************************
757 Creates a STRING2 structure.
758 ********************************************************************/
760 void init_string2(STRING2 *str, const char *buf, size_t max_len, size_t str_len)
762 /* set up string lengths. */
763 SMB_ASSERT(max_len >= str_len);
765 str->str_max_len = max_len;
767 str->str_str_len = str_len;
769 /* store the string */
771 str->buffer = TALLOC_ZERO(get_talloc_ctx(), str->str_max_len);
772 if (str->buffer == NULL)
773 smb_panic("init_string2: malloc fail\n");
774 memcpy(str->buffer, buf, str_len);
778 /*******************************************************************
779 Reads or writes a STRING2 structure.
780 XXXX NOTE: STRING2 structures need NOT be null-terminated.
781 the str_str_len member tells you how long the string is;
782 the str_max_len member tells you how large the buffer is.
783 ********************************************************************/
785 BOOL smb_io_string2(const char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
792 prs_debug(ps, depth, desc, "smb_io_string2");
798 if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len))
800 if(!prs_uint32("offset ", ps, depth, &str2->offset))
802 if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len))
805 /* buffer advanced by indicated length of string
806 NOT by searching for null-termination */
807 if(!prs_string2(True, "buffer ", ps, depth, str2))
812 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
814 memset((char *)str2, '\0', sizeof(*str2));
821 /*******************************************************************
822 Inits a UNISTR2 structure.
823 ********************************************************************/
825 void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags)
828 uint32 num_chars = 0;
831 /* We always null terminate the copy. */
832 len = strlen(buf) + 1;
834 /* no buffer -- nothing to do */
835 str->uni_max_len = 0;
837 str->uni_str_len = 0;
843 str->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, len);
844 if (str->buffer == NULL) {
845 smb_panic("init_unistr2: malloc fail\n");
849 /* Ensure len is the length in *bytes* */
850 len *= sizeof(uint16);
853 * The UNISTR2 must be initialized !!!
857 rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE);
858 num_chars = strlen_w(str->buffer);
859 if (flags == UNI_STR_TERMINATE || flags == UNI_MAXLEN_TERMINATE) {
864 str->uni_max_len = num_chars;
866 str->uni_str_len = num_chars;
867 if ( num_chars && ((flags == UNI_MAXLEN_TERMINATE) || (flags == UNI_BROKEN_NON_NULL)) )
871 /*******************************************************************
872 Inits a UNISTR4 structure.
873 ********************************************************************/
875 void init_unistr4(UNISTR4 *uni4, const char *buf, enum unistr2_term_codes flags)
877 uni4->string = TALLOC_P( get_talloc_ctx(), UNISTR2 );
878 init_unistr2( uni4->string, buf, flags );
880 uni4->length = 2 * (uni4->string->uni_str_len);
881 uni4->size = 2 * (uni4->string->uni_max_len);
884 void init_unistr4_w( TALLOC_CTX *ctx, UNISTR4 *uni4, const smb_ucs2_t *buf )
886 uni4->string = TALLOC_P( ctx, UNISTR2 );
887 init_unistr2_w( ctx, uni4->string, buf );
889 uni4->length = 2 * (uni4->string->uni_str_len);
890 uni4->size = 2 * (uni4->string->uni_max_len);
894 * Inits a UNISTR2 structure.
895 * @param ctx talloc context to allocate string on
896 * @param str pointer to string to create
897 * @param buf UCS2 null-terminated buffer to init from
900 void init_unistr2_w(TALLOC_CTX *ctx, UNISTR2 *str, const smb_ucs2_t *buf)
902 uint32 len = strlen_w(buf);
906 /* set up string lengths. */
907 str->uni_max_len = len;
909 str->uni_str_len = len;
911 str->buffer = TALLOC_ZERO_ARRAY(ctx, uint16, len + 1);
912 if (str->buffer == NULL) {
913 smb_panic("init_unistr2_w: malloc fail\n");
918 * don't move this test above ! The UNISTR2 must be initialized !!!
924 /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
925 long as the buffer above is talloc()ed correctly then this
926 is the correct thing to do */
927 strncpy_w(str->buffer, buf, len + 1);
930 /*******************************************************************
931 Inits a UNISTR2 structure from a UNISTR
932 ********************************************************************/
934 void init_unistr2_from_unistr(UNISTR2 *to, const UNISTR *from)
938 /* the destination UNISTR2 should never be NULL.
939 if it is it is a programming error */
941 /* if the source UNISTR is NULL, then zero out
942 the destination string and return */
944 if ((from == NULL) || (from->buffer == NULL))
947 /* get the length; UNISTR must be NULL terminated */
949 while ((from->buffer)[i]!='\0')
951 i++; /* one more to catch the terminating NULL */
952 /* is this necessary -- jerry? I need to think */
954 /* set up string lengths; uni_max_len is set to i+1
955 because we need to account for the final NULL termination */
960 /* allocate the space and copy the string buffer */
961 to->buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, i);
962 if (to->buffer == NULL)
963 smb_panic("init_unistr2_from_unistr: malloc fail\n");
964 memcpy(to->buffer, from->buffer, i*sizeof(uint16));
968 /*******************************************************************
969 Inits a UNISTR2 structure from a DATA_BLOB.
970 The length of the data_blob must count the bytes of the buffer.
971 Copies the blob data.
972 ********************************************************************/
974 void init_unistr2_from_datablob(UNISTR2 *str, DATA_BLOB *blob)
976 /* Allocs the unistring */
977 init_unistr2(str, NULL, UNI_FLAGS_NONE);
979 /* Sets the values */
980 str->uni_str_len = blob->length / sizeof(uint16);
981 str->uni_max_len = str->uni_str_len;
984 str->buffer = (uint16 *) memdup(blob->data, blob->length);
988 if ((str->buffer == NULL) && (blob->length > 0)) {
989 smb_panic("init_unistr2_from_datablob: malloc fail\n");
993 /*******************************************************************
994 UNISTR2* are a little different in that the pointer and the UNISTR2
995 are not necessarily read/written back to back. So we break it up
996 into 2 separate functions.
997 See SPOOL_USER_1 in include/rpc_spoolss.h for an example.
998 ********************************************************************/
1000 BOOL prs_io_unistr2_p(const char *desc, prs_struct *ps, int depth, UNISTR2 **uni2)
1004 /* caputure the pointer value to stream */
1006 data_p = *uni2 ? 0xf000baaa : 0;
1008 if ( !prs_uint32("ptr", ps, depth, &data_p ))
1011 /* we're done if there is no data */
1016 if (UNMARSHALLING(ps)) {
1017 if ( !(*uni2 = PRS_ALLOC_MEM(ps, UNISTR2, 1)) )
1024 /*******************************************************************
1025 now read/write the actual UNISTR2. Memory for the UNISTR2 (but
1026 not UNISTR2.buffer) has been allocated previously by prs_unistr2_p()
1027 ********************************************************************/
1029 BOOL prs_io_unistr2(const char *desc, prs_struct *ps, int depth, UNISTR2 *uni2 )
1031 /* just return true if there is no pointer to deal with.
1032 the memory must have been previously allocated on unmarshalling
1033 by prs_unistr2_p() */
1038 /* just pass off to smb_io_unstr2() passing the uni2 address as
1039 the pointer (like you would expect) */
1041 return smb_io_unistr2( desc, uni2, uni2 ? 1 : 0, ps, depth );
1044 /*******************************************************************
1045 Reads or writes a UNISTR2 structure.
1046 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
1047 the uni_str_len member tells you how long the string is;
1048 the uni_max_len member tells you how large the buffer is.
1049 ********************************************************************/
1051 BOOL smb_io_unistr2(const char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
1058 prs_debug(ps, depth, desc, "smb_io_unistr2");
1064 if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len))
1066 if(!prs_uint32("offset ", ps, depth, &uni2->offset))
1068 if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len))
1071 /* buffer advanced by indicated length of string
1072 NOT by searching for null-termination */
1073 if(!prs_unistr2(True, "buffer ", ps, depth, uni2))
1078 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
1080 memset((char *)uni2, '\0', sizeof(*uni2));
1087 /*******************************************************************
1088 now read/write UNISTR4
1089 ********************************************************************/
1091 BOOL prs_unistr4(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1093 prs_debug(ps, depth, desc, "prs_unistr4");
1096 if ( !prs_uint16("length", ps, depth, &uni4->length ))
1098 if ( !prs_uint16("size", ps, depth, &uni4->size ))
1101 if ( !prs_pointer( desc, ps, depth, (void**)&uni4->string, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2 ) )
1107 /*******************************************************************
1108 now read/write UNISTR4 header
1109 ********************************************************************/
1111 BOOL prs_unistr4_hdr(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1113 prs_debug(ps, depth, desc, "prs_unistr4_hdr");
1116 if ( !prs_uint16("length", ps, depth, &uni4->length) )
1118 if ( !prs_uint16("size", ps, depth, &uni4->size) )
1120 if ( !prs_io_unistr2_p(desc, ps, depth, &uni4->string) )
1126 /*******************************************************************
1127 now read/write UNISTR4 string
1128 ********************************************************************/
1130 BOOL prs_unistr4_str(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1132 prs_debug(ps, depth, desc, "prs_unistr4_str");
1135 if ( !prs_io_unistr2(desc, ps, depth, uni4->string) )
1141 /*******************************************************************
1142 Reads or writes a UNISTR4_ARRAY structure.
1143 ********************************************************************/
1145 BOOL prs_unistr4_array(const char *desc, prs_struct *ps, int depth, UNISTR4_ARRAY *array )
1149 prs_debug(ps, depth, desc, "prs_unistr4_array");
1152 if(!prs_uint32("count", ps, depth, &array->count))
1155 if ( array->count == 0 )
1158 if (UNMARSHALLING(ps)) {
1159 if ( !(array->strings = TALLOC_ZERO_ARRAY( get_talloc_ctx(), UNISTR4, array->count)) )
1163 /* write the headers and then the actual string buffer */
1165 for ( i=0; i<array->count; i++ ) {
1166 if ( !prs_unistr4_hdr( "string", ps, depth, &array->strings[i]) )
1170 for (i=0;i<array->count;i++) {
1171 if ( !prs_unistr4_str("string", ps, depth, &array->strings[i]) )
1178 /********************************************************************
1179 initialise a UNISTR_ARRAY from a char**
1180 ********************************************************************/
1182 BOOL init_unistr4_array( UNISTR4_ARRAY *array, uint32 count, const char **strings )
1186 array->count = count;
1188 if ( array->count == 0 )
1191 /* allocate memory for the array of UNISTR4 objects */
1193 if ( !(array->strings = TALLOC_ZERO_ARRAY(get_talloc_ctx(), UNISTR4, count )) )
1196 for ( i=0; i<count; i++ )
1197 init_unistr4( &array->strings[i], strings[i], UNI_STR_TERMINATE );
1202 BOOL smb_io_lockout_string_hdr(const char *desc, HDR_LOCKOUT_STRING *hdr_account_lockout, prs_struct *ps, int depth)
1204 prs_debug(ps, depth, desc, "smb_io_lockout_string_hdr");
1210 if(!prs_uint16("size", ps, depth, &hdr_account_lockout->size))
1212 if(!prs_uint16("length", ps, depth, &hdr_account_lockout->length))
1214 if(!prs_uint32("buffer", ps, depth, &hdr_account_lockout->buffer))
1220 BOOL smb_io_account_lockout_str(const char *desc, LOCKOUT_STRING *account_lockout, uint32 buffer, prs_struct *ps, int depth)
1222 prs_debug(ps, depth, desc, "smb_io_account_lockout_string");
1225 if(!prs_uint32("array_size", ps, depth, &account_lockout->array_size))
1228 if(!prs_uint32("offset", ps, depth, &account_lockout->offset))
1230 if(!prs_uint32("length", ps, depth, &account_lockout->length))
1233 if (!prs_uint64("lockout_duration", ps, depth, &account_lockout->lockout_duration))
1235 if (!prs_uint64("reset_count", ps, depth, &account_lockout->reset_count))
1237 if (!prs_uint32("bad_attempt_lockout", ps, depth, &account_lockout->bad_attempt_lockout))
1239 if (!prs_uint32("dummy", ps, depth, &account_lockout->dummy))
1242 if(!prs_uint16s (False, "bindata", ps, depth, &account_lockout->bindata, length))
1249 /*******************************************************************
1250 Inits a DOM_RID2 structure.
1251 ********************************************************************/
1253 void init_dom_rid2(DOM_RID2 *rid2, uint32 rid, uint8 type, uint32 idx)
1257 rid2->rid_idx = idx;
1260 /*******************************************************************
1261 Reads or writes a DOM_RID2 structure.
1262 ********************************************************************/
1264 BOOL smb_io_dom_rid2(const char *desc, DOM_RID2 *rid2, prs_struct *ps, int depth)
1269 prs_debug(ps, depth, desc, "smb_io_dom_rid2");
1275 if(!prs_uint8("type ", ps, depth, &rid2->type))
1279 if(!prs_uint32("rid ", ps, depth, &rid2->rid))
1281 if(!prs_uint32("rid_idx", ps, depth, &rid2->rid_idx))
1287 /*******************************************************************
1288 creates a DOM_RID3 structure.
1289 ********************************************************************/
1291 void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
1295 rid3->ptr_type = 0x1; /* non-zero, basically. */
1300 /*******************************************************************
1301 reads or writes a DOM_RID3 structure.
1302 ********************************************************************/
1304 BOOL smb_io_dom_rid3(const char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth)
1309 prs_debug(ps, depth, desc, "smb_io_dom_rid3");
1315 if(!prs_uint32("rid ", ps, depth, &rid3->rid))
1317 if(!prs_uint32("type1 ", ps, depth, &rid3->type1))
1319 if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type))
1321 if(!prs_uint32("type2 ", ps, depth, &rid3->type2))
1323 if(!prs_uint32("unk ", ps, depth, &rid3->unk))
1329 /*******************************************************************
1330 Inits a DOM_RID4 structure.
1331 ********************************************************************/
1333 void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
1335 rid4->unknown = unknown;
1340 /*******************************************************************
1341 Inits a DOM_CLNT_SRV structure.
1342 ********************************************************************/
1344 static void init_clnt_srv(DOM_CLNT_SRV *logcln, const char *logon_srv, const char *comp_name)
1346 DEBUG(5,("init_clnt_srv: %d\n", __LINE__));
1348 if (logon_srv != NULL) {
1349 logcln->undoc_buffer = 1;
1350 init_unistr2(&logcln->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1352 logcln->undoc_buffer = 0;
1355 if (comp_name != NULL) {
1356 logcln->undoc_buffer2 = 1;
1357 init_unistr2(&logcln->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1359 logcln->undoc_buffer2 = 0;
1363 /*******************************************************************
1364 Inits or writes a DOM_CLNT_SRV structure.
1365 ********************************************************************/
1367 static BOOL smb_io_clnt_srv(const char *desc, DOM_CLNT_SRV *logcln, prs_struct *ps, int depth)
1372 prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1378 if(!prs_uint32("undoc_buffer ", ps, depth, &logcln->undoc_buffer))
1381 if (logcln->undoc_buffer != 0) {
1382 if(!smb_io_unistr2("unistr2", &logcln->uni_logon_srv, logcln->undoc_buffer, ps, depth))
1389 if(!prs_uint32("undoc_buffer2", ps, depth, &logcln->undoc_buffer2))
1392 if (logcln->undoc_buffer2 != 0) {
1393 if(!smb_io_unistr2("unistr2", &logcln->uni_comp_name, logcln->undoc_buffer2, ps, depth))
1400 /*******************************************************************
1401 Inits a DOM_LOG_INFO structure.
1402 ********************************************************************/
1404 void init_log_info(DOM_LOG_INFO *loginfo, const char *logon_srv, const char *acct_name,
1405 uint16 sec_chan, const char *comp_name)
1407 DEBUG(5,("make_log_info %d\n", __LINE__));
1409 loginfo->undoc_buffer = 1;
1411 init_unistr2(&loginfo->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1412 init_unistr2(&loginfo->uni_acct_name, acct_name, UNI_STR_TERMINATE);
1414 loginfo->sec_chan = sec_chan;
1416 init_unistr2(&loginfo->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1419 /*******************************************************************
1420 Reads or writes a DOM_LOG_INFO structure.
1421 ********************************************************************/
1423 BOOL smb_io_log_info(const char *desc, DOM_LOG_INFO *loginfo, prs_struct *ps, int depth)
1425 if (loginfo == NULL)
1428 prs_debug(ps, depth, desc, "smb_io_log_info");
1434 if(!prs_uint32("undoc_buffer", ps, depth, &loginfo->undoc_buffer))
1437 if(!smb_io_unistr2("unistr2", &loginfo->uni_logon_srv, True, ps, depth))
1439 if(!smb_io_unistr2("unistr2", &loginfo->uni_acct_name, True, ps, depth))
1442 if(!prs_uint16("sec_chan", ps, depth, &loginfo->sec_chan))
1445 if(!smb_io_unistr2("unistr2", &loginfo->uni_comp_name, True, ps, depth))
1451 /*******************************************************************
1452 Reads or writes a DOM_CHAL structure.
1453 ********************************************************************/
1455 BOOL smb_io_chal(const char *desc, DOM_CHAL *chal, prs_struct *ps, int depth)
1460 prs_debug(ps, depth, desc, "smb_io_chal");
1463 if(!prs_uint8s (False, "data", ps, depth, chal->data, 8))
1469 /*******************************************************************
1470 Reads or writes a DOM_CRED structure.
1471 ********************************************************************/
1473 BOOL smb_io_cred(const char *desc, DOM_CRED *cred, prs_struct *ps, int depth)
1478 prs_debug(ps, depth, desc, "smb_io_cred");
1484 if(!smb_io_chal ("", &cred->challenge, ps, depth))
1487 if(!smb_io_utime("", &cred->timestamp, ps, depth))
1493 /*******************************************************************
1494 Inits a DOM_CLNT_INFO2 structure.
1495 ********************************************************************/
1497 void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1498 const char *logon_srv, const char *comp_name,
1499 const DOM_CRED *clnt_cred)
1501 DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1503 init_clnt_srv(&clnt->login, logon_srv, comp_name);
1505 if (clnt_cred != NULL) {
1507 memcpy(&clnt->cred, clnt_cred, sizeof(clnt->cred));
1513 /*******************************************************************
1514 Reads or writes a DOM_CLNT_INFO2 structure.
1515 ********************************************************************/
1517 BOOL smb_io_clnt_info2(const char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1522 prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1528 if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1534 if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1536 if(!smb_io_cred("", &clnt->cred, ps, depth))
1542 /*******************************************************************
1543 Inits a DOM_CLNT_INFO structure.
1544 ********************************************************************/
1546 void init_clnt_info(DOM_CLNT_INFO *clnt,
1547 const char *logon_srv, const char *acct_name,
1548 uint16 sec_chan, const char *comp_name,
1549 const DOM_CRED *cred)
1551 DEBUG(5,("make_clnt_info\n"));
1553 init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1554 memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1557 /*******************************************************************
1558 Reads or writes a DOM_CLNT_INFO structure.
1559 ********************************************************************/
1561 BOOL smb_io_clnt_info(const char *desc, DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1566 prs_debug(ps, depth, desc, "smb_io_clnt_info");
1572 if(!smb_io_log_info("", &clnt->login, ps, depth))
1574 if(!smb_io_cred("", &clnt->cred, ps, depth))
1580 /*******************************************************************
1581 Inits a DOM_LOGON_ID structure.
1582 ********************************************************************/
1584 void init_logon_id(DOM_LOGON_ID *logonid, uint32 log_id_low, uint32 log_id_high)
1586 DEBUG(5,("make_logon_id: %d\n", __LINE__));
1588 logonid->low = log_id_low;
1589 logonid->high = log_id_high;
1592 /*******************************************************************
1593 Reads or writes a DOM_LOGON_ID structure.
1594 ********************************************************************/
1596 BOOL smb_io_logon_id(const char *desc, DOM_LOGON_ID *logonid, prs_struct *ps, int depth)
1598 if (logonid == NULL)
1601 prs_debug(ps, depth, desc, "smb_io_logon_id");
1607 if(!prs_uint32("low ", ps, depth, &logonid->low ))
1609 if(!prs_uint32("high", ps, depth, &logonid->high))
1615 /*******************************************************************
1616 Inits an OWF_INFO structure.
1617 ********************************************************************/
1619 void init_owf_info(OWF_INFO *hash, const uint8 data[16])
1621 DEBUG(5,("init_owf_info: %d\n", __LINE__));
1624 memcpy(hash->data, data, sizeof(hash->data));
1626 memset((char *)hash->data, '\0', sizeof(hash->data));
1629 /*******************************************************************
1630 Reads or writes an OWF_INFO structure.
1631 ********************************************************************/
1633 BOOL smb_io_owf_info(const char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1638 prs_debug(ps, depth, desc, "smb_io_owf_info");
1644 if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1650 /*******************************************************************
1651 Reads or writes a DOM_GID structure.
1652 ********************************************************************/
1654 BOOL smb_io_gid(const char *desc, DOM_GID *gid, prs_struct *ps, int depth)
1659 prs_debug(ps, depth, desc, "smb_io_gid");
1665 if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1667 if(!prs_uint32("attr ", ps, depth, &gid->attr))
1673 /*******************************************************************
1674 Reads or writes an POLICY_HND structure.
1675 ********************************************************************/
1677 BOOL smb_io_pol_hnd(const char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1682 prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1688 if(UNMARSHALLING(ps))
1691 if (!prs_uint32("data1", ps, depth, &pol->data1))
1693 if (!prs_uint32("data2", ps, depth, &pol->data2))
1695 if (!prs_uint16("data3", ps, depth, &pol->data3))
1697 if (!prs_uint16("data4", ps, depth, &pol->data4))
1699 if(!prs_uint8s (False, "data5", ps, depth, pol->data5, sizeof(pol->data5)))
1705 /*******************************************************************
1707 ********************************************************************/
1709 void init_unistr3(UNISTR3 *str, const char *buf)
1713 str->str.buffer = NULL;
1717 str->uni_str_len = strlen(buf) + 1;
1719 str->str.buffer = TALLOC_ZERO_ARRAY(get_talloc_ctx(), uint16, str->uni_str_len);
1720 if (str->str.buffer == NULL)
1721 smb_panic("init_unistr3: malloc fail\n");
1723 rpcstr_push((char *)str->str.buffer, buf, str->uni_str_len * sizeof(uint16), STR_TERMINATE);
1726 /*******************************************************************
1727 Reads or writes a UNISTR3 structure.
1728 ********************************************************************/
1730 BOOL smb_io_unistr3(const char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1735 prs_debug(ps, depth, desc, "smb_io_unistr3");
1741 if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1744 /* we're done if there is no string */
1746 if ( name->uni_str_len == 0 )
1749 /* don't know if len is specified by uni_str_len member... */
1750 /* assume unicode string is unicode-null-terminated, instead */
1752 if(!prs_unistr3(True, "unistr", name, ps, depth))
1758 /*******************************************************************
1759 Stream a uint64_struct
1760 ********************************************************************/
1761 BOOL prs_uint64(const char *name, prs_struct *ps, int depth, UINT64_S *data64)
1763 return prs_uint32(name, ps, depth+1, &data64->low) &&
1764 prs_uint32(name, ps, depth+1, &data64->high);
1767 /*******************************************************************
1768 reads or writes a BUFHDR2 structure.
1769 ********************************************************************/
1770 BOOL smb_io_bufhdr2(const char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth)
1772 prs_debug(ps, depth, desc, "smb_io_bufhdr2");
1776 prs_uint32("info_level", ps, depth, &(hdr->info_level));
1777 prs_uint32("length ", ps, depth, &(hdr->length ));
1778 prs_uint32("buffer ", ps, depth, &(hdr->buffer ));
1783 /*******************************************************************
1784 reads or writes a BUFHDR4 structure.
1785 ********************************************************************/
1786 BOOL smb_io_bufhdr4(const char *desc, BUFHDR4 *hdr, prs_struct *ps, int depth)
1788 prs_debug(ps, depth, desc, "smb_io_bufhdr4");
1792 prs_uint32("size", ps, depth, &hdr->size);
1793 prs_uint32("buffer", ps, depth, &hdr->buffer);
1798 /*******************************************************************
1799 reads or writes a RPC_DATA_BLOB structure.
1800 ********************************************************************/
1802 BOOL smb_io_rpc_blob(const char *desc, RPC_DATA_BLOB *blob, prs_struct *ps, int depth)
1804 prs_debug(ps, depth, desc, "smb_io_rpc_blob");
1808 if ( !prs_uint32("buf_len", ps, depth, &blob->buf_len) )
1811 if ( blob->buf_len == 0 )
1814 if (UNMARSHALLING(ps)) {
1815 blob->buffer = PRS_ALLOC_MEM(ps, uint8, blob->buf_len);
1816 if (!blob->buffer) {
1821 if ( !prs_uint8s(True, "buffer", ps, depth, blob->buffer, blob->buf_len) )
1827 /*******************************************************************
1828 creates a UNIHDR structure.
1829 ********************************************************************/
1831 BOOL make_uni_hdr(UNIHDR *hdr, int len)
1837 hdr->uni_str_len = 2 * len;
1838 hdr->uni_max_len = 2 * len;
1839 hdr->buffer = len != 0 ? 1 : 0;
1844 /*******************************************************************
1845 creates a BUFHDR2 structure.
1846 ********************************************************************/
1847 BOOL make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer)
1849 hdr->info_level = info_level;
1850 hdr->length = length;
1851 hdr->buffer = buffer;
1856 /*******************************************************************
1857 return the length of a UNISTR string.
1858 ********************************************************************/
1860 uint32 str_len_uni(UNISTR *source)
1864 if (!source->buffer)
1867 while (source->buffer[i])