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));
556 q_i->ptr = sec_buf != NULL ? 1 : 0;
561 make_buf_hdr(&(q_i->hdr_sec), buf_len, 0);
562 q_i->data->max_len = buf_len;
563 q_i->data->undoc = 0;
565 q_i->data->sec = NULL;
569 /*******************************************************************
570 reads or writes a structure.
571 ********************************************************************/
572 void reg_io_q_get_key_sec(char *desc, REG_Q_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
574 if (r_q == NULL) return;
576 prs_debug(ps, depth, desc, "reg_io_q_get_key_sec");
581 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
583 prs_uint32("unknown", ps, depth, &(r_q->unknown));
584 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
588 smb_io_hdrbuf ("hdr_sec", &(r_q->hdr_sec), ps, depth);
589 sec_io_desc_buf("data ", r_q->data , ps, depth);
596 /*******************************************************************
598 ********************************************************************/
599 void make_reg_r_get_key_sec(REG_R_GET_KEY_SEC *r_i, POLICY_HND *pol,
600 uint32 buf_len, uint8 *buf,
603 if (r_i == NULL) return;
606 make_buf_hdr(&(r_i->hdr_sec), buf_len, buf_len);
607 make_sec_desc_buf(r_i->data, buf_len, 1);
609 r_i->status = status; /* 0x0000 0000 or 0x0000 007a */
613 /*******************************************************************
614 reads or writes a structure.
615 ********************************************************************/
616 void reg_io_r_get_key_sec(char *desc, REG_R_GET_KEY_SEC *r_q, prs_struct *ps, int depth)
618 if (r_q == NULL) return;
620 prs_debug(ps, depth, desc, "reg_io_r_get_key_sec");
625 prs_uint32("ptr ", ps, depth, &(r_q->ptr ));
629 smb_io_hdrbuf("", &(r_q->hdr_sec), ps, depth);
630 sec_io_desc_buf("", r_q->data, ps, depth);
635 prs_uint32("status", ps, depth, &(r_q->status));
639 /*******************************************************************
641 ********************************************************************/
642 void make_reg_q_info(REG_Q_INFO *q_i, POLICY_HND *pol, char *product_type,
643 time_t unix_time, uint8 major, uint8 minor)
645 int len_type = strlen(product_type);
647 if (q_i == NULL) return;
649 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
651 make_uni_hdr(&(q_i->hdr_type), len_type, len_type, 1);
652 make_unistr2(&(q_i->uni_type), product_type, len_type);
655 unix_to_nt_time(&(q_i->time), unix_time);
656 q_i->major_version1 = major;
657 q_i->minor_version1 = minor;
658 memset(q_i->pad1, 0, sizeof(q_i->pad1));
661 q_i->major_version2 = major;
662 q_i->minor_version2 = minor;
663 memset(q_i->pad2, 0, sizeof(q_i->pad2));
666 q_i->unknown = 0x00000000;
669 /*******************************************************************
670 reads or writes a structure.
671 ********************************************************************/
672 void reg_io_q_info(char *desc, REG_Q_INFO *r_q, prs_struct *ps, int depth)
674 if (r_q == NULL) return;
676 prs_debug(ps, depth, desc, "reg_io_q_info");
681 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
682 smb_io_unihdr ("", &(r_q->hdr_type), ps, depth);
683 smb_io_unistr2("", &(r_q->uni_type), r_q->hdr_type.buffer, ps, depth);
687 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
691 smb_io_time("", &(r_q->time), ps, depth);
692 prs_uint8 ("major_version1", ps, depth, &(r_q->major_version1));
693 prs_uint8 ("minor_version1", ps, depth, &(r_q->minor_version1));
694 prs_uint8s(False, "pad1", ps, depth, r_q->pad1, sizeof(r_q->pad1));
697 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
701 prs_uint8 ("major_version2", ps, depth, &(r_q->major_version2));
702 prs_uint8 ("minor_version2", ps, depth, &(r_q->minor_version2));
703 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
706 prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
710 prs_uint32("unknown", ps, depth, &(r_q->unknown));
715 /*******************************************************************
717 ********************************************************************/
718 void make_reg_r_info(REG_R_INFO *r_r,
719 uint32 level, char *os_type,
720 uint32 unknown_0, uint32 unknown_1,
724 int len = struni2((uint16*)buf, os_type);
730 make_buffer2(&(r_r->uni_type), buf, len*2);
733 r_r->unknown_0 = unknown_0;
736 r_r->unknown_1 = unknown_1;
738 r_r->status = status;
741 /*******************************************************************
742 reads or writes a structure.
743 ********************************************************************/
744 void reg_io_r_info(char *desc, REG_R_INFO *r_r, prs_struct *ps, int depth)
746 if (r_r == NULL) return;
748 prs_debug(ps, depth, desc, "reg_io_r_info");
753 prs_uint32("ptr1", ps, depth, &(r_r->ptr1));
757 prs_uint32("level", ps, depth, &(r_r->level));
758 prs_uint32("ptr_type", ps, depth, &(r_r->ptr_type));
760 smb_io_buffer2("uni_type", &(r_r->uni_type), r_r->ptr_type, ps, depth);
762 prs_uint32("ptr2", ps, depth, &(r_r->ptr2));
766 prs_uint32("unknown_0", ps, depth, &(r_r->unknown_0));
769 prs_uint32("ptr3", ps, depth, &(r_r->ptr3));
773 prs_uint32("unknown_1", ps, depth, &(r_r->unknown_1));
777 prs_uint32("status", ps, depth, &(r_r->status));
780 /*******************************************************************
782 ********************************************************************/
783 void make_reg_q_enum_val(REG_Q_ENUM_VALUE *q_i, POLICY_HND *pol,
784 uint32 val_idx, uint32 max_val_len,
787 if (q_i == NULL) return;
791 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
793 q_i->val_index = val_idx;
794 make_uni_hdr(&q_i->hdr_name, max_val_len, 0, 1);
795 q_i->uni_name.uni_max_len = max_val_len;
801 q_i->buf_value.buf_max_len = max_buf_len;
804 q_i->len_value1 = max_buf_len;
810 /*******************************************************************
811 reads or writes a structure.
812 ********************************************************************/
813 void reg_io_q_enum_val(char *desc, REG_Q_ENUM_VALUE *q_q, prs_struct *ps, int depth)
815 if (q_q == NULL) return;
817 prs_debug(ps, depth, desc, "reg_io_q_enum_val");
822 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
824 prs_uint32("val_index", ps, depth, &(q_q->val_index));
825 smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
826 smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
829 prs_uint32("ptr_type", ps, depth, &(q_q->ptr_type));
831 if (q_q->ptr_type != 0)
833 prs_uint32("type", ps, depth, &(q_q->type));
836 prs_uint32("ptr_value", ps, depth, &(q_q->ptr_value));
837 smb_io_buffer2("buf_value", &(q_q->buf_value), q_q->ptr_value, ps, depth);
840 prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
843 prs_uint32("len_value1", ps, depth, &(q_q->len_value1));
845 prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
848 prs_uint32("len_value2", ps, depth, &(q_q->len_value2));
852 /*******************************************************************
853 reads or writes a structure.
854 ********************************************************************/
855 void reg_io_r_enum_val(char *desc, REG_R_ENUM_VALUE *r_q, prs_struct *ps, int depth)
857 if (r_q == NULL) return;
859 prs_debug(ps, depth, desc, "reg_io_r_enum_val");
864 smb_io_unihdr ("hdr_name", &(r_q->hdr_name), ps, depth);
865 smb_io_unistr2("uni_name", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
868 prs_uint32("ptr_type", ps, depth, &(r_q->ptr_type));
870 if (r_q->ptr_type != 0)
872 prs_uint32("type", ps, depth, &(r_q->type));
875 prs_uint32("ptr_value", ps, depth, &(r_q->ptr_value));
876 smb_io_buffer2("buf_value", r_q->buf_value, r_q->ptr_value, ps, depth);
879 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
882 prs_uint32("len_value1", ps, depth, &(r_q->len_value1));
885 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
888 prs_uint32("len_value2", ps, depth, &(r_q->len_value2));
891 prs_uint32("status", ps, depth, &(r_q->status));
894 /*******************************************************************
896 ********************************************************************/
897 void make_reg_q_create_val(REG_Q_CREATE_VALUE *q_i, POLICY_HND *pol,
898 char *val_name, uint32 type,
901 int val_len = strlen(val_name) + 1;
903 if (q_i == NULL) return;
907 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
909 make_uni_hdr(&q_i->hdr_name, val_len, val_len, 1);
910 make_unistr2(&(q_i->uni_name), val_name, val_len);
913 q_i->buf_value = val;
916 /*******************************************************************
917 reads or writes a structure.
918 ********************************************************************/
919 void reg_io_q_create_val(char *desc, REG_Q_CREATE_VALUE *q_q, prs_struct *ps, int depth)
921 if (q_q == NULL) return;
923 prs_debug(ps, depth, desc, "reg_io_q_create_val");
928 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
930 smb_io_unihdr ("hdr_name", &(q_q->hdr_name), ps, depth);
931 smb_io_unistr2("uni_name", &(q_q->uni_name), q_q->hdr_name.buffer, ps, depth);
934 prs_uint32("type", ps, depth, &(q_q->type));
935 smb_io_buffer3("buf_value", q_q->buf_value, ps, depth);
939 /*******************************************************************
940 reads or writes a structure.
941 ********************************************************************/
942 void reg_io_r_create_val(char *desc, REG_R_CREATE_VALUE *r_q, prs_struct *ps, int depth)
944 if (r_q == NULL) return;
946 prs_debug(ps, depth, desc, "reg_io_r_create_val");
951 prs_uint32("status", ps, depth, &(r_q->status));
954 /*******************************************************************
956 ********************************************************************/
957 void make_reg_q_enum_key(REG_Q_ENUM_KEY *q_i, POLICY_HND *pol, uint32 key_idx)
959 if (q_i == NULL) return;
961 memcpy(&(q_i->pol), pol, sizeof(q_i->pol));
963 q_i->key_index = key_idx;
964 q_i->key_name_len = 0;
965 q_i->unknown_1 = 0x0414;
968 q_i->unknown_2 = 0x0000020A;
969 memset(q_i->pad1, 0, sizeof(q_i->pad1));
972 memset(q_i->pad2, 0, sizeof(q_i->pad2));
975 unix_to_nt_time(&q_i->time, 0); /* current time? */
978 /*******************************************************************
979 reads or writes a structure.
980 ********************************************************************/
981 void reg_io_q_enum_key(char *desc, REG_Q_ENUM_KEY *q_q, prs_struct *ps, int depth)
983 if (q_q == NULL) return;
985 prs_debug(ps, depth, desc, "reg_io_q_enum_key");
990 smb_io_pol_hnd("", &(q_q->pol), ps, depth);
992 prs_uint32("key_index", ps, depth, &(q_q->key_index));
993 prs_uint16("key_name_len", ps, depth, &(q_q->key_name_len));
994 prs_uint16("unknown_1", ps, depth, &(q_q->unknown_1));
996 prs_uint32("ptr1", ps, depth, &(q_q->ptr1));
1000 prs_uint32("unknown_2", ps, depth, &(q_q->unknown_2));
1001 prs_uint8s(False, "pad1", ps, depth, q_q->pad1, sizeof(q_q->pad1));
1004 prs_uint32("ptr2", ps, depth, &(q_q->ptr2));
1008 prs_uint8s(False, "pad2", ps, depth, q_q->pad2, sizeof(q_q->pad2));
1011 prs_uint32("ptr3", ps, depth, &(q_q->ptr3));
1015 smb_io_time("", &(q_q->time), ps, depth);
1019 /*******************************************************************
1020 reads or writes a structure.
1021 ********************************************************************/
1022 void reg_io_r_enum_key(char *desc, REG_R_ENUM_KEY *r_q, prs_struct *ps, int depth)
1024 if (r_q == NULL) return;
1026 prs_debug(ps, depth, desc, "reg_io_r_enum_key");
1031 prs_uint16("key_name_len", ps, depth, &(r_q->key_name_len));
1032 prs_uint16("unknown_1", ps, depth, &(r_q->unknown_1));
1034 prs_uint32("ptr1", ps, depth, &(r_q->ptr1));
1038 prs_uint32("unknown_2", ps, depth, &(r_q->unknown_2));
1039 prs_uint32("unknown_3", ps, depth, &(r_q->unknown_3));
1040 smb_io_unistr3("key_name", &(r_q->key_name), ps, depth);
1044 prs_uint32("ptr2", ps, depth, &(r_q->ptr2));
1048 prs_uint8s(False, "pad2", ps, depth, r_q->pad2, sizeof(r_q->pad2));
1051 prs_uint32("ptr3", ps, depth, &(r_q->ptr3));
1055 smb_io_time("", &(r_q->time), ps, depth);
1058 prs_uint32("status", ps, depth, &(r_q->status));
1062 /*******************************************************************
1064 ********************************************************************/
1065 void make_reg_q_open_entry(REG_Q_OPEN_ENTRY *r_q, POLICY_HND *pol,
1066 char *key_name, uint32 unk)
1068 int len_name = strlen(key_name)+1;
1070 if (r_q == NULL) return;
1072 memcpy(&(r_q->pol), pol, sizeof(r_q->pol));
1074 make_uni_hdr(&(r_q->hdr_name), len_name, len_name, 1);
1075 make_unistr2(&(r_q->uni_name), key_name, len_name);
1077 r_q->unknown_0 = 0x00000000;
1078 r_q->unknown_1 = unk;
1081 /*******************************************************************
1082 reads or writes a structure.
1083 ********************************************************************/
1084 void reg_io_q_open_entry(char *desc, REG_Q_OPEN_ENTRY *r_q, prs_struct *ps, int depth)
1086 if (r_q == NULL) return;
1088 prs_debug(ps, depth, desc, "reg_io_q_entry");
1093 smb_io_pol_hnd("", &(r_q->pol), ps, depth);
1094 smb_io_unihdr ("", &(r_q->hdr_name), ps, depth);
1095 smb_io_unistr2("", &(r_q->uni_name), r_q->hdr_name.buffer, ps, depth);
1099 prs_uint32("unknown_0", ps, depth, &(r_q->unknown_0));
1100 prs_uint32("unknown_1", ps, depth, &(r_q->unknown_1));
1104 /*******************************************************************
1105 creates a structure.
1106 ********************************************************************/
1107 void make_reg_r_open_entry(REG_R_OPEN_ENTRY *r_r,
1108 POLICY_HND *pol, uint32 status)
1110 if (r_r == NULL) return;
1112 memcpy(&(r_r->pol), pol, sizeof(r_r->pol));
1113 r_r->status = status;
1116 /*******************************************************************
1117 reads or writes a structure.
1118 ********************************************************************/
1119 void reg_io_r_open_entry(char *desc, REG_R_OPEN_ENTRY *r_r, prs_struct *ps, int depth)
1121 if (r_r == NULL) return;
1123 prs_debug(ps, depth, desc, "reg_io_r_open_entry");
1128 smb_io_pol_hnd("", &(r_r->pol), ps, depth);
1130 prs_uint32("status", ps, depth, &(r_r->status));