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_set_key_sec(REG_Q_SET_KEY_SEC *q_i, POLICY_HND *pol,
548 uint32 buf_len, SEC_DESC *sec_desc)
550 if (q_i == NULL) return;
552 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
557 make_buf_hdr(&(q_i->hdr_sec), buf_len, buf_len);
558 make_sec_desc_buf(&(q_i->data), buf_len, sec_desc);
561 /*******************************************************************
562 reads or writes a structure.
563 ********************************************************************/
564 void reg_io_q_set_key_sec(char *desc, REG_Q_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
566 if (r_q == NULL) return;
568 prs_debug(ps, depth, desc, "reg_io_q_set_key_sec");
573 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
575 prs_uint32("unknown", ps, depth, &(r_q->unknown));
576 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
582 smb_io_hdrbuf_pre("hdr_sec", &(r_q->hdr_sec), ps, depth, &hdr_offset);
583 old_offset = ps->offset;
584 sec_io_desc_buf("data ", &(r_q->data ), ps, depth);
585 smb_io_hdrbuf_post("hdr_sec", &(r_q->hdr_sec), ps, depth, hdr_offset,
586 r_q->data.max_len, r_q->data.len);
587 ps->offset = old_offset + r_q->data.len + sizeof(uint32) * 3;
592 /*******************************************************************
593 reads or writes a structure.
594 ********************************************************************/
595 void reg_io_r_set_key_sec(char *desc, REG_R_SET_KEY_SEC *r_q, prs_struct *ps, int depth)
597 if (r_q == NULL) return;
599 prs_debug(ps, depth, desc, "reg_io_r_set_key_sec");
604 prs_uint32("status", ps, depth, &(r_q->status));
608 /*******************************************************************
610 ********************************************************************/
611 void make_reg_q_get_key_sec(REG_Q_GET_KEY_SEC *q_i, POLICY_HND *pol,
612 uint32 buf_len, SEC_DESC_BUF *sec_buf)
614 if (q_i == NULL) return;
616 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
620 q_i->ptr = sec_buf != NULL ? 1 : 0;
625 make_buf_hdr(&(q_i->hdr_sec), buf_len, 0);
626 make_sec_desc_buf(q_i->data, buf_len, NULL);
630 /*******************************************************************
631 reads or writes a structure.
632 ********************************************************************/
633 void reg_io_q_get_key_sec(char *desc, REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
635 if (r_q == NULL) return;
637 prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
642 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
644 prs_uint32("unknown", ps, depth, &(r_q->unknown));
645 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
651 smb_io_hdrbuf_pre("hdr_sec", &(r_q->hdr_sec), ps, depth, &hdr_offset);
652 old_offset = ps->offset;
653 sec_io_desc_buf("data ", r_q->data , ps, depth);
654 smb_io_hdrbuf_post("hdr_sec", &(r_q->hdr_sec), ps, depth, hdr_offset,
655 r_q->data->max_len, r_q->data->len);
656 ps->offset = old_offset + r_q->data->len + sizeof(uint32) * 3;
662 /*******************************************************************
664 ********************************************************************/
665 void make_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
666 uint32 buf_len, uint8 *buf,
669 if (r_i == NULL) return;
672 make_buf_hdr(&(r_i->hdr_sec), buf_len, buf_len);
673 make_sec_desc_buf(r_i->data, buf_len, 1);
675 r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
679 /*******************************************************************
680 reads or writes a structure.
681 ********************************************************************/
682 void reg_io_r_get_key_sec(char *desc, REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
684 if (r_q == NULL) return;
686 prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
691 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
695 smb_io_hdrbuf("", &(r_q->hdr_sec), ps, depth);
696 sec_io_desc_buf("", r_q->data, ps, depth);
701 prs_uint32("status", ps, depth, &(r_q->status));
705 /*******************************************************************
707 ********************************************************************/
708 void make_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char *product_type,
709 time_t unix_time, uint8 major, uint8 minor)
711 int len_type = strlen(product_type);
713 if (q_i == NULL) return;
715 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
717 make_uni_hdr(&(q_i->hdr_type), len_type, len_type, 1);
718 make_unistr2(&(q_i->uni_type), product_type, len_type);
721 unix_to_nt_time(&(q_i->time), unix_time);
722 q_i->major_version1 = major;
723 q_i->minor_version1 = minor;
724 memset(q_i->pad1, 0, sizeof(q_i->pad1));
727 q_i->major_version2 = major;
728 q_i->minor_version2 = minor;
729 memset(q_i->pad2, 0, sizeof(q_i->pad2));
732 q_i->unknown = 0x00000000;
735 /*******************************************************************
736 reads or writes a structure.
737 ********************************************************************/
738 void reg_io_q_info(char *desc, REG_Q_INFO *r_q, prs_struct *ps, int depth)
740 if (r_q == NULL) return;
742 prs_debug(ps, depth, desc, "reg_io_q_info");
747 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
748 smb_io_unihdr ("", &(r_q->hdr_type), ps, depth);
749 smb_io_unistr2("", &(r_q->uni_type), r_q->hdr_type.buffer, ps, depth);
753 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
757 smb_io_time("", &(r_q->time), ps, depth);
758 prs_uint8 ("major_version1", ps, depth, &(r_q->major_version1));
759 prs_uint8 ("minor_version1", ps, depth, &(r_q->minor_version1));
760 prs_uint8s(False, "pad1", ps, depth, r_q->pad1, sizeof(r_q->pad1));
763 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
767 prs_uint8 ("major_version2", ps, depth, &(r_q->major_version2));
768 prs_uint8 ("minor_version2", ps, depth, &(r_q->minor_version2));
769 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
772 prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
776 prs_uint32("unknown", ps, depth, &(r_q->unknown));
781 /*******************************************************************
783 ********************************************************************/
784 void make_reg_r_info(REG_R_INFO *r_r,
785 uint32 level, char *os_type,
786 uint32 unknown_0, uint32 unknown_1,
790 int len = struni2((uint16*)buf, os_type);
796 make_buffer2(&(r_r->uni_type), buf, len*2);
799 r_r->unknown_0 = unknown_0;
802 r_r->unknown_1 = unknown_1;
804 r_r->status = status;
807 /*******************************************************************
808 reads or writes a structure.
809 ********************************************************************/
810 void reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
812 if (r_r == NULL) return;
814 prs_debug(ps, depth, desc, "reg_io_r_info");
819 prs_uint32("ptr1", ps, depth, &(r_r->ptr1));
823 prs_uint32("level", ps, depth, &(r_r->level));
824 prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type));
826 smb_io_buffer2("uni_type", &(r_r->uni_type), r_r->ptr_type, ps, depth);
828 prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
832 prs_uint32("unknown_0", ps, depth, &(r_r->unknown_0));
835 prs_uint32("ptr3", ps, depth, &(r_r->ptr3));
839 prs_uint32("unknown_1", ps, depth, &(r_r->unknown_1));
843 prs_uint32("status", ps, depth, &(r_r->status));
846 /*******************************************************************
848 ********************************************************************/
849 void make_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
850 uint32 val_idx, uint32 max_val_len,
853 if (q_i == NULL) return;
857 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
859 q_i->val_index = val_idx;
860 make_uni_hdr(&q_i->hdr_name, max_val_len, 0, 1);
861 q_i->uni_name.uni_max_len = max_val_len;
867 q_i->buf_value.buf_max_len = max_buf_len;
870 q_i->len_value1 = max_buf_len;
876 /*******************************************************************
877 reads or writes a structure.
878 ********************************************************************/
879 void reg_io_q_enum_val(char *desc, REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
881 if (q_q == NULL) return;
883 prs_debug(ps, depth, desc, "reg_io_q_enum_val");
888 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
890 prs_uint32("val_index", ps, depth, &(q_q->val_index));
891 smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
892 smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
895 prs_uint32("ptr_type", ps, depth, &(q_q->ptr_type));
897 if (q_q->ptr_type != 0)
899 prs_uint32("type", ps, depth, &(q_q->type));
902 prs_uint32("ptr_value", ps, depth, &(q_q->ptr_value));
903 smb_io_buffer2("buf_value", &(q_q->buf_value), q_q->ptr_value, ps, depth);
906 prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
909 prs_uint32("len_value1", ps, depth, &(q_q->len_value1));
911 prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
914 prs_uint32("len_value2", ps, depth, &(q_q->len_value2));
918 /*******************************************************************
919 reads or writes a structure.
920 ********************************************************************/
921 void reg_io_r_enum_val(char *desc, REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
923 if (r_q == NULL) return;
925 prs_debug(ps, depth, desc, "reg_io_r_enum_val");
930 smb_io_unihdr ("hdr_name", &(r_q->hdr_name), ps, depth);
931 smb_io_unistr2("uni_name", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
934 prs_uint32("ptr_type", ps, depth, &(r_q->ptr_type));
936 if (r_q->ptr_type != 0)
938 prs_uint32("type", ps, depth, &(r_q->type));
941 prs_uint32("ptr_value", ps, depth, &(r_q->ptr_value));
942 smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth);
945 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
948 prs_uint32("len_value1", ps, depth, &(r_q->len_value1));
951 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
954 prs_uint32("len_value2", ps, depth, &(r_q->len_value2));
957 prs_uint32("status", ps, depth, &(r_q->status));
960 /*******************************************************************
962 ********************************************************************/
963 void make_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
964 char *val_name, uint32 type,
967 int val_len = strlen(val_name) + 1;
969 if (q_i == NULL) return;
973 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
975 make_uni_hdr(&q_i->hdr_name, val_len, val_len, 1);
976 make_unistr2(&(q_i->uni_name), val_name, val_len);
979 q_i->buf_value = val;
982 /*******************************************************************
983 reads or writes a structure.
984 ********************************************************************/
985 void reg_io_q_create_val(char *desc, REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
987 if (q_q == NULL) return;
989 prs_debug(ps, depth, desc, "reg_io_q_create_val");
994 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
996 smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
997 smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
1000 prs_uint32("type", ps, depth, &(q_q->type));
1001 smb_io_buffer3("buf_value", q_q->buf_value, ps, depth);
1005 /*******************************************************************
1006 reads or writes a structure.
1007 ********************************************************************/
1008 void reg_io_r_create_val(char *desc, REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
1010 if (r_q == NULL) return;
1012 prs_debug(ps, depth, desc, "reg_io_r_create_val");
1017 prs_uint32("status", ps, depth, &(r_q->status));
1020 /*******************************************************************
1022 ********************************************************************/
1023 void make_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
1025 if (q_i == NULL) return;
1027 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
1029 q_i->key_index = key_idx;
1030 q_i->key_name_len = 0;
1031 q_i->unknown_1 = 0x0414;
1034 q_i->unknown_2 = 0x0000020A;
1035 memset(q_i->pad1, 0, sizeof(q_i->pad1));
1038 memset(q_i->pad2, 0, sizeof(q_i->pad2));
1041 unix_to_nt_time(&q_i->time, 0); /* current time? */
1044 /*******************************************************************
1045 reads or writes a structure.
1046 ********************************************************************/
1047 void reg_io_q_enum_key(char *desc, REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
1049 if (q_q == NULL) return;
1051 prs_debug(ps, depth, desc, "reg_io_q_enum_key");
1056 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
1058 prs_uint32("key_index", ps, depth, &(q_q->key_index));
1059 prs_uint16("key_name_len", ps, depth, &(q_q->key_name_len));
1060 prs_uint16("unknown_1", ps, depth, &(q_q->unknown_1));
1062 prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
1066 prs_uint32("unknown_2", ps, depth, &(q_q->unknown_2));
1067 prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1));
1070 prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
1074 prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2));
1077 prs_uint32("ptr3", ps, depth, &(q_q->ptr3));
1081 smb_io_time("", &(q_q->time), ps, depth);
1085 /*******************************************************************
1086 reads or writes a structure.
1087 ********************************************************************/
1088 void reg_io_r_enum_key(char *desc, REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1090 if (r_q == NULL) return;
1092 prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1097 prs_uint16("key_name_len", ps, depth, &(r_q->key_name_len));
1098 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
1100 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
1104 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
1105 prs_uint32("unknown_3", ps, depth, &(r_q->unknown_3));
1106 smb_io_unistr3("key_name", &(r_q->key_name), ps, depth);
1110 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
1114 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
1117 prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
1121 smb_io_time("", &(r_q->time), ps, depth);
1124 prs_uint32("status", ps, depth, &(r_q->status));
1128 /*******************************************************************
1130 ********************************************************************/
1131 void make_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1132 char *key_name, uint32 unk)
1134 int len_name = strlen(key_name)+1;
1136 if (r_q == NULL) return;
1138 memcpy(&(r_q->pol), pol, sizeof(r_q->pol));
1140 make_uni_hdr(&(r_q->hdr_name), len_name, len_name, 1);
1141 make_unistr2(&(r_q->uni_name), key_name, len_name);
1143 r_q->unknown_0 = 0x00000000;
1144 r_q->unknown_1 = unk;
1147 /*******************************************************************
1148 reads or writes a structure.
1149 ********************************************************************/
1150 void reg_io_q_open_entry(char *desc, REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1152 if (r_q == NULL) return;
1154 prs_debug(ps, depth, desc, "reg_io_q_entry");
1159 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
1160 smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
1161 smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1165 prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
1166 prs_uint32("unknown_1", ps, depth, &(r_q->unknown_1));
1170 /*******************************************************************
1171 creates a structure.
1172 ********************************************************************/
1173 void make_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1174 POLICY_HND *pol, uint32 status)
1176 if (r_r == NULL) return;
1178 memcpy(&(r_r->pol), pol, sizeof(r_r->pol));
1179 r_r->status = status;
1182 /*******************************************************************
1183 reads or writes a structure.
1184 ********************************************************************/
1185 void reg_io_r_open_entry(char *desc, REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1187 if (r_r == NULL) return;
1189 prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1194 smb_io_pol_hnd("", &(r_r->pol), ps, depth);
1196 prs_uint32("status", ps, depth, &(r_r->status));