problem been there for months: reg_r_info not aligning after string buffer.
[samba.git] / source3 / rpc_parse / parse_reg.c
1 /* 
2  *  Unix SMB/Netbios implementation.
3  *  Version 1.9.
4  *  RPC Pipe client / server routines
5  *  Copyright (C) Andrew Tridgell              1992-1997,
6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
7  *  Copyright (C) Paul Ashton                       1997.
8  *  
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *  
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *  
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  */
23
24
25 #include "includes.h"
26
27 extern int DEBUGLEVEL;
28
29
30 /*******************************************************************
31 creates a structure.
32 ********************************************************************/
33 void make_reg_q_open_hklm(REG_Q_OPEN_HKLM *q_o,
34                                 uint16 unknown_0, uint32 level)
35 {
36         q_o->ptr = 1;
37         q_o->unknown_0 = unknown_0;
38         q_o->unknown_1 = 0x0; /* random - changes */
39         q_o->level = level;
40 }
41
42 /*******************************************************************
43 reads or writes a structure.
44 ********************************************************************/
45 void reg_io_q_open_hklm(char *desc,  REG_Q_OPEN_HKLM *r_q, prs_struct *ps, int depth)
46 {
47         if (r_q == NULL) return;
48
49         prs_debug(ps, depth, desc, "reg_io_q_open_hklm");
50         depth++;
51
52         prs_align(ps);
53         
54         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
55         if (r_q->ptr != 0)
56         {
57                 prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0));
58                 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
59                 prs_uint32("level    ", ps, depth, &(r_q->level    ));
60         }
61 }
62
63
64 /*******************************************************************
65 reads or writes a structure.
66 ********************************************************************/
67 void reg_io_r_open_hklm(char *desc,  REG_R_OPEN_HKLM *r_r, prs_struct *ps, int depth)
68 {
69         if (r_r == NULL) return;
70
71         prs_debug(ps, depth, desc, "reg_io_r_open_hklm");
72         depth++;
73
74         prs_align(ps);
75         
76         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
77
78         prs_uint32("status", ps, depth, &(r_r->status));
79 }
80
81
82 /*******************************************************************
83 creates a structure.
84 ********************************************************************/
85 void make_reg_q_flush_key(REG_Q_FLUSH_KEY *q_u, POLICY_HND *pol)
86 {
87         memcpy(&(q_u->pol), pol, sizeof(q_u->pol));
88 }
89
90 /*******************************************************************
91 reads or writes a structure.
92 ********************************************************************/
93 void reg_io_q_flush_key(char *desc,  REG_Q_FLUSH_KEY *r_q, prs_struct *ps, int depth)
94 {
95         if (r_q == NULL) return;
96
97         prs_debug(ps, depth, desc, "reg_io_q_flush_key");
98         depth++;
99
100         prs_align(ps);
101         
102         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
103 }
104
105
106 /*******************************************************************
107 reads or writes a structure.
108 ********************************************************************/
109 void reg_io_r_flush_key(char *desc,  REG_R_FLUSH_KEY *r_r, prs_struct *ps, int depth)
110 {
111         if (r_r == NULL) return;
112
113         prs_debug(ps, depth, desc, "reg_io_r_flush_key");
114         depth++;
115
116         prs_align(ps);
117         
118         prs_uint32("status", ps, depth, &(r_r->status));
119 }
120
121 /*******************************************************************
122 reads or writes SEC_DESC_BUF and SEC_DATA structures.
123 ********************************************************************/
124 static void reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec, SEC_DESC_BUF *data, prs_struct *ps, int depth)
125 {
126         if (ptr != 0)
127         {
128                 uint32 hdr_offset;
129                 uint32 old_offset;
130                 smb_io_hdrbuf_pre("hdr_sec", hdr_sec, ps, depth, &hdr_offset);
131                 old_offset = ps->offset;
132                 if (ptr3 != NULL)
133                 {
134                         prs_uint32("ptr3", ps, depth, ptr3);
135                 }
136                 if (ptr3 == NULL || *ptr3 != 0)
137                 {
138                         sec_io_desc_buf("data   ", data   , ps, depth);
139                 }
140                 smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth, hdr_offset,
141                                    data->max_len, data->len);
142                 ps->offset = old_offset + data->len + sizeof(uint32) * ((ptr3 != NULL) ? 5 : 3);
143                 prs_align(ps);
144         }
145 }
146
147
148
149 /*******************************************************************
150 creates a structure.
151 ********************************************************************/
152 void make_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
153                                 char *name, char *class,
154                                 SEC_ACCESS *sam_access,
155                                 SEC_DESC_BUF *sec_buf,
156                                 int sec_len, SEC_DESC *sec)
157 {
158         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
159         int len_class = class != NULL ? strlen(class) + 1: 0;
160
161         ZERO_STRUCTP(q_c);
162
163         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
164
165         make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
166         make_unistr2(&(q_c->uni_name), name, len_name);
167
168         make_uni_hdr(&(q_c->hdr_class), len_class, len_class, 1);
169         make_unistr2(&(q_c->uni_class), class, len_class);
170
171         q_c->reserved = 0x00000000;
172         memcpy(&(q_c->sam_access), sam_access, sizeof(q_c->sam_access));
173
174         q_c->ptr1 = 1;
175         q_c->sec_info = DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
176
177         q_c->data = sec_buf;
178         q_c->ptr2 = 1;
179         make_buf_hdr(&(q_c->hdr_sec), sec_len, sec_len);
180         q_c->ptr3 = 1;
181         make_sec_desc_buf(q_c->data, sec_len, sec);
182
183         q_c->unknown_2 = 0x00000000;
184 }
185
186 /*******************************************************************
187 reads or writes a structure.
188 ********************************************************************/
189 void reg_io_q_create_key(char *desc,  REG_Q_CREATE_KEY *r_q, prs_struct *ps, int depth)
190 {
191         if (r_q == NULL) return;
192
193         prs_debug(ps, depth, desc, "reg_io_q_create_key");
194         depth++;
195
196         prs_align(ps);
197         
198         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
199
200         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
201         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
202         prs_align(ps);
203
204         smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
205         smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
206         prs_align(ps);
207
208         prs_uint32("reserved", ps, depth, &(r_q->reserved));
209         sec_io_access("sam_access", &r_q->sam_access, ps, depth);
210
211         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
212         if (r_q->ptr1 != 0)
213         {
214                 prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
215         }
216
217         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
218         reg_io_hdrbuf_sec(r_q->ptr2, &r_q->ptr3, &r_q->hdr_sec, r_q->data, ps, depth);
219
220         prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
221 }
222
223
224 /*******************************************************************
225 reads or writes a structure.
226 ********************************************************************/
227 void reg_io_r_create_key(char *desc,  REG_R_CREATE_KEY *r_r, prs_struct *ps, int depth)
228 {
229         if (r_r == NULL) return;
230
231         prs_debug(ps, depth, desc, "reg_io_r_create_key");
232         depth++;
233
234         prs_align(ps);
235         
236         smb_io_pol_hnd("", &(r_r->key_pol), ps, depth);
237         prs_uint32("unknown", ps, depth, &(r_r->unknown));
238
239         prs_uint32("status", ps, depth, &(r_r->status));
240 }
241
242
243 /*******************************************************************
244 creates a structure.
245 ********************************************************************/
246 void make_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
247                                 char *name)
248 {
249         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
250         ZERO_STRUCTP(q_c);
251
252         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
253
254         make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
255         make_unistr2(&(q_c->uni_name), name, len_name);
256 }
257
258 /*******************************************************************
259 reads or writes a structure.
260 ********************************************************************/
261 void reg_io_q_delete_val(char *desc,  REG_Q_DELETE_VALUE *r_q, prs_struct *ps, int depth)
262 {
263         if (r_q == NULL) return;
264
265         prs_debug(ps, depth, desc, "reg_io_q_delete_val");
266         depth++;
267
268         prs_align(ps);
269         
270         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
271
272         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
273         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
274         prs_align(ps);
275 }
276
277
278 /*******************************************************************
279 reads or writes a structure.
280 ********************************************************************/
281 void reg_io_r_delete_val(char *desc,  REG_R_DELETE_VALUE *r_r, prs_struct *ps, int depth)
282 {
283         if (r_r == NULL) return;
284
285         prs_debug(ps, depth, desc, "reg_io_r_delete_val");
286         depth++;
287
288         prs_align(ps);
289         
290         prs_uint32("status", ps, depth, &(r_r->status));
291 }
292
293
294 /*******************************************************************
295 creates a structure.
296 ********************************************************************/
297 void make_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
298                                 char *name)
299 {
300         int len_name  = name  != NULL ? strlen(name ) + 1: 0;
301         ZERO_STRUCTP(q_c);
302
303         memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
304
305         make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
306         make_unistr2(&(q_c->uni_name), name, len_name);
307 }
308
309 /*******************************************************************
310 reads or writes a structure.
311 ********************************************************************/
312 void reg_io_q_delete_key(char *desc,  REG_Q_DELETE_KEY *r_q, prs_struct *ps, int depth)
313 {
314         if (r_q == NULL) return;
315
316         prs_debug(ps, depth, desc, "reg_io_q_delete_key");
317         depth++;
318
319         prs_align(ps);
320         
321         smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
322
323         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
324         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
325         prs_align(ps);
326 }
327
328
329 /*******************************************************************
330 reads or writes a structure.
331 ********************************************************************/
332 void reg_io_r_delete_key(char *desc,  REG_R_DELETE_KEY *r_r, prs_struct *ps, int depth)
333 {
334         if (r_r == NULL) return;
335
336         prs_debug(ps, depth, desc, "reg_io_r_delete_key");
337         depth++;
338
339         prs_align(ps);
340         
341         prs_uint32("status", ps, depth, &(r_r->status));
342 }
343
344
345 /*******************************************************************
346 creates a structure.
347 ********************************************************************/
348 void make_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd,
349                                 uint32 max_class_len)
350 {
351         ZERO_STRUCTP(q_o);
352
353         memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
354         make_uni_hdr(&q_o->hdr_class, max_class_len, 0, max_class_len > 0 ? 1 : 0);
355         q_o->uni_class.uni_max_len = max_class_len;
356 }
357
358 /*******************************************************************
359 reads or writes a structure.
360 ********************************************************************/
361 void reg_io_q_query_key(char *desc,  REG_Q_QUERY_KEY *r_q, prs_struct *ps, int depth)
362 {
363         if (r_q == NULL) return;
364
365         prs_debug(ps, depth, desc, "reg_io_q_query_key");
366         depth++;
367
368         prs_align(ps);
369         
370         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
371         smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
372         smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
373
374         prs_align(ps);
375 }
376
377
378 /*******************************************************************
379 reads or writes a structure.
380 ********************************************************************/
381 void reg_io_r_query_key(char *desc,  REG_R_QUERY_KEY *r_r, prs_struct *ps, int depth)
382 {
383         if (r_r == NULL) return;
384
385         prs_debug(ps, depth, desc, "reg_io_r_query_key");
386         depth++;
387
388         prs_align(ps);
389         
390         smb_io_unihdr ("", &(r_r->hdr_class), ps, depth);
391         smb_io_unistr2("", &(r_r->uni_class), r_r->hdr_class.buffer, ps, depth);
392
393         prs_align(ps);
394
395         prs_uint32("num_subkeys   ", ps, depth, &(r_r->num_subkeys   ));
396         prs_uint32("max_subkeylen ", ps, depth, &(r_r->max_subkeylen ));
397         prs_uint32("mak_subkeysize", ps, depth, &(r_r->max_subkeysize));
398         prs_uint32("num_values    ", ps, depth, &(r_r->num_values    ));
399         prs_uint32("max_valnamelen", ps, depth, &(r_r->max_valnamelen));
400         prs_uint32("max_valbufsize", ps, depth, &(r_r->max_valbufsize));
401         prs_uint32("sec_desc      ", ps, depth, &(r_r->sec_desc      ));
402         smb_io_time("mod_time     ", &(r_r->mod_time), ps, depth);
403         
404         prs_uint32("status", ps, depth, &(r_r->status));
405 }
406
407
408 /*******************************************************************
409 creates a structure.
410 ********************************************************************/
411 void make_reg_q_unk_1a(REG_Q_UNK_1A *q_o, POLICY_HND *hnd)
412 {
413         memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
414 }
415
416 /*******************************************************************
417 reads or writes a structure.
418 ********************************************************************/
419 void reg_io_q_unk_1a(char *desc,  REG_Q_UNK_1A *r_q, prs_struct *ps, int depth)
420 {
421         if (r_q == NULL) return;
422
423         prs_debug(ps, depth, desc, "reg_io_q_unk_1a");
424         depth++;
425
426         prs_align(ps);
427         
428         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
429 }
430
431
432 /*******************************************************************
433 reads or writes a structure.
434 ********************************************************************/
435 void reg_io_r_unk_1a(char *desc,  REG_R_UNK_1A *r_r, prs_struct *ps, int depth)
436 {
437         if (r_r == NULL) return;
438
439         prs_debug(ps, depth, desc, "reg_io_r_unk_1a");
440         depth++;
441
442         prs_align(ps);
443         
444         prs_uint32("unknown", ps, depth, &(r_r->unknown));
445         prs_uint32("status" , ps, depth, &(r_r->status ));
446 }
447
448
449 /*******************************************************************
450 creates a structure.
451 ********************************************************************/
452 void make_reg_q_open_hku(REG_Q_OPEN_HKU *q_o,
453                                 uint16 unknown_0, uint32 level)
454 {
455         q_o->ptr = 1;
456         q_o->unknown_0 = unknown_0;
457         q_o->unknown_1 = 0x0; /* random - changes */
458         q_o->level = level;
459 }
460
461 /*******************************************************************
462 reads or writes a structure.
463 ********************************************************************/
464 void reg_io_q_open_hku(char *desc,  REG_Q_OPEN_HKU *r_q, prs_struct *ps, int depth)
465 {
466         if (r_q == NULL) return;
467
468         prs_debug(ps, depth, desc, "reg_io_q_open_hku");
469         depth++;
470
471         prs_align(ps);
472         
473         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
474         if (r_q->ptr != 0)
475         {
476                 prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0));
477                 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
478                 prs_uint32("level    ", ps, depth, &(r_q->level    ));
479         }
480 }
481
482
483 /*******************************************************************
484 reads or writes a structure.
485 ********************************************************************/
486 void reg_io_r_open_hku(char *desc,  REG_R_OPEN_HKU *r_r, prs_struct *ps, int depth)
487 {
488         if (r_r == NULL) return;
489
490         prs_debug(ps, depth, desc, "reg_io_r_open_hku");
491         depth++;
492
493         prs_align(ps);
494         
495         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
496
497         prs_uint32("status", ps, depth, &(r_r->status));
498 }
499
500
501 /*******************************************************************
502 makes an REG_Q_CLOSE structure.
503 ********************************************************************/
504 void make_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
505 {
506         if (q_c == NULL || hnd == NULL) return;
507
508         DEBUG(5,("make_reg_q_close\n"));
509
510         memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
511 }
512
513 /*******************************************************************
514 reads or writes a structure.
515 ********************************************************************/
516 void reg_io_q_close(char *desc,  REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
517 {
518         if (q_u == NULL) return;
519
520         prs_debug(ps, depth, desc, "reg_io_q_unknown_1");
521         depth++;
522
523         prs_align(ps);
524
525         smb_io_pol_hnd("", &(q_u->pol), ps, depth); 
526         prs_align(ps);
527 }
528
529 /*******************************************************************
530 reads or writes a structure.
531 ********************************************************************/
532 void reg_io_r_close(char *desc,  REG_R_CLOSE *r_u, prs_struct *ps, int depth)
533 {
534         if (r_u == NULL) return;
535
536         prs_debug(ps, depth, desc, "reg_io_r_unknown_1");
537         depth++;
538
539         prs_align(ps);
540
541         smb_io_pol_hnd("", &(r_u->pol), ps, depth); 
542         prs_align(ps);
543
544         prs_uint32("status", ps, depth, &(r_u->status));
545 }
546
547 /*******************************************************************
548 makes a structure.
549 ********************************************************************/
550 void make_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol, 
551                                 uint32 buf_len, SEC_DESC *sec_desc)
552 {
553         if (q_i == NULL) return;
554
555         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
556
557         q_i->sec_info = DACL_SECURITY_INFORMATION;
558
559         q_i->ptr = 1;
560         make_buf_hdr(&(q_i->hdr_sec), buf_len, buf_len);
561         make_sec_desc_buf(q_i->data, buf_len, sec_desc);
562 }
563
564 /*******************************************************************
565 reads or writes a structure.
566 ********************************************************************/
567 void reg_io_q_set_key_sec(char *desc,  REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
568 {
569         if (r_q == NULL) return;
570
571         prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
572         depth++;
573
574         prs_align(ps);
575         
576         smb_io_pol_hnd("", &(r_q->pol), ps, depth); 
577
578         prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
579         prs_uint32("ptr    ", ps, depth, &(r_q->ptr    ));
580
581         reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth);
582 }
583
584 /*******************************************************************
585 reads or writes a structure.
586 ********************************************************************/
587 void reg_io_r_set_key_sec(char *desc, REG_R_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
588 {
589         if (r_q == NULL) return;
590
591         prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
592         depth++;
593
594         prs_align(ps);
595         
596         prs_uint32("status", ps, depth, &(r_q->status));
597 }
598
599
600 /*******************************************************************
601 makes a structure.
602 ********************************************************************/
603 void make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol, 
604                                 uint32 buf_len, SEC_DESC_BUF *sec_buf)
605 {
606         if (q_i == NULL) return;
607
608         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
609
610         q_i->sec_info = OWNER_SECURITY_INFORMATION |
611                         GROUP_SECURITY_INFORMATION |
612                         DACL_SECURITY_INFORMATION;
613
614         q_i->ptr = sec_buf != NULL ? 1 : 0;
615         q_i->data = sec_buf;
616
617         if (sec_buf != NULL)
618         {
619                 make_buf_hdr(&(q_i->hdr_sec), buf_len, 0);
620                 make_sec_desc_buf(q_i->data, buf_len, NULL);
621         }
622 }
623
624 /*******************************************************************
625 reads or writes a structure.
626 ********************************************************************/
627 void reg_io_q_get_key_sec(char *desc,  REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
628 {
629         if (r_q == NULL) return;
630
631         prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
632         depth++;
633
634         prs_align(ps);
635         
636         smb_io_pol_hnd("", &(r_q->pol), ps, depth); 
637
638         prs_uint32("sec_info", ps, depth, &(r_q->sec_info));
639         prs_uint32("ptr     ", ps, depth, &(r_q->ptr     ));
640
641         reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth);
642 }
643
644 #if 0
645 /*******************************************************************
646 makes a structure.
647 ********************************************************************/
648  void make_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol, 
649                                 uint32 buf_len, uint8 *buf,
650                                 uint32 status)
651 {
652         if (r_i == NULL) return;
653
654         r_i->ptr = 1;
655         make_buf_hdr(&(r_i->hdr_sec), buf_len, buf_len);
656         make_sec_desc_buf(r_i->data, buf_len, 1);
657
658         r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
659 }
660 #endif 
661
662 /*******************************************************************
663 reads or writes a structure.
664 ********************************************************************/
665 void reg_io_r_get_key_sec(char *desc,  REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
666 {
667         if (r_q == NULL) return;
668
669         prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
670         depth++;
671
672         prs_align(ps);
673         
674         prs_uint32("ptr      ", ps, depth, &(r_q->ptr      ));
675
676         if (r_q->ptr != 0)
677         {
678                 smb_io_hdrbuf("", &(r_q->hdr_sec), ps, depth);
679                 sec_io_desc_buf("", r_q->data, ps, depth);
680
681                 prs_align(ps);
682         }
683
684         prs_uint32("status", ps, depth, &(r_q->status));
685 }
686
687
688 /*******************************************************************
689 makes a structure.
690 ********************************************************************/
691 void make_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char *product_type,
692                                 time_t unix_time, uint8 major, uint8 minor)
693 {
694         int len_type  = strlen(product_type);
695
696         if (q_i == NULL) return;
697
698         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
699
700         make_uni_hdr(&(q_i->hdr_type), len_type, len_type, 1);
701         make_unistr2(&(q_i->uni_type), product_type, len_type);
702
703         q_i->ptr1 = 1;
704         unix_to_nt_time(&(q_i->time), unix_time);
705         q_i->major_version1 = major;
706         q_i->minor_version1 = minor;
707         memset(q_i->pad1, 0, sizeof(q_i->pad1));
708
709         q_i->ptr2 = 1;
710         q_i->major_version2 = major;
711         q_i->minor_version2 = minor;
712         memset(q_i->pad2, 0, sizeof(q_i->pad2));
713
714         q_i->ptr3 = 1;
715         q_i->unknown = 0x00000000;
716 }
717
718 /*******************************************************************
719 reads or writes a structure.
720 ********************************************************************/
721 void reg_io_q_info(char *desc,  REG_Q_INFO *r_q, prs_struct *ps, int depth)
722 {
723         if (r_q == NULL) return;
724
725         prs_debug(ps, depth, desc, "reg_io_q_info");
726         depth++;
727
728         prs_align(ps);
729         
730         smb_io_pol_hnd("", &(r_q->pol), ps, depth); 
731         smb_io_unihdr ("", &(r_q->hdr_type), ps, depth);
732         smb_io_unistr2("", &(r_q->uni_type), r_q->hdr_type.buffer, ps, depth);
733
734         prs_align(ps);
735         
736         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
737
738         if (r_q->ptr1 != 0)
739         {
740                 smb_io_time("", &(r_q->time), ps, depth);
741                 prs_uint8 ("major_version1", ps, depth, &(r_q->major_version1));
742                 prs_uint8 ("minor_version1", ps, depth, &(r_q->minor_version1));
743                 prs_uint8s(False, "pad1", ps, depth, r_q->pad1, sizeof(r_q->pad1));
744         }
745
746         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
747
748         if (r_q->ptr2 != 0)
749         {
750                 prs_uint8 ("major_version2", ps, depth, &(r_q->major_version2));
751                 prs_uint8 ("minor_version2", ps, depth, &(r_q->minor_version2));
752                 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
753         }
754
755         prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
756
757         if (r_q->ptr3 != 0)
758         {
759                 prs_uint32("unknown", ps, depth, &(r_q->unknown));
760         }
761 }
762
763
764 /*******************************************************************
765 creates a structure.
766 ********************************************************************/
767 void make_reg_r_info(REG_R_INFO *r_r,
768                                 uint32 level, char *os_type,
769                                 uint32 status)
770 {
771         char buf[512];
772         int len;
773
774         len = ascii_to_unibuf(buf, os_type, sizeof(buf)-2) - buf;
775
776         r_r->ptr1 = 1;
777         r_r->level = level;
778
779         r_r->ptr_type = 1;
780         make_buffer2(&(r_r->uni_type), buf, len);
781
782         r_r->ptr2 = 1;
783         r_r->unknown_0 = len;
784
785         r_r->ptr3 = 1;
786         r_r->unknown_1 = len;
787
788         r_r->status = status;
789 }
790
791 /*******************************************************************
792 reads or writes a structure.
793 ********************************************************************/
794 void reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
795 {
796         if (r_r == NULL) return;
797
798         prs_debug(ps, depth, desc, "reg_io_r_info");
799         depth++;
800
801         prs_align(ps);
802         
803         prs_uint32("ptr1", ps, depth, &(r_r->ptr1));
804
805         if (r_r->ptr1 != 0)
806         {
807                 prs_uint32("level", ps, depth, &(r_r->level));
808                 prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type));
809
810                 smb_io_buffer2("uni_type", &(r_r->uni_type), r_r->ptr_type, ps, depth);
811                 prs_align(ps);
812
813                 prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
814
815                 if (r_r->ptr2 != 0)
816                 {
817                         prs_uint32("unknown_0", ps, depth, &(r_r->unknown_0));
818                 }
819
820                 prs_uint32("ptr3", ps, depth, &(r_r->ptr3));
821
822                 if (r_r->ptr3 != 0)
823                 {
824                         prs_uint32("unknown_1", ps, depth, &(r_r->unknown_1));
825                 }
826
827         }
828         prs_uint32("status", ps, depth, &(r_r->status));
829 }
830
831 /*******************************************************************
832 makes a structure.
833 ********************************************************************/
834 void make_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
835                                 uint32 val_idx, uint32 max_val_len,
836                                 uint32 max_buf_len)
837 {
838         if (q_i == NULL) return;
839
840         ZERO_STRUCTP(q_i);
841
842         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
843
844         q_i->val_index = val_idx;
845         make_uni_hdr(&q_i->hdr_name, max_val_len, 0, 1);
846         q_i->uni_name.uni_max_len = max_val_len;
847         
848         q_i->ptr_type = 1;
849         q_i->type = 0x0;
850
851         q_i->ptr_value = 1;
852         q_i->buf_value.buf_max_len = max_buf_len;
853
854         q_i->ptr1 = 1;
855         q_i->len_value1 = max_buf_len;
856
857         q_i->ptr2 = 1;
858         q_i->len_value2 = 0;
859 }
860
861 /*******************************************************************
862 reads or writes a structure.
863 ********************************************************************/
864 void reg_io_q_enum_val(char *desc,  REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
865 {
866         if (q_q == NULL) return;
867
868         prs_debug(ps, depth, desc, "reg_io_q_enum_val");
869         depth++;
870
871         prs_align(ps);
872         
873         smb_io_pol_hnd("", &(q_q->pol), ps, depth); 
874         
875         prs_uint32("val_index", ps, depth, &(q_q->val_index));
876         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
877         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
878         prs_align(ps);
879
880         prs_uint32("ptr_type", ps, depth, &(q_q->ptr_type));
881
882         if (q_q->ptr_type != 0)
883         {
884                 prs_uint32("type", ps, depth, &(q_q->type));
885         }
886
887         prs_uint32("ptr_value", ps, depth, &(q_q->ptr_value));
888         smb_io_buffer2("buf_value", &(q_q->buf_value), q_q->ptr_value, ps, depth);
889         prs_align(ps);
890
891         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
892         if (q_q->ptr1 != 0)
893         {
894                 prs_uint32("len_value1", ps, depth, &(q_q->len_value1));
895         }
896         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
897         if (q_q->ptr2 != 0)
898         {
899                 prs_uint32("len_value2", ps, depth, &(q_q->len_value2));
900         }
901 }
902
903 /*******************************************************************
904 reads or writes a structure.
905 ********************************************************************/
906 void reg_io_r_enum_val(char *desc,  REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
907 {
908         if (r_q == NULL) return;
909
910         prs_debug(ps, depth, desc, "reg_io_r_enum_val");
911         depth++;
912
913         prs_align(ps);
914         
915         smb_io_unihdr ("hdr_name", &(r_q->hdr_name), ps, depth);
916         smb_io_unistr2("uni_name", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
917         prs_align(ps);
918
919         prs_uint32("ptr_type", ps, depth, &(r_q->ptr_type));
920
921         if (r_q->ptr_type != 0)
922         {
923                 prs_uint32("type", ps, depth, &(r_q->type));
924         }
925
926         prs_uint32("ptr_value", ps, depth, &(r_q->ptr_value));
927         smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth);
928         prs_align(ps);
929
930         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
931         if (r_q->ptr1 != 0)
932         {
933                 prs_uint32("len_value1", ps, depth, &(r_q->len_value1));
934         }
935
936         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
937         if (r_q->ptr2 != 0)
938         {
939                 prs_uint32("len_value2", ps, depth, &(r_q->len_value2));
940         }
941
942         prs_uint32("status", ps, depth, &(r_q->status));
943 }
944
945 /*******************************************************************
946 makes a structure.
947 ********************************************************************/
948 void make_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
949                                 char *val_name, uint32 type,
950                                 BUFFER3 *val)
951 {
952         int val_len = strlen(val_name) + 1;
953
954         if (q_i == NULL) return;
955
956         ZERO_STRUCTP(q_i);
957
958         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
959
960         make_uni_hdr(&q_i->hdr_name, val_len, val_len, 1);
961         make_unistr2(&(q_i->uni_name), val_name, val_len);
962         
963         q_i->type      = type;
964         q_i->buf_value = val;
965 }
966
967 /*******************************************************************
968 reads or writes a structure.
969 ********************************************************************/
970 void reg_io_q_create_val(char *desc,  REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
971 {
972         if (q_q == NULL) return;
973
974         prs_debug(ps, depth, desc, "reg_io_q_create_val");
975         depth++;
976
977         prs_align(ps);
978         
979         smb_io_pol_hnd("", &(q_q->pol), ps, depth); 
980         
981         smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
982         smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
983         prs_align(ps);
984
985         prs_uint32("type", ps, depth, &(q_q->type));
986         smb_io_buffer3("buf_value", q_q->buf_value, ps, depth);
987         prs_align(ps);
988 }
989
990 /*******************************************************************
991 reads or writes a structure.
992 ********************************************************************/
993 void reg_io_r_create_val(char *desc,  REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
994 {
995         if (r_q == NULL) return;
996
997         prs_debug(ps, depth, desc, "reg_io_r_create_val");
998         depth++;
999
1000         prs_align(ps);
1001         
1002         prs_uint32("status", ps, depth, &(r_q->status));
1003 }
1004
1005 /*******************************************************************
1006 makes a structure.
1007 ********************************************************************/
1008 void make_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
1009 {
1010         if (q_i == NULL) return;
1011
1012         memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
1013
1014         q_i->key_index = key_idx;
1015         q_i->key_name_len = 0;
1016         q_i->unknown_1 = 0x0414;
1017
1018         q_i->ptr1 = 1;
1019         q_i->unknown_2 = 0x0000020A;
1020         memset(q_i->pad1, 0, sizeof(q_i->pad1));
1021
1022         q_i->ptr2 = 1;
1023         memset(q_i->pad2, 0, sizeof(q_i->pad2));
1024
1025         q_i->ptr3 = 1;
1026         init_nt_time(&(q_i->time));   /* ignored ? */
1027 }
1028
1029 /*******************************************************************
1030 reads or writes a structure.
1031 ********************************************************************/
1032 void reg_io_q_enum_key(char *desc,  REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
1033 {
1034         if (q_q == NULL) return;
1035
1036         prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1037         depth++;
1038
1039         prs_align(ps);
1040         
1041         smb_io_pol_hnd("", &(q_q->pol), ps, depth); 
1042         
1043         prs_uint32("key_index", ps, depth, &(q_q->key_index));
1044         prs_uint16("key_name_len", ps, depth, &(q_q->key_name_len));
1045         prs_uint16("unknown_1", ps, depth, &(q_q->unknown_1));
1046
1047         prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
1048
1049         if (q_q->ptr1 != 0)
1050         {
1051                 prs_uint32("unknown_2", ps, depth, &(q_q->unknown_2));
1052                 prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1));
1053         }
1054
1055         prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
1056
1057         if (q_q->ptr2 != 0)
1058         {
1059                 prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2));
1060         }
1061
1062         prs_uint32("ptr3", ps, depth, &(q_q->ptr3));
1063
1064         if (q_q->ptr3 != 0)
1065         {
1066                 smb_io_time("", &(q_q->time), ps, depth);
1067         }
1068 }
1069
1070 /*******************************************************************
1071 reads or writes a structure.
1072 ********************************************************************/
1073 void reg_io_r_enum_key(char *desc,  REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1074 {
1075         if (r_q == NULL) return;
1076
1077         prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1078         depth++;
1079
1080         prs_align(ps);
1081         
1082         prs_uint16("key_name_len", ps, depth, &(r_q->key_name_len));
1083         prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
1084
1085         prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
1086
1087         if (r_q->ptr1 != 0)
1088         {
1089                 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
1090                 prs_uint32("unknown_3", ps, depth, &(r_q->unknown_3));
1091                 smb_io_unistr3("key_name", &(r_q->key_name), ps, depth);
1092                 prs_align(ps);
1093         }
1094
1095         prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
1096
1097         if (r_q->ptr2 != 0)
1098         {
1099                 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
1100         }
1101
1102         prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
1103
1104         if (r_q->ptr3 != 0)
1105         {
1106                 smb_io_time("", &(r_q->time), ps, depth);
1107         }
1108
1109         prs_uint32("status", ps, depth, &(r_q->status));
1110 }
1111
1112
1113 /*******************************************************************
1114 makes a structure.
1115 ********************************************************************/
1116 void make_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1117                                 char *key_name, uint32 unk)
1118 {
1119         int len_name = strlen(key_name)+1;
1120
1121         if (r_q == NULL) return;
1122
1123         memcpy(&(r_q->pol), pol, sizeof(r_q->pol));
1124
1125         make_uni_hdr(&(r_q->hdr_name), len_name, len_name, 1);
1126         make_unistr2(&(r_q->uni_name), key_name, len_name);
1127
1128         r_q->unknown_0 = 0x00000000;
1129         r_q->unknown_1 = unk;
1130 }
1131
1132 /*******************************************************************
1133 reads or writes a structure.
1134 ********************************************************************/
1135 void reg_io_q_open_entry(char *desc,  REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1136 {
1137         if (r_q == NULL) return;
1138
1139         prs_debug(ps, depth, desc, "reg_io_q_entry");
1140         depth++;
1141
1142         prs_align(ps);
1143         
1144         smb_io_pol_hnd("", &(r_q->pol), ps, depth);
1145         smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
1146         smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1147
1148         prs_align(ps);
1149         
1150         prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
1151         prs_uint32("unknown_1", ps, depth, &(r_q->unknown_1));
1152 }
1153
1154
1155 /*******************************************************************
1156 creates a structure.
1157 ********************************************************************/
1158 void make_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1159                                 POLICY_HND *pol, uint32 status)
1160 {
1161         if (r_r == NULL) return;
1162
1163         memcpy(&(r_r->pol), pol, sizeof(r_r->pol));
1164         r_r->status = status;
1165 }
1166
1167 /*******************************************************************
1168 reads or writes a structure.
1169 ********************************************************************/
1170 void reg_io_r_open_entry(char *desc,  REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1171 {
1172         if (r_r == NULL) return;
1173
1174         prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1175         depth++;
1176
1177         prs_align(ps);
1178         
1179         smb_io_pol_hnd("", &(r_r->pol), ps, depth);
1180
1181         prs_uint32("status", ps, depth, &(r_r->status));
1182 }
1183
1184 /*******************************************************************
1185 makes a structure.
1186 ********************************************************************/
1187 void make_reg_q_shutdown(REG_Q_SHUTDOWN *q_i,
1188                                 char *msg, uint32 timeout, uint16 flags)
1189 {
1190         int len = strlen(msg) + 1;
1191
1192         if (q_i == NULL) return;
1193
1194         ZERO_STRUCTP(q_i);
1195
1196         q_i->ptr_0 = 1;
1197         q_i->ptr_1 = 1;
1198         q_i->ptr_2 = 1;
1199
1200         make_uni_hdr(&q_i->hdr_msg, len, len, 1);
1201         make_unistr2(&(q_i->uni_msg), msg, len);
1202         
1203         q_i->timeout = timeout;
1204         q_i->flags   = flags;
1205 }
1206
1207 /*******************************************************************
1208 reads or writes a structure.
1209 ********************************************************************/
1210 void reg_io_q_shutdown(char *desc,  REG_Q_SHUTDOWN *q_q, prs_struct *ps, int depth)
1211 {
1212         if (q_q == NULL) return;
1213
1214         prs_debug(ps, depth, desc, "reg_io_q_shutdown");
1215         depth++;
1216
1217         prs_align(ps);
1218         
1219         prs_uint32("ptr_0", ps, depth, &(q_q->ptr_0));
1220         prs_uint32("ptr_1", ps, depth, &(q_q->ptr_1));
1221         prs_uint32("ptr_2", ps, depth, &(q_q->ptr_2));
1222         
1223         smb_io_unihdr ("hdr_msg", &(q_q->hdr_msg), ps, depth);
1224         smb_io_unistr2("uni_msg", &(q_q->uni_msg), q_q->hdr_msg.buffer, ps, depth);
1225         prs_align(ps);
1226
1227         prs_uint32("timeout", ps, depth, &(q_q->timeout));
1228         prs_uint16("flags  ", ps, depth, &(q_q->flags  ));
1229         prs_align(ps);
1230 }
1231
1232 /*******************************************************************
1233 reads or writes a structure.
1234 ********************************************************************/
1235 void reg_io_r_shutdown(char *desc,  REG_R_SHUTDOWN *r_q, prs_struct *ps, int depth)
1236 {
1237         if (r_q == NULL) return;
1238
1239         prs_debug(ps, depth, desc, "reg_io_r_shutdown");
1240         depth++;
1241
1242         prs_align(ps);
1243         
1244         prs_uint32("status", ps, depth, &(r_q->status));
1245 }
1246