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 ********************************************************************/
34 void init_reg_q_open_hklm(REG_Q_OPEN_HKLM *q_o,
35 uint16 unknown_0, uint32 level)
38 q_o->unknown_0 = unknown_0;
39 q_o->unknown_1 = 0x0; /* random - changes */
43 /*******************************************************************
44 reads or writes a structure.
45 ********************************************************************/
47 BOOL reg_io_q_open_hklm(char *desc, REG_Q_OPEN_HKLM *r_q, prs_struct *ps, int depth)
52 prs_debug(ps, depth, desc, "reg_io_q_open_hklm");
58 if(!prs_uint32("ptr ", ps, depth, &r_q->ptr))
62 if(!prs_uint16("unknown_0", ps, depth, &r_q->unknown_0))
64 if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
66 if(!prs_uint32("level ", ps, depth, &r_q->level))
74 /*******************************************************************
75 reads or writes a structure.
76 ********************************************************************/
78 BOOL reg_io_r_open_hklm(char *desc, REG_R_OPEN_HKLM *r_r, prs_struct *ps, int depth)
83 prs_debug(ps, depth, desc, "reg_io_r_open_hklm");
89 if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
92 if(!prs_uint32("status", ps, depth, &r_r->status))
99 /*******************************************************************
101 ********************************************************************/
103 void init_reg_q_flush_key(REG_Q_FLUSH_KEY *q_u, POLICY_HND *pol)
105 memcpy(&q_u->pol, pol, sizeof(q_u->pol));
108 /*******************************************************************
109 reads or writes a structure.
110 ********************************************************************/
112 BOOL reg_io_q_flush_key(char *desc, REG_Q_FLUSH_KEY *r_q, prs_struct *ps, int depth)
117 prs_debug(ps, depth, desc, "reg_io_q_flush_key");
123 if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
129 /*******************************************************************
130 reads or writes a structure.
131 ********************************************************************/
133 BOOL reg_io_r_flush_key(char *desc, REG_R_FLUSH_KEY *r_r, prs_struct *ps, int depth)
138 prs_debug(ps, depth, desc, "reg_io_r_flush_key");
144 if(!prs_uint32("status", ps, depth, &r_r->status))
150 /*******************************************************************
151 reads or writes SEC_DESC_BUF and SEC_DATA structures.
152 ********************************************************************/
154 static BOOL reg_io_hdrbuf_sec(uint32 ptr, uint32 *ptr3, BUFHDR *hdr_sec, SEC_DESC_BUF *data, prs_struct *ps, int depth)
159 if(!smb_io_hdrbuf_pre("hdr_sec", hdr_sec, ps, depth, &hdr_offset))
162 old_offset = prs_offset(ps);
165 if(!prs_uint32("ptr3", ps, depth, ptr3))
169 if (ptr3 == NULL || *ptr3 != 0) {
170 if(!sec_io_desc_buf("data ", &data, ps, depth)) /* JRA - this line is probably wrong... */
174 if(!smb_io_hdrbuf_post("hdr_sec", hdr_sec, ps, depth, hdr_offset,
175 data->max_len, data->len))
177 if(!prs_set_offset(ps, old_offset + data->len + sizeof(uint32) * ((ptr3 != NULL) ? 5 : 3)))
187 /*******************************************************************
189 ********************************************************************/
191 void init_reg_q_create_key(REG_Q_CREATE_KEY *q_c, POLICY_HND *hnd,
192 char *name, char *class, SEC_ACCESS *sam_access,
193 SEC_DESC_BUF *sec_buf)
195 int len_name = name != NULL ? strlen(name ) + 1: 0;
196 int len_class = class != NULL ? strlen(class) + 1: 0;
200 memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
202 init_uni_hdr(&q_c->hdr_name, len_name);
203 init_unistr2(&q_c->uni_name, name, len_name);
205 init_uni_hdr(&q_c->hdr_class, len_class);
206 init_unistr2(&q_c->uni_class, class, len_class);
208 q_c->reserved = 0x00000000;
209 memcpy(&q_c->sam_access, sam_access, sizeof(q_c->sam_access));
212 q_c->sec_info = DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION;
216 init_buf_hdr(&q_c->hdr_sec, sec_buf->len, sec_buf->len);
218 q_c->unknown_2 = 0x00000000;
221 /*******************************************************************
222 reads or writes a structure.
223 ********************************************************************/
225 BOOL reg_io_q_create_key(char *desc, REG_Q_CREATE_KEY *r_q, prs_struct *ps, int depth)
230 prs_debug(ps, depth, desc, "reg_io_q_create_key");
236 if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
239 if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
241 if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
246 if(!smb_io_unihdr ("", &r_q->hdr_class, ps, depth))
248 if(!smb_io_unistr2("", &r_q->uni_class, r_q->hdr_class.buffer, ps, depth))
253 if(!prs_uint32("reserved", ps, depth, &r_q->reserved))
255 if(!sec_io_access("sam_access", &r_q->sam_access, ps, depth))
258 if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
261 if (r_q->ptr1 != 0) {
262 if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
266 if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
268 if(!reg_io_hdrbuf_sec(r_q->ptr2, &r_q->ptr3, &r_q->hdr_sec, r_q->data, ps, depth))
271 if(!prs_uint32("unknown_2", ps, depth, &r_q->unknown_2))
277 /*******************************************************************
278 reads or writes a structure.
279 ********************************************************************/
281 BOOL reg_io_r_create_key(char *desc, REG_R_CREATE_KEY *r_r, prs_struct *ps, int depth)
286 prs_debug(ps, depth, desc, "reg_io_r_create_key");
292 if(!smb_io_pol_hnd("", &r_r->key_pol, ps, depth))
294 if(!prs_uint32("unknown", ps, depth, &r_r->unknown))
297 if(!prs_uint32("status", ps, depth, &r_r->status))
304 /*******************************************************************
306 ********************************************************************/
308 void init_reg_q_delete_val(REG_Q_DELETE_VALUE *q_c, POLICY_HND *hnd,
311 int len_name = name != NULL ? strlen(name ) + 1: 0;
314 memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
316 init_uni_hdr(&q_c->hdr_name, len_name);
317 init_unistr2(&q_c->uni_name, name, len_name);
320 /*******************************************************************
321 reads or writes a structure.
322 ********************************************************************/
324 BOOL reg_io_q_delete_val(char *desc, REG_Q_DELETE_VALUE *r_q, prs_struct *ps, int depth)
329 prs_debug(ps, depth, desc, "reg_io_q_delete_val");
335 if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
338 if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
340 if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
349 /*******************************************************************
350 reads or writes a structure.
351 ********************************************************************/
353 BOOL reg_io_r_delete_val(char *desc, REG_R_DELETE_VALUE *r_r, prs_struct *ps, int depth)
358 prs_debug(ps, depth, desc, "reg_io_r_delete_val");
364 if(!prs_uint32("status", ps, depth, &r_r->status))
370 /*******************************************************************
372 ********************************************************************/
374 void init_reg_q_delete_key(REG_Q_DELETE_KEY *q_c, POLICY_HND *hnd,
377 int len_name = name != NULL ? strlen(name ) + 1: 0;
380 memcpy(&q_c->pnt_pol, hnd, sizeof(q_c->pnt_pol));
382 init_uni_hdr(&q_c->hdr_name, len_name);
383 init_unistr2(&q_c->uni_name, name, len_name);
386 /*******************************************************************
387 reads or writes a structure.
388 ********************************************************************/
390 BOOL reg_io_q_delete_key(char *desc, REG_Q_DELETE_KEY *r_q, prs_struct *ps, int depth)
395 prs_debug(ps, depth, desc, "reg_io_q_delete_key");
401 if(!smb_io_pol_hnd("", &r_q->pnt_pol, ps, depth))
404 if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
406 if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
414 /*******************************************************************
415 reads or writes a structure.
416 ********************************************************************/
418 BOOL reg_io_r_delete_key(char *desc, REG_R_DELETE_KEY *r_r, prs_struct *ps, int depth)
423 prs_debug(ps, depth, desc, "reg_io_r_delete_key");
429 if(!prs_uint32("status", ps, depth, &r_r->status))
435 /*******************************************************************
437 ********************************************************************/
439 void init_reg_q_query_key(REG_Q_QUERY_KEY *q_o, POLICY_HND *hnd,
440 uint32 max_class_len)
444 memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
445 init_uni_hdr(&q_o->hdr_class, max_class_len);
446 q_o->uni_class.uni_max_len = max_class_len;
449 /*******************************************************************
450 reads or writes a structure.
451 ********************************************************************/
453 BOOL reg_io_q_query_key(char *desc, REG_Q_QUERY_KEY *r_q, prs_struct *ps, int depth)
458 prs_debug(ps, depth, desc, "reg_io_q_query_key");
464 if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
466 if(!smb_io_unihdr ("", &r_q->hdr_class, ps, depth))
468 if(!smb_io_unistr2("", &r_q->uni_class, r_q->hdr_class.buffer, ps, depth))
478 /*******************************************************************
479 reads or writes a structure.
480 ********************************************************************/
482 BOOL reg_io_r_query_key(char *desc, REG_R_QUERY_KEY *r_r, prs_struct *ps, int depth)
487 prs_debug(ps, depth, desc, "reg_io_r_query_key");
493 if(!smb_io_unihdr ("", &r_r->hdr_class, ps, depth))
495 if(!smb_io_unistr2("", &r_r->uni_class, r_r->hdr_class.buffer, ps, depth))
501 if(!prs_uint32("num_subkeys ", ps, depth, &r_r->num_subkeys))
503 if(!prs_uint32("max_subkeylen ", ps, depth, &r_r->max_subkeylen))
505 if(!prs_uint32("mak_subkeysize", ps, depth, &r_r->max_subkeysize))
507 if(!prs_uint32("num_values ", ps, depth, &r_r->num_values))
509 if(!prs_uint32("max_valnamelen", ps, depth, &r_r->max_valnamelen))
511 if(!prs_uint32("max_valbufsize", ps, depth, &r_r->max_valbufsize))
513 if(!prs_uint32("sec_desc ", ps, depth, &r_r->sec_desc))
515 if(!smb_io_time("mod_time ", &r_r->mod_time, ps, depth))
518 if(!prs_uint32("status", ps, depth, &r_r->status))
524 /*******************************************************************
526 ********************************************************************/
528 void init_reg_q_unk_1a(REG_Q_UNK_1A *q_o, POLICY_HND *hnd)
530 memcpy(&q_o->pol, hnd, sizeof(q_o->pol));
533 /*******************************************************************
534 reads or writes a structure.
535 ********************************************************************/
537 BOOL reg_io_q_unk_1a(char *desc, REG_Q_UNK_1A *r_q, prs_struct *ps, int depth)
542 prs_debug(ps, depth, desc, "reg_io_q_unk_1a");
548 if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
554 /*******************************************************************
555 reads or writes a structure.
556 ********************************************************************/
558 BOOL reg_io_r_unk_1a(char *desc, REG_R_UNK_1A *r_r, prs_struct *ps, int depth)
563 prs_debug(ps, depth, desc, "reg_io_r_unk_1a");
569 if(!prs_uint32("unknown", ps, depth, &r_r->unknown))
571 if(!prs_uint32("status" , ps, depth, &r_r->status))
577 /*******************************************************************
579 ********************************************************************/
581 void init_reg_q_open_hku(REG_Q_OPEN_HKU *q_o,
582 uint16 unknown_0, uint32 level)
585 q_o->unknown_0 = unknown_0;
586 q_o->unknown_1 = 0x0; /* random - changes */
590 /*******************************************************************
591 reads or writes a structure.
592 ********************************************************************/
594 BOOL reg_io_q_open_hku(char *desc, REG_Q_OPEN_HKU *r_q, prs_struct *ps, int depth)
599 prs_debug(ps, depth, desc, "reg_io_q_open_hku");
605 if(!prs_uint32("ptr ", ps, depth, &r_q->ptr))
608 if(!prs_uint16("unknown_0", ps, depth, &r_q->unknown_0))
610 if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
612 if(!prs_uint32("level ", ps, depth, &r_q->level))
619 /*******************************************************************
620 reads or writes a structure.
621 ********************************************************************/
623 BOOL reg_io_r_open_hku(char *desc, REG_R_OPEN_HKU *r_r, prs_struct *ps, int depth)
628 prs_debug(ps, depth, desc, "reg_io_r_open_hku");
634 if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
637 if(!prs_uint32("status", ps, depth, &r_r->status))
643 /*******************************************************************
644 Inits an REG_Q_CLOSE structure.
645 ********************************************************************/
647 void init_reg_q_close(REG_Q_CLOSE *q_c, POLICY_HND *hnd)
649 DEBUG(5,("init_reg_q_close\n"));
651 memcpy(&q_c->pol, hnd, sizeof(q_c->pol));
654 /*******************************************************************
655 reads or writes a structure.
656 ********************************************************************/
658 BOOL reg_io_q_close(char *desc, REG_Q_CLOSE *q_u, prs_struct *ps, int depth)
663 prs_debug(ps, depth, desc, "reg_io_q_unknown_1");
669 if(!smb_io_pol_hnd("", &q_u->pol, ps, depth))
677 /*******************************************************************
678 reads or writes a structure.
679 ********************************************************************/
681 BOOL reg_io_r_close(char *desc, REG_R_CLOSE *r_u, prs_struct *ps, int depth)
686 prs_debug(ps, depth, desc, "reg_io_r_unknown_1");
692 if(!smb_io_pol_hnd("", &r_u->pol, ps, depth))
697 if(!prs_uint32("status", ps, depth, &r_u->status))
703 /*******************************************************************
705 ********************************************************************/
707 void init_reg_q_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol, SEC_DESC_BUF *sec_desc_buf)
709 memcpy(&q_i->pol, pol, sizeof(q_i->pol));
711 q_i->sec_info = DACL_SECURITY_INFORMATION;
714 init_buf_hdr(&q_i->hdr_sec, sec_desc_buf->len, sec_desc_buf->len);
715 q_i->data = sec_desc_buf;
718 /*******************************************************************
719 reads or writes a structure.
720 ********************************************************************/
722 BOOL reg_io_q_set_key_sec(char *desc, REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
727 prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
733 if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
736 if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
738 if(!prs_uint32("ptr ", ps, depth, &r_q->ptr))
741 if(!reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth))
747 /*******************************************************************
748 reads or writes a structure.
749 ********************************************************************/
751 BOOL reg_io_r_set_key_sec(char *desc, REG_R_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
756 prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
762 if(!prs_uint32("status", ps, depth, &r_q->status))
769 /*******************************************************************
771 ********************************************************************/
773 void init_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
774 uint32 sec_buf_size, SEC_DESC_BUF *psdb)
776 memcpy(&q_i->pol, pol, sizeof(q_i->pol));
778 q_i->sec_info = OWNER_SECURITY_INFORMATION |
779 GROUP_SECURITY_INFORMATION |
780 DACL_SECURITY_INFORMATION;
782 q_i->ptr = psdb != NULL ? 1 : 0;
785 init_buf_hdr(&q_i->hdr_sec, sec_buf_size, 0);
788 /*******************************************************************
789 reads or writes a structure.
790 ********************************************************************/
792 BOOL reg_io_q_get_key_sec(char *desc, REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
797 prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
803 if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
806 if(!prs_uint32("sec_info", ps, depth, &r_q->sec_info))
808 if(!prs_uint32("ptr ", ps, depth, &r_q->ptr))
811 if(!reg_io_hdrbuf_sec(r_q->ptr, NULL, &r_q->hdr_sec, r_q->data, ps, depth))
818 /*******************************************************************
820 ********************************************************************/
821 void init_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
822 uint32 buf_len, uint8 *buf,
826 init_buf_hdr(&r_i->hdr_sec, buf_len, buf_len);
827 init_sec_desc_buf(r_i->data, buf_len, 1);
829 r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
833 /*******************************************************************
834 reads or writes a structure.
835 ********************************************************************/
837 BOOL reg_io_r_get_key_sec(char *desc, REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
842 prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
848 if(!prs_uint32("ptr ", ps, depth, &r_q->ptr))
852 if(!smb_io_hdrbuf("", &r_q->hdr_sec, ps, depth))
854 if(!sec_io_desc_buf("", &r_q->data, ps, depth))
860 if(!prs_uint32("status", ps, depth, &r_q->status))
866 /*******************************************************************
868 ********************************************************************/
870 void init_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char *product_type,
871 time_t unix_time, uint8 major, uint8 minor)
873 int len_type = strlen(product_type);
875 memcpy(&q_i->pol, pol, sizeof(q_i->pol));
877 init_uni_hdr(&q_i->hdr_type, len_type);
878 init_unistr2(&q_i->uni_type, product_type, len_type);
881 unix_to_nt_time(&q_i->time, unix_time);
882 q_i->major_version1 = major;
883 q_i->minor_version1 = minor;
884 memset(q_i->pad1, 0, sizeof(q_i->pad1));
887 q_i->major_version2 = major;
888 q_i->minor_version2 = minor;
889 memset(q_i->pad2, 0, sizeof(q_i->pad2));
892 q_i->unknown = 0x00000000;
895 /*******************************************************************
896 reads or writes a structure.
897 ********************************************************************/
899 BOOL reg_io_q_info(char *desc, REG_Q_INFO *r_q, prs_struct *ps, int depth)
904 prs_debug(ps, depth, desc, "reg_io_q_info");
910 if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
912 if(!smb_io_unihdr ("", &r_q->hdr_type, ps, depth))
914 if(!smb_io_unistr2("", &r_q->uni_type, r_q->hdr_type.buffer, ps, depth))
920 if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
923 if (r_q->ptr1 != 0) {
924 if(!smb_io_time("", &r_q->time, ps, depth))
926 if(!prs_uint8 ("major_version1", ps, depth, &r_q->major_version1))
928 if(!prs_uint8 ("minor_version1", ps, depth, &r_q->minor_version1))
930 if(!prs_uint8s(False, "pad1", ps, depth, r_q->pad1, sizeof(r_q->pad1)))
934 if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
937 if (r_q->ptr2 != 0) {
938 if(!prs_uint8 ("major_version2", ps, depth, &r_q->major_version2))
940 if(!prs_uint8 ("minor_version2", ps, depth, &r_q->minor_version2))
942 if(!prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2)))
946 if(!prs_uint32("ptr3", ps, depth, &r_q->ptr3))
949 if (r_q->ptr3 != 0) {
950 if(!prs_uint32("unknown", ps, depth, &r_q->unknown))
957 /*******************************************************************
959 ********************************************************************/
961 void init_reg_r_info(REG_R_INFO *r_r,
962 uint32 level, char *os_type,
963 uint32 unknown_0, uint32 unknown_1,
967 int len = dos_struni2((char *)buf, os_type, sizeof(buf));
973 init_buffer2(&r_r->uni_type, buf, len*2);
976 r_r->unknown_0 = unknown_0;
979 r_r->unknown_1 = unknown_1;
981 r_r->status = status;
984 /*******************************************************************
985 reads or writes a structure.
986 ********************************************************************/
988 BOOL reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
993 prs_debug(ps, depth, desc, "reg_io_r_info");
999 if(!prs_uint32("ptr1", ps, depth, &r_r->ptr1))
1002 if (r_r->ptr1 != 0) {
1003 if(!prs_uint32("level", ps, depth, &r_r->level))
1005 if(!prs_uint32("ptr_type", ps, depth, &r_r->ptr_type))
1008 if(!smb_io_buffer2("uni_type", &r_r->uni_type, r_r->ptr_type, ps, depth))
1013 if(!prs_uint32("ptr2", ps, depth, &r_r->ptr2))
1016 if (r_r->ptr2 != 0) {
1017 if(!prs_uint32("unknown_0", ps, depth, &r_r->unknown_0))
1021 if(!prs_uint32("ptr3", ps, depth, &r_r->ptr3))
1024 if (r_r->ptr3 != 0) {
1025 if(!prs_uint32("unknown_1", ps, depth, &r_r->unknown_1))
1030 if(!prs_uint32("status", ps, depth, &r_r->status))
1036 /*******************************************************************
1038 ********************************************************************/
1040 void init_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
1041 uint32 val_idx, uint32 max_val_len,
1046 memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1048 q_i->val_index = val_idx;
1049 init_uni_hdr(&q_i->hdr_name, max_val_len);
1050 q_i->uni_name.uni_max_len = max_val_len;
1056 q_i->buf_value.buf_max_len = max_buf_len;
1059 q_i->len_value1 = max_buf_len;
1062 q_i->len_value2 = 0;
1065 /*******************************************************************
1066 reads or writes a structure.
1067 ********************************************************************/
1069 BOOL reg_io_q_enum_val(char *desc, REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
1074 prs_debug(ps, depth, desc, "reg_io_q_enum_val");
1080 if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1083 if(!prs_uint32("val_index", ps, depth, &q_q->val_index))
1085 if(!smb_io_unihdr ("hdr_name", &q_q->hdr_name, ps, depth))
1087 if(!smb_io_unistr2("uni_name", &q_q->uni_name, q_q->hdr_name.buffer, ps, depth))
1092 if(!prs_uint32("ptr_type", ps, depth, &q_q->ptr_type))
1095 if (q_q->ptr_type != 0) {
1096 if(!prs_uint32("type", ps, depth, &q_q->type))
1100 if(!prs_uint32("ptr_value", ps, depth, &q_q->ptr_value))
1102 if(!smb_io_buffer2("buf_value", &q_q->buf_value, q_q->ptr_value, ps, depth))
1107 if(!prs_uint32("ptr1", ps, depth, &q_q->ptr1))
1109 if (q_q->ptr1 != 0) {
1110 if(!prs_uint32("len_value1", ps, depth, &q_q->len_value1))
1113 if(!prs_uint32("ptr2", ps, depth, &q_q->ptr2))
1115 if (q_q->ptr2 != 0) {
1116 if(!prs_uint32("len_value2", ps, depth, &q_q->len_value2))
1123 /*******************************************************************
1124 reads or writes a structure.
1125 ********************************************************************/
1127 BOOL reg_io_r_enum_val(char *desc, REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
1132 prs_debug(ps, depth, desc, "reg_io_r_enum_val");
1138 if(!smb_io_unihdr ("hdr_name", &r_q->hdr_name, ps, depth))
1140 if(!smb_io_unistr2("uni_name", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
1145 if(!prs_uint32("ptr_type", ps, depth, &r_q->ptr_type))
1148 if (r_q->ptr_type != 0) {
1149 if(!prs_uint32("type", ps, depth, &r_q->type))
1153 if(!prs_uint32("ptr_value", ps, depth, &r_q->ptr_value))
1155 if(!smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth))
1160 if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
1162 if (r_q->ptr1 != 0) {
1163 if(!prs_uint32("len_value1", ps, depth, &r_q->len_value1))
1167 if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
1169 if (r_q->ptr2 != 0) {
1170 if(!prs_uint32("len_value2", ps, depth, &r_q->len_value2))
1174 if(!prs_uint32("status", ps, depth, &r_q->status))
1180 /*******************************************************************
1182 ********************************************************************/
1184 void init_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
1185 char *val_name, uint32 type,
1188 int val_len = strlen(val_name) + 1;
1192 memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1194 init_uni_hdr(&q_i->hdr_name, val_len);
1195 init_unistr2(&q_i->uni_name, val_name, val_len);
1198 q_i->buf_value = val;
1201 /*******************************************************************
1202 reads or writes a structure.
1203 ********************************************************************/
1205 BOOL reg_io_q_create_val(char *desc, REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
1210 prs_debug(ps, depth, desc, "reg_io_q_create_val");
1216 if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1219 if(!smb_io_unihdr ("hdr_name", &q_q->hdr_name, ps, depth))
1221 if(!smb_io_unistr2("uni_name", &q_q->uni_name, q_q->hdr_name.buffer, ps, depth))
1226 if(!prs_uint32("type", ps, depth, &q_q->type))
1228 if(!smb_io_buffer3("buf_value", q_q->buf_value, ps, depth))
1236 /*******************************************************************
1237 reads or writes a structure.
1238 ********************************************************************/
1240 BOOL reg_io_r_create_val(char *desc, REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
1245 prs_debug(ps, depth, desc, "reg_io_r_create_val");
1251 if(!prs_uint32("status", ps, depth, &r_q->status))
1257 /*******************************************************************
1259 ********************************************************************/
1261 void init_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
1263 memcpy(&q_i->pol, pol, sizeof(q_i->pol));
1265 q_i->key_index = key_idx;
1266 q_i->key_name_len = 0;
1267 q_i->unknown_1 = 0x0414;
1270 q_i->unknown_2 = 0x0000020A;
1271 memset(q_i->pad1, 0, sizeof(q_i->pad1));
1274 memset(q_i->pad2, 0, sizeof(q_i->pad2));
1277 unix_to_nt_time(&q_i->time, 0); /* current time? */
1280 /*******************************************************************
1281 reads or writes a structure.
1282 ********************************************************************/
1284 BOOL reg_io_q_enum_key(char *desc, REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
1289 prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1295 if(!smb_io_pol_hnd("", &q_q->pol, ps, depth))
1298 if(!prs_uint32("key_index", ps, depth, &q_q->key_index))
1300 if(!prs_uint16("key_name_len", ps, depth, &q_q->key_name_len))
1302 if(!prs_uint16("unknown_1", ps, depth, &q_q->unknown_1))
1305 if(!prs_uint32("ptr1", ps, depth, &q_q->ptr1))
1308 if (q_q->ptr1 != 0) {
1309 if(!prs_uint32("unknown_2", ps, depth, &q_q->unknown_2))
1311 if(!prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1)))
1315 if(!prs_uint32("ptr2", ps, depth, &q_q->ptr2))
1318 if (q_q->ptr2 != 0) {
1319 if(!prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2)))
1323 if(!prs_uint32("ptr3", ps, depth, &q_q->ptr3))
1326 if (q_q->ptr3 != 0) {
1327 if(!smb_io_time("", &q_q->time, ps, depth))
1334 /*******************************************************************
1335 reads or writes a structure.
1336 ********************************************************************/
1338 BOOL reg_io_r_enum_key(char *desc, REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1343 prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1349 if(!prs_uint16("key_name_len", ps, depth, &r_q->key_name_len))
1351 if(!prs_uint16("unknown_1", ps, depth, &r_q->unknown_1))
1354 if(!prs_uint32("ptr1", ps, depth, &r_q->ptr1))
1357 if (r_q->ptr1 != 0) {
1358 if(!prs_uint32("unknown_2", ps, depth, &r_q->unknown_2))
1360 if(!prs_uint32("unknown_3", ps, depth, &r_q->unknown_3))
1362 if(!smb_io_unistr3("key_name", &r_q->key_name, ps, depth))
1368 if(!prs_uint32("ptr2", ps, depth, &r_q->ptr2))
1371 if (r_q->ptr2 != 0) {
1372 if(!prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2)))
1376 if(!prs_uint32("ptr3", ps, depth, &r_q->ptr3))
1379 if (r_q->ptr3 != 0) {
1380 if(!smb_io_time("", &r_q->time, ps, depth))
1384 if(!prs_uint32("status", ps, depth, &r_q->status))
1390 /*******************************************************************
1392 ********************************************************************/
1394 void init_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1395 char *key_name, uint32 unk)
1397 int len_name = strlen(key_name)+1;
1399 memcpy(&r_q->pol, pol, sizeof(r_q->pol));
1401 init_uni_hdr(&r_q->hdr_name, len_name);
1402 init_unistr2(&r_q->uni_name, key_name, len_name);
1404 r_q->unknown_0 = 0x00000000;
1405 r_q->unknown_1 = unk;
1408 /*******************************************************************
1409 reads or writes a structure.
1410 ********************************************************************/
1412 BOOL reg_io_q_open_entry(char *desc, REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1417 prs_debug(ps, depth, desc, "reg_io_q_entry");
1423 if(!smb_io_pol_hnd("", &r_q->pol, ps, depth))
1425 if(!smb_io_unihdr ("", &r_q->hdr_name, ps, depth))
1427 if(!smb_io_unistr2("", &r_q->uni_name, r_q->hdr_name.buffer, ps, depth))
1433 if(!prs_uint32("unknown_0", ps, depth, &r_q->unknown_0))
1435 if(!prs_uint32("unknown_1", ps, depth, &r_q->unknown_1))
1441 /*******************************************************************
1443 ********************************************************************/
1445 void init_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1446 POLICY_HND *pol, uint32 status)
1448 memcpy(&r_r->pol, pol, sizeof(r_r->pol));
1449 r_r->status = status;
1452 /*******************************************************************
1453 reads or writes a structure.
1454 ********************************************************************/
1456 BOOL reg_io_r_open_entry(char *desc, REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1461 prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1467 if(!smb_io_pol_hnd("", &r_r->pol, ps, depth))
1470 if(!prs_uint32("status", ps, depth, &r_r->status))