rpcclient shutdown command
[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         uint16 fnum;
64         BOOL res = True;
65         BOOL res1 = True;
66         BOOL res2 = True;
67         int i;
68
69         POLICY_HND key_pol;
70         fstring full_keyname;
71         fstring key_name;
72
73         /*
74          * query key info
75          */
76
77         fstring key_class;
78         uint32 max_class_len = 0;
79         uint32 num_subkeys;
80         uint32 max_subkeylen;
81         uint32 max_subkeysize; 
82         uint32 num_values;
83         uint32 max_valnamelen;
84         uint32 max_valbufsize;
85         uint32 sec_desc;
86         NTTIME mod_time;
87
88         /*
89          * unknown 0x1a request
90          */
91
92         uint32 unk_1a_response;
93
94         DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
95
96         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
97         {
98                 fprintf(out_hnd, "regenum <key_name>\n");
99                 return;
100         }
101
102         /* open WINREG session. */
103         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
104
105         /* open registry receive a policy handle */
106         res = res ? do_reg_connect(smb_cli, fnum, full_keyname, key_name,
107                                 &info->dom.reg_pol_connect) : False;
108
109         if ((*key_name) != 0)
110         {
111                 /* open an entry */
112                 res1 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
113                                          key_name, 0x02000000, &key_pol) : False;
114         }
115         else
116         {
117                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
118         }
119
120         res1 = res1 ? do_reg_query_key(smb_cli, fnum,
121                                 &key_pol,
122                                 key_class, &max_class_len,
123                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
124                                 &num_values, &max_valnamelen, &max_valbufsize,
125                                 &sec_desc, &mod_time) : False;
126
127         if (res1 && num_subkeys > 0)
128         {
129                 fprintf(out_hnd,"Subkeys\n");
130                 fprintf(out_hnd,"-------\n");
131         }
132
133         for (i = 0; i < num_subkeys; i++)
134         {
135                 /*
136                  * enumerate key
137                  */
138
139                 fstring enum_name;
140                 uint32 enum_unk1;
141                 uint32 enum_unk2;
142                 time_t key_mod_time;
143
144                 /* unknown 1a it */
145                 res2 = res1 ? do_reg_unknown_1a(smb_cli, fnum, &key_pol,
146                                         &unk_1a_response) : False;
147
148                 if (res2 && unk_1a_response != 5)
149                 {
150                         fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
151                 }
152
153                 /* enum key */
154                 res2 = res2 ? do_reg_enum_key(smb_cli, fnum, &key_pol,
155                                         i, enum_name,
156                                         &enum_unk1, &enum_unk2,
157                                         &key_mod_time) : False;
158                 
159                 if (res2)
160                 {
161                         display_reg_key_info(out_hnd, ACTION_HEADER   , enum_name, key_mod_time);
162                         display_reg_key_info(out_hnd, ACTION_ENUMERATE, enum_name, key_mod_time);
163                         display_reg_key_info(out_hnd, ACTION_FOOTER   , enum_name, key_mod_time);
164                 }
165
166         }
167
168         if (num_values > 0)
169         {
170                 fprintf(out_hnd,"Key Values\n");
171                 fprintf(out_hnd,"----------\n");
172         }
173
174         for (i = 0; i < num_values; i++)
175         {
176                 /*
177                  * enumerate key
178                  */
179
180                 uint32 val_type;
181                 BUFFER2 value;
182                 fstring val_name;
183
184                 /* unknown 1a it */
185                 res2 = res1 ? do_reg_unknown_1a(smb_cli, fnum, &key_pol,
186                                         &unk_1a_response) : False;
187
188                 if (res2 && unk_1a_response != 5)
189                 {
190                         fprintf(out_hnd,"Unknown 1a response: %x\n", unk_1a_response);
191                 }
192
193                 /* enum key */
194                 res2 = res2 ? do_reg_enum_val(smb_cli, fnum, &key_pol,
195                                         i, max_valnamelen, max_valbufsize,
196                                         val_name, &val_type, &value) : False;
197                 
198                 if (res2)
199                 {
200                         display_reg_value_info(out_hnd, ACTION_HEADER   , val_name, val_type, &value);
201                         display_reg_value_info(out_hnd, ACTION_ENUMERATE, val_name, val_type, &value);
202                         display_reg_value_info(out_hnd, ACTION_FOOTER   , val_name, val_type, &value);
203                 }
204         }
205
206         /* close the handles */
207         if ((*key_name) != 0)
208         {
209                 res1 = res1 ? do_reg_close(smb_cli, fnum, &key_pol) : False;
210         }
211         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
212
213         /* close the session */
214         cli_nt_session_close(smb_cli, fnum);
215
216         if (res && res1 && res2)
217         {
218                 DEBUG(5,("cmd_reg_enum: query succeeded\n"));
219         }
220         else
221         {
222                 DEBUG(5,("cmd_reg_enum: query failed\n"));
223         }
224 }
225
226 /****************************************************************************
227 nt registry query key
228 ****************************************************************************/
229 void cmd_reg_query_key(struct client_info *info)
230 {
231         uint16 fnum;
232         BOOL res = True;
233         BOOL res1 = True;
234
235         POLICY_HND key_pol;
236         fstring full_keyname;
237         fstring key_name;
238
239         /*
240          * query key info
241          */
242
243         fstring key_class;
244         uint32 key_class_len = 0;
245         uint32 num_subkeys;
246         uint32 max_subkeylen;
247         uint32 max_subkeysize; 
248         uint32 num_values;
249         uint32 max_valnamelen;
250         uint32 max_valbufsize;
251         uint32 sec_desc;
252         NTTIME mod_time;
253
254         DEBUG(5, ("cmd_reg_enum: smb_cli->fd:%d\n", smb_cli->fd));
255
256         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
257         {
258                 fprintf(out_hnd, "regquery key_name\n");
259                 return;
260         }
261
262         /* open WINREG session. */
263         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
264
265         /* open registry receive a policy handle */
266         res = res ? do_reg_connect(smb_cli, fnum, full_keyname, key_name,
267                                 &info->dom.reg_pol_connect) : False;
268
269         if ((*key_name) != 0)
270         {
271                 /* open an entry */
272                 res1 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
273                                          key_name, 0x02000000, &key_pol) : False;
274         }
275         else
276         {
277                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
278         }
279
280         res1 = res1 ? do_reg_query_key(smb_cli, fnum,
281                                 &key_pol,
282                                 key_class, &key_class_len,
283                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
284                                 &num_values, &max_valnamelen, &max_valbufsize,
285                                 &sec_desc, &mod_time) : False;
286
287         if (res1 && key_class_len != 0)
288         {
289                 res1 = res1 ? do_reg_query_key(smb_cli, fnum,
290                                 &key_pol,
291                                 key_class, &key_class_len,
292                                 &num_subkeys, &max_subkeylen, &max_subkeysize,
293                                 &num_values, &max_valnamelen, &max_valbufsize,
294                                 &sec_desc, &mod_time) : False;
295         }
296
297         if (res1)
298         {
299                 fprintf(out_hnd,"Registry Query Info Key\n");
300                 fprintf(out_hnd,"key class: %s\n", key_class);
301                 fprintf(out_hnd,"subkeys, max_len, max_size: %d %d %d\n", num_subkeys, max_subkeylen, max_subkeysize);
302                 fprintf(out_hnd,"vals, max_len, max_size: 0x%x 0x%x 0x%x\n", num_values, max_valnamelen, max_valbufsize);
303                 fprintf(out_hnd,"sec desc: 0x%x\n", sec_desc);
304                 fprintf(out_hnd,"mod time: %s\n", http_timestring(nt_time_to_unix(&mod_time)));
305         }
306
307         /* close the handles */
308         if ((*key_name) != 0)
309         {
310                 res1 = res1 ? do_reg_close(smb_cli, fnum, &key_pol) : False;
311         }
312         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
313
314         /* close the session */
315         cli_nt_session_close(smb_cli, fnum);
316
317         if (res && res1)
318         {
319                 DEBUG(5,("cmd_reg_query: query succeeded\n"));
320         }
321         else
322         {
323                 DEBUG(5,("cmd_reg_query: query failed\n"));
324         }
325 }
326
327 /****************************************************************************
328 nt registry create value
329 ****************************************************************************/
330 void cmd_reg_create_val(struct client_info *info)
331 {
332         uint16 fnum;
333         BOOL res = True;
334         BOOL res3 = True;
335         BOOL res4 = True;
336
337         POLICY_HND parent_pol;
338         fstring full_keyname;
339         fstring keyname;
340         fstring parent_name;
341         fstring val_name;
342         fstring tmp;
343         uint32 val_type;
344         BUFFER3 value;
345
346 #if 0
347         uint32 unk_0;
348         uint32 unk_1;
349         /* query it */
350         res1 = res1 ? do_reg_query_info(smb_cli, fnum, &val_pol,
351                                 type, &unk_0, &unk_1) : False;
352 #endif
353
354         DEBUG(5, ("cmd_reg_create_val: smb_cli->fd:%d\n", smb_cli->fd));
355
356         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
357         {
358                 fprintf(out_hnd, "regcreate <val_name> <val_type> <val>\n");
359                 return;
360         }
361
362         reg_get_subkey(full_keyname, keyname, val_name);
363
364         if (keyname[0] == 0 || val_name[0] == 0)
365         {
366                 fprintf(out_hnd, "invalid key name\n");
367                 return;
368         }
369         
370         if (!next_token(NULL, tmp, NULL, sizeof(tmp)))
371         {
372                 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
373                 return;
374         }
375
376         val_type = atoi(tmp);
377
378         if (val_type != 1 && val_type != 3 && val_type != 4)
379         {
380                 fprintf(out_hnd, "val_type 1=UNISTR, 3=BYTES, 4=DWORD supported\n");
381                 return;
382         }
383
384         if (!next_token(NULL, tmp, NULL, sizeof(tmp)))
385         {
386                 fprintf(out_hnd, "regcreate <val_name> <val_type (1|4)> <val>\n");
387                 return;
388         }
389
390         switch (val_type)
391         {
392                 case 0x01: /* UNISTR */
393                 {
394                         make_buffer3_str(&value, tmp, strlen(tmp)+1);
395                         break;
396                 }
397                 case 0x03: /* BYTES */
398                 {
399                         make_buffer3_hex(&value, tmp);
400                         break;
401                 }
402                 case 0x04: /* DWORD */
403                 {
404                         uint32 tmp_val;
405                         if (strnequal(tmp, "0x", 2))
406                         {
407                                 tmp_val = strtol(tmp, (char**)NULL, 16);
408                         }
409                         else
410                         {
411                                 tmp_val = strtol(tmp, (char**)NULL, 10);
412                         }
413                         make_buffer3_uint32(&value, tmp_val);
414                         break;
415                 }
416                 default:
417                 {
418                         fprintf(out_hnd, "i told you i only deal with UNISTR, DWORD and BYTES!\n");
419                         return;
420                 }
421         }
422                 
423         DEBUG(10,("key data:\n"));
424         dump_data(10, (char *)value.buffer, value.buf_len);
425
426         /* open WINREG session. */
427         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
428
429         /* open registry receive a policy handle */
430         res = res ? do_reg_connect(smb_cli, fnum, keyname, parent_name,
431                                 &info->dom.reg_pol_connect) : False;
432
433         if ((*val_name) != 0)
434         {
435                 /* open an entry */
436                 res3 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
437                                          parent_name, 0x02000000, &parent_pol) : False;
438         }
439         else
440         {
441                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
442         }
443
444         /* create an entry */
445         res4 = res3 ? do_reg_create_val(smb_cli, fnum, &parent_pol,
446                                  val_name, val_type, &value) : False;
447
448         /* flush the modified key */
449         res4 = res4 ? do_reg_flush_key(smb_cli, fnum, &parent_pol) : False;
450
451         /* close the val handle */
452         if ((*val_name) != 0)
453         {
454                 res3 = res3 ? do_reg_close(smb_cli, fnum, &parent_pol) : False;
455         }
456
457         /* close the registry handles */
458         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
459
460         /* close the session */
461         cli_nt_session_close(smb_cli, fnum);
462
463         if (res && res3 && res4)
464         {
465                 DEBUG(5,("cmd_reg_create_val: query succeeded\n"));
466                 fprintf(out_hnd,"OK\n");
467         }
468         else
469         {
470                 DEBUG(5,("cmd_reg_create_val: query failed\n"));
471         }
472 }
473
474 /****************************************************************************
475 nt registry delete value
476 ****************************************************************************/
477 void cmd_reg_delete_val(struct client_info *info)
478 {
479         uint16 fnum;
480         BOOL res = True;
481         BOOL res3 = True;
482         BOOL res4 = True;
483
484         POLICY_HND parent_pol;
485         fstring full_keyname;
486         fstring keyname;
487         fstring parent_name;
488         fstring val_name;
489
490         DEBUG(5, ("cmd_reg_delete_val: smb_cli->fd:%d\n", smb_cli->fd));
491
492         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
493         {
494                 fprintf(out_hnd, "regdelete <val_name>\n");
495                 return;
496         }
497
498         reg_get_subkey(full_keyname, keyname, val_name);
499
500         if (keyname[0] == 0 || val_name[0] == 0)
501         {
502                 fprintf(out_hnd, "invalid key name\n");
503                 return;
504         }
505         
506         /* open WINREG session. */
507         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
508
509         /* open registry receive a policy handle */
510         res = res ? do_reg_connect(smb_cli, fnum, keyname, parent_name,
511                                 &info->dom.reg_pol_connect) : False;
512
513         if ((*val_name) != 0)
514         {
515                 /* open an entry */
516                 res3 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
517                                          parent_name, 0x02000000, &parent_pol) : False;
518         }
519         else
520         {
521                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
522         }
523
524         /* delete an entry */
525         res4 = res3 ? do_reg_delete_val(smb_cli, fnum, &parent_pol, val_name) : False;
526
527         /* flush the modified key */
528         res4 = res4 ? do_reg_flush_key(smb_cli, fnum, &parent_pol) : False;
529
530         /* close the key handle */
531         res3 = res3 ? do_reg_close(smb_cli, fnum, &parent_pol) : False;
532
533         /* close the registry handles */
534         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
535
536         /* close the session */
537         cli_nt_session_close(smb_cli, fnum);
538
539         if (res && res3 && res4)
540         {
541                 DEBUG(5,("cmd_reg_delete_val: query succeeded\n"));
542                 fprintf(out_hnd,"OK\n");
543         }
544         else
545         {
546                 DEBUG(5,("cmd_reg_delete_val: query failed\n"));
547         }
548 }
549
550 /****************************************************************************
551 nt registry delete key
552 ****************************************************************************/
553 void cmd_reg_delete_key(struct client_info *info)
554 {
555         uint16 fnum;
556         BOOL res = True;
557         BOOL res3 = True;
558         BOOL res4 = True;
559
560         POLICY_HND parent_pol;
561         fstring full_keyname;
562         fstring parent_name;
563         fstring key_name;
564         fstring subkey_name;
565
566         DEBUG(5, ("cmd_reg_delete_key: smb_cli->fd:%d\n", smb_cli->fd));
567
568         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
569         {
570                 fprintf(out_hnd, "regdeletekey <key_name>\n");
571                 return;
572         }
573
574         reg_get_subkey(full_keyname, parent_name, subkey_name);
575
576         if (parent_name[0] == 0 || subkey_name[0] == 0)
577         {
578                 fprintf(out_hnd, "invalid key name\n");
579                 return;
580         }
581         
582         /* open WINREG session. */
583         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
584
585         /* open registry receive a policy handle */
586         res = res ? do_reg_connect(smb_cli, fnum, parent_name, key_name,
587                                 &info->dom.reg_pol_connect) : False;
588
589         if ((*key_name) != 0)
590         {
591                 /* open an entry */
592                 res3 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
593                                          key_name, 0x02000000, &parent_pol) : False;
594         }
595         else
596         {
597                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
598         }
599
600         /* create an entry */
601         res4 = res3 ? do_reg_delete_key(smb_cli, fnum, &parent_pol, subkey_name) : False;
602
603         /* flush the modified key */
604         res4 = res4 ? do_reg_flush_key(smb_cli, fnum, &parent_pol) : False;
605
606         /* close the key handle */
607         if ((*key_name) != 0)
608         {
609                 res3 = res3 ? do_reg_close(smb_cli, fnum, &parent_pol) : False;
610         }
611
612         /* close the registry handles */
613         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
614
615         /* close the session */
616         cli_nt_session_close(smb_cli, fnum);
617
618         if (res && res3 && res4)
619         {
620                 DEBUG(5,("cmd_reg_delete_key: query succeeded\n"));
621                 fprintf(out_hnd,"OK\n");
622         }
623         else
624         {
625                 DEBUG(5,("cmd_reg_delete_key: query failed\n"));
626         }
627 }
628
629 /****************************************************************************
630 nt registry create key
631 ****************************************************************************/
632 void cmd_reg_create_key(struct client_info *info)
633 {
634         uint16 fnum;
635         BOOL res = True;
636         BOOL res3 = True;
637         BOOL res4 = True;
638
639         POLICY_HND parent_pol;
640         POLICY_HND key_pol;
641         fstring full_keyname;
642         fstring parent_key;
643         fstring parent_name;
644         fstring key_name;
645         fstring key_class;
646         SEC_ACCESS sam_access;
647
648         DEBUG(5, ("cmd_reg_create_key: smb_cli->fd:%d\n", smb_cli->fd));
649
650         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
651         {
652                 fprintf(out_hnd, "regcreate <key_name> [key_class]\n");
653                 return;
654         }
655
656         reg_get_subkey(full_keyname, parent_key, key_name);
657
658         if (parent_key[0] == 0 || key_name[0] == 0)
659         {
660                 fprintf(out_hnd, "invalid key name\n");
661                 return;
662         }
663         
664         if (!next_token(NULL, key_class, NULL, sizeof(key_class)))
665         {
666                 memset(key_class, 0, sizeof(key_class));
667         }
668
669         /* set access permissions */
670         sam_access.mask = SEC_RIGHTS_READ;
671
672         /* open WINREG session. */
673         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
674
675         /* open registry receive a policy handle */
676         res = res ? do_reg_connect(smb_cli, fnum, parent_key, parent_name,
677                                 &info->dom.reg_pol_connect) : False;
678
679         if ((*parent_name) != 0)
680         {
681                 /* open an entry */
682                 res3 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
683                                          parent_name, 0x02000000, &parent_pol) : False;
684         }
685         else
686         {
687                 memcpy(&parent_pol, &info->dom.reg_pol_connect, sizeof(parent_pol));
688         }
689
690         /* create an entry */
691         res4 = res3 ? do_reg_create_key(smb_cli, fnum, &parent_pol,
692                                  key_name, key_class, &sam_access, &key_pol) : False;
693
694         /* flush the modified key */
695         res4 = res4 ? do_reg_flush_key(smb_cli, fnum, &parent_pol) : False;
696
697         /* close the key handle */
698         res4 = res4 ? do_reg_close(smb_cli, fnum, &key_pol) : False;
699
700         /* close the key handle */
701         if ((*parent_name) != 0)
702         {
703                 res3 = res3 ? do_reg_close(smb_cli, fnum, &parent_pol) : False;
704         }
705
706         /* close the registry handles */
707         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
708
709         /* close the session */
710         cli_nt_session_close(smb_cli, fnum);
711
712         if (res && res3 && res4)
713         {
714                 DEBUG(5,("cmd_reg_create_key: query succeeded\n"));
715                 fprintf(out_hnd,"OK\n");
716         }
717         else
718         {
719                 DEBUG(5,("cmd_reg_create_key: query failed\n"));
720         }
721 }
722
723 /****************************************************************************
724 nt registry security info
725 ****************************************************************************/
726 void cmd_reg_test_key_sec(struct client_info *info)
727 {
728         uint16 fnum;
729         BOOL res = True;
730         BOOL res3 = True;
731         BOOL res4 = True;
732
733         POLICY_HND key_pol;
734         fstring full_keyname;
735         fstring key_name;
736
737         /*
738          * security info
739          */
740
741         uint32 sec_buf_size;
742         SEC_DESC_BUF sec_buf;
743
744         DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
745
746         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
747         {
748                 fprintf(out_hnd, "reggetsec <key_name>\n");
749                 return;
750         }
751
752         /* open WINREG session. */
753         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
754
755         /* open registry receive a policy handle */
756         res = res ? do_reg_connect(smb_cli, fnum, full_keyname, key_name,
757                                 &info->dom.reg_pol_connect) : False;
758
759         if ((*key_name) != 0)
760         {
761                 /* open an entry */
762                 res3 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
763                                          key_name, 0x02000000, &key_pol) : False;
764         }
765         else
766         {
767                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
768         }
769
770         /* open an entry */
771         res3 = res ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
772                                  key_name, 0x02000000, &key_pol) : False;
773
774         /* query key sec info.  first call sets sec_buf_size. */
775         sec_buf_size = 0;
776         ZERO_STRUCT(sec_buf);
777
778         res4 = res3 ? do_reg_get_key_sec(smb_cli, fnum, &key_pol,
779                                 &sec_buf_size, &sec_buf) : False;
780         
781         if (res4)
782         {
783                 free_sec_desc_buf(&sec_buf);
784         }
785
786         res4 = res4 ? do_reg_get_key_sec(smb_cli, fnum, &key_pol,
787                                 &sec_buf_size, &sec_buf) : False;
788
789         if (res4 && sec_buf.len > 0 && sec_buf.sec != NULL)
790         {
791                 display_sec_desc(out_hnd, ACTION_HEADER   , sec_buf.sec);
792                 display_sec_desc(out_hnd, ACTION_ENUMERATE, sec_buf.sec);
793                 display_sec_desc(out_hnd, ACTION_FOOTER   , sec_buf.sec);
794
795                 res4 = res4 ? do_reg_set_key_sec(smb_cli, fnum, &key_pol,
796                                 sec_buf_size, sec_buf.sec) : False;
797
798                 free_sec_desc_buf(&sec_buf);
799         }
800
801         /* close the key handle */
802         if ((*key_name) != 0)
803         {
804                 res3 = res3 ? do_reg_close(smb_cli, fnum, &key_pol) : False;
805         }
806
807         /* close the registry handles */
808         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
809
810         /* close the session */
811         cli_nt_session_close(smb_cli, fnum);
812
813         if (res && res3 && res4)
814         {
815                 DEBUG(5,("cmd_reg_test2: query succeeded\n"));
816                 fprintf(out_hnd,"Registry Test2\n");
817         }
818         else
819         {
820                 DEBUG(5,("cmd_reg_test2: query failed\n"));
821         }
822 }
823
824 /****************************************************************************
825 nt registry security info
826 ****************************************************************************/
827 void cmd_reg_get_key_sec(struct client_info *info)
828 {
829         uint16 fnum;
830         BOOL res = True;
831         BOOL res3 = True;
832         BOOL res4 = True;
833
834         POLICY_HND key_pol;
835         fstring full_keyname;
836         fstring key_name;
837
838         /*
839          * security info
840          */
841
842         uint32 sec_buf_size;
843         SEC_DESC_BUF sec_buf;
844
845         DEBUG(5, ("cmd_reg_get_key_sec: smb_cli->fd:%d\n", smb_cli->fd));
846
847         if (!next_token(NULL, full_keyname, NULL, sizeof(full_keyname)))
848         {
849                 fprintf(out_hnd, "reggetsec <key_name>\n");
850                 return;
851         }
852
853         /* open WINREG session. */
854         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
855
856         /* open registry receive a policy handle */
857         res = res ? do_reg_connect(smb_cli, fnum, full_keyname, key_name,
858                                 &info->dom.reg_pol_connect) : False;
859
860         if ((*key_name) != 0)
861         {
862                 /* open an entry */
863                 res3 = res  ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
864                                          key_name, 0x02000000, &key_pol) : False;
865         }
866         else
867         {
868                 memcpy(&key_pol, &info->dom.reg_pol_connect, sizeof(key_pol));
869         }
870
871         /* open an entry */
872         res3 = res ? do_reg_open_entry(smb_cli, fnum, &info->dom.reg_pol_connect,
873                                  key_name, 0x02000000, &key_pol) : False;
874
875         /* query key sec info.  first call sets sec_buf_size. */
876         sec_buf_size = 0;
877         ZERO_STRUCT(sec_buf);
878
879         res4 = res3 ? do_reg_get_key_sec(smb_cli, fnum, &key_pol,
880                                 &sec_buf_size, &sec_buf) : False;
881         
882         if (res4)
883         {
884                 free_sec_desc_buf(&sec_buf);
885         }
886
887         res4 = res4 ? do_reg_get_key_sec(smb_cli, fnum, &key_pol,
888                                 &sec_buf_size, &sec_buf) : False;
889
890         if (res4 && sec_buf.len > 0 && sec_buf.sec != NULL)
891         {
892                 display_sec_desc(out_hnd, ACTION_HEADER   , sec_buf.sec);
893                 display_sec_desc(out_hnd, ACTION_ENUMERATE, sec_buf.sec);
894                 display_sec_desc(out_hnd, ACTION_FOOTER   , sec_buf.sec);
895
896                 free(sec_buf.sec);
897         }
898
899         /* close the key handle */
900         if ((*key_name) != 0)
901         {
902                 res3 = res3 ? do_reg_close(smb_cli, fnum, &key_pol) : False;
903         }
904
905         /* close the registry handles */
906         res  = res  ? do_reg_close(smb_cli, fnum, &info->dom.reg_pol_connect) : False;
907
908         /* close the session */
909         cli_nt_session_close(smb_cli, fnum);
910
911         if (res && res3 && res4)
912         {
913                 DEBUG(5,("cmd_reg_get_key_sec: query succeeded\n"));
914         }
915         else
916         {
917                 DEBUG(5,("cmd_reg_get_key_sec: query failed\n"));
918         }
919 }
920
921 /****************************************************************************
922 nt registry shutdown
923 ****************************************************************************/
924 void cmd_reg_shutdown(struct client_info *info)
925 {
926         uint16 fnum;
927         BOOL res = True;
928
929         fstring msg;
930         fstring tmp;
931         uint32 timeout = 20;
932
933         DEBUG(5, ("cmd_reg_shutdown: smb_cli->fd:%d\n", smb_cli->fd));
934
935         if (!next_token(NULL, msg, NULL, sizeof(msg)))
936         {
937                 msg[0] = 0;
938         }
939         else if (next_token(NULL, tmp, NULL, sizeof(tmp)))
940         {
941                 timeout = atoi(tmp);
942         }
943
944
945         /* open WINREG session. */
946         res = res ? cli_nt_session_open(smb_cli, PIPE_WINREG, &fnum) : False;
947
948         /* create an entry */
949         res = res ? do_reg_shutdown(smb_cli, fnum, msg, timeout, 1) : False;
950
951         /* close the session */
952         cli_nt_session_close(smb_cli, fnum);
953
954         if (res)
955         {
956                 DEBUG(5,("cmd_reg_shutdown: query succeeded\n"));
957                 fprintf(out_hnd,"OK\n");
958         }
959         else
960         {
961                 DEBUG(5,("cmd_reg_shutdown: query failed\n"));
962                 fprintf(out_hnd,"Failed\n");
963         }
964 }
965