import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / rpc_parse / parse_reg.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  *  Copyright (C) Marc Jacobsen                     1999.
8  *  Copyright (C) Simo Sorce                        2000.
9  *  Copyright (C) Gerald Carter                     2002.
10  *  
11  *  This program is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2 of the License, or
14  *  (at your option) any later version.
15  *  
16  *  This program is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *  
21  *  You should have received a copy of the GNU General Public License
22  *  along with this program; if not, write to the Free Software
23  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25
26 #include "includes.h"
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS DBGC_RPC_PARSE
30
31 /*******************************************************************
32  Fill in a BUFFER2 for the data given a REGISTRY_VALUE
33  *******************************************************************/
34
35 static uint32 reg_init_buffer2( BUFFER2 *buf2, REGISTRY_VALUE *val )
36 {
37         uint32          real_size = 0;
38         
39         if ( !buf2 || !val )
40                 return 0;
41                 
42         real_size = regval_size(val);
43         init_buffer2( buf2, (unsigned char*)regval_data_p(val), real_size );
44
45         return real_size;
46 }
47
48 /*******************************************************************
49  Inits a structure.
50 ********************************************************************/
51
52 void init_reg_q_open_hkcr(REG_Q_OPEN_HKCR *q_o,
53                                 uint16 unknown_0, uint32 level)
54 {
55         q_o->ptr = 1;
56         q_o->unknown_0 = unknown_0;
57         q_o->unknown_1 = 0x0; /* random - changes */
58         q_o->level = level;
59 }
60
61 /*******************************************************************
62 reads or writes a structure.
63 ********************************************************************/
64
65 BOOL reg_io_q_open_hkcr(const char *desc,  REG_Q_OPEN_HKCR *r_q, prs_struct *ps, int depth)
66 {
67         if (r_q == NULL)
68                 return False;
69
70         prs_debug(ps, depth, desc, "reg_io_q_open_hkcr");
71         depth++;
72
73         if(!prs_align(ps))
74                 return False;
75
76         if(!prs_uint32("ptr      ", ps, depth, &r_q->ptr))
77                 return False;
78
79         if (r_q->ptr != 0) {
80                 if(!prs_uint16("unknown_0", ps, depth, &r_q->unknown_0))
81                         return False;
82                 if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
83                         return False;
84                 if(!prs_uint32("level    ", ps, depth, &r_q->level))
85                         return False;
86         }
87
88         return True;
89 }
90
91
92 /*******************************************************************
93 reads or writes a structure.
94 ********************************************************************/
95
96 BOOL reg_io_r_open_hkcr(const char *desc,  REG_R_OPEN_HKCR *r_r, prs_struct *ps, int depth)
97 {
98         if (r_r == NULL)
99                 return False;
100
101         prs_debug(ps, depth, desc, "reg_io_r_open_hkcr");
102         depth++;
103
104         if(!prs_align(ps))
105                 return False;
106         
107         if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
108                 return False;
109
110         if(!prs_ntstatus("status", ps, depth, &r_r->status))
111                 return False;
112
113         return True;
114 }
115
116 /*******************************************************************
117  Inits a structure.
118 ********************************************************************/
119
120 void init_reg_q_open_hklm(REG_Q_OPEN_HKLM * q_o,
121                           uint16 unknown_0, uint32 access_mask)
122 {
123         q_o->ptr = 1;
124         q_o->unknown_0 = unknown_0;
125         q_o->unknown_1 = 0x0;   /* random - changes */
126         q_o->access_mask = access_mask;
127
128 }
129
130 /*******************************************************************
131 reads or writes a structure.
132 ********************************************************************/
133 BOOL reg_io_q_open_hklm(const char *desc, REG_Q_OPEN_HKLM * r_q, prs_struct *ps,
134                         int depth)
135 {
136         if (r_q == NULL)
137                 return False;
138
139         prs_debug(ps, depth, desc, "reg_io_q_open_hklm");
140         depth++;
141
142         if (!prs_align(ps))
143                 return False;
144
145         if (!prs_uint32("ptr      ", ps, depth, &(r_q->ptr)))
146                 return False;
147         if (r_q->ptr != 0)
148         {
149                 if (!prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0)))
150                         return False;
151                 if (!prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1)))
152                         return False;
153                 if (!prs_uint32("access_mask", ps, depth, &(r_q->access_mask)))
154                         return False;
155         }
156
157         return True;
158 }
159
160
161 /*******************************************************************
162 reads or writes a structure.
163 ********************************************************************/
164 BOOL reg_io_r_open_hklm(const char *desc, REG_R_OPEN_HKLM * r_r, prs_struct *ps,
165                         int depth)
166 {
167         if (r_r == NULL)
168                 return False;
169
170         prs_debug(ps, depth, desc, "reg_io_r_open_hklm");
171         depth++;
172
173         if (!prs_align(ps))
174                 return False;
175
176         if (!smb_io_pol_hnd("", &r_r->pol, ps, depth))
177                 return False;
178
179         if (!prs_ntstatus("status", ps, depth, &r_r->status))
180                 return False;
181
182         return True;
183 }
184
185
186
187
188 /*******************************************************************
189  Inits a structure.
190 ********************************************************************/
191
192 void init_reg_q_flush_key(REG_Q_FLUSH_KEY *q_u, POLICY_HND *pol)
193 {
194         memcpy(&q_u->pol, pol, sizeof(q_u->pol));
195 }
196
197 /*******************************************************************
198 reads or writes a structure.
199 ********************************************************************/
200
201 BOOL reg_io_q_flush_key(const char *desc,  REG_Q_FLUSH_KEY *r_q, prs_struct *ps, int depth)
202 {
203         if (r_q == NULL)
204                 return False;
205
206         prs_debug(ps, depth, desc, "reg_io_q_flush_key");
207         depth++;
208
209         if(!prs_align(ps))
210                 return False;
211         
212         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
213                 return False;
214
215         return True;
216 }
217
218 /*******************************************************************
219 reads or writes a structure.
220 ********************************************************************/
221
222 BOOL reg_io_r_flush_key(const char *desc,  REG_R_FLUSH_KEY *r_r, prs_struct *ps, int depth)
223 {
224         if (r_r == NULL)
225                 return False;
226
227         prs_debug(ps, depth, desc, "reg_io_r_flush_key");
228         depth++;
229
230         if(!prs_align(ps))
231                 return False;
232         
233         if(!prs_ntstatus("status", ps, depth, &r_r->status))
234                 return False;
235
236         return True;
237 }
238
239 /*******************************************************************
240 reads or writes SEC_DESC_BUF and SEC_DATA structures.
241 ********************************************************************/
242
243 static BOOL reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec, SEC_DESC_BUF *data, prs_struct *ps, int depth)
244 {
245         if (ptr != 0) {
246                 uint32 hdr_offset;
247                 uint32 old_offset;
248                 if(!smb_io_hdrbuf_pre("hdr_sec", hdr_sec, ps, depth, &hdr_offset))
249                         return False;
250
251                 old_offset = prs_offset(ps);
252
253                 if (ptr3 != NULL) {
254                         if(!prs_uint32("ptr3", ps, depth, ptr3))
255                                 return False;
256                 }
257
258                 if (ptr3 == NULL || *ptr3 != 0) {
259                         if(!sec_io_desc_buf("data   ", &data, ps, depth)) /* JRA - this line is probably wrong... */
260                                 return False;
261                 }
262
263                 if(!smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth, hdr_offset,
264                                    data->max_len, data->len))
265                                 return False;
266                 if(!prs_set_offset(ps, old_offset + data->len + sizeof(uint32) * ((ptr3 != NULL) ? 5 : 3)))
267                         return False;
268
269                 if(!prs_align(ps))
270                         return False;
271         }
272
273         return True;
274 }
275
276 /*******************************************************************
277  Inits a structure.
278 ********************************************************************/
279
280 void init_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
281                                 char *name, char *class, SEC_ACCESS *sam_access,
282                                 SEC_DESC_BUF *sec_buf)
283 {
284         ZERO_STRUCTP(q_c);
285
286         memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
287
288         init_unistr2(&q_c->uni_name, name, UNI_STR_TERMINATE);
289         init_uni_hdr(&q_c->hdr_name, &q_c->uni_name);
290
291         init_unistr2(&q_c->uni_class, class, UNI_STR_TERMINATE);
292         init_uni_hdr(&q_c->hdr_class, &q_c->uni_class);
293
294         q_c->reserved = 0x00000000;
295         memcpy(&q_c->sam_access, sam_access, sizeof(q_c->sam_access));
296
297         q_c->ptr1 = 1;
298         q_c->sec_info = DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
299
300         q_c->data = sec_buf;
301         q_c->ptr2 = 1;
302         init_buf_hdr(&q_c->hdr_sec, sec_buf->len, sec_buf->len);
303         q_c->ptr3 = 1;
304         q_c->unknown_2 = 0x00000000;
305 }
306
307 /*******************************************************************
308 reads or writes a structure.
309 ********************************************************************/
310
311 BOOL reg_io_q_create_key(const char *desc,  REG_Q_CREATE_KEY *r_q, prs_struct *ps, int depth)
312 {
313         if (r_q == NULL)
314                 return False;
315
316         prs_debug(ps, depth, desc, "reg_io_q_create_key");
317         depth++;
318
319         if(!prs_align(ps))
320                 return False;
321         
322         if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
323                 return False;
324
325         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
326                 return False;
327         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
328                 return False;
329         if(!prs_align(ps))
330                 return False;
331
332         if(!smb_io_unihdr ("", &r_q->hdr_class, ps, depth))
333                 return False;
334         if(!smb_io_unistr2("", &r_q->uni_class, r_q->hdr_class.buffer, ps, depth))
335                 return False;
336         if(!prs_align(ps))
337                 return False;
338
339         if(!prs_uint32("reserved", ps, depth, &r_q->reserved))
340                 return False;
341         if(!sec_io_access("sam_access", &r_q->sam_access, ps, depth))
342                 return False;
343
344         if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
345                 return False;
346
347         if (r_q->ptr1 != 0) {
348                 if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
349                         return False;
350         }
351
352         if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
353                 return False;
354         if(!reg_io_hdrbuf_sec(r_q->ptr2, &r_q->ptr3, &r_q->hdr_sec, r_q->data, ps, depth))
355                 return False;
356
357         if(!prs_uint32("unknown_2", ps, depth, &r_q->unknown_2))
358                 return False;
359
360         return True;
361 }
362
363 /*******************************************************************
364 reads or writes a structure.
365 ********************************************************************/
366
367 BOOL reg_io_r_create_key(const char *desc,  REG_R_CREATE_KEY *r_r, prs_struct *ps, int depth)
368 {
369         if (r_r == NULL)
370                 return False;
371
372         prs_debug(ps, depth, desc, "reg_io_r_create_key");
373         depth++;
374
375         if(!prs_align(ps))
376                 return False;
377         
378         if(!smb_io_pol_hnd("", &r_r->key_pol, ps, depth))
379                 return False;
380         if(!prs_uint32("unknown", ps, depth, &r_r->unknown))
381                 return False;
382
383         if(!prs_ntstatus("status", ps, depth, &r_r->status))
384                 return False;
385
386         return True;
387 }
388
389
390 /*******************************************************************
391  Inits a structure.
392 ********************************************************************/
393
394 void init_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
395                                 char *name)
396 {
397         ZERO_STRUCTP(q_c);
398
399         memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
400
401         init_unistr2(&q_c->uni_name, name, UNI_STR_TERMINATE);
402         init_uni_hdr(&q_c->hdr_name, &q_c->uni_name);
403 }
404
405 /*******************************************************************
406 reads or writes a structure.
407 ********************************************************************/
408
409 BOOL reg_io_q_delete_val(const char *desc,  REG_Q_DELETE_VALUE *r_q, prs_struct *ps, int depth)
410 {
411         if (r_q == NULL)
412                 return False;
413
414         prs_debug(ps, depth, desc, "reg_io_q_delete_val");
415         depth++;
416
417         if(!prs_align(ps))
418                 return False;
419         
420         if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
421                 return False;
422
423         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
424                 return False;
425         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
426                 return False;
427         if(!prs_align(ps))
428                 return False;
429
430         return True;
431 }
432
433
434 /*******************************************************************
435 reads or writes a structure.
436 ********************************************************************/
437
438 BOOL reg_io_r_delete_val(const char *desc,  REG_R_DELETE_VALUE *r_r, prs_struct *ps, int depth)
439 {
440         if (r_r == NULL)
441                 return False;
442
443         prs_debug(ps, depth, desc, "reg_io_r_delete_val");
444         depth++;
445
446         if(!prs_align(ps))
447                 return False;
448         
449         if(!prs_ntstatus("status", ps, depth, &r_r->status))
450                 return False;
451
452         return True;
453 }
454
455 /*******************************************************************
456  Inits a structure.
457 ********************************************************************/
458
459 void init_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
460                                 char *name)
461 {
462         ZERO_STRUCTP(q_c);
463
464         memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
465
466         init_unistr2(&q_c->uni_name, name, UNI_STR_TERMINATE);
467         init_uni_hdr(&q_c->hdr_name, &q_c->uni_name);
468 }
469
470 /*******************************************************************
471 reads or writes a structure.
472 ********************************************************************/
473
474 BOOL reg_io_q_delete_key(const char *desc,  REG_Q_DELETE_KEY *r_q, prs_struct *ps, int depth)
475 {
476         if (r_q == NULL)
477                 return False;
478
479         prs_debug(ps, depth, desc, "reg_io_q_delete_key");
480         depth++;
481
482         if(!prs_align(ps))
483                 return False;
484         
485         if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
486                 return False;
487
488         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
489                 return False;
490         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
491                 return False;
492         if(!prs_align(ps))
493                 return False;
494
495         return True;
496 }
497
498 /*******************************************************************
499 reads or writes a structure.
500 ********************************************************************/
501
502 BOOL reg_io_r_delete_key(const char *desc,  REG_R_DELETE_KEY *r_r, prs_struct *ps, int depth)
503 {
504         if (r_r == NULL)
505                 return False;
506
507         prs_debug(ps, depth, desc, "reg_io_r_delete_key");
508         depth++;
509
510         if(!prs_align(ps))
511                 return False;
512         
513         if(!prs_ntstatus("status", ps, depth, &r_r->status))
514                 return False;
515
516         return True;
517 }
518
519 /*******************************************************************
520  Inits a structure.
521 ********************************************************************/
522
523 void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd, UNISTR2 *uni2)
524 {
525         ZERO_STRUCTP(q_o);
526
527         memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
528         init_uni_hdr(&q_o->hdr_class, uni2);
529 }
530
531 /*******************************************************************
532 reads or writes a structure.
533 ********************************************************************/
534
535 BOOL reg_io_q_query_key(const char *desc,  REG_Q_QUERY_KEY *r_q, prs_struct *ps, int depth)
536 {
537         if (r_q == NULL)
538                 return False;
539
540         prs_debug(ps, depth, desc, "reg_io_q_query_key");
541         depth++;
542
543         if(!prs_align(ps))
544                 return False;
545         
546         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
547                 return False;
548         if(!smb_io_unihdr ("", &r_q->hdr_class, ps, depth))
549                 return False;
550         if(!smb_io_unistr2("", &r_q->uni_class, r_q->hdr_class.buffer, ps, depth))
551                 return False;
552
553         if(!prs_align(ps))
554                 return False;
555
556         return True;
557 }
558
559
560 /*******************************************************************
561 reads or writes a structure.
562 ********************************************************************/
563
564 BOOL reg_io_r_query_key(const char *desc,  REG_R_QUERY_KEY *r_r, prs_struct *ps, int depth)
565 {
566         if (r_r == NULL)
567                 return False;
568
569         prs_debug(ps, depth, desc, "reg_io_r_query_key");
570         depth++;
571
572         if(!prs_align(ps))
573                 return False;
574         
575         if(!smb_io_unihdr ("", &r_r->hdr_class, ps, depth))
576                 return False;
577         if(!smb_io_unistr2("", &r_r->uni_class, r_r->hdr_class.buffer, ps, depth))
578                 return False;
579
580         if(!prs_align(ps))
581                 return False;
582
583         if(!prs_uint32("num_subkeys   ", ps, depth, &r_r->num_subkeys))
584                 return False;
585         if(!prs_uint32("max_subkeylen ", ps, depth, &r_r->max_subkeylen))
586                 return False;
587         if(!prs_uint32("reserved      ", ps, depth, &r_r->reserved))
588                 return False;
589         if(!prs_uint32("num_values    ", ps, depth, &r_r->num_values))
590                 return False;
591         if(!prs_uint32("max_valnamelen", ps, depth, &r_r->max_valnamelen))
592                 return False;
593         if(!prs_uint32("max_valbufsize", ps, depth, &r_r->max_valbufsize))
594                 return False;
595         if(!prs_uint32("sec_desc      ", ps, depth, &r_r->sec_desc))
596                 return False;
597         if(!smb_io_time("mod_time     ", &r_r->mod_time, ps, depth))
598                 return False;
599
600         if(!prs_ntstatus("status", ps, depth, &r_r->status))
601                 return False;
602
603         return True;
604 }
605
606 /*******************************************************************
607  Inits a structure.
608 ********************************************************************/
609
610 void init_reg_q_unknown_1a(REG_Q_UNKNOWN_1A *q_o, POLICY_HND *hnd)
611 {
612         memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
613 }
614
615
616 /*******************************************************************
617 reads or writes a structure.
618 ********************************************************************/
619
620 BOOL reg_io_q_unknown_1a(const char *desc,  REG_Q_UNKNOWN_1A *r_q, prs_struct *ps, int depth)
621 {
622         if (r_q == NULL)
623                 return False;
624
625         prs_debug(ps, depth, desc, "reg_io_q_unknown_1a");
626         depth++;
627
628         if(!prs_align(ps))
629                 return False;
630
631         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
632                 return False;
633
634         return True;
635 }
636
637 /*******************************************************************
638 reads or writes a structure.
639 ********************************************************************/
640
641 BOOL reg_io_r_unknown_1a(const char *desc,  REG_R_UNKNOWN_1A *r_r, prs_struct *ps, int depth)
642 {
643         if (r_r == NULL)
644                 return False;
645
646         prs_debug(ps, depth, desc, "reg_io_r_unknown_1a");
647         depth++;
648
649         if(!prs_align(ps))
650                 return False;
651
652         if(!prs_uint32("unknown", ps, depth, &r_r->unknown))
653                 return False;
654         if(!prs_ntstatus("status" , ps, depth, &r_r->status))
655                 return False;
656
657         return True;
658 }
659
660
661 /*******************************************************************
662 reads or writes a structure.
663 ********************************************************************/
664
665 BOOL reg_io_q_save_key(const char *desc,  REG_Q_SAVE_KEY *r_q, prs_struct *ps, int depth)
666 {
667         if (r_q == NULL)
668                 return False;
669
670         prs_debug(ps, depth, desc, "reg_io_q_save_key");
671         depth++;
672
673         if(!prs_align(ps))
674                 return False;
675
676         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
677                 return False;
678
679         if(!smb_io_unihdr ("hdr_file", &r_q->hdr_file, ps, depth))
680                 return False;
681         if(!smb_io_unistr2("uni_file", &r_q->uni_file, r_q->hdr_file.buffer, ps, depth))
682                 return False;
683
684         if(!prs_uint32("unknown", ps, depth, &r_q->unknown))
685                 return False;
686
687         return True;
688 }
689
690 /*******************************************************************
691 reads or writes a structure.
692 ********************************************************************/
693
694 BOOL reg_io_r_save_key(const char *desc,  REG_R_SAVE_KEY *r_r, prs_struct *ps, int depth)
695 {
696         if (r_r == NULL)
697                 return False;
698
699         prs_debug(ps, depth, desc, "reg_io_r_save_key");
700         depth++;
701
702         if(!prs_align(ps))
703                 return False;
704         
705         if(!prs_ntstatus("status" , ps, depth, &r_r->status))
706                 return False;
707
708         return True;
709 }
710
711 /*******************************************************************
712  Inits a structure.
713 ********************************************************************/
714
715 void init_reg_q_open_hku(REG_Q_OPEN_HKU *q_o,
716                                 uint16 unknown_0, uint32 access_mask)
717 {
718         q_o->ptr = 1;
719         q_o->unknown_0 = unknown_0;
720         q_o->unknown_1 = 0x0; /* random - changes */
721         q_o->access_mask = access_mask;
722 }
723
724 /*******************************************************************
725 reads or writes a structure.
726 ********************************************************************/
727
728 BOOL reg_io_q_open_hku(const char *desc,  REG_Q_OPEN_HKU *r_q, prs_struct *ps, int depth)
729 {
730         if (r_q == NULL)
731                 return False;
732
733         prs_debug(ps, depth, desc, "reg_io_q_open_hku");
734         depth++;
735
736         if(!prs_align(ps))
737                 return False;
738         
739         if(!prs_uint32("ptr      ", ps, depth, &r_q->ptr))
740                 return False;
741         if (r_q->ptr != 0) {
742                 if(!prs_uint16("unknown_0   ", ps, depth, &r_q->unknown_0))
743                         return False;
744                 if(!prs_uint16("unknown_1   ", ps, depth, &r_q->unknown_1))
745                         return False;
746                 if(!prs_uint32("access_mask ", ps, depth, &r_q->access_mask))
747                         return False;
748         }
749
750         return True;
751 }
752
753 /*******************************************************************
754 reads or writes a structure.
755 ********************************************************************/
756
757 BOOL reg_io_r_open_hku(const char *desc,  REG_R_OPEN_HKU *r_r, prs_struct *ps, int depth)
758 {
759         if (r_r == NULL)
760                 return False;
761
762         prs_debug(ps, depth, desc, "reg_io_r_open_hku");
763         depth++;
764
765         if(!prs_align(ps))
766                 return False;
767         
768         if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
769                 return False;
770
771         if(!prs_ntstatus("status", ps, depth, &r_r->status))
772                 return False;
773
774         return True;
775 }
776
777 /*******************************************************************
778  Inits an REG_Q_CLOSE structure.
779 ********************************************************************/
780
781 void init_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
782 {
783         DEBUG(5,("init_reg_q_close\n"));
784
785         memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
786 }
787
788 /*******************************************************************
789 reads or writes a structure.
790 ********************************************************************/
791
792 BOOL reg_io_q_close(const char *desc,  REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
793 {
794         if (q_u == NULL)
795                 return False;
796
797         prs_debug(ps, depth, desc, "reg_io_q_close");
798         depth++;
799
800         if(!prs_align(ps))
801                 return False;
802
803         if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
804                 return False;
805         if(!prs_align(ps))
806                 return False;
807
808         return True;
809 }
810
811 /*******************************************************************
812 reads or writes a structure.
813 ********************************************************************/
814
815 BOOL reg_io_r_close(const char *desc,  REG_R_CLOSE *r_u, prs_struct *ps, int depth)
816 {
817         if (r_u == NULL)
818                 return False;
819
820         prs_debug(ps, depth, desc, "reg_io_r_close");
821         depth++;
822
823         if(!prs_align(ps))
824                 return False;
825
826         if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
827                 return False;
828         if(!prs_align(ps))
829                 return False;
830
831         if(!prs_ntstatus("status", ps, depth, &r_u->status))
832                 return False;
833
834         return True;
835 }
836
837 /*******************************************************************
838 makes a structure.
839 ********************************************************************/
840
841 void init_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol, SEC_DESC_BUF *sec_desc_buf)
842 {
843         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
844
845         q_i->sec_info = DACL_SECURITY_INFORMATION;
846
847         q_i->ptr = 1;
848         init_buf_hdr(&q_i->hdr_sec, sec_desc_buf->len, sec_desc_buf->len);
849         q_i->data = sec_desc_buf;
850 }
851
852 /*******************************************************************
853 reads or writes a structure.
854 ********************************************************************/
855
856 BOOL reg_io_q_set_key_sec(const char *desc,  REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
857 {
858         if (r_q == NULL)
859                 return False;
860
861         prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
862         depth++;
863
864         if(!prs_align(ps))
865                 return False;
866         
867         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
868                 return False;
869
870         if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
871                 return False;
872         if(!prs_uint32("ptr    ", ps, depth, &r_q->ptr))
873                 return False;
874
875         if(!reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth))
876                 return False;
877
878         return True;
879 }
880
881 /*******************************************************************
882 reads or writes a structure.
883 ********************************************************************/
884
885 BOOL reg_io_r_set_key_sec(const char *desc, REG_R_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
886 {
887         if (r_q == NULL)
888                 return False;
889
890         prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
891         depth++;
892
893         if(!prs_align(ps))
894                 return False;
895         
896         if(!prs_ntstatus("status", ps, depth, &r_q->status))
897                 return False;
898
899         return True;
900 }
901
902
903 /*******************************************************************
904 makes a structure.
905 ********************************************************************/
906
907 void init_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol, 
908                                 uint32 sec_buf_size, SEC_DESC_BUF *psdb)
909 {
910         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
911
912         q_i->sec_info = OWNER_SECURITY_INFORMATION |
913                         GROUP_SECURITY_INFORMATION |
914                         DACL_SECURITY_INFORMATION;
915
916         q_i->ptr = psdb != NULL ? 1 : 0;
917         q_i->data = psdb;
918
919         init_buf_hdr(&q_i->hdr_sec, sec_buf_size, 0);
920 }
921
922 /*******************************************************************
923 reads or writes a structure.
924 ********************************************************************/
925
926 BOOL reg_io_q_get_key_sec(const char *desc,  REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
927 {
928         if (r_q == NULL)
929                 return False;
930
931         prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
932         depth++;
933
934         if(!prs_align(ps))
935                 return False;
936         
937         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
938                 return False;
939
940         if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
941                 return False;
942         if(!prs_uint32("ptr     ", ps, depth, &r_q->ptr))
943                 return False;
944
945         if(!reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth))
946                 return False;
947
948         return True;
949 }
950
951 #if 0
952 /*******************************************************************
953 makes a structure.
954 ********************************************************************/
955  void init_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol, 
956                                 uint32 buf_len, uint8 *buf,
957                                 NTSTATUS status)
958 {
959         r_i->ptr = 1;
960         init_buf_hdr(&r_i->hdr_sec, buf_len, buf_len);
961         init_sec_desc_buf(r_i->data, buf_len, 1);
962
963         r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
964 }
965 #endif 
966
967 /*******************************************************************
968 reads or writes a structure.
969 ********************************************************************/
970
971 BOOL reg_io_r_get_key_sec(const char *desc,  REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
972 {
973         if (r_q == NULL)
974                 return False;
975
976         prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
977         depth++;
978
979         if(!prs_align(ps))
980                 return False;
981         
982         if(!prs_uint32("ptr      ", ps, depth, &r_q->ptr))
983                 return False;
984
985         if (r_q->ptr != 0) {
986                 if(!smb_io_hdrbuf("", &r_q->hdr_sec, ps, depth))
987                         return False;
988                 if(!sec_io_desc_buf("", &r_q->data, ps, depth))
989                         return False;
990                 if(!prs_align(ps))
991                         return False;
992         }
993
994         if(!prs_ntstatus("status", ps, depth, &r_q->status))
995                 return False;
996
997         return True;
998 }
999
1000 /*******************************************************************
1001 makes a structure.
1002 ********************************************************************/
1003
1004 BOOL init_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char* val_name)
1005 {
1006         if (q_i == NULL)
1007                 return False;
1008
1009         q_i->pol = *pol;
1010
1011         init_unistr2(&q_i->uni_type, val_name, UNI_STR_TERMINATE);
1012         init_uni_hdr(&q_i->hdr_type, &q_i->uni_type);
1013
1014         q_i->ptr_reserved = 1;
1015         q_i->ptr_buf = 1;
1016
1017         q_i->ptr_bufsize = 1;
1018         q_i->bufsize = 0;
1019         q_i->buf_unk = 0;
1020
1021         q_i->unk1 = 0;
1022         q_i->ptr_buflen = 1;
1023         q_i->buflen = 0;
1024
1025         q_i->ptr_buflen2 = 1;
1026         q_i->buflen2 = 0;
1027
1028         return True;
1029 }
1030
1031 /*******************************************************************
1032 reads or writes a structure.
1033 ********************************************************************/
1034
1035 BOOL reg_io_q_info(const char *desc,  REG_Q_INFO *r_q, prs_struct *ps, int depth)
1036 {
1037         if (r_q == NULL)
1038                 return False;
1039
1040         prs_debug(ps, depth, desc, "reg_io_q_info");
1041         depth++;
1042
1043         if(!prs_align(ps))
1044                 return False;
1045         
1046         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
1047                 return False;
1048         if(!smb_io_unihdr ("", &r_q->hdr_type, ps, depth))
1049                 return False;
1050         if(!smb_io_unistr2("", &r_q->uni_type, r_q->hdr_type.buffer, ps, depth))
1051                 return False;
1052
1053         if(!prs_align(ps))
1054                 return False;
1055         
1056         if(!prs_uint32("ptr_reserved", ps, depth, &(r_q->ptr_reserved)))
1057                 return False;
1058
1059         if(!prs_uint32("ptr_buf", ps, depth, &(r_q->ptr_buf)))
1060                 return False;
1061
1062         if(r_q->ptr_buf) {
1063                 if(!prs_uint32("ptr_bufsize", ps, depth, &(r_q->ptr_bufsize)))
1064                         return False;
1065                 if(!prs_uint32("bufsize", ps, depth, &(r_q->bufsize)))
1066                         return False;
1067                 if(!prs_uint32("buf_unk", ps, depth, &(r_q->buf_unk)))
1068                         return False;
1069         }
1070
1071         if(!prs_uint32("unk1", ps, depth, &(r_q->unk1)))
1072                 return False;
1073
1074         if(!prs_uint32("ptr_buflen", ps, depth, &(r_q->ptr_buflen)))
1075                 return False;
1076
1077         if (r_q->ptr_buflen) {
1078                 if(!prs_uint32("buflen", ps, depth, &(r_q->buflen)))
1079                         return False;
1080                 if(!prs_uint32("ptr_buflen2", ps, depth, &(r_q->ptr_buflen2)))
1081                         return False;
1082                 if(!prs_uint32("buflen2", ps, depth, &(r_q->buflen2)))
1083                         return False;
1084         }
1085
1086         return True;
1087 }
1088
1089 /*******************************************************************
1090  Inits a structure.
1091  New version to replace older init_reg_r_info()
1092 ********************************************************************/
1093
1094 BOOL new_init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_r,
1095                      REGISTRY_VALUE *val, NTSTATUS status)
1096 {
1097         uint32          buf_len = 0;
1098         BUFFER2         buf2;
1099                 
1100         if(r_r == NULL)
1101                 return False;
1102         
1103         if ( !val )
1104                 return False;
1105   
1106         r_r->ptr_type = 1;
1107         r_r->type = val->type;
1108
1109         /* if include_keyval is not set, don't send the key value, just
1110            the buflen data. probably used by NT5 to allocate buffer space - SK */
1111
1112         if ( include_keyval ) {
1113                 r_r->ptr_uni_val = 1;
1114                 buf_len = reg_init_buffer2( &r_r->uni_val, val );
1115         
1116         }
1117         else {
1118                 /* dummy buffer used so we can get the size */
1119                 r_r->ptr_uni_val = 0;
1120                 buf_len = reg_init_buffer2( &buf2, val );
1121         }
1122
1123         r_r->ptr_max_len = 1;
1124         r_r->buf_max_len = buf_len;
1125
1126         r_r->ptr_len = 1;
1127         r_r->buf_len = buf_len;
1128
1129         r_r->status = status;
1130
1131         return True;
1132 }
1133
1134 /*******************************************************************
1135  Inits a structure.
1136 ********************************************************************/
1137
1138 BOOL init_reg_r_info(uint32 include_keyval, REG_R_INFO *r_r,
1139                      BUFFER2* buf, uint32 type, NTSTATUS status)
1140 {
1141         if(r_r == NULL)
1142                 return False;
1143   
1144         r_r->ptr_type = 1;
1145         r_r->type = type;
1146
1147         /* if include_keyval is not set, don't send the key value, just
1148            the buflen data. probably used by NT5 to allocate buffer space - SK */
1149
1150         r_r->ptr_uni_val = include_keyval ? 1:0;
1151         r_r->uni_val = *buf;
1152
1153         r_r->ptr_max_len = 1;
1154         r_r->buf_max_len = r_r->uni_val.buf_max_len;
1155
1156         r_r->ptr_len = 1;
1157         r_r->buf_len = r_r->uni_val.buf_len;
1158
1159         r_r->status = status;
1160
1161         return True;
1162 }
1163
1164 /*******************************************************************
1165 reads or writes a structure.
1166 ********************************************************************/
1167
1168 BOOL reg_io_r_info(const char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
1169 {
1170         if (r_r == NULL)
1171                 return False;
1172
1173         prs_debug(ps, depth, desc, "reg_io_r_info");
1174         depth++;
1175
1176         if(!prs_align(ps))
1177                 return False;
1178         
1179         if(!prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type)))
1180                 return False;
1181
1182         if (r_r->ptr_type != 0) {
1183                 if(!prs_uint32("type", ps, depth, &r_r->type))
1184                         return False;
1185         }
1186
1187         if(!prs_uint32("ptr_uni_val", ps, depth, &(r_r->ptr_uni_val)))
1188                 return False;
1189
1190         if(r_r->ptr_uni_val != 0) {
1191                 if(!smb_io_buffer2("uni_val", &r_r->uni_val, r_r->ptr_uni_val, ps, depth))
1192                         return False;
1193         }
1194
1195         if(!prs_align(ps))
1196                 return False;
1197
1198         if(!prs_uint32("ptr_max_len", ps, depth, &(r_r->ptr_max_len)))
1199                 return False;
1200
1201         if (r_r->ptr_max_len != 0) {
1202                 if(!prs_uint32("buf_max_len", ps, depth, &(r_r->buf_max_len)))
1203                 return False;
1204         }
1205
1206         if(!prs_uint32("ptr_len", ps, depth, &(r_r->ptr_len)))
1207                 return False;
1208         if (r_r->ptr_len != 0) {
1209                 if(!prs_uint32("buf_len", ps, depth, &(r_r->buf_len)))
1210                         return False;
1211         }
1212
1213         if(!prs_ntstatus("status", ps, depth, &r_r->status))
1214                 return False;
1215
1216         return True;
1217 }
1218
1219 /*******************************************************************
1220 makes a structure.
1221 ********************************************************************/
1222
1223 void init_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
1224                                 uint32 val_idx, UNISTR2 *uni2,
1225                                 uint32 max_buf_len)
1226 {
1227         ZERO_STRUCTP(q_i);
1228
1229         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1230
1231         q_i->val_index = val_idx;
1232         init_uni_hdr(&q_i->hdr_name, uni2);
1233         
1234         q_i->ptr_type = 1;
1235         q_i->type = 0x0;
1236
1237         q_i->ptr_value = 1;
1238         q_i->buf_value.buf_max_len = max_buf_len;
1239
1240         q_i->ptr1 = 1;
1241         q_i->len_value1 = max_buf_len;
1242
1243         q_i->ptr2 = 1;
1244         q_i->len_value2 = 0;
1245 }
1246
1247 /*******************************************************************
1248 makes a structure.
1249 ********************************************************************/
1250
1251 void init_reg_r_enum_val(REG_R_ENUM_VALUE *r_u, REGISTRY_VALUE *val )
1252 {
1253         uint32 real_size;
1254         
1255         DEBUG(8,("init_reg_r_enum_val: Enter\n"));
1256         
1257         ZERO_STRUCTP(r_u);
1258
1259         /* value name */
1260
1261         DEBUG(10,("init_reg_r_enum_val: Valuename => [%s]\n", val->valuename));
1262         
1263         init_unistr2( &r_u->uni_name, val->valuename, UNI_STR_TERMINATE);
1264         init_uni_hdr( &r_u->hdr_name, &r_u->uni_name);
1265                 
1266         /* type */
1267         
1268         r_u->ptr_type = 1;
1269         r_u->type = val->type;
1270
1271         /* REG_SZ & REG_MULTI_SZ must be converted to UNICODE */
1272         
1273         r_u->ptr_value = 1;
1274         real_size = reg_init_buffer2( &r_u->buf_value, val );
1275         
1276         /* lengths */
1277
1278         r_u->ptr1 = 1;
1279         r_u->len_value1 = real_size;
1280         
1281         r_u->ptr2 = 1;
1282         r_u->len_value2 = real_size;
1283                 
1284         DEBUG(8,("init_reg_r_enum_val: Exit\n"));
1285 }
1286
1287 /*******************************************************************
1288 reads or writes a structure.
1289 ********************************************************************/
1290
1291 BOOL reg_io_q_enum_val(const char *desc,  REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
1292 {
1293         if (q_q == NULL)
1294                 return False;
1295
1296         prs_debug(ps, depth, desc, "reg_io_q_enum_val");
1297         depth++;
1298
1299         if(!prs_align(ps))
1300                 return False;
1301         
1302         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1303                 return False;
1304         
1305         if(!prs_uint32("val_index", ps, depth, &q_q->val_index))
1306                 return False;
1307                 
1308         if(!smb_io_unihdr ("hdr_name", &q_q->hdr_name, ps, depth))
1309                 return False;
1310         if(!smb_io_unistr2("uni_name", &q_q->uni_name, q_q->hdr_name.buffer, ps, depth))
1311                 return False;
1312         if(!prs_align(ps))
1313                 return False;
1314
1315         if(!prs_uint32("ptr_type", ps, depth, &q_q->ptr_type))
1316                 return False;
1317
1318         if (q_q->ptr_type != 0) {
1319                 if(!prs_uint32("type", ps, depth, &q_q->type))
1320                         return False;
1321         }
1322
1323         if(!prs_uint32("ptr_value", ps, depth, &q_q->ptr_value))
1324                 return False;
1325         if(!smb_io_buffer2("buf_value", &q_q->buf_value, q_q->ptr_value, ps, depth))
1326                 return False;
1327         if(!prs_align(ps))
1328                 return False;
1329
1330         if(!prs_uint32("ptr1", ps, depth, &q_q->ptr1))
1331                 return False;
1332         if (q_q->ptr1 != 0) {
1333                 if(!prs_uint32("len_value1", ps, depth, &q_q->len_value1))
1334                         return False;
1335         }
1336         if(!prs_uint32("ptr2", ps, depth, &q_q->ptr2))
1337                 return False;
1338         if (q_q->ptr2 != 0) {
1339                 if(!prs_uint32("len_value2", ps, depth, &q_q->len_value2))
1340                         return False;
1341         }
1342
1343         return True;
1344 }
1345
1346 /*******************************************************************
1347 reads or writes a structure.
1348 ********************************************************************/
1349
1350 BOOL reg_io_r_enum_val(const char *desc,  REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
1351 {
1352         if (r_q == NULL)
1353                 return False;
1354
1355         prs_debug(ps, depth, desc, "reg_io_r_enum_val");
1356         depth++;
1357
1358         if(!prs_align(ps))
1359                 return False;
1360         
1361         if(!smb_io_unihdr ("hdr_name", &r_q->hdr_name, ps, depth))
1362                 return False;
1363         if(!smb_io_unistr2("uni_name", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
1364                 return False;
1365         if(!prs_align(ps))
1366                 return False;
1367
1368         if(!prs_uint32("ptr_type", ps, depth, &r_q->ptr_type))
1369                 return False;
1370
1371         if (r_q->ptr_type != 0) {
1372                 if(!prs_uint32("type", ps, depth, &r_q->type))
1373                         return False;
1374         }
1375
1376         if(!prs_uint32("ptr_value", ps, depth, &r_q->ptr_value))
1377                 return False;
1378         if(!smb_io_buffer2("buf_value", &r_q->buf_value, r_q->ptr_value, ps, depth))
1379                 return False;
1380         if(!prs_align(ps))
1381                 return False;
1382
1383         if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
1384                 return False;
1385         if (r_q->ptr1 != 0) {
1386                 if(!prs_uint32("len_value1", ps, depth, &r_q->len_value1))
1387                         return False;
1388         }
1389
1390         if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
1391                 return False;
1392         if (r_q->ptr2 != 0) {
1393                 if(!prs_uint32("len_value2", ps, depth, &r_q->len_value2))
1394                         return False;
1395         }
1396
1397         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1398                 return False;
1399
1400         return True;
1401 }
1402
1403 /*******************************************************************
1404 makes a structure.
1405 ********************************************************************/
1406
1407 void init_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
1408                                 char *val_name, uint32 type,
1409                                 BUFFER3 *val)
1410 {
1411         ZERO_STRUCTP(q_i);
1412
1413         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1414
1415         init_unistr2(&q_i->uni_name, val_name, UNI_STR_TERMINATE);
1416         init_uni_hdr(&q_i->hdr_name, &q_i->uni_name);
1417         
1418         q_i->type      = type;
1419         q_i->buf_value = val;
1420 }
1421
1422 /*******************************************************************
1423 reads or writes a structure.
1424 ********************************************************************/
1425
1426 BOOL reg_io_q_create_val(const char *desc,  REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
1427 {
1428         if (q_q == NULL)
1429                 return False;
1430
1431         prs_debug(ps, depth, desc, "reg_io_q_create_val");
1432         depth++;
1433
1434         if(!prs_align(ps))
1435                 return False;
1436         
1437         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1438                 return False;
1439         
1440         if(!smb_io_unihdr ("hdr_name", &q_q->hdr_name, ps, depth))
1441                 return False;
1442         if(!smb_io_unistr2("uni_name", &q_q->uni_name, q_q->hdr_name.buffer, ps, depth))
1443                 return False;
1444         if(!prs_align(ps))
1445                 return False;
1446
1447         if(!prs_uint32("type", ps, depth, &q_q->type))
1448                 return False;
1449         if(!smb_io_buffer3("buf_value", q_q->buf_value, ps, depth))
1450                 return False;
1451         if(!prs_align(ps))
1452                 return False;
1453
1454         return True;
1455 }
1456
1457 /*******************************************************************
1458 reads or writes a structure.
1459 ********************************************************************/
1460
1461 BOOL reg_io_r_create_val(const char *desc,  REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
1462 {
1463         if (r_q == NULL)
1464                 return False;
1465
1466         prs_debug(ps, depth, desc, "reg_io_r_create_val");
1467         depth++;
1468
1469         if(!prs_align(ps))
1470                 return False;
1471         
1472         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1473                 return False;
1474
1475         return True;
1476 }
1477
1478 /*******************************************************************
1479 makes a structure.
1480 ********************************************************************/
1481
1482 void init_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
1483 {
1484         memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1485
1486         q_i->key_index = key_idx;
1487         q_i->key_name_len = 0;
1488         q_i->unknown_1 = 0x0414;
1489
1490         q_i->ptr1 = 1;
1491         q_i->unknown_2 = 0x0000020A;
1492         memset(q_i->pad1, 0, sizeof(q_i->pad1));
1493
1494         q_i->ptr2 = 1;
1495         memset(q_i->pad2, 0, sizeof(q_i->pad2));
1496
1497         q_i->ptr3 = 1;
1498         unix_to_nt_time(&q_i->time, 0);            /* current time? */
1499 }
1500
1501 /*******************************************************************
1502 makes a reply structure.
1503 ********************************************************************/
1504
1505 void init_reg_r_enum_key(REG_R_ENUM_KEY *r_u, char *subkey, uint32 unknown_1,
1506                         uint32 unknown_2)
1507 {
1508         if ( !r_u )
1509                 return;
1510                 
1511         r_u->unknown_1 = unknown_1;
1512         r_u->unknown_2 = unknown_2;
1513         r_u->unknown_3 = 0x0;
1514         
1515         r_u->key_name_len = (strlen(subkey)+1) * 2;
1516         if (r_u->key_name_len)
1517                 r_u->ptr1 = 0x1;
1518         init_unistr3( &r_u->key_name, subkey );
1519         
1520         r_u->ptr2 = 0x1;
1521         r_u->ptr3 = 0x1;
1522 }
1523
1524 /*******************************************************************
1525 reads or writes a structure.
1526 ********************************************************************/
1527
1528 BOOL reg_io_q_enum_key(const char *desc,  REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
1529 {
1530         if (q_q == NULL)
1531                 return False;
1532
1533         prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1534         depth++;
1535
1536         if(!prs_align(ps))
1537                 return False;
1538         
1539         if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1540                 return False;
1541         
1542         if(!prs_uint32("key_index", ps, depth, &q_q->key_index))
1543                 return False;
1544         if(!prs_uint16("key_name_len", ps, depth, &q_q->key_name_len))
1545                 return False;
1546         if(!prs_uint16("unknown_1", ps, depth, &q_q->unknown_1))
1547                 return False;
1548
1549         if(!prs_uint32("ptr1", ps, depth, &q_q->ptr1))
1550                 return False;
1551
1552         if (q_q->ptr1 != 0) {
1553                 if(!prs_uint32("unknown_2", ps, depth, &q_q->unknown_2))
1554                         return False;
1555                 if(!prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1)))
1556                         return False;
1557         }
1558
1559         if(!prs_uint32("ptr2", ps, depth, &q_q->ptr2))
1560                 return False;
1561
1562         if (q_q->ptr2 != 0) {
1563                 if(!prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2)))
1564                         return False;
1565         }
1566
1567         if(!prs_uint32("ptr3", ps, depth, &q_q->ptr3))
1568                 return False;
1569
1570         if (q_q->ptr3 != 0) {
1571                 if(!smb_io_time("", &q_q->time, ps, depth))
1572                         return False;
1573         }
1574
1575         return True;
1576 }
1577
1578 /*******************************************************************
1579 reads or writes a structure.
1580 ********************************************************************/
1581
1582 BOOL reg_io_r_enum_key(const char *desc,  REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1583 {
1584         if (r_q == NULL)
1585                 return False;
1586
1587         prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1588         depth++;
1589
1590         if(!prs_align(ps))
1591                 return False;
1592         
1593         if(!prs_uint16("key_name_len", ps, depth, &r_q->key_name_len))
1594                 return False;
1595         if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
1596                 return False;
1597
1598         if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
1599                 return False;
1600
1601         if (r_q->ptr1 != 0) {
1602                 if(!prs_uint32("unknown_2", ps, depth, &r_q->unknown_2))
1603                         return False;
1604                 if(!prs_uint32("unknown_3", ps, depth, &r_q->unknown_3))
1605                         return False;
1606                 if(!smb_io_unistr3("key_name", &r_q->key_name, ps, depth))
1607                         return False;
1608                 if(!prs_align(ps))
1609                         return False;
1610         }
1611
1612         if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
1613                 return False;
1614
1615         if (r_q->ptr2 != 0) {
1616                 if(!prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2)))
1617                         return False;
1618         }
1619
1620         if(!prs_uint32("ptr3", ps, depth, &r_q->ptr3))
1621                 return False;
1622
1623         if (r_q->ptr3 != 0) {
1624                 if(!smb_io_time("", &r_q->time, ps, depth))
1625                         return False;
1626         }
1627
1628         if(!prs_ntstatus("status", ps, depth, &r_q->status))
1629                 return False;
1630
1631         return True;
1632 }
1633
1634 /*******************************************************************
1635 makes a structure.
1636 ********************************************************************/
1637
1638 void init_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1639                                 char *key_name, uint32 access_desired)
1640 {
1641         memcpy(&r_q->pol, pol, sizeof(r_q->pol));
1642
1643         init_unistr2(&r_q->uni_name, key_name, UNI_STR_TERMINATE);
1644         init_uni_hdr(&r_q->hdr_name, &r_q->uni_name);
1645
1646         r_q->unknown_0 = 0x00000000;
1647         r_q->access_desired = access_desired;
1648 }
1649
1650 /*******************************************************************
1651 reads or writes a structure.
1652 ********************************************************************/
1653
1654 BOOL reg_io_q_open_entry(const char *desc,  REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1655 {
1656         if (r_q == NULL)
1657                 return False;
1658
1659         prs_debug(ps, depth, desc, "reg_io_q_entry");
1660         depth++;
1661
1662         if(!prs_align(ps))
1663                 return False;
1664         
1665         if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
1666                 return False;
1667         if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
1668                 return False;
1669         if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
1670                 return False;
1671
1672         if(!prs_align(ps))
1673                 return False;
1674         
1675         if(!prs_uint32("unknown_0        ", ps, depth, &r_q->unknown_0))
1676                 return False;
1677         if(!prs_uint32("access_desired  ", ps, depth, &r_q->access_desired))
1678                 return False;
1679
1680         return True;
1681 }
1682
1683 /*******************************************************************
1684  Inits a structure.
1685 ********************************************************************/
1686
1687 void init_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1688                            POLICY_HND *pol, NTSTATUS status)
1689 {
1690         if (NT_STATUS_IS_OK(status)) {
1691                 memcpy(&r_r->pol, pol, sizeof(r_r->pol));
1692         } else {
1693                 ZERO_STRUCT(r_r->pol);
1694         }
1695         r_r->status = status;
1696 }
1697
1698 /*******************************************************************
1699 reads or writes a structure.
1700 ********************************************************************/
1701
1702 BOOL reg_io_r_open_entry(const char *desc,  REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1703 {
1704         if (r_r == NULL)
1705                 return False;
1706
1707         prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1708         depth++;
1709
1710         if(!prs_align(ps))
1711                 return False;
1712         
1713         if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
1714                 return False;
1715
1716         if(!prs_ntstatus("status", ps, depth, &r_r->status))
1717                 return False;
1718
1719         return True;
1720 }
1721
1722 /*******************************************************************
1723 Inits a structure.
1724 ********************************************************************/
1725
1726 void init_reg_q_shutdown(REG_Q_SHUTDOWN * q_s, const char *msg,
1727                         uint32 timeout, BOOL do_reboot, BOOL force)
1728 {
1729         q_s->ptr_0 = 1;
1730         q_s->ptr_1 = 1;
1731         q_s->ptr_2 = 1;
1732
1733         init_unistr2(&q_s->uni_msg, msg, UNI_FLAGS_NONE);
1734         init_uni_hdr(&q_s->hdr_msg, &q_s->uni_msg);
1735
1736         q_s->timeout = timeout;
1737
1738         q_s->reboot = do_reboot ? 1 : 0;
1739         q_s->force = force ? 1 : 0;
1740 }
1741
1742 /*******************************************************************
1743 reads or writes a structure.
1744 ********************************************************************/
1745
1746 BOOL reg_io_q_shutdown(const char *desc, REG_Q_SHUTDOWN * q_s, prs_struct *ps,
1747                        int depth)
1748 {
1749         if (q_s == NULL)
1750                 return False;
1751
1752         prs_debug(ps, depth, desc, "reg_io_q_shutdown");
1753         depth++;
1754
1755         if (!prs_align(ps))
1756                 return False;
1757
1758         if (!prs_uint32("ptr_0", ps, depth, &(q_s->ptr_0)))
1759                 return False;
1760         if (!prs_uint32("ptr_1", ps, depth, &(q_s->ptr_1)))
1761                 return False;
1762         if (!prs_uint32("ptr_2", ps, depth, &(q_s->ptr_2)))
1763                 return False;
1764
1765         if (!smb_io_unihdr("hdr_msg", &(q_s->hdr_msg), ps, depth))
1766                 return False;
1767         if (!smb_io_unistr2("uni_msg", &(q_s->uni_msg), q_s->hdr_msg.buffer, ps, depth))
1768                 return False;
1769         if (!prs_align(ps))
1770                 return False;
1771
1772         if (!prs_uint32("timeout", ps, depth, &(q_s->timeout)))
1773                 return False;
1774         if (!prs_uint8("force  ", ps, depth, &(q_s->force)))
1775                 return False;
1776         if (!prs_uint8("reboot ", ps, depth, &(q_s->reboot)))
1777                 return False;
1778
1779         return True;
1780 }
1781
1782 /*******************************************************************
1783 reads or writes a structure.
1784 ********************************************************************/
1785 BOOL reg_io_r_shutdown(const char *desc, REG_R_SHUTDOWN * r_s, prs_struct *ps,
1786                        int depth)
1787 {
1788         if (r_s == NULL)
1789                 return False;
1790
1791         prs_debug(ps, depth, desc, "reg_io_r_shutdown");
1792         depth++;
1793
1794         if(!prs_align(ps))
1795                 return False;
1796
1797         if(!prs_ntstatus("status", ps, depth, &r_s->status))
1798                 return False;
1799
1800         return True;
1801 }
1802
1803 /*******************************************************************
1804 Inits a structure.
1805 ********************************************************************/
1806 void init_reg_q_abort_shutdown(REG_Q_ABORT_SHUTDOWN * q_s)
1807 {
1808
1809         q_s->ptr_server = 0;
1810
1811 }
1812
1813 /*******************************************************************
1814 reads or writes a structure.
1815 ********************************************************************/
1816 BOOL reg_io_q_abort_shutdown(const char *desc, REG_Q_ABORT_SHUTDOWN * q_s,
1817                              prs_struct *ps, int depth)
1818 {
1819         if (q_s == NULL)
1820                 return False;
1821
1822         prs_debug(ps, depth, desc, "reg_io_q_abort_shutdown");
1823         depth++;
1824
1825         if (!prs_align(ps))
1826                 return False;
1827
1828         if (!prs_uint32("ptr_server", ps, depth, &(q_s->ptr_server)))
1829                 return False;
1830         if (q_s->ptr_server != 0)
1831                 if (!prs_uint16("server", ps, depth, &(q_s->server)))
1832                         return False;
1833
1834         return True;
1835 }
1836
1837 /*******************************************************************
1838 reads or writes a structure.
1839 ********************************************************************/
1840 BOOL reg_io_r_abort_shutdown(const char *desc, REG_R_ABORT_SHUTDOWN * r_s,
1841                              prs_struct *ps, int depth)
1842 {
1843         if (r_s == NULL)
1844                 return False;
1845
1846         prs_debug(ps, depth, desc, "reg_io_r_abort_shutdown");
1847         depth++;
1848
1849         if (!prs_align(ps))
1850                 return False;
1851
1852         if (!prs_ntstatus("status", ps, depth, &r_s->status))
1853                 return False;
1854
1855         return True;
1856 }