?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make sure we don't clobber the stack when response consists of the empty
[Samba/gebeck_regimport.git] / source3 / rpc_parse / parse_misc.c
blobcea31c88a80353eff2c8698182a139d2d42f7e91
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 }
reg import