2 * Unix SMB/Netbios implementation.
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.
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.
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.
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.
27 extern int DEBUGLEVEL;
30 /*******************************************************************
32 ********************************************************************/
33 void make_reg_q_open_hklm(REG_Q_OPEN_HKLM *q_o,
34 uint16 unknown_0, uint32 level)
37 q_o->unknown_0 = unknown_0;
38 q_o->unknown_1 = 0x0; /* random - changes */
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)
47 if (r_q == NULL) return;
49 prs_debug(ps, depth, desc, "reg_io_q_open_hklm");
54 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
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 ));
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)
69 if (r_r == NULL) return;
71 prs_debug(ps, depth, desc, "reg_io_r_open_hklm");
76 smb_io_pol_hnd("", &(r_r->pol), ps, depth);
78 prs_uint32("status", ps, depth, &(r_r->status));
82 /*******************************************************************
84 ********************************************************************/
85 void make_reg_q_flush_key(REG_Q_FLUSH_KEY *q_u, POLICY_HND *pol)
87 memcpy(&(q_u->pol), pol, sizeof(q_u->pol));
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)
95 if (r_q == NULL) return;
97 prs_debug(ps, depth, desc, "reg_io_q_flush_key");
102 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
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)
111 if (r_r == NULL) return;
113 prs_debug(ps, depth, desc, "reg_io_r_flush_key");
118 prs_uint32("status", ps, depth, &(r_r->status));
123 /*******************************************************************
125 ********************************************************************/
126 void make_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
127 char *name, char *class,
128 SEC_INFO *sam_access)
130 int len_name = name != NULL ? strlen(name ) + 1: 0;
131 int len_class = class != NULL ? strlen(class) + 1: 0;
133 static unsigned char data[] =
135 0x01, 0x00, 0x00, 0x80,
136 0x00, 0x00, 0x00, 0x00,
137 0x00, 0x00, 0x00, 0x00,
138 0x00, 0x00, 0x00, 0x00,
139 0x00, 0x00, 0x00, 0x00
144 memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
146 make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
147 make_unistr2(&(q_c->uni_name), name, len_name);
149 make_uni_hdr(&(q_c->hdr_class), len_class, len_class, 1);
150 make_unistr2(&(q_c->uni_class), class, len_class);
152 q_c->reserved = 0x00000000;
153 memcpy(&(q_c->sam_access), sam_access, sizeof(q_c->sam_access));
156 q_c->unknown_0 = 0x0000000C;
159 q_c->sec_len1 = 0x14;
160 q_c->sec_len2 = 0x14;
162 q_c->sec_len4 = 0x14;
164 q_c->sec_len6 = 0x14;
166 memcpy(&q_c->buf_unk, data, sizeof(q_c->buf_unk));
168 q_c->unknown_2 = 0x00000000;
171 /*******************************************************************
172 reads or writes a structure.
173 ********************************************************************/
174 void reg_io_q_create_key(char *desc, REG_Q_CREATE_KEY *r_q, prs_struct *ps, int depth)
176 if (r_q == NULL) return;
178 prs_debug(ps, depth, desc, "reg_io_q_create_key");
183 smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
185 smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
186 smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
189 smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
190 smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
193 prs_uint32("reserved", ps, depth, &(r_q->reserved));
194 sec_io_info("sam_access", &r_q->sam_access, ps, depth);
196 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
199 prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
202 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
205 prs_uint32("sec_len1", ps, depth, &(r_q->sec_len1));
206 prs_uint32("sec_len2", ps, depth, &(r_q->sec_len2));
207 prs_uint32("sec_len3", ps, depth, &(r_q->sec_len3));
208 prs_uint32("sec_len4", ps, depth, &(r_q->sec_len4));
209 prs_uint32("sec_len5", ps, depth, &(r_q->sec_len5));
210 prs_uint32("sec_len6", ps, depth, &(r_q->sec_len6));
211 prs_uint8s(False, "buf_unk", ps, depth, r_q->buf_unk, sizeof(r_q->buf_unk));
214 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
221 /*******************************************************************
222 reads or writes a structure.
223 ********************************************************************/
224 void reg_io_r_create_key(char *desc, REG_R_CREATE_KEY *r_r, prs_struct *ps, int depth)
226 if (r_r == NULL) return;
228 prs_debug(ps, depth, desc, "reg_io_r_create_key");
233 smb_io_pol_hnd("", &(r_r->key_pol), ps, depth);
234 prs_uint32("unknown", ps, depth, &(r_r->unknown));
236 prs_uint32("status", ps, depth, &(r_r->status));
240 /*******************************************************************
242 ********************************************************************/
243 void make_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
246 int len_name = name != NULL ? strlen(name ) + 1: 0;
249 memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
251 make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
252 make_unistr2(&(q_c->uni_name), name, len_name);
255 /*******************************************************************
256 reads or writes a structure.
257 ********************************************************************/
258 void reg_io_q_delete_val(char *desc, REG_Q_DELETE_VALUE *r_q, prs_struct *ps, int depth)
260 if (r_q == NULL) return;
262 prs_debug(ps, depth, desc, "reg_io_q_delete_val");
267 smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
269 smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
270 smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
275 /*******************************************************************
276 reads or writes a structure.
277 ********************************************************************/
278 void reg_io_r_delete_val(char *desc, REG_R_DELETE_VALUE *r_r, prs_struct *ps, int depth)
280 if (r_r == NULL) return;
282 prs_debug(ps, depth, desc, "reg_io_r_delete_val");
287 prs_uint32("status", ps, depth, &(r_r->status));
291 /*******************************************************************
293 ********************************************************************/
294 void make_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
297 int len_name = name != NULL ? strlen(name ) + 1: 0;
300 memcpy(&(q_c->pnt_pol), hnd, sizeof(q_c->pnt_pol));
302 make_uni_hdr(&(q_c->hdr_name), len_name, len_name, 1);
303 make_unistr2(&(q_c->uni_name), name, len_name);
306 /*******************************************************************
307 reads or writes a structure.
308 ********************************************************************/
309 void reg_io_q_delete_key(char *desc, REG_Q_DELETE_KEY *r_q, prs_struct *ps, int depth)
311 if (r_q == NULL) return;
313 prs_debug(ps, depth, desc, "reg_io_q_delete_key");
318 smb_io_pol_hnd("", &(r_q->pnt_pol), ps, depth);
320 smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
321 smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
326 /*******************************************************************
327 reads or writes a structure.
328 ********************************************************************/
329 void reg_io_r_delete_key(char *desc, REG_R_DELETE_KEY *r_r, prs_struct *ps, int depth)
331 if (r_r == NULL) return;
333 prs_debug(ps, depth, desc, "reg_io_r_delete_key");
338 prs_uint32("status", ps, depth, &(r_r->status));
342 /*******************************************************************
344 ********************************************************************/
345 void make_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd,
346 uint32 max_class_len)
350 memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
351 make_uni_hdr(&q_o->hdr_class, max_class_len, 0, max_class_len > 0 ? 1 : 0);
352 q_o->uni_class.uni_max_len = max_class_len;
355 /*******************************************************************
356 reads or writes a structure.
357 ********************************************************************/
358 void reg_io_q_query_key(char *desc, REG_Q_QUERY_KEY *r_q, prs_struct *ps, int depth)
360 if (r_q == NULL) return;
362 prs_debug(ps, depth, desc, "reg_io_q_query_key");
367 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
368 smb_io_unihdr ("", &(r_q->hdr_class), ps, depth);
369 smb_io_unistr2("", &(r_q->uni_class), r_q->hdr_class.buffer, ps, depth);
375 /*******************************************************************
376 reads or writes a structure.
377 ********************************************************************/
378 void reg_io_r_query_key(char *desc, REG_R_QUERY_KEY *r_r, prs_struct *ps, int depth)
380 if (r_r == NULL) return;
382 prs_debug(ps, depth, desc, "reg_io_r_query_key");
387 smb_io_unihdr ("", &(r_r->hdr_class), ps, depth);
388 smb_io_unistr2("", &(r_r->uni_class), r_r->hdr_class.buffer, ps, depth);
392 prs_uint32("num_subkeys ", ps, depth, &(r_r->num_subkeys ));
393 prs_uint32("max_subkeylen ", ps, depth, &(r_r->max_subkeylen ));
394 prs_uint32("mak_subkeysize", ps, depth, &(r_r->max_subkeysize));
395 prs_uint32("num_values ", ps, depth, &(r_r->num_values ));
396 prs_uint32("max_valnamelen", ps, depth, &(r_r->max_valnamelen));
397 prs_uint32("max_valbufsize", ps, depth, &(r_r->max_valbufsize));
398 prs_uint32("sec_desc ", ps, depth, &(r_r->sec_desc ));
399 smb_io_time("mod_time ", &(r_r->mod_time), ps, depth);
401 prs_uint32("status", ps, depth, &(r_r->status));
405 /*******************************************************************
407 ********************************************************************/
408 void make_reg_q_unk_1a(REG_Q_UNK_1A *q_o, POLICY_HND *hnd)
410 memcpy(&(q_o->pol), hnd, sizeof(q_o->pol));
413 /*******************************************************************
414 reads or writes a structure.
415 ********************************************************************/
416 void reg_io_q_unk_1a(char *desc, REG_Q_UNK_1A *r_q, prs_struct *ps, int depth)
418 if (r_q == NULL) return;
420 prs_debug(ps, depth, desc, "reg_io_q_unk_1a");
425 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
429 /*******************************************************************
430 reads or writes a structure.
431 ********************************************************************/
432 void reg_io_r_unk_1a(char *desc, REG_R_UNK_1A *r_r, prs_struct *ps, int depth)
434 if (r_r == NULL) return;
436 prs_debug(ps, depth, desc, "reg_io_r_unk_1a");
441 prs_uint32("unknown", ps, depth, &(r_r->unknown));
442 prs_uint32("status" , ps, depth, &(r_r->status ));
446 /*******************************************************************
448 ********************************************************************/
449 void make_reg_q_open_hku(REG_Q_OPEN_HKU *q_o,
450 uint16 unknown_0, uint32 level)
453 q_o->unknown_0 = unknown_0;
454 q_o->unknown_1 = 0x0; /* random - changes */
458 /*******************************************************************
459 reads or writes a structure.
460 ********************************************************************/
461 void reg_io_q_open_hku(char *desc, REG_Q_OPEN_HKU *r_q, prs_struct *ps, int depth)
463 if (r_q == NULL) return;
465 prs_debug(ps, depth, desc, "reg_io_q_open_hku");
470 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
473 prs_uint16("unknown_0", ps, depth, &(r_q->unknown_0));
474 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
475 prs_uint32("level ", ps, depth, &(r_q->level ));
480 /*******************************************************************
481 reads or writes a structure.
482 ********************************************************************/
483 void reg_io_r_open_hku(char *desc, REG_R_OPEN_HKU *r_r, prs_struct *ps, int depth)
485 if (r_r == NULL) return;
487 prs_debug(ps, depth, desc, "reg_io_r_open_hku");
492 smb_io_pol_hnd("", &(r_r->pol), ps, depth);
494 prs_uint32("status", ps, depth, &(r_r->status));
498 /*******************************************************************
499 makes an REG_Q_CLOSE structure.
500 ********************************************************************/
501 void make_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
503 if (q_c == NULL || hnd == NULL) return;
505 DEBUG(5,("make_reg_q_close\n"));
507 memcpy(&(q_c->pol), hnd, sizeof(q_c->pol));
510 /*******************************************************************
511 reads or writes a structure.
512 ********************************************************************/
513 void reg_io_q_close(char *desc, REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
515 if (q_u == NULL) return;
517 prs_debug(ps, depth, desc, "reg_io_q_unknown_1");
522 smb_io_pol_hnd("", &(q_u->pol), ps, depth);
526 /*******************************************************************
527 reads or writes a structure.
528 ********************************************************************/
529 void reg_io_r_close(char *desc, REG_R_CLOSE *r_u, prs_struct *ps, int depth)
531 if (r_u == NULL) return;
533 prs_debug(ps, depth, desc, "reg_io_r_unknown_1");
538 smb_io_pol_hnd("", &(r_u->pol), ps, depth);
541 prs_uint32("status", ps, depth, &(r_u->status));
544 /*******************************************************************
546 ********************************************************************/
547 void make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
548 uint32 buf_len, SEC_DESC_BUF *sec_buf)
550 if (q_i == NULL) return;
552 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
559 make_buf_hdr(&(q_i->hdr_sec), buf_len, 0);
560 make_sec_desc_buf(q_i->data, buf_len, 0);
563 /*******************************************************************
564 reads or writes a structure.
565 ********************************************************************/
566 void reg_io_q_get_key_sec(char *desc, REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
568 if (r_q == NULL) return;
570 prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
575 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
577 prs_uint32("unknown", ps, depth, &(r_q->unknown));
578 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
582 smb_io_hdrbuf ("hdr_sec", &(r_q->hdr_sec), ps, depth);
583 sec_io_desc_buf("data ", r_q->data , ps, depth);
589 /*******************************************************************
591 ********************************************************************/
592 void make_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
593 uint32 buf_len, uint8 *buf,
596 if (r_i == NULL) return;
599 make_buf_hdr(&(r_i->hdr_sec), buf_len, buf_len);
600 make_sec_desc_buf(r_i->data, buf_len, 1);
602 r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
605 /*******************************************************************
606 reads or writes a structure.
607 ********************************************************************/
608 void reg_io_r_get_key_sec(char *desc, REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
610 if (r_q == NULL) return;
612 prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
617 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
621 smb_io_hdrbuf("", &(r_q->hdr_sec), ps, depth);
622 sec_io_desc_buf("", r_q->data, ps, depth);
627 prs_uint32("status", ps, depth, &(r_q->status));
631 /*******************************************************************
633 ********************************************************************/
634 void make_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char *product_type,
635 time_t unix_time, uint8 major, uint8 minor)
637 int len_type = strlen(product_type);
639 if (q_i == NULL) return;
641 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
643 make_uni_hdr(&(q_i->hdr_type), len_type, len_type, 1);
644 make_unistr2(&(q_i->uni_type), product_type, len_type);
647 unix_to_nt_time(&(q_i->time), unix_time);
648 q_i->major_version1 = major;
649 q_i->minor_version1 = minor;
650 memset(q_i->pad1, 0, sizeof(q_i->pad1));
653 q_i->major_version2 = major;
654 q_i->minor_version2 = minor;
655 memset(q_i->pad2, 0, sizeof(q_i->pad2));
658 q_i->unknown = 0x00000000;
661 /*******************************************************************
662 reads or writes a structure.
663 ********************************************************************/
664 void reg_io_q_info(char *desc, REG_Q_INFO *r_q, prs_struct *ps, int depth)
666 if (r_q == NULL) return;
668 prs_debug(ps, depth, desc, "reg_io_q_info");
673 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
674 smb_io_unihdr ("", &(r_q->hdr_type), ps, depth);
675 smb_io_unistr2("", &(r_q->uni_type), r_q->hdr_type.buffer, ps, depth);
679 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
683 smb_io_time("", &(r_q->time), ps, depth);
684 prs_uint8 ("major_version1", ps, depth, &(r_q->major_version1));
685 prs_uint8 ("minor_version1", ps, depth, &(r_q->minor_version1));
686 prs_uint8s(False, "pad1", ps, depth, r_q->pad1, sizeof(r_q->pad1));
689 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
693 prs_uint8 ("major_version2", ps, depth, &(r_q->major_version2));
694 prs_uint8 ("minor_version2", ps, depth, &(r_q->minor_version2));
695 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
698 prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
702 prs_uint32("unknown", ps, depth, &(r_q->unknown));
707 /*******************************************************************
709 ********************************************************************/
710 void make_reg_r_info(REG_R_INFO *r_r,
711 uint32 level, char *os_type,
712 uint32 unknown_0, uint32 unknown_1,
716 int len = struni2((uint16*)buf, os_type);
722 make_buffer2(&(r_r->uni_type), buf, len*2);
725 r_r->unknown_0 = unknown_0;
728 r_r->unknown_1 = unknown_1;
730 r_r->status = status;
733 /*******************************************************************
734 reads or writes a structure.
735 ********************************************************************/
736 void reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
738 if (r_r == NULL) return;
740 prs_debug(ps, depth, desc, "reg_io_r_info");
745 prs_uint32("ptr1", ps, depth, &(r_r->ptr1));
749 prs_uint32("level", ps, depth, &(r_r->level));
750 prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type));
752 smb_io_buffer2("uni_type", &(r_r->uni_type), r_r->ptr_type, ps, depth);
754 prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
758 prs_uint32("unknown_0", ps, depth, &(r_r->unknown_0));
761 prs_uint32("ptr3", ps, depth, &(r_r->ptr3));
765 prs_uint32("unknown_1", ps, depth, &(r_r->unknown_1));
769 prs_uint32("status", ps, depth, &(r_r->status));
772 /*******************************************************************
774 ********************************************************************/
775 void make_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
776 uint32 val_idx, uint32 max_val_len,
779 if (q_i == NULL) return;
783 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
785 q_i->val_index = val_idx;
786 make_uni_hdr(&q_i->hdr_name, max_val_len, 0, 1);
787 q_i->uni_name.uni_max_len = max_val_len;
793 q_i->buf_value.buf_max_len = max_buf_len;
796 q_i->len_value1 = max_buf_len;
802 /*******************************************************************
803 reads or writes a structure.
804 ********************************************************************/
805 void reg_io_q_enum_val(char *desc, REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
807 if (q_q == NULL) return;
809 prs_debug(ps, depth, desc, "reg_io_q_enum_val");
814 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
816 prs_uint32("val_index", ps, depth, &(q_q->val_index));
817 smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
818 smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
821 prs_uint32("ptr_type", ps, depth, &(q_q->ptr_type));
823 if (q_q->ptr_type != 0)
825 prs_uint32("type", ps, depth, &(q_q->type));
828 prs_uint32("ptr_value", ps, depth, &(q_q->ptr_value));
829 smb_io_buffer2("buf_value", &(q_q->buf_value), q_q->ptr_value, ps, depth);
832 prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
835 prs_uint32("len_value1", ps, depth, &(q_q->len_value1));
837 prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
840 prs_uint32("len_value2", ps, depth, &(q_q->len_value2));
844 /*******************************************************************
845 reads or writes a structure.
846 ********************************************************************/
847 void reg_io_r_enum_val(char *desc, REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
849 if (r_q == NULL) return;
851 prs_debug(ps, depth, desc, "reg_io_r_enum_val");
856 smb_io_unihdr ("hdr_name", &(r_q->hdr_name), ps, depth);
857 smb_io_unistr2("uni_name", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
860 prs_uint32("ptr_type", ps, depth, &(r_q->ptr_type));
862 if (r_q->ptr_type != 0)
864 prs_uint32("type", ps, depth, &(r_q->type));
867 prs_uint32("ptr_value", ps, depth, &(r_q->ptr_value));
868 smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth);
871 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
874 prs_uint32("len_value1", ps, depth, &(r_q->len_value1));
877 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
880 prs_uint32("len_value2", ps, depth, &(r_q->len_value2));
883 prs_uint32("status", ps, depth, &(r_q->status));
886 /*******************************************************************
888 ********************************************************************/
889 void make_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
890 char *val_name, uint32 type,
893 int val_len = strlen(val_name) + 1;
895 if (q_i == NULL) return;
899 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
901 make_uni_hdr(&q_i->hdr_name, val_len, val_len, 1);
902 make_unistr2(&(q_i->uni_name), val_name, val_len);
905 q_i->buf_value = val;
908 /*******************************************************************
909 reads or writes a structure.
910 ********************************************************************/
911 void reg_io_q_create_val(char *desc, REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
913 if (q_q == NULL) return;
915 prs_debug(ps, depth, desc, "reg_io_q_create_val");
920 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
922 smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
923 smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
926 prs_uint32("type", ps, depth, &(q_q->type));
927 smb_io_buffer3("buf_value", q_q->buf_value, ps, depth);
931 /*******************************************************************
932 reads or writes a structure.
933 ********************************************************************/
934 void reg_io_r_create_val(char *desc, REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
936 if (r_q == NULL) return;
938 prs_debug(ps, depth, desc, "reg_io_r_create_val");
943 prs_uint32("status", ps, depth, &(r_q->status));
946 /*******************************************************************
948 ********************************************************************/
949 void make_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
951 if (q_i == NULL) return;
953 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
955 q_i->key_index = key_idx;
956 q_i->key_name_len = 0;
957 q_i->unknown_1 = 0x0414;
960 q_i->unknown_2 = 0x0000020A;
961 memset(q_i->pad1, 0, sizeof(q_i->pad1));
964 memset(q_i->pad2, 0, sizeof(q_i->pad2));
967 unix_to_nt_time(&q_i->time, 0); /* current time? */
970 /*******************************************************************
971 reads or writes a structure.
972 ********************************************************************/
973 void reg_io_q_enum_key(char *desc, REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
975 if (q_q == NULL) return;
977 prs_debug(ps, depth, desc, "reg_io_q_enum_key");
982 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
984 prs_uint32("key_index", ps, depth, &(q_q->key_index));
985 prs_uint16("key_name_len", ps, depth, &(q_q->key_name_len));
986 prs_uint16("unknown_1", ps, depth, &(q_q->unknown_1));
988 prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
992 prs_uint32("unknown_2", ps, depth, &(q_q->unknown_2));
993 prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1));
996 prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
1000 prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2));
1003 prs_uint32("ptr3", ps, depth, &(q_q->ptr3));
1007 smb_io_time("", &(q_q->time), ps, depth);
1011 /*******************************************************************
1012 reads or writes a structure.
1013 ********************************************************************/
1014 void reg_io_r_enum_key(char *desc, REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1016 if (r_q == NULL) return;
1018 prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1023 prs_uint16("key_name_len", ps, depth, &(r_q->key_name_len));
1024 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
1026 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
1030 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
1031 prs_uint32("unknown_3", ps, depth, &(r_q->unknown_3));
1032 smb_io_unistr3("key_name", &(r_q->key_name), ps, depth);
1036 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
1040 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
1043 prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
1047 smb_io_time("", &(r_q->time), ps, depth);
1050 prs_uint32("status", ps, depth, &(r_q->status));
1054 /*******************************************************************
1056 ********************************************************************/
1057 void make_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1058 char *key_name, uint32 unk)
1060 int len_name = strlen(key_name)+1;
1062 if (r_q == NULL) return;
1064 memcpy(&(r_q->pol), pol, sizeof(r_q->pol));
1066 make_uni_hdr(&(r_q->hdr_name), len_name, len_name, 1);
1067 make_unistr2(&(r_q->uni_name), key_name, len_name);
1069 r_q->unknown_0 = 0x00000000;
1070 r_q->unknown_1 = unk;
1073 /*******************************************************************
1074 reads or writes a structure.
1075 ********************************************************************/
1076 void reg_io_q_open_entry(char *desc, REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1078 if (r_q == NULL) return;
1080 prs_debug(ps, depth, desc, "reg_io_q_entry");
1085 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
1086 smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
1087 smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1091 prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
1092 prs_uint32("unknown_1", ps, depth, &(r_q->unknown_1));
1096 /*******************************************************************
1097 creates a structure.
1098 ********************************************************************/
1099 void make_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1100 POLICY_HND *pol, uint32 status)
1102 if (r_r == NULL) return;
1104 memcpy(&(r_r->pol), pol, sizeof(r_r->pol));
1105 r_r->status = status;
1108 /*******************************************************************
1109 reads or writes a structure.
1110 ********************************************************************/
1111 void reg_io_r_open_entry(char *desc, REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1113 if (r_r == NULL) return;
1115 prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1120 smb_io_pol_hnd("", &(r_r->pol), ps, depth);
1122 prs_uint32("status", ps, depth, &(r_r->status));