source: branches/samba-3.2.x/source/rpc_parse/parse_misc.c

Last change on this file was 133, checked in by Paul Smedley, 17 years ago

Update trunk to 3.2.0pre3
File size: 47.2 KB
Line 
1/*
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
8 *
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 3 of the License, or
12 * (at your option) any later version.
13 *
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.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 */
22
23#include "includes.h"
24
25#undef DBGC_CLASS
26#define DBGC_CLASS DBGC_RPC_PARSE
27
28/*******************************************************************
29 Reads or writes a UTIME type.
30********************************************************************/
31
32static bool smb_io_utime(const char *desc, UTIME *t, prs_struct *ps, int depth)
33{
34 if (t == NULL)
35 return False;
36
37 prs_debug(ps, depth, desc, "smb_io_utime");
38 depth++;
39
40 if(!prs_align(ps))
41 return False;
42
43 if(!prs_uint32 ("time", ps, depth, &t->time))
44 return False;
45
46 return True;
47}
48
49/*******************************************************************
50 Reads or writes an NTTIME structure.
51********************************************************************/
52
53bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
54{
55 uint32 low, high;
56 if (nttime == NULL)
57 return False;
58
59 prs_debug(ps, depth, desc, "smb_io_time");
60 depth++;
61
62 if(!prs_align(ps))
63 return False;
64
65 if (MARSHALLING(ps)) {
66 low = *nttime & 0xFFFFFFFF;
67 high = *nttime >> 32;
68 }
69
70 if(!prs_uint32("low ", ps, depth, &low)) /* low part */
71 return False;
72 if(!prs_uint32("high", ps, depth, &high)) /* high part */
73 return False;
74
75 if (UNMARSHALLING(ps)) {
76 *nttime = (((uint64_t)high << 32) + low);
77 }
78
79 return True;
80}
81
82/*******************************************************************
83 Reads or writes an NTTIME structure.
84********************************************************************/
85
86bool smb_io_nttime(const char *desc, prs_struct *ps, int depth, NTTIME *nttime)
87{
88 return smb_io_time( desc, nttime, ps, depth );
89}
90
91/*******************************************************************
92 Gets an enumeration handle from an ENUM_HND structure.
93********************************************************************/
94
95uint32 get_enum_hnd(ENUM_HND *enh)
96{
97 return (enh && enh->ptr_hnd != 0) ? enh->handle : 0;
98}
99
100/*******************************************************************
101 Inits an ENUM_HND structure.
102********************************************************************/
103
104void init_enum_hnd(ENUM_HND *enh, uint32 hnd)
105{
106 DEBUG(5,("smb_io_enum_hnd\n"));
107
108 enh->ptr_hnd = (hnd != 0) ? 1 : 0;
109 enh->handle = hnd;
110}
111
112/*******************************************************************
113 Reads or writes an ENUM_HND structure.
114********************************************************************/
115
116bool smb_io_enum_hnd(const char *desc, ENUM_HND *hnd, prs_struct *ps, int depth)
117{
118 if (hnd == NULL)
119 return False;
120
121 prs_debug(ps, depth, desc, "smb_io_enum_hnd");
122 depth++;
123
124 if(!prs_align(ps))
125 return False;
126
127 if(!prs_uint32("ptr_hnd", ps, depth, &hnd->ptr_hnd)) /* pointer */
128 return False;
129
130 if (hnd->ptr_hnd != 0) {
131 if(!prs_uint32("handle ", ps, depth, &hnd->handle )) /* enum handle */
132 return False;
133 }
134
135 return True;
136}
137
138/*******************************************************************
139 Reads or writes a DOM_SID structure.
140********************************************************************/
141
142bool smb_io_dom_sid(const char *desc, DOM_SID *sid, prs_struct *ps, int depth)
143{
144 int i;
145
146 if (sid == NULL)
147 return False;
148
149 prs_debug(ps, depth, desc, "smb_io_dom_sid");
150 depth++;
151
152 if(!prs_uint8 ("sid_rev_num", ps, depth, &sid->sid_rev_num))
153 return False;
154
155 if(!prs_uint8 ("num_auths ", ps, depth, &sid->num_auths))
156 return False;
157
158 for (i = 0; i < 6; i++)
159 {
160 fstring tmp;
161 slprintf(tmp, sizeof(tmp) - 1, "id_auth[%d] ", i);
162 if(!prs_uint8 (tmp, ps, depth, &sid->id_auth[i]))
163 return False;
164 }
165
166 /* oops! XXXX should really issue a warning here... */
167 if (sid->num_auths > MAXSUBAUTHS)
168 sid->num_auths = MAXSUBAUTHS;
169
170 if(!prs_uint32s(False, "sub_auths ", ps, depth, sid->sub_auths, sid->num_auths))
171 return False;
172
173 return True;
174}
175
176/*******************************************************************
177 Inits a DOM_SID2 structure.
178********************************************************************/
179
180void init_dom_sid2(DOM_SID2 *sid2, const DOM_SID *sid)
181{
182 sid2->sid = *sid;
183 sid2->num_auths = sid2->sid.num_auths;
184}
185
186/*******************************************************************
187 Reads or writes a DOM_SID2 structure.
188********************************************************************/
189
190bool smb_io_dom_sid2_p(const char *desc, prs_struct *ps, int depth, DOM_SID2 **sid2)
191{
192 uint32 data_p;
193
194 /* caputure the pointer value to stream */
195
196 data_p = *sid2 ? 0xf000baaa : 0;
197
198 if ( !prs_uint32("dom_sid2_p", ps, depth, &data_p ))
199 return False;
200
201 /* we're done if there is no data */
202
203 if ( !data_p )
204 return True;
205
206 if (UNMARSHALLING(ps)) {
207 if ( !(*sid2 = PRS_ALLOC_MEM(ps, DOM_SID2, 1)) )
208 return False;
209 }
210
211 return True;
212}
213/*******************************************************************
214 Reads or writes a DOM_SID2 structure.
215********************************************************************/
216
217bool smb_io_dom_sid2(const char *desc, DOM_SID2 *sid, prs_struct *ps, int depth)
218{
219 if (sid == NULL)
220 return False;
221
222 prs_debug(ps, depth, desc, "smb_io_dom_sid2");
223 depth++;
224
225 if(!prs_align(ps))
226 return False;
227
228 if(!prs_uint32("num_auths", ps, depth, &sid->num_auths))
229 return False;
230
231 if(!smb_io_dom_sid("sid", &sid->sid, ps, depth))
232 return False;
233
234 return True;
235}
236
237/*******************************************************************
238 Reads or writes a struct GUID
239********************************************************************/
240
241bool smb_io_uuid(const char *desc, struct GUID *uuid,
242 prs_struct *ps, int depth)
243{
244 if (uuid == NULL)
245 return False;
246
247 prs_debug(ps, depth, desc, "smb_io_uuid");
248 depth++;
249
250 if(!prs_uint32 ("data ", ps, depth, &uuid->time_low))
251 return False;
252 if(!prs_uint16 ("data ", ps, depth, &uuid->time_mid))
253 return False;
254 if(!prs_uint16 ("data ", ps, depth, &uuid->time_hi_and_version))
255 return False;
256
257 if(!prs_uint8s (False, "data ", ps, depth, uuid->clock_seq, sizeof(uuid->clock_seq)))
258 return False;
259 if(!prs_uint8s (False, "data ", ps, depth, uuid->node, sizeof(uuid->node)))
260 return False;
261
262 return True;
263}
264
265/*******************************************************************
266creates a STRHDR structure.
267********************************************************************/
268
269void init_str_hdr(STRHDR *hdr, int max_len, int len, uint32 buffer)
270{
271 hdr->str_max_len = max_len;
272 hdr->str_str_len = len;
273 hdr->buffer = buffer;
274}
275
276/*******************************************************************
277 Reads or writes a STRHDR structure.
278********************************************************************/
279
280bool smb_io_strhdr(const char *desc, STRHDR *hdr, prs_struct *ps, int depth)
281{
282 if (hdr == NULL)
283 return False;
284
285 prs_debug(ps, depth, desc, "smb_io_strhdr");
286 depth++;
287
288 if(!prs_align(ps))
289 return False;
290
291 if(!prs_uint16("str_str_len", ps, depth, &hdr->str_str_len))
292 return False;
293 if(!prs_uint16("str_max_len", ps, depth, &hdr->str_max_len))
294 return False;
295 if(!prs_uint32("buffer ", ps, depth, &hdr->buffer))
296 return False;
297
298 return True;
299}
300
301/*******************************************************************
302 Inits a UNIHDR structure.
303********************************************************************/
304
305void init_uni_hdr(UNIHDR *hdr, UNISTR2 *str2)
306{
307 hdr->uni_str_len = 2 * (str2->uni_str_len);
308 hdr->uni_max_len = 2 * (str2->uni_max_len);
309 hdr->buffer = (str2->uni_str_len != 0) ? 1 : 0;
310}
311
312/*******************************************************************
313 Reads or writes a UNIHDR structure.
314********************************************************************/
315
316bool smb_io_unihdr(const char *desc, UNIHDR *hdr, prs_struct *ps, int depth)
317{
318 if (hdr == NULL)
319 return False;
320
321 prs_debug(ps, depth, desc, "smb_io_unihdr");
322 depth++;
323
324 if(!prs_align(ps))
325 return False;
326
327 if(!prs_uint16("uni_str_len", ps, depth, &hdr->uni_str_len))
328 return False;
329 if(!prs_uint16("uni_max_len", ps, depth, &hdr->uni_max_len))
330 return False;
331 if(!prs_uint32("buffer ", ps, depth, &hdr->buffer))
332 return False;
333
334 return True;
335}
336
337/*******************************************************************
338 Inits a BUFHDR structure.
339********************************************************************/
340
341void init_buf_hdr(BUFHDR *hdr, int max_len, int len)
342{
343 hdr->buf_max_len = max_len;
344 hdr->buf_len = len;
345}
346
347/*******************************************************************
348 prs_uint16 wrapper. Call this and it sets up a pointer to where the
349 uint16 should be stored, or gets the size if reading.
350 ********************************************************************/
351
352bool smb_io_hdrbuf_pre(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth, uint32 *offset)
353{
354 (*offset) = prs_offset(ps);
355 if (ps->io) {
356
357 /* reading. */
358
359 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
360 return False;
361
362 } else {
363
364 /* writing. */
365
366 if(!prs_set_offset(ps, prs_offset(ps) + (sizeof(uint32) * 2)))
367 return False;
368 }
369
370 return True;
371}
372
373/*******************************************************************
374 smb_io_hdrbuf wrapper. Call this and it retrospectively stores the size.
375 Does nothing on reading, as that is already handled by ...._pre()
376 ********************************************************************/
377
378bool smb_io_hdrbuf_post(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth,
379 uint32 ptr_hdrbuf, uint32 max_len, uint32 len)
380{
381 if (!ps->io) {
382 /* writing: go back and do a retrospective job. i hate this */
383
384 uint32 old_offset = prs_offset(ps);
385
386 init_buf_hdr(hdr, max_len, len);
387 if(!prs_set_offset(ps, ptr_hdrbuf))
388 return False;
389 if(!smb_io_hdrbuf(desc, hdr, ps, depth))
390 return False;
391
392 if(!prs_set_offset(ps, old_offset))
393 return False;
394 }
395
396 return True;
397}
398
399/*******************************************************************
400 Reads or writes a BUFHDR structure.
401********************************************************************/
402
403bool smb_io_hdrbuf(const char *desc, BUFHDR *hdr, prs_struct *ps, int depth)
404{
405 if (hdr == NULL)
406 return False;
407
408 prs_debug(ps, depth, desc, "smb_io_hdrbuf");
409 depth++;
410
411 if(!prs_align(ps))
412 return False;
413
414 if(!prs_uint32("buf_max_len", ps, depth, &hdr->buf_max_len))
415 return False;
416 if(!prs_uint32("buf_len ", ps, depth, &hdr->buf_len))
417 return False;
418
419 return True;
420}
421
422/*******************************************************************
423 Inits a UNISTR structure.
424********************************************************************/
425
426void init_unistr(UNISTR *str, const char *buf)
427{
428 size_t len;
429
430 if (buf == NULL) {
431 str->buffer = NULL;
432 return;
433 }
434
435 len = rpcstr_push_talloc(talloc_tos(), &str->buffer, buf);
436 if (len == (size_t)-1) {
437 str->buffer = NULL;
438 }
439}
440
441/*******************************************************************
442reads or writes a UNISTR structure.
443XXXX NOTE: UNISTR structures NEED to be null-terminated.
444********************************************************************/
445
446bool smb_io_unistr(const char *desc, UNISTR *uni, prs_struct *ps, int depth)
447{
448 if (uni == NULL)
449 return False;
450
451 prs_debug(ps, depth, desc, "smb_io_unistr");
452 depth++;
453
454 if(!prs_unistr("unistr", ps, depth, uni))
455 return False;
456
457 return True;
458}
459
460/*******************************************************************
461 Allocate the RPC_DATA_BLOB memory.
462********************************************************************/
463
464static void create_rpc_blob(RPC_DATA_BLOB *str, size_t len)
465{
466 if (len) {
467 str->buffer = (uint8 *)TALLOC_ZERO(talloc_tos(), len);
468 if (str->buffer == NULL)
469 smb_panic("create_rpc_blob: talloc fail");
470 str->buf_len = len;
471 } else {
472 str->buffer = NULL;
473 str->buf_len = 0;
474 }
475}
476
477/*******************************************************************
478 Inits a RPC_DATA_BLOB structure from a uint32
479********************************************************************/
480
481void init_rpc_blob_uint32(RPC_DATA_BLOB *str, uint32 val)
482{
483 ZERO_STRUCTP(str);
484
485 /* set up string lengths. */
486 create_rpc_blob(str, sizeof(uint32));
487 SIVAL(str->buffer, 0, val);
488}
489
490/*******************************************************************
491 Inits a RPC_DATA_BLOB structure.
492********************************************************************/
493
494void init_rpc_blob_str(RPC_DATA_BLOB *str, const char *buf, int len)
495{
496 ZERO_STRUCTP(str);
497
498 /* set up string lengths. */
499 if (len) {
500 create_rpc_blob(str, len*2);
501 rpcstr_push(str->buffer, buf, (size_t)str->buf_len, STR_TERMINATE);
502 }
503}
504
505/*******************************************************************
506 Inits a RPC_DATA_BLOB structure from a hex string.
507********************************************************************/
508
509void init_rpc_blob_hex(RPC_DATA_BLOB *str, const char *buf)
510{
511 ZERO_STRUCTP(str);
512 if (buf && *buf) {
513 size_t len = strlen(buf);
514 create_rpc_blob(str, len);
515 str->buf_len = strhex_to_str((char *)str->buffer, str->buf_len,
516 buf, len);
517 }
518}
519
520/*******************************************************************
521 Inits a RPC_DATA_BLOB structure.
522********************************************************************/
523
524void init_rpc_blob_bytes(RPC_DATA_BLOB *str, uint8 *buf, size_t len)
525{
526 ZERO_STRUCTP(str);
527
528 /* max buffer size (allocated size) */
529 if (buf != NULL && len) {
530 create_rpc_blob(str, len);
531 memcpy(str->buffer, buf, len);
532 }
533 str->buf_len = len;
534}
535
536/*******************************************************************
537reads or writes a BUFFER5 structure.
538the buf_len member tells you how large the buffer is.
539********************************************************************/
540bool smb_io_buffer5(const char *desc, BUFFER5 *buf5, prs_struct *ps, int depth)
541{
542 prs_debug(ps, depth, desc, "smb_io_buffer5");
543 depth++;
544
545 if (buf5 == NULL) return False;
546
547 if(!prs_align(ps))
548 return False;
549 if(!prs_uint32("buf_len", ps, depth, &buf5->buf_len))
550 return False;
551
552 if(buf5->buf_len) {
553 if(!prs_buffer5(True, "buffer" , ps, depth, buf5))
554 return False;
555 }
556
557 return True;
558}
559
560/*******************************************************************
561 Inits a REGVAL_BUFFER structure.
562********************************************************************/
563
564void init_regval_buffer(REGVAL_BUFFER *str, const uint8 *buf, size_t len)
565{
566 ZERO_STRUCTP(str);
567
568 /* max buffer size (allocated size) */
569 str->buf_max_len = len;
570 str->offset = 0;
571 str->buf_len = buf != NULL ? len : 0;
572
573 if (buf != NULL) {
574 SMB_ASSERT(str->buf_max_len >= str->buf_len);
575 str->buffer = (uint16 *)TALLOC_ZERO(talloc_tos(),
576 str->buf_max_len);
577 if (str->buffer == NULL)
578 smb_panic("init_regval_buffer: talloc fail");
579 memcpy(str->buffer, buf, str->buf_len);
580 }
581}
582
583/*******************************************************************
584 Reads or writes a REGVAL_BUFFER structure.
585 the uni_max_len member tells you how large the buffer is.
586 the uni_str_len member tells you how much of the buffer is really used.
587********************************************************************/
588
589bool smb_io_regval_buffer(const char *desc, prs_struct *ps, int depth, REGVAL_BUFFER *buf2)
590{
591
592 prs_debug(ps, depth, desc, "smb_io_regval_buffer");
593 depth++;
594
595 if(!prs_align(ps))
596 return False;
597
598 if(!prs_uint32("buf_max_len", ps, depth, &buf2->buf_max_len))
599 return False;
600 if(!prs_uint32("offset ", ps, depth, &buf2->offset))
601 return False;
602 if(!prs_uint32("buf_len ", ps, depth, &buf2->buf_len))
603 return False;
604
605 /* buffer advanced by indicated length of string
606 NOT by searching for null-termination */
607
608 if(!prs_regval_buffer(True, "buffer ", ps, depth, buf2))
609 return False;
610
611 return True;
612}
613
614/*******************************************************************
615creates a UNISTR2 structure: sets up the buffer, too
616********************************************************************/
617
618void init_buf_unistr2(UNISTR2 *str, uint32 *ptr, const char *buf)
619{
620 if (buf != NULL) {
621 *ptr = 1;
622 init_unistr2(str, buf, UNI_STR_TERMINATE);
623 } else {
624 *ptr = 0;
625 init_unistr2(str, NULL, UNI_FLAGS_NONE);
626
627 }
628}
629
630/*******************************************************************
631 Copies a UNISTR2 structure.
632********************************************************************/
633
634void copy_unistr2(UNISTR2 *str, const UNISTR2 *from)
635{
636 if (from->buffer == NULL) {
637 ZERO_STRUCTP(str);
638 return;
639 }
640
641 SMB_ASSERT(from->uni_max_len >= from->uni_str_len);
642
643 str->uni_max_len = from->uni_max_len;
644 str->offset = from->offset;
645 str->uni_str_len = from->uni_str_len;
646
647 /* the string buffer is allocated to the maximum size
648 (the the length of the source string) to prevent
649 reallocation of memory. */
650 if (str->buffer == NULL) {
651 if (str->uni_max_len) {
652 str->buffer = (uint16 *)TALLOC_ZERO_ARRAY(talloc_tos(), uint16, str->uni_max_len);
653 if ((str->buffer == NULL)) {
654 smb_panic("copy_unistr2: talloc fail");
655 return;
656 }
657 /* copy the string */
658 memcpy(str->buffer, from->buffer, str->uni_max_len*sizeof(uint16));
659 } else {
660 str->buffer = NULL;
661 }
662 }
663}
664
665/*******************************************************************
666 Creates a STRING2 structure.
667********************************************************************/
668
669void init_string2(STRING2 *str, const char *buf, size_t max_len, size_t str_len)
670{
671 /* set up string lengths. */
672 SMB_ASSERT(max_len >= str_len);
673
674 /* Ensure buf is valid if str_len was set. Coverity check. */
675 if (str_len && !buf) {
676 return;
677 }
678
679 str->str_max_len = max_len;
680 str->offset = 0;
681 str->str_str_len = str_len;
682
683 /* store the string */
684 if(str_len != 0) {
685 str->buffer = (uint8 *)TALLOC_ZERO(talloc_tos(),
686 str->str_max_len);
687 if (str->buffer == NULL)
688 smb_panic("init_string2: malloc fail");
689 memcpy(str->buffer, buf, str_len);
690 }
691}
692
693/*******************************************************************
694 Reads or writes a STRING2 structure.
695 XXXX NOTE: STRING2 structures need NOT be null-terminated.
696 the str_str_len member tells you how long the string is;
697 the str_max_len member tells you how large the buffer is.
698********************************************************************/
699
700bool smb_io_string2(const char *desc, STRING2 *str2, uint32 buffer, prs_struct *ps, int depth)
701{
702 if (str2 == NULL)
703 return False;
704
705 if (buffer) {
706
707 prs_debug(ps, depth, desc, "smb_io_string2");
708 depth++;
709
710 if(!prs_align(ps))
711 return False;
712
713 if(!prs_uint32("str_max_len", ps, depth, &str2->str_max_len))
714 return False;
715 if(!prs_uint32("offset ", ps, depth, &str2->offset))
716 return False;
717 if(!prs_uint32("str_str_len", ps, depth, &str2->str_str_len))
718 return False;
719
720 /* buffer advanced by indicated length of string
721 NOT by searching for null-termination */
722 if(!prs_string2(True, "buffer ", ps, depth, str2))
723 return False;
724
725 } else {
726
727 prs_debug(ps, depth, desc, "smb_io_string2 - NULL");
728 depth++;
729 memset((char *)str2, '\0', sizeof(*str2));
730
731 }
732
733 return True;
734}
735
736/*******************************************************************
737 Inits a UNISTR2 structure.
738********************************************************************/
739
740void init_unistr2(UNISTR2 *str, const char *buf, enum unistr2_term_codes flags)
741{
742 size_t len = 0;
743 uint32 num_chars = 0;
744
745 if (buf) {
746 /* We always null terminate the copy. */
747 len = strlen(buf) + 1;
748 if ( flags == UNI_STR_DBLTERMINATE )
749 len++;
750 }
751
752 if (buf == NULL || len == 0) {
753 /* no buffer -- nothing to do */
754 str->uni_max_len = 0;
755 str->offset = 0;
756 str->uni_str_len = 0;
757
758 return;
759 }
760
761
762 str->buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, len);
763 if (str->buffer == NULL) {
764 smb_panic("init_unistr2: malloc fail");
765 return;
766 }
767
768 /* Ensure len is the length in *bytes* */
769 len *= sizeof(uint16);
770
771 /*
772 * The UNISTR2 must be initialized !!!
773 * jfm, 7/7/2001.
774 */
775 if (buf) {
776 rpcstr_push((char *)str->buffer, buf, len, STR_TERMINATE);
777 num_chars = strlen_w(str->buffer);
778 if (flags == UNI_STR_TERMINATE || flags == UNI_MAXLEN_TERMINATE) {
779 num_chars++;
780 }
781 if ( flags == UNI_STR_DBLTERMINATE )
782 num_chars += 2;
783 }
784
785 str->uni_max_len = num_chars;
786 str->offset = 0;
787 str->uni_str_len = num_chars;
788 if ( num_chars && ((flags == UNI_MAXLEN_TERMINATE) || (flags == UNI_BROKEN_NON_NULL)) )
789 str->uni_max_len++;
790}
791
792/*******************************************************************
793 Inits a UNISTR4 structure.
794********************************************************************/
795
796void init_unistr4(UNISTR4 *uni4, const char *buf, enum unistr2_term_codes flags)
797{
798 uni4->string = TALLOC_P( talloc_tos(), UNISTR2 );
799 if (!uni4->string) {
800 smb_panic("init_unistr4: talloc fail");
801 return;
802 }
803 init_unistr2( uni4->string, buf, flags );
804
805 uni4->length = 2 * (uni4->string->uni_str_len);
806 uni4->size = 2 * (uni4->string->uni_max_len);
807}
808
809void init_unistr4_w( TALLOC_CTX *ctx, UNISTR4 *uni4, const smb_ucs2_t *buf )
810{
811 uni4->string = TALLOC_P( ctx, UNISTR2 );
812 if (!uni4->string) {
813 smb_panic("init_unistr4_w: talloc fail");
814 return;
815 }
816 init_unistr2_w( ctx, uni4->string, buf );
817
818 uni4->length = 2 * (uni4->string->uni_str_len);
819 uni4->size = 2 * (uni4->string->uni_max_len);
820}
821
822/**
823 * Inits a UNISTR2 structure.
824 * @param ctx talloc context to allocate string on
825 * @param str pointer to string to create
826 * @param buf UCS2 null-terminated buffer to init from
827*/
828
829void init_unistr2_w(TALLOC_CTX *ctx, UNISTR2 *str, const smb_ucs2_t *buf)
830{
831 uint32 len = buf ? strlen_w(buf) : 0;
832
833 ZERO_STRUCTP(str);
834
835 /* set up string lengths. */
836 str->uni_max_len = len;
837 str->offset = 0;
838 str->uni_str_len = len;
839
840 if (len + 1) {
841 str->buffer = TALLOC_ZERO_ARRAY(ctx, uint16, len + 1);
842 if (str->buffer == NULL) {
843 smb_panic("init_unistr2_w: talloc fail");
844 return;
845 }
846 } else {
847 str->buffer = NULL;
848 }
849
850 /*
851 * don't move this test above ! The UNISTR2 must be initialized !!!
852 * jfm, 7/7/2001.
853 */
854 if (buf==NULL)
855 return;
856
857 /* Yes, this is a strncpy( foo, bar, strlen(bar)) - but as
858 long as the buffer above is talloc()ed correctly then this
859 is the correct thing to do */
860 if (len+1) {
861 strncpy_w(str->buffer, buf, len + 1);
862 }
863}
864
865/*******************************************************************
866 Inits a UNISTR2 structure from a UNISTR
867********************************************************************/
868
869void init_unistr2_from_unistr(TALLOC_CTX *ctx, UNISTR2 *to, const UNISTR *from)
870{
871 uint32 i;
872
873 /* the destination UNISTR2 should never be NULL.
874 if it is it is a programming error */
875
876 /* if the source UNISTR is NULL, then zero out
877 the destination string and return */
878 ZERO_STRUCTP (to);
879 if ((from == NULL) || (from->buffer == NULL))
880 return;
881
882 /* get the length; UNISTR must be NULL terminated */
883 i = 0;
884 while ((from->buffer)[i]!='\0')
885 i++;
886 i++; /* one more to catch the terminating NULL */
887 /* is this necessary -- jerry? I need to think */
888
889 /* set up string lengths; uni_max_len is set to i+1
890 because we need to account for the final NULL termination */
891 to->uni_max_len = i;
892 to->offset = 0;
893 to->uni_str_len = i;
894
895 /* allocate the space and copy the string buffer */
896 if (i) {
897 to->buffer = TALLOC_ZERO_ARRAY(ctx, uint16, i);
898 if (to->buffer == NULL)
899 smb_panic("init_unistr2_from_unistr: talloc fail");
900 memcpy(to->buffer, from->buffer, i*sizeof(uint16));
901 } else {
902 to->buffer = NULL;
903 }
904 return;
905}
906
907/*******************************************************************
908 Inits a UNISTR2 structure from a DATA_BLOB.
909 The length of the data_blob must count the bytes of the buffer.
910 Copies the blob data.
911********************************************************************/
912
913void init_unistr2_from_datablob(UNISTR2 *str, DATA_BLOB *blob)
914{
915 /* Allocs the unistring */
916 init_unistr2(str, NULL, UNI_FLAGS_NONE);
917
918 /* Sets the values */
919 str->uni_str_len = blob->length / sizeof(uint16);
920 str->uni_max_len = str->uni_str_len;
921 str->offset = 0;
922 if (blob->length) {
923 str->buffer = (uint16 *) memdup(blob->data, blob->length);
924 } else {
925 str->buffer = NULL;
926 }
927 if ((str->buffer == NULL) && (blob->length > 0)) {
928 smb_panic("init_unistr2_from_datablob: malloc fail");
929 }
930}
931
932/*******************************************************************
933 UNISTR2* are a little different in that the pointer and the UNISTR2
934 are not necessarily read/written back to back. So we break it up
935 into 2 separate functions.
936 See SPOOL_USER_1 in include/rpc_spoolss.h for an example.
937********************************************************************/
938
939bool prs_io_unistr2_p(const char *desc, prs_struct *ps, int depth, UNISTR2 **uni2)
940{
941 uint32 data_p;
942
943 /* caputure the pointer value to stream */
944
945 data_p = *uni2 ? 0xf000baaa : 0;
946
947 if ( !prs_uint32("ptr", ps, depth, &data_p ))
948 return False;
949
950 /* we're done if there is no data */
951
952 if ( !data_p )
953 return True;
954
955 if (UNMARSHALLING(ps)) {
956 if ( !(*uni2 = PRS_ALLOC_MEM(ps, UNISTR2, 1)) )
957 return False;
958 }
959
960 return True;
961}
962
963/*******************************************************************
964 now read/write the actual UNISTR2. Memory for the UNISTR2 (but
965 not UNISTR2.buffer) has been allocated previously by prs_unistr2_p()
966********************************************************************/
967
968bool prs_io_unistr2(const char *desc, prs_struct *ps, int depth, UNISTR2 *uni2 )
969{
970 /* just return true if there is no pointer to deal with.
971 the memory must have been previously allocated on unmarshalling
972 by prs_unistr2_p() */
973
974 if ( !uni2 )
975 return True;
976
977 /* just pass off to smb_io_unstr2() passing the uni2 address as
978 the pointer (like you would expect) */
979
980 return smb_io_unistr2( desc, uni2, uni2 ? 1 : 0, ps, depth );
981}
982
983/*******************************************************************
984 Reads or writes a UNISTR2 structure.
985 XXXX NOTE: UNISTR2 structures need NOT be null-terminated.
986 the uni_str_len member tells you how long the string is;
987 the uni_max_len member tells you how large the buffer is.
988********************************************************************/
989
990bool smb_io_unistr2(const char *desc, UNISTR2 *uni2, uint32 buffer, prs_struct *ps, int depth)
991{
992 if (uni2 == NULL)
993 return False;
994
995 if (buffer) {
996
997 prs_debug(ps, depth, desc, "smb_io_unistr2");
998 depth++;
999
1000 if(!prs_align(ps))
1001 return False;
1002
1003 if(!prs_uint32("uni_max_len", ps, depth, &uni2->uni_max_len))
1004 return False;
1005 if(!prs_uint32("offset ", ps, depth, &uni2->offset))
1006 return False;
1007 if(!prs_uint32("uni_str_len", ps, depth, &uni2->uni_str_len))
1008 return False;
1009
1010 /* buffer advanced by indicated length of string
1011 NOT by searching for null-termination */
1012 if(!prs_unistr2(True, "buffer ", ps, depth, uni2))
1013 return False;
1014
1015 } else {
1016
1017 prs_debug(ps, depth, desc, "smb_io_unistr2 - NULL");
1018 depth++;
1019 memset((char *)uni2, '\0', sizeof(*uni2));
1020
1021 }
1022
1023 return True;
1024}
1025
1026/*******************************************************************
1027 now read/write UNISTR4
1028********************************************************************/
1029
1030bool prs_unistr4(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1031{
1032 void *ptr;
1033 prs_debug(ps, depth, desc, "prs_unistr4");
1034 depth++;
1035
1036 if ( !prs_uint16("length", ps, depth, &uni4->length ))
1037 return False;
1038 if ( !prs_uint16("size", ps, depth, &uni4->size ))
1039 return False;
1040
1041 ptr = uni4->string;
1042
1043 if ( !prs_pointer( desc, ps, depth, &ptr, sizeof(UNISTR2), (PRS_POINTER_CAST)prs_io_unistr2 ) )
1044 return False;
1045
1046 uni4->string = (UNISTR2 *)ptr;
1047
1048 return True;
1049}
1050
1051/*******************************************************************
1052 now read/write UNISTR4 header
1053********************************************************************/
1054
1055bool prs_unistr4_hdr(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1056{
1057 prs_debug(ps, depth, desc, "prs_unistr4_hdr");
1058 depth++;
1059
1060 if ( !prs_uint16("length", ps, depth, &uni4->length) )
1061 return False;
1062 if ( !prs_uint16("size", ps, depth, &uni4->size) )
1063 return False;
1064 if ( !prs_io_unistr2_p(desc, ps, depth, &uni4->string) )
1065 return False;
1066
1067 return True;
1068}
1069
1070/*******************************************************************
1071 now read/write UNISTR4 string
1072********************************************************************/
1073
1074bool prs_unistr4_str(const char *desc, prs_struct *ps, int depth, UNISTR4 *uni4)
1075{
1076 prs_debug(ps, depth, desc, "prs_unistr4_str");
1077 depth++;
1078
1079 if ( !prs_io_unistr2(desc, ps, depth, uni4->string) )
1080 return False;
1081
1082 return True;
1083}
1084
1085/*******************************************************************
1086 Reads or writes a UNISTR4_ARRAY structure.
1087********************************************************************/
1088
1089bool prs_unistr4_array(const char *desc, prs_struct *ps, int depth, UNISTR4_ARRAY *array )
1090{
1091 unsigned int i;
1092
1093 prs_debug(ps, depth, desc, "prs_unistr4_array");
1094 depth++;
1095
1096 if(!prs_uint32("count", ps, depth, &array->count))
1097 return False;
1098
1099 if (UNMARSHALLING(ps)) {
1100 if (array->count) {
1101 if ( !(array->strings = TALLOC_ZERO_ARRAY( talloc_tos(), UNISTR4, array->count)) )
1102 return False;
1103 } else {
1104 array->strings = NULL;
1105 }
1106 }
1107
1108 /* write the headers and then the actual string buffer */
1109
1110 for ( i=0; i<array->count; i++ ) {
1111 if ( !prs_unistr4_hdr( "string", ps, depth, &array->strings[i]) )
1112 return False;
1113 }
1114
1115 for (i=0;i<array->count;i++) {
1116 if ( !prs_unistr4_str("string", ps, depth, &array->strings[i]) )
1117 return False;
1118 }
1119
1120 return True;
1121}
1122
1123/********************************************************************
1124 initialise a UNISTR_ARRAY from a char**
1125********************************************************************/
1126
1127bool init_unistr4_array( UNISTR4_ARRAY *array, uint32 count, const char **strings )
1128{
1129 unsigned int i;
1130
1131 array->count = count;
1132
1133 /* allocate memory for the array of UNISTR4 objects */
1134
1135 if (array->count) {
1136 if ( !(array->strings = TALLOC_ZERO_ARRAY(talloc_tos(), UNISTR4, count )) )
1137 return False;
1138 } else {
1139 array->strings = NULL;
1140 }
1141
1142 for ( i=0; i<count; i++ )
1143 init_unistr4( &array->strings[i], strings[i], UNI_STR_TERMINATE );
1144
1145 return True;
1146}
1147
1148/*******************************************************************
1149 Inits a DOM_RID structure.
1150********************************************************************/
1151
1152void init_dom_rid(DOM_RID *prid, uint32 rid, uint16 type, uint32 idx)
1153{
1154 prid->type = type;
1155 prid->rid = rid;
1156 prid->rid_idx = idx;
1157}
1158
1159/*******************************************************************
1160 Reads or writes a DOM_RID structure.
1161********************************************************************/
1162
1163bool smb_io_dom_rid(const char *desc, DOM_RID *rid, prs_struct *ps, int depth)
1164{
1165 if (rid == NULL)
1166 return False;
1167
1168 prs_debug(ps, depth, desc, "smb_io_dom_rid");
1169 depth++;
1170
1171 if(!prs_align(ps))
1172 return False;
1173
1174 if(!prs_uint16("type ", ps, depth, &rid->type))
1175 return False;
1176 if(!prs_align(ps))
1177 return False;
1178 if(!prs_uint32("rid ", ps, depth, &rid->rid))
1179 return False;
1180 if(!prs_uint32("rid_idx", ps, depth, &rid->rid_idx))
1181 return False;
1182
1183 return True;
1184}
1185
1186/*******************************************************************
1187 Reads or writes a DOM_RID2 structure.
1188********************************************************************/
1189
1190bool smb_io_dom_rid2(const char *desc, DOM_RID2 *rid, prs_struct *ps, int depth)
1191{
1192 if (rid == NULL)
1193 return False;
1194
1195 prs_debug(ps, depth, desc, "smb_io_dom_rid2");
1196 depth++;
1197
1198 if(!prs_align(ps))
1199 return False;
1200
1201 if(!prs_uint16("type ", ps, depth, &rid->type))
1202 return False;
1203 if(!prs_align(ps))
1204 return False;
1205 if(!prs_uint32("rid ", ps, depth, &rid->rid))
1206 return False;
1207 if(!prs_uint32("rid_idx", ps, depth, &rid->rid_idx))
1208 return False;
1209 if(!prs_uint32("unknown", ps, depth, &rid->unknown))
1210 return False;
1211
1212 return True;
1213}
1214
1215
1216/*******************************************************************
1217creates a DOM_RID3 structure.
1218********************************************************************/
1219
1220void init_dom_rid3(DOM_RID3 *rid3, uint32 rid, uint8 type)
1221{
1222 rid3->rid = rid;
1223 rid3->type1 = type;
1224 rid3->ptr_type = 0x1; /* non-zero, basically. */
1225 rid3->type2 = 0x1;
1226 rid3->unk = type;
1227}
1228
1229/*******************************************************************
1230reads or writes a DOM_RID3 structure.
1231********************************************************************/
1232
1233bool smb_io_dom_rid3(const char *desc, DOM_RID3 *rid3, prs_struct *ps, int depth)
1234{
1235 if (rid3 == NULL)
1236 return False;
1237
1238 prs_debug(ps, depth, desc, "smb_io_dom_rid3");
1239 depth++;
1240
1241 if(!prs_align(ps))
1242 return False;
1243
1244 if(!prs_uint32("rid ", ps, depth, &rid3->rid))
1245 return False;
1246 if(!prs_uint32("type1 ", ps, depth, &rid3->type1))
1247 return False;
1248 if(!prs_uint32("ptr_type", ps, depth, &rid3->ptr_type))
1249 return False;
1250 if(!prs_uint32("type2 ", ps, depth, &rid3->type2))
1251 return False;
1252 if(!prs_uint32("unk ", ps, depth, &rid3->unk))
1253 return False;
1254
1255 return True;
1256}
1257
1258/*******************************************************************
1259 Inits a DOM_RID4 structure.
1260********************************************************************/
1261
1262void init_dom_rid4(DOM_RID4 *rid4, uint16 unknown, uint16 attr, uint32 rid)
1263{
1264 rid4->unknown = unknown;
1265 rid4->attr = attr;
1266 rid4->rid = rid;
1267}
1268
1269/*******************************************************************
1270 Inits a DOM_CLNT_SRV structure.
1271********************************************************************/
1272
1273void init_clnt_srv(DOM_CLNT_SRV *logcln, const char *logon_srv,
1274 const char *comp_name)
1275{
1276 DEBUG(5,("init_clnt_srv: %d\n", __LINE__));
1277
1278 if (logon_srv != NULL) {
1279 logcln->undoc_buffer = 1;
1280 init_unistr2(&logcln->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1281 } else {
1282 logcln->undoc_buffer = 0;
1283 }
1284
1285 if (comp_name != NULL) {
1286 logcln->undoc_buffer2 = 1;
1287 init_unistr2(&logcln->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1288 } else {
1289 logcln->undoc_buffer2 = 0;
1290 }
1291}
1292
1293/*******************************************************************
1294 Inits or writes a DOM_CLNT_SRV structure.
1295********************************************************************/
1296
1297bool smb_io_clnt_srv(const char *desc, DOM_CLNT_SRV *logcln, prs_struct *ps, int depth)
1298{
1299 if (logcln == NULL)
1300 return False;
1301
1302 prs_debug(ps, depth, desc, "smb_io_clnt_srv");
1303 depth++;
1304
1305 if(!prs_align(ps))
1306 return False;
1307
1308 if(!prs_uint32("undoc_buffer ", ps, depth, &logcln->undoc_buffer))
1309 return False;
1310
1311 if (logcln->undoc_buffer != 0) {
1312 if(!smb_io_unistr2("unistr2", &logcln->uni_logon_srv, logcln->undoc_buffer, ps, depth))
1313 return False;
1314 }
1315
1316 if(!prs_align(ps))
1317 return False;
1318
1319 if(!prs_uint32("undoc_buffer2", ps, depth, &logcln->undoc_buffer2))
1320 return False;
1321
1322 if (logcln->undoc_buffer2 != 0) {
1323 if(!smb_io_unistr2("unistr2", &logcln->uni_comp_name, logcln->undoc_buffer2, ps, depth))
1324 return False;
1325 }
1326
1327 return True;
1328}
1329
1330/*******************************************************************
1331 Inits a DOM_LOG_INFO structure.
1332********************************************************************/
1333
1334void init_log_info(DOM_LOG_INFO *loginfo, const char *logon_srv, const char *acct_name,
1335 uint16 sec_chan, const char *comp_name)
1336{
1337 DEBUG(5,("make_log_info %d\n", __LINE__));
1338
1339 loginfo->undoc_buffer = 1;
1340
1341 init_unistr2(&loginfo->uni_logon_srv, logon_srv, UNI_STR_TERMINATE);
1342 init_unistr2(&loginfo->uni_acct_name, acct_name, UNI_STR_TERMINATE);
1343
1344 loginfo->sec_chan = sec_chan;
1345
1346 init_unistr2(&loginfo->uni_comp_name, comp_name, UNI_STR_TERMINATE);
1347}
1348
1349/*******************************************************************
1350 Reads or writes a DOM_LOG_INFO structure.
1351********************************************************************/
1352
1353bool smb_io_log_info(const char *desc, DOM_LOG_INFO *loginfo, prs_struct *ps, int depth)
1354{
1355 if (loginfo == NULL)
1356 return False;
1357
1358 prs_debug(ps, depth, desc, "smb_io_log_info");
1359 depth++;
1360
1361 if(!prs_align(ps))
1362 return False;
1363
1364 if(!prs_uint32("undoc_buffer", ps, depth, &loginfo->undoc_buffer))
1365 return False;
1366
1367 if(!smb_io_unistr2("unistr2", &loginfo->uni_logon_srv, True, ps, depth))
1368 return False;
1369 if(!smb_io_unistr2("unistr2", &loginfo->uni_acct_name, True, ps, depth))
1370 return False;
1371
1372 if(!prs_uint16("sec_chan", ps, depth, &loginfo->sec_chan))
1373 return False;
1374
1375 if(!smb_io_unistr2("unistr2", &loginfo->uni_comp_name, True, ps, depth))
1376 return False;
1377
1378 return True;
1379}
1380
1381/*******************************************************************
1382 Reads or writes a DOM_CHAL structure.
1383********************************************************************/
1384
1385bool smb_io_chal(const char *desc, DOM_CHAL *chal, prs_struct *ps, int depth)
1386{
1387 if (chal == NULL)
1388 return False;
1389
1390 prs_debug(ps, depth, desc, "smb_io_chal");
1391 depth++;
1392
1393 if(!prs_uint8s (False, "data", ps, depth, chal->data, 8))
1394 return False;
1395
1396 return True;
1397}
1398
1399/*******************************************************************
1400 Reads or writes a DOM_CRED structure.
1401********************************************************************/
1402
1403bool smb_io_cred(const char *desc, DOM_CRED *cred, prs_struct *ps, int depth)
1404{
1405 if (cred == NULL)
1406 return False;
1407
1408 prs_debug(ps, depth, desc, "smb_io_cred");
1409 depth++;
1410
1411 if(!prs_align(ps))
1412 return False;
1413
1414 if(!smb_io_chal ("", &cred->challenge, ps, depth))
1415 return False;
1416
1417 if(!smb_io_utime("", &cred->timestamp, ps, depth))
1418 return False;
1419
1420 return True;
1421}
1422
1423/*******************************************************************
1424 Inits a DOM_CLNT_INFO2 structure.
1425********************************************************************/
1426
1427void init_clnt_info2(DOM_CLNT_INFO2 *clnt,
1428 const char *logon_srv, const char *comp_name,
1429 const DOM_CRED *clnt_cred)
1430{
1431 DEBUG(5,("make_clnt_info: %d\n", __LINE__));
1432
1433 init_clnt_srv(&clnt->login, logon_srv, comp_name);
1434
1435 if (clnt_cred != NULL) {
1436 clnt->ptr_cred = 1;
1437 memcpy(&clnt->cred, clnt_cred, sizeof(clnt->cred));
1438 } else {
1439 clnt->ptr_cred = 0;
1440 }
1441}
1442
1443/*******************************************************************
1444 Reads or writes a DOM_CLNT_INFO2 structure.
1445********************************************************************/
1446
1447bool smb_io_clnt_info2(const char *desc, DOM_CLNT_INFO2 *clnt, prs_struct *ps, int depth)
1448{
1449 if (clnt == NULL)
1450 return False;
1451
1452 prs_debug(ps, depth, desc, "smb_io_clnt_info2");
1453 depth++;
1454
1455 if(!prs_align(ps))
1456 return False;
1457
1458 if(!smb_io_clnt_srv("", &clnt->login, ps, depth))
1459 return False;
1460
1461 if(!prs_align(ps))
1462 return False;
1463
1464 if(!prs_uint32("ptr_cred", ps, depth, &clnt->ptr_cred))
1465 return False;
1466 if(!smb_io_cred("", &clnt->cred, ps, depth))
1467 return False;
1468
1469 return True;
1470}
1471
1472/*******************************************************************
1473 Inits a DOM_CLNT_INFO structure.
1474********************************************************************/
1475
1476void init_clnt_info(DOM_CLNT_INFO *clnt,
1477 const char *logon_srv, const char *acct_name,
1478 uint16 sec_chan, const char *comp_name,
1479 const DOM_CRED *cred)
1480{
1481 DEBUG(5,("make_clnt_info\n"));
1482
1483 init_log_info(&clnt->login, logon_srv, acct_name, sec_chan, comp_name);
1484 memcpy(&clnt->cred, cred, sizeof(clnt->cred));
1485}
1486
1487/*******************************************************************
1488 Reads or writes a DOM_CLNT_INFO structure.
1489********************************************************************/
1490
1491bool smb_io_clnt_info(const char *desc, DOM_CLNT_INFO *clnt, prs_struct *ps, int depth)
1492{
1493 if (clnt == NULL)
1494 return False;
1495
1496 prs_debug(ps, depth, desc, "smb_io_clnt_info");
1497 depth++;
1498
1499 if(!prs_align(ps))
1500 return False;
1501
1502 if(!smb_io_log_info("", &clnt->login, ps, depth))
1503 return False;
1504 if(!smb_io_cred("", &clnt->cred, ps, depth))
1505 return False;
1506
1507 return True;
1508}
1509
1510/*******************************************************************
1511 Inits a DOM_LOGON_ID structure.
1512********************************************************************/
1513
1514void init_logon_id(DOM_LOGON_ID *logonid, uint32 log_id_low, uint32 log_id_high)
1515{
1516 DEBUG(5,("make_logon_id: %d\n", __LINE__));
1517
1518 logonid->low = log_id_low;
1519 logonid->high = log_id_high;
1520}
1521
1522/*******************************************************************
1523 Reads or writes a DOM_LOGON_ID structure.
1524********************************************************************/
1525
1526bool smb_io_logon_id(const char *desc, DOM_LOGON_ID *logonid, prs_struct *ps, int depth)
1527{
1528 if (logonid == NULL)
1529 return False;
1530
1531 prs_debug(ps, depth, desc, "smb_io_logon_id");
1532 depth++;
1533
1534 if(!prs_align(ps))
1535 return False;
1536
1537 if(!prs_uint32("low ", ps, depth, &logonid->low ))
1538 return False;
1539 if(!prs_uint32("high", ps, depth, &logonid->high))
1540 return False;
1541
1542 return True;
1543}
1544
1545/*******************************************************************
1546 Inits an OWF_INFO structure.
1547********************************************************************/
1548
1549void init_owf_info(OWF_INFO *hash, const uint8 data[16])
1550{
1551 DEBUG(5,("init_owf_info: %d\n", __LINE__));
1552
1553 if (data != NULL)
1554 memcpy(hash->data, data, sizeof(hash->data));
1555 else
1556 memset((char *)hash->data, '\0', sizeof(hash->data));
1557}
1558
1559/*******************************************************************
1560 Reads or writes an OWF_INFO structure.
1561********************************************************************/
1562
1563bool smb_io_owf_info(const char *desc, OWF_INFO *hash, prs_struct *ps, int depth)
1564{
1565 if (hash == NULL)
1566 return False;
1567
1568 prs_debug(ps, depth, desc, "smb_io_owf_info");
1569 depth++;
1570
1571 if(!prs_align(ps))
1572 return False;
1573
1574 if(!prs_uint8s (False, "data", ps, depth, hash->data, 16))
1575 return False;
1576
1577 return True;
1578}
1579
1580/*******************************************************************
1581 Reads or writes a DOM_GID structure.
1582********************************************************************/
1583
1584bool smb_io_gid(const char *desc, DOM_GID *gid, prs_struct *ps, int depth)
1585{
1586 if (gid == NULL)
1587 return False;
1588
1589 prs_debug(ps, depth, desc, "smb_io_gid");
1590 depth++;
1591
1592 if(!prs_align(ps))
1593 return False;
1594
1595 if(!prs_uint32("g_rid", ps, depth, &gid->g_rid))
1596 return False;
1597 if(!prs_uint32("attr ", ps, depth, &gid->attr))
1598 return False;
1599
1600 return True;
1601}
1602
1603/*******************************************************************
1604 Reads or writes an POLICY_HND structure.
1605********************************************************************/
1606
1607bool smb_io_pol_hnd(const char *desc, POLICY_HND *pol, prs_struct *ps, int depth)
1608{
1609 if (pol == NULL)
1610 return False;
1611
1612 prs_debug(ps, depth, desc, "smb_io_pol_hnd");
1613 depth++;
1614
1615 if(!prs_align(ps))
1616 return False;
1617
1618 if(UNMARSHALLING(ps))
1619 ZERO_STRUCTP(pol);
1620
1621 if (!prs_uint32("handle_type", ps, depth, &pol->handle_type))
1622 return False;
1623 if (!smb_io_uuid("uuid", (struct GUID*)&pol->uuid, ps, depth))
1624 return False;
1625
1626 return True;
1627}
1628
1629/*******************************************************************
1630 Create a UNISTR3.
1631********************************************************************/
1632
1633void init_unistr3(UNISTR3 *str, const char *buf)
1634{
1635 if (buf == NULL) {
1636 str->uni_str_len=0;
1637 str->str.buffer = NULL;
1638 return;
1639 }
1640
1641 str->uni_str_len = strlen(buf) + 1;
1642
1643 if (str->uni_str_len) {
1644 str->str.buffer = TALLOC_ZERO_ARRAY(talloc_tos(), uint16, str->uni_str_len);
1645 if (str->str.buffer == NULL)
1646 smb_panic("init_unistr3: malloc fail");
1647
1648 rpcstr_push((char *)str->str.buffer, buf, str->uni_str_len * sizeof(uint16), STR_TERMINATE);
1649 } else {
1650 str->str.buffer = NULL;
1651 }
1652}
1653
1654/*******************************************************************
1655 Reads or writes a UNISTR3 structure.
1656********************************************************************/
1657
1658bool smb_io_unistr3(const char *desc, UNISTR3 *name, prs_struct *ps, int depth)
1659{
1660 if (name == NULL)
1661 return False;
1662
1663 prs_debug(ps, depth, desc, "smb_io_unistr3");
1664 depth++;
1665
1666 if(!prs_align(ps))
1667 return False;
1668
1669 if(!prs_uint32("uni_str_len", ps, depth, &name->uni_str_len))
1670 return False;
1671
1672 /* we're done if there is no string */
1673
1674 if ( name->uni_str_len == 0 )
1675 return True;
1676
1677 /* don't know if len is specified by uni_str_len member... */
1678 /* assume unicode string is unicode-null-terminated, instead */
1679
1680 if(!prs_unistr3(True, "unistr", name, ps, depth))
1681 return False;
1682
1683 return True;
1684}
1685
1686/*******************************************************************
1687 Stream a uint64_struct
1688 ********************************************************************/
1689bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64)
1690{
1691 if (UNMARSHALLING(ps)) {
1692 uint32 high, low;
1693
1694 if (!prs_uint32(name, ps, depth+1, &low))
1695 return False;
1696
1697 if (!prs_uint32(name, ps, depth+1, &high))
1698 return False;
1699
1700 *data64 = ((uint64_t)high << 32) + low;
1701
1702 return True;
1703 } else {
1704 uint32 high = (*data64) >> 32, low = (*data64) & 0xFFFFFFFF;
1705 return prs_uint32(name, ps, depth+1, &low) &&
1706 prs_uint32(name, ps, depth+1, &high);
1707 }
1708}
1709
1710/*******************************************************************
1711reads or writes a BUFHDR2 structure.
1712********************************************************************/
1713bool smb_io_bufhdr2(const char *desc, BUFHDR2 *hdr, prs_struct *ps, int depth)
1714{
1715 prs_debug(ps, depth, desc, "smb_io_bufhdr2");
1716 depth++;
1717
1718 if (!prs_align(ps))
1719 return False;
1720 if (!prs_uint32("info_level", ps, depth, &(hdr->info_level)))
1721 return False;
1722 if (!prs_uint32("length ", ps, depth, &(hdr->length )))
1723 return False;
1724 if (!prs_uint32("buffer ", ps, depth, &(hdr->buffer )))
1725 return False;
1726
1727 return True;
1728}
1729
1730/*******************************************************************
1731reads or writes a BUFHDR4 structure.
1732********************************************************************/
1733bool smb_io_bufhdr4(const char *desc, BUFHDR4 *hdr, prs_struct *ps, int depth)
1734{
1735 prs_debug(ps, depth, desc, "smb_io_bufhdr4");
1736 depth++;
1737
1738 if (!prs_align(ps))
1739 return False;
1740 if (!prs_uint32("size", ps, depth, &hdr->size))
1741 return False;
1742 if (!prs_uint32("buffer", ps, depth, &hdr->buffer))
1743 return False;
1744
1745 return True;
1746}
1747
1748/*******************************************************************
1749reads or writes a RPC_DATA_BLOB structure.
1750********************************************************************/
1751
1752bool smb_io_rpc_blob(const char *desc, RPC_DATA_BLOB *blob, prs_struct *ps, int depth)
1753{
1754 prs_debug(ps, depth, desc, "smb_io_rpc_blob");
1755 depth++;
1756
1757 if (!prs_align(ps))
1758 return False;
1759 if ( !prs_uint32("buf_len", ps, depth, &blob->buf_len) )
1760 return False;
1761
1762 if ( blob->buf_len == 0 )
1763 return True;
1764
1765 if (UNMARSHALLING(ps)) {
1766 blob->buffer = PRS_ALLOC_MEM(ps, uint8, blob->buf_len);
1767 if (!blob->buffer) {
1768 return False;
1769 }
1770 }
1771
1772 if ( !prs_uint8s(True, "buffer", ps, depth, blob->buffer, blob->buf_len) )
1773 return False;
1774
1775 return True;
1776}
1777
1778/*******************************************************************
1779creates a UNIHDR structure.
1780********************************************************************/
1781
1782bool make_uni_hdr(UNIHDR *hdr, int len)
1783{
1784 if (hdr == NULL)
1785 {
1786 return False;
1787 }
1788 hdr->uni_str_len = 2 * len;
1789 hdr->uni_max_len = 2 * len;
1790 hdr->buffer = len != 0 ? 1 : 0;
1791
1792 return True;
1793}
1794
1795/*******************************************************************
1796creates a BUFHDR2 structure.
1797********************************************************************/
1798bool make_bufhdr2(BUFHDR2 *hdr, uint32 info_level, uint32 length, uint32 buffer)
1799{
1800 hdr->info_level = info_level;
1801 hdr->length = length;
1802 hdr->buffer = buffer;
1803
1804 return True;
1805}
1806
1807/*******************************************************************
1808return the length of a UNISTR string.
1809********************************************************************/
1810
1811uint32 str_len_uni(UNISTR *source)
1812{
1813 uint32 i=0;
1814
1815 if (!source->buffer)
1816 return 0;
1817
1818 while (source->buffer[i])
1819 i++;
1820
1821 return i;
1822}
1823
1824/*******************************************************************
1825 Verifies policy handle
1826********************************************************************/
1827
1828bool policy_handle_is_valid(const POLICY_HND *hnd)
1829{
1830 POLICY_HND zero_pol;
1831
1832 ZERO_STRUCT(zero_pol);
1833 return ((memcmp(&zero_pol, hnd, sizeof(POLICY_HND)) == 0) ? false : true );
1834}
Note: See TracBrowser for help on using the repository browser.