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