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