changed syntax of registry commands so keys can start with HKLM or HKU.
[samba.git] / source3 / rpcclient / cmd_reg.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    NT Domain Authentication SMB / MSRPC client
5    Copyright (C) Andrew Tridgell 1994-1997
6    Copyright (C) Luke Kenneth Casson Leighton 1996-1997
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23
24
25 #ifdef SYSLOG
26 #undef SYSLOG
27 #endif
28
29 #include "includes.h"
30 #include "nterr.h"
31
32 extern int DEBUGLEVEL;
33
34 extern struct cli_state *smb_cli;
35 extern int smb_tidx;
36
37 extern FILE* out_hnd;
38
39 /*
40  * keys.  of the form:
41  * ----
42  *
43  * [HKLM]|[HKU]\[parent_keyname_components]\[subkey]|[value]
44  *
45  * reg_getsubkey() splits this down into:
46  * [HKLM]|[HKU]\[parent_keyname_components] and [subkey]|[value]
47  *
48  * do_reg_connect() splits the left side down further into:
49  * [HKLM]|[HKU] and [parent_keyname_components].
50  *
51  * HKLM is short for HKEY_LOCAL_MACHINE
52  * HKU  is short for HKEY_USERS
53  *
54  * oh, and HKEY stands for "Hive Key".
55  *
56  */
57
58 /****************************************************************************
59 nt registry enum
60 ****************************************************************************/
61 void cmd_reg_enum(struct client_info *info)
62 {
63         BOOL res = True;
64         BOOL res1 = True;
65         BOOL res2 = True;
66         int i;
67
68         POLICY_HND key_pol;
69         fstring full_keyname;
70         fstring key_name;
71
72         /*
73          * query key info
74          */
75
76         fstring key_class;
77         uint32 max_class_len = 0;
78         uint32 num_subkeys;
79         uint32 max_subkeylen;
80         uint32 max_subkeysize; 
81         uint32 num_values;
82         uint32 max_valnamelen;
83         uint32 max_valbufsize;
84         uint32 sec_desc;
85         NTTIME mod_time;
86
87         /*
88          * unknown 0x1a request
89          */
90
91         uint32 unk_1a_response;
92
93         DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
94
95         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
96         {
97                 fprintf(out_hnd, "regenum <key_name>\n");
98                 return;
99         }
100
101         /* open WINREG session. */
102         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
103
104         /* open registry receive a policy handle */
105         res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
106                                 &info->dom.reg_pol_connect) : False;
107
108         if ((*key_name) != 0)
109         {
110                 /* open an entry */
111                 res1 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
112                                          key_name, 0x02000000, &key_pol) : False;
113         }
114         else
115         {
116                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
117         }
118
119         res1 = res1 ? do_reg_query_key(smb_cli,
120                                 &key_pol,
121                                 key_class, &max_class_len,
122                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
123                                 &num_values, &max_valnamelen, &max_valbufsize,
124                                 &sec_desc, &mod_time) : False;
125
126         if (res1 && num_subkeys > 0)
127         {
128                 fprintf(out_hnd,"Subkeys\n");
129                 fprintf(out_hnd,"-------\n");
130         }
131
132         for (i = 0; i < num_subkeys; i++)
133         {
134                 /*
135                  * enumerate key
136                  */
137
138                 fstring enum_name;
139                 uint32 enum_unk1;
140                 uint32 enum_unk2;
141                 time_t key_mod_time;
142
143                 /* unknown 1a it */
144                 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
145                                         &unk_1a_response) : False;
146
147                 if (res2 && unk_1a_response != 5)
148                 {
149                         fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
150                 }
151
152                 /* enum key */
153                 res2 = res2 ? do_reg_enum_key(smb_cli, &key_pol,
154                                         i, enum_name,
155                                         &enum_unk1, &enum_unk2,
156                                         &key_mod_time) : False;
157                 
158                 if (res2)
159                 {
160                         display_reg_key_info(out_hnd, ACTION_HEADER   , enum_name, key_mod_time);
161                         display_reg_key_info(out_hnd, ACTION_ENUMERATE, enum_name, key_mod_time);
162                         display_reg_key_info(out_hnd, ACTION_FOOTER   , enum_name, key_mod_time);
163                 }
164
165         }
166
167         if (num_values > 0)
168         {
169                 fprintf(out_hnd,"Key Values\n");
170                 fprintf(out_hnd,"----------\n");
171         }
172
173         for (i = 0; i < num_values; i++)
174         {
175                 /*
176                  * enumerate key
177                  */
178
179                 uint32 val_type;
180                 BUFFER2 value;
181                 fstring val_name;
182
183                 /* unknown 1a it */
184                 res2 = res1 ? do_reg_unknown_1a(smb_cli, &key_pol,
185                                         &unk_1a_response) : False;
186
187                 if (res2 && unk_1a_response != 5)
188                 {
189                         fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
190                 }
191
192                 /* enum key */
193                 res2 = res2 ? do_reg_enum_val(smb_cli, &key_pol,
194                                         i, max_valnamelen, max_valbufsize,
195                                         val_name, &val_type, &value) : False;
196                 
197                 if (res2)
198                 {
199                         display_reg_value_info(out_hnd, ACTION_HEADER   , val_name, val_type, &value);
200                         display_reg_value_info(out_hnd, ACTION_ENUMERATE, val_name, val_type, &value);
201                         display_reg_value_info(out_hnd, ACTION_FOOTER   , val_name, val_type, &value);
202                 }
203         }
204
205         /* close the handles */
206         if ((*key_name) != 0)
207         {
208                 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
209         }
210         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
211
212         /* close the session */
213         cli_nt_session_close(smb_cli);
214
215         if (res && res1 && res2)
216         {
217                 DEBUG(5,("cmd_reg_enum: query succeeded\n"));
218         }
219         else
220         {
221                 DEBUG(5,("cmd_reg_enum: query failed\n"));
222         }
223 }
224
225 /****************************************************************************
226 nt registry query key
227 ****************************************************************************/
228 void cmd_reg_query_key(struct client_info *info)
229 {
230         BOOL res = True;
231         BOOL res1 = True;
232
233         POLICY_HND key_pol;
234         fstring full_keyname;
235         fstring key_name;
236
237         /*
238          * query key info
239          */
240
241         fstring key_class;
242         uint32 key_class_len = 0;
243         uint32 num_subkeys;
244         uint32 max_subkeylen;
245         uint32 max_subkeysize; 
246         uint32 num_values;
247         uint32 max_valnamelen;
248         uint32 max_valbufsize;
249         uint32 sec_desc;
250         NTTIME mod_time;
251
252         DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
253
254         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
255         {
256                 fprintf(out_hnd, "regquery key_name\n");
257                 return;
258         }
259
260         /* open WINREG session. */
261         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
262
263         /* open registry receive a policy handle */
264         res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
265                                 &info->dom.reg_pol_connect) : False;
266
267         if ((*key_name) != 0)
268         {
269                 /* open an entry */
270                 res1 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
271                                          key_name, 0x02000000, &key_pol) : False;
272         }
273         else
274         {
275                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
276         }
277
278         res1 = res1 ? do_reg_query_key(smb_cli,
279                                 &key_pol,
280                                 key_class, &key_class_len,
281                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
282                                 &num_values, &max_valnamelen, &max_valbufsize,
283                                 &sec_desc, &mod_time) : False;
284
285         if (res1 && key_class_len != 0)
286         {
287                 res1 = res1 ? do_reg_query_key(smb_cli,
288                                 &key_pol,
289                                 key_class, &key_class_len,
290                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
291                                 &num_values, &max_valnamelen, &max_valbufsize,
292                                 &sec_desc, &mod_time) : False;
293         }
294
295         if (res1)
296         {
297                 fprintf(out_hnd,"Registry Query Info Key\n");
298                 fprintf(out_hnd,"key class: %s\n", key_class);
299                 fprintf(out_hnd,"subkeys, max_len, max_size: %d %d %d\n", num_subkeys, max_subkeylen, max_subkeysize);
300                 fprintf(out_hnd,"vals, max_len, max_size: 0x%x 0x%x 0x%x\n", num_values, max_valnamelen, max_valbufsize);
301                 fprintf(out_hnd,"sec desc: 0x%x\n", sec_desc);
302                 fprintf(out_hnd,"mod time: %s\n", http_timestring(nt_time_to_unix(&mod_time)));
303         }
304
305         /* close the handles */
306         if ((*key_name) != 0)
307         {
308                 res1 = res1 ? do_reg_close(smb_cli, &key_pol) : False;
309         }
310         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
311
312         /* close the session */
313         cli_nt_session_close(smb_cli);
314
315         if (res && res1)
316         {
317                 DEBUG(5,("cmd_reg_query: query succeeded\n"));
318         }
319         else
320         {
321                 DEBUG(5,("cmd_reg_query: query failed\n"));
322         }
323 }
324
325 /****************************************************************************
326 nt registry create value
327 ****************************************************************************/
328 void cmd_reg_create_val(struct client_info *info)
329 {
330         BOOL res = True;
331         BOOL res3 = True;
332         BOOL res4 = True;
333
334         POLICY_HND parent_pol;
335         fstring full_keyname;
336         fstring keyname;
337         fstring parent_name;
338         fstring val_name;
339         fstring tmp;
340         uint32 val_type;
341         BUFFER3 value;
342
343 #if 0
344         uint32 unk_0;
345         uint32 unk_1;
346         /* query it */
347         res1 = res1 ? do_reg_query_info(smb_cli, &val_pol,
348                                 type, &unk_0, &unk_1) : False;
349 #endif
350
351         DEBUG(5, ("cmd_reg_create_val: smb_cli->fd:%d\n", smb_cli->fd));
352
353         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
354         {
355                 fprintf(out_hnd, "regcreate <val_name> <val_type> <val>\n");
356                 return;
357         }
358
359         reg_get_subkey(full_keyname, keyname, val_name);
360
361         if (keyname[0] == 0 || val_name[0] == 0)
362         {
363                 fprintf(out_hnd, "invalid key name\n");
364                 return;
365         }
366         
367         if (!next_token(NULL, tmp, NULL, sizeof(tmp)))
368         {
369                 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
370                 return;
371         }
372
373         val_type = atoi(tmp);
374
375         if (val_type != 1 && val_type != 3 && val_type != 4)
376         {
377                 fprintf(out_hnd, "val_type 1=UNISTR, 3=BYTES, 4=DWORD supported\n");
378                 return;
379         }
380
381         if (!next_token(NULL, tmp, NULL, sizeof(tmp)))
382         {
383                 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
384                 return;
385         }
386
387         switch (val_type)
388         {
389                 case 0x01: /* UNISTR */
390                 {
391                         make_buffer3_str(&value, tmp, strlen(tmp)+1);
392                         break;
393                 }
394                 case 0x03: /* BYTES */
395                 {
396                         make_buffer3_hex(&value, tmp);
397                         break;
398                 }
399                 case 0x04: /* DWORD */
400                 {
401                         uint32 tmp_val;
402                         if (strnequal(tmp, "0x", 2))
403                         {
404                                 tmp_val = strtol(tmp, (char**)NULL, 16);
405                         }
406                         else
407                         {
408                                 tmp_val = strtol(tmp, (char**)NULL, 10);
409                         }
410                         make_buffer3_uint32(&value, tmp_val);
411                         break;
412                 }
413                 default:
414                 {
415                         fprintf(out_hnd, "i told you i only deal with UNISTR, DWORD and BYTES!\n");
416                         return;
417                 }
418         }
419                 
420         DEBUG(10,("key data:\n"));
421         dump_data(10, (char *)value.buffer, value.buf_len);
422
423         /* open WINREG session. */
424         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
425
426         /* open registry receive a policy handle */
427         res = res ? do_reg_connect(smb_cli, keyname, parent_name,
428                                 &info->dom.reg_pol_connect) : False;
429
430         if ((*val_name) != 0)
431         {
432                 /* open an entry */
433                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
434                                          parent_name, 0x02000000, &parent_pol) : False;
435         }
436         else
437         {
438                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
439         }
440
441         /* create an entry */
442         res4 = res3 ? do_reg_create_val(smb_cli, &parent_pol,
443                                  val_name, val_type, &value) : False;
444
445         /* flush the modified key */
446         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
447
448         /* close the val handle */
449         if ((*val_name) != 0)
450         {
451                 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
452         }
453
454         /* close the registry handles */
455         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
456
457         /* close the session */
458         cli_nt_session_close(smb_cli);
459
460         if (res && res3 && res4)
461         {
462                 DEBUG(5,("cmd_reg_create_val: query succeeded\n"));
463                 fprintf(out_hnd,"OK\n");
464         }
465         else
466         {
467                 DEBUG(5,("cmd_reg_create_val: query failed\n"));
468         }
469 }
470
471 /****************************************************************************
472 nt registry delete value
473 ****************************************************************************/
474 void cmd_reg_delete_val(struct client_info *info)
475 {
476         BOOL res = True;
477         BOOL res3 = True;
478         BOOL res4 = True;
479
480         POLICY_HND parent_pol;
481         fstring full_keyname;
482         fstring keyname;
483         fstring parent_name;
484         fstring val_name;
485
486         DEBUG(5, ("cmd_reg_delete_val: smb_cli->fd:%d\n", smb_cli->fd));
487
488         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
489         {
490                 fprintf(out_hnd, "regdelete <val_name>\n");
491                 return;
492         }
493
494         reg_get_subkey(full_keyname, keyname, val_name);
495
496         if (keyname[0] == 0 || val_name[0] == 0)
497         {
498                 fprintf(out_hnd, "invalid key name\n");
499                 return;
500         }
501         
502         /* open WINREG session. */
503         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
504
505         /* open registry receive a policy handle */
506         res = res ? do_reg_connect(smb_cli, keyname, parent_name,
507                                 &info->dom.reg_pol_connect) : False;
508
509         if ((*val_name) != 0)
510         {
511                 /* open an entry */
512                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
513                                          parent_name, 0x02000000, &parent_pol) : False;
514         }
515         else
516         {
517                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
518         }
519
520         /* delete an entry */
521         res4 = res3 ? do_reg_delete_val(smb_cli, &parent_pol, val_name) : False;
522
523         /* flush the modified key */
524         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
525
526         /* close the key handle */
527         res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
528
529         /* close the registry handles */
530         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
531
532         /* close the session */
533         cli_nt_session_close(smb_cli);
534
535         if (res && res3 && res4)
536         {
537                 DEBUG(5,("cmd_reg_delete_val: query succeeded\n"));
538                 fprintf(out_hnd,"OK\n");
539         }
540         else
541         {
542                 DEBUG(5,("cmd_reg_delete_val: query failed\n"));
543         }
544 }
545
546 /****************************************************************************
547 nt registry delete key
548 ****************************************************************************/
549 void cmd_reg_delete_key(struct client_info *info)
550 {
551         BOOL res = True;
552         BOOL res3 = True;
553         BOOL res4 = True;
554
555         POLICY_HND parent_pol;
556         fstring full_keyname;
557         fstring parent_name;
558         fstring key_name;
559         fstring subkey_name;
560
561         DEBUG(5, ("cmd_reg_delete_key: smb_cli->fd:%d\n", smb_cli->fd));
562
563         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
564         {
565                 fprintf(out_hnd, "regdeletekey <key_name>\n");
566                 return;
567         }
568
569         reg_get_subkey(full_keyname, parent_name, subkey_name);
570
571         if (parent_name[0] == 0 || subkey_name[0] == 0)
572         {
573                 fprintf(out_hnd, "invalid key name\n");
574                 return;
575         }
576         
577         /* open WINREG session. */
578         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
579
580         /* open registry receive a policy handle */
581         res = res ? do_reg_connect(smb_cli, parent_name, key_name,
582                                 &info->dom.reg_pol_connect) : False;
583
584         if ((*key_name) != 0)
585         {
586                 /* open an entry */
587                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
588                                          key_name, 0x02000000, &parent_pol) : False;
589         }
590         else
591         {
592                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
593         }
594
595         /* create an entry */
596         res4 = res3 ? do_reg_delete_key(smb_cli, &parent_pol, subkey_name) : False;
597
598         /* flush the modified key */
599         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
600
601         /* close the key handle */
602         if ((*key_name) != 0)
603         {
604                 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
605         }
606
607         /* close the registry handles */
608         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
609
610         /* close the session */
611         cli_nt_session_close(smb_cli);
612
613         if (res && res3 && res4)
614         {
615                 DEBUG(5,("cmd_reg_delete_key: query succeeded\n"));
616                 fprintf(out_hnd,"OK\n");
617         }
618         else
619         {
620                 DEBUG(5,("cmd_reg_delete_key: query failed\n"));
621         }
622 }
623
624 /****************************************************************************
625 nt registry create key
626 ****************************************************************************/
627 void cmd_reg_create_key(struct client_info *info)
628 {
629         BOOL res = True;
630         BOOL res3 = True;
631         BOOL res4 = True;
632
633         POLICY_HND parent_pol;
634         POLICY_HND key_pol;
635         fstring full_keyname;
636         fstring parent_key;
637         fstring parent_name;
638         fstring key_name;
639         fstring key_class;
640         SEC_INFO sam_access;
641
642         DEBUG(5, ("cmd_reg_create_key: smb_cli->fd:%d\n", smb_cli->fd));
643
644         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
645         {
646                 fprintf(out_hnd, "regcreate <key_name> [key_class]\n");
647                 return;
648         }
649
650         reg_get_subkey(full_keyname, parent_key, key_name);
651
652         if (parent_key[0] == 0 || key_name[0] == 0)
653         {
654                 fprintf(out_hnd, "invalid key name\n");
655                 return;
656         }
657         
658         if (!next_token(NULL, key_class, NULL, sizeof(key_class)))
659         {
660                 memset(key_class, 0, sizeof(key_class));
661         }
662
663         /* set access permissions */
664         sam_access.perms = SEC_RIGHTS_READ;
665
666         /* open WINREG session. */
667         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
668
669         /* open registry receive a policy handle */
670         res = res ? do_reg_connect(smb_cli, parent_key, parent_name,
671                                 &info->dom.reg_pol_connect) : False;
672
673         if ((*parent_name) != 0)
674         {
675                 /* open an entry */
676                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
677                                          parent_name, 0x02000000, &parent_pol) : False;
678         }
679         else
680         {
681                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
682         }
683
684         /* create an entry */
685         res4 = res3 ? do_reg_create_key(smb_cli, &parent_pol,
686                                  key_name, key_class, &sam_access, &key_pol) : False;
687
688         /* flush the modified key */
689         res4 = res4 ? do_reg_flush_key(smb_cli, &parent_pol) : False;
690
691         /* close the key handle */
692         res4 = res4 ? do_reg_close(smb_cli, &key_pol) : False;
693
694         /* close the key handle */
695         if ((*parent_name) != 0)
696         {
697                 res3 = res3 ? do_reg_close(smb_cli, &parent_pol) : False;
698         }
699
700         /* close the registry handles */
701         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
702
703         /* close the session */
704         cli_nt_session_close(smb_cli);
705
706         if (res && res3 && res4)
707         {
708                 DEBUG(5,("cmd_reg_create_key: query succeeded\n"));
709                 fprintf(out_hnd,"OK\n");
710         }
711         else
712         {
713                 DEBUG(5,("cmd_reg_create_key: query failed\n"));
714         }
715 }
716
717 /****************************************************************************
718 nt registry security info
719 ****************************************************************************/
720 void cmd_reg_get_key_sec(struct client_info *info)
721 {
722         BOOL res = True;
723         BOOL res3 = True;
724         BOOL res4 = True;
725
726         POLICY_HND key_pol;
727         fstring full_keyname;
728         fstring key_name;
729
730         /*
731          * security info
732          */
733
734         uint32 sec_buf_size;
735         SEC_DESC_BUF sec_buf;
736
737         DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
738
739         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
740         {
741                 fprintf(out_hnd, "reggetsec <key_name>\n");
742                 return;
743         }
744
745         /* open WINREG session. */
746         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG) : False;
747
748         /* open registry receive a policy handle */
749         res = res ? do_reg_connect(smb_cli, full_keyname, key_name,
750                                 &info->dom.reg_pol_connect) : False;
751
752         if ((*key_name) != 0)
753         {
754                 /* open an entry */
755                 res3 = res  ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
756                                          key_name, 0x02000000, &key_pol) : False;
757         }
758         else
759         {
760                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
761         }
762
763         /* open an entry */
764         res3 = res ? do_reg_open_entry(smb_cli, &info->dom.reg_pol_connect,
765                                  key_name, 0x02000000, &key_pol) : False;
766
767         /* query key sec info.  first call sets sec_buf_size. */
768         sec_buf_size = 0;
769         res4 = res3 ? do_reg_get_key_sec(smb_cli, &key_pol,
770                                 &sec_buf_size, &sec_buf) : False;
771         
772         res4 = res4 ? do_reg_get_key_sec(smb_cli, &key_pol,
773                                 &sec_buf_size, &sec_buf) : False;
774
775         if (res4 && sec_buf.len > 0)
776         {
777                 display_sec_desc(out_hnd, ACTION_HEADER   , &sec_buf.sec);
778                 display_sec_desc(out_hnd, ACTION_ENUMERATE, &sec_buf.sec);
779                 display_sec_desc(out_hnd, ACTION_FOOTER   , &sec_buf.sec);
780         }
781
782         /* close the key handle */
783         if ((*key_name) != 0)
784         {
785                 res3 = res3 ? do_reg_close(smb_cli, &key_pol) : False;
786         }
787
788         /* close the registry handles */
789         res  = res  ? do_reg_close(smb_cli, &info->dom.reg_pol_connect) : False;
790
791         /* close the session */
792         cli_nt_session_close(smb_cli);
793
794         if (res && res3 && res4)
795         {
796                 DEBUG(5,("cmd_reg_test2: query succeeded\n"));
797                 fprintf(out_hnd,"Registry Test2\n");
798         }
799         else
800         {
801                 DEBUG(5,("cmd_reg_test2: query failed\n"));
802         }
803 }
804