changed syntax of registry commands so keys can start with HKLM or HKU.
[samba.git] / source3 / rpc_client / cli_reg.c
1
2 /* 
3  *  Unix SMB/Netbios implementation.
4  *  Version 1.9.
5  *  RPC Pipe client / server routines
6  *  Copyright (C) Andrew Tridgell              1992-1997,
7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
8  *  Copyright (C) Paul Ashton                       1997.
9  *  
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
14  *  
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *  
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25
26 #ifdef SYSLOG
27 #undef SYSLOG
28 #endif
29
30 #include "includes.h"
31
32 extern int DEBUGLEVEL;
33
34 /****************************************************************************
35 do a REG Open Policy
36 ****************************************************************************/
37 BOOL do_reg_connect(struct cli_state *cli, char *full_keyname, char *key_name,
38                                 POLICY_HND *reg_hnd)
39 {
40         BOOL res = True;
41         uint32 reg_type = 0;
42
43         if (full_keyname == NULL)
44         {
45                 return False;
46         }
47
48         ZERO_STRUCTP(reg_hnd);
49
50         /*
51          * open registry receive a policy handle
52          */
53
54         if (!reg_split_key(full_keyname, &reg_type, key_name))
55         {
56                 DEBUG(0,("do_reg_connect: unrecognised key name %s\n", full_keyname));  
57                 return False;
58         }
59
60         switch (reg_type)
61         {
62                 case HKEY_LOCAL_MACHINE:
63                 {
64                         res = res ? do_reg_open_hklm(cli,
65                                         0x84E0, 0x02000000,
66                                         reg_hnd) : False;
67                         break;
68                 }
69         
70                 case HKEY_USERS:
71                 {
72                         res = res ? do_reg_open_hku(cli,
73                                         0x84E0, 0x02000000,
74                                         reg_hnd) : False;
75                         break;
76                 }
77                 default:
78                 {
79                         DEBUG(0,("do_reg_connect: unrecognised hive key\n"));   
80                         return False;
81                 }
82         }
83
84         return res;
85 }
86
87 /****************************************************************************
88 do a REG Open Policy
89 ****************************************************************************/
90 BOOL do_reg_open_hklm(struct cli_state *cli, uint16 unknown_0, uint32 level,
91                                 POLICY_HND *hnd)
92 {
93         prs_struct rbuf;
94         prs_struct buf; 
95         REG_Q_OPEN_HKLM q_o;
96         BOOL valid_pol = False;
97
98         if (hnd == NULL) return False;
99
100         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
101         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
102
103         /* create and send a MSRPC command with api REG_OPEN_HKLM */
104
105         DEBUG(4,("REG Open HKLM\n"));
106
107         make_reg_q_open_hklm(&q_o, unknown_0, level);
108
109         /* turn parameters into data stream */
110         reg_io_q_open_hklm("", &q_o, &buf, 0);
111
112         /* send the data on \PIPE\ */
113         if (rpc_api_pipe_req(cli, REG_OPEN_HKLM, &buf, &rbuf))
114         {
115                 REG_R_OPEN_HKLM r_o;
116                 BOOL p;
117
118                 ZERO_STRUCT(r_o);
119
120                 reg_io_r_open_hklm("", &r_o, &rbuf, 0);
121                 p = rbuf.offset != 0;
122
123                 if (p && r_o.status != 0)
124                 {
125                         /* report error code */
126                         DEBUG(0,("REG_OPEN_HKLM: %s\n", get_nt_error_msg(r_o.status)));
127                         p = False;
128                 }
129
130                 if (p)
131                 {
132                         /* ok, at last: we're happy. return the policy handle */
133                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
134                         valid_pol = True;
135                 }
136         }
137
138         prs_mem_free(&rbuf);
139         prs_mem_free(&buf );
140
141         return valid_pol;
142 }
143
144 /****************************************************************************
145 do a REG Open HKU
146 ****************************************************************************/
147 BOOL do_reg_open_hku(struct cli_state *cli, uint16 unknown_0, uint32 level,
148                                 POLICY_HND *hnd)
149 {
150         prs_struct rbuf;
151         prs_struct buf; 
152         REG_Q_OPEN_HKU q_o;
153         BOOL valid_pol = False;
154
155         if (hnd == NULL) return False;
156
157         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
158         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
159
160         /* create and send a MSRPC command with api REG_OPEN_HKU */
161
162         DEBUG(4,("REG Open HKU\n"));
163
164         make_reg_q_open_hku(&q_o, unknown_0, level);
165
166         /* turn parameters into data stream */
167         reg_io_q_open_hku("", &q_o, &buf, 0);
168
169         /* send the data on \PIPE\ */
170         if (rpc_api_pipe_req(cli, REG_OPEN_HKU, &buf, &rbuf))
171         {
172                 REG_R_OPEN_HKU r_o;
173                 BOOL p;
174
175                 ZERO_STRUCT(r_o);
176
177                 reg_io_r_open_hku("", &r_o, &rbuf, 0);
178                 p = rbuf.offset != 0;
179
180                 if (p && r_o.status != 0)
181                 {
182                         /* report error code */
183                         DEBUG(0,("REG_OPEN_HKU: %s\n", get_nt_error_msg(r_o.status)));
184                         p = False;
185                 }
186
187                 if (p)
188                 {
189                         /* ok, at last: we're happy. return the policy handle */
190                         memcpy(hnd, r_o.pol.data, sizeof(hnd->data));
191                         valid_pol = True;
192                 }
193         }
194
195         prs_mem_free(&rbuf);
196         prs_mem_free(&buf );
197
198         return valid_pol;
199 }
200
201 /****************************************************************************
202 do a REG Unknown 0xB command.  sent after a create key or create value.
203 this might be some sort of "sync" or "refresh" command, sent after
204 modification of the registry...
205 ****************************************************************************/
206 BOOL do_reg_flush_key(struct cli_state *cli, POLICY_HND *hnd)
207 {
208         prs_struct rbuf;
209         prs_struct buf; 
210         REG_Q_FLUSH_KEY q_o;
211         BOOL valid_query = False;
212
213         if (hnd == NULL) return False;
214
215         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
216         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
217
218         /* create and send a MSRPC command with api REG_FLUSH_KEY */
219
220         DEBUG(4,("REG Unknown 0xB\n"));
221
222         make_reg_q_flush_key(&q_o, hnd);
223
224         /* turn parameters into data stream */
225         reg_io_q_flush_key("", &q_o, &buf, 0);
226
227         /* send the data on \PIPE\ */
228         if (rpc_api_pipe_req(cli, REG_FLUSH_KEY, &buf, &rbuf))
229         {
230                 REG_R_FLUSH_KEY r_o;
231                 BOOL p;
232
233                 ZERO_STRUCT(r_o);
234
235                 reg_io_r_flush_key("", &r_o, &rbuf, 0);
236                 p = rbuf.offset != 0;
237
238                 if (p && r_o.status != 0)
239                 {
240                         /* report error code */
241                         DEBUG(0,("REG_FLUSH_KEY: %s\n", get_nt_error_msg(r_o.status)));
242                         p = False;
243                 }
244
245                 if (p)
246                 {
247                         valid_query = True;
248                 }
249         }
250
251         prs_mem_free(&rbuf);
252         prs_mem_free(&buf );
253
254         return valid_query;
255 }
256
257 /****************************************************************************
258 do a REG Query Key
259 ****************************************************************************/
260 BOOL do_reg_query_key(struct cli_state *cli, POLICY_HND *hnd,
261                                 char *class, uint32 *class_len,
262                                 uint32 *num_subkeys, uint32 *max_subkeylen,
263                                 uint32 *max_subkeysize, uint32 *num_values,
264                                 uint32 *max_valnamelen, uint32 *max_valbufsize,
265                                 uint32 *sec_desc, NTTIME *mod_time)
266 {
267         prs_struct rbuf;
268         prs_struct buf; 
269         REG_Q_QUERY_KEY q_o;
270         BOOL valid_query = False;
271
272         if (hnd == NULL) return False;
273
274         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
275         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
276
277         /* create and send a MSRPC command with api REG_QUERY_KEY */
278
279         DEBUG(4,("REG Query Key\n"));
280
281         make_reg_q_query_key(&q_o, hnd, *class_len);
282
283         /* turn parameters into data stream */
284         reg_io_q_query_key("", &q_o, &buf, 0);
285
286         /* send the data on \PIPE\ */
287         if (rpc_api_pipe_req(cli, REG_QUERY_KEY, &buf, &rbuf))
288         {
289                 REG_R_QUERY_KEY r_o;
290                 BOOL p;
291
292                 ZERO_STRUCT(r_o);
293
294                 reg_io_r_query_key("", &r_o, &rbuf, 0);
295                 p = rbuf.offset != 0;
296
297                 if (p && r_o.status != 0)
298                 {
299                         /* report error code */
300                         DEBUG(0,("REG_QUERY_KEY: %s\n", get_nt_error_msg(r_o.status)));
301                         p = False;
302                 }
303
304                 if (p)
305                 {
306                         valid_query = True;
307                         
308                         *class_len      = r_o.hdr_class.uni_max_len;
309                         fstrcpy(class, unistr2_to_str(&r_o.uni_class));
310                         *num_subkeys    = r_o.num_subkeys   ;
311                         *max_subkeylen  = r_o.max_subkeylen ;
312                         *max_subkeysize = r_o.max_subkeysize;
313                         *num_values     = r_o.num_values    ;
314                         *max_valnamelen = r_o.max_valnamelen;
315                         *max_valbufsize = r_o.max_valbufsize;
316                         *sec_desc       = r_o.sec_desc      ;
317                         *mod_time       = r_o.mod_time      ;
318                 }
319         }
320
321         prs_mem_free(&rbuf);
322         prs_mem_free(&buf );
323
324         return valid_query;
325 }
326
327 /****************************************************************************
328 do a REG Unknown 1A
329 ****************************************************************************/
330 BOOL do_reg_unknown_1a(struct cli_state *cli, POLICY_HND *hnd, uint32 *unk)
331 {
332         prs_struct rbuf;
333         prs_struct buf; 
334         REG_Q_UNK_1A q_o;
335         BOOL valid_query = False;
336
337         if (hnd == NULL) return False;
338
339         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
340         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
341
342         /* create and send a MSRPC command with api REG_UNKNOWN_1A */
343
344         DEBUG(4,("REG Unknown 1a\n"));
345
346         make_reg_q_unk_1a(&q_o, hnd);
347
348         /* turn parameters into data stream */
349         reg_io_q_unk_1a("", &q_o, &buf, 0);
350
351         /* send the data on \PIPE\ */
352         if (rpc_api_pipe_req(cli, REG_UNK_1A, &buf, &rbuf))
353         {
354                 REG_R_UNK_1A r_o;
355                 BOOL p;
356
357                 ZERO_STRUCT(r_o);
358
359                 reg_io_r_unk_1a("", &r_o, &rbuf, 0);
360                 p = rbuf.offset != 0;
361
362                 if (p && r_o.status != 0)
363                 {
364                         /* report error code */
365                         DEBUG(0,("REG_UNK_1A: %s\n", get_nt_error_msg(r_o.status)));
366                         p = False;
367                 }
368
369                 if (p)
370                 {
371                         valid_query = True;
372                         (*unk) = r_o.unknown;
373                 }
374         }
375
376         prs_mem_free(&rbuf);
377         prs_mem_free(&buf );
378
379         return valid_query;
380 }
381
382 /****************************************************************************
383 do a REG Query Info
384 ****************************************************************************/
385 BOOL do_reg_query_info(struct cli_state *cli, POLICY_HND *hnd,
386                                 char *type, uint32 *unk_0, uint32 *unk_1)
387 {
388         prs_struct rbuf;
389         prs_struct buf; 
390         REG_Q_INFO q_o;
391         BOOL valid_query = False;
392
393         if (hnd == NULL) return False;
394
395         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
396         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
397
398         /* create and send a MSRPC command with api REG_INFO */
399
400         DEBUG(4,("REG Query Info\n"));
401
402         make_reg_q_info(&q_o, hnd, "ProductType", time(NULL), 4, 1);
403
404         /* turn parameters into data stream */
405         reg_io_q_info("", &q_o, &buf, 0);
406
407         /* send the data on \PIPE\ */
408         if (rpc_api_pipe_req(cli, REG_INFO, &buf, &rbuf))
409         {
410                 REG_R_INFO r_o;
411                 BOOL p;
412
413                 ZERO_STRUCT(r_o);
414
415                 reg_io_r_info("", &r_o, &rbuf, 0);
416                 p = rbuf.offset != 0;
417
418                 if (p && r_o.status != 0)
419                 {
420                         /* report error code */
421                         DEBUG(0,("REG_INFO: %s\n", get_nt_error_msg(r_o.status)));
422                         p = False;
423                 }
424
425                 if (p)
426                 {
427                         valid_query = True;
428                         fstrcpy(type, buffer2_to_str(&r_o.uni_type));
429                         (*unk_0) = r_o.unknown_0;
430                         (*unk_1) = r_o.unknown_1;
431                 }
432         }
433
434         prs_mem_free(&rbuf);
435         prs_mem_free(&buf );
436
437         return valid_query;
438 }
439
440 /****************************************************************************
441 do a REG Query Key Security 
442 ****************************************************************************/
443 BOOL do_reg_get_key_sec(struct cli_state *cli, POLICY_HND *hnd,
444                                 uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf)
445 {
446         prs_struct rbuf;
447         prs_struct buf; 
448         REG_Q_GET_KEY_SEC q_o;
449         BOOL valid_query = False;
450
451         if (hnd == NULL) return False;
452
453         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
454         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
455
456         /* create and send a MSRPC command with api REG_GET_KEY_SEC */
457
458         DEBUG(4,("REG query key security.  buf_size: %d\n", *sec_buf_size));
459
460         make_reg_q_get_key_sec(&q_o, hnd, *sec_buf_size, sec_buf);
461
462         /* turn parameters into data stream */
463         reg_io_q_get_key_sec("", &q_o, &buf, 0);
464
465         /* send the data on \PIPE\ */
466         if (rpc_api_pipe_req(cli, REG_GET_KEY_SEC, &buf, &rbuf))
467         {
468                 REG_R_GET_KEY_SEC r_o;
469                 BOOL p;
470
471                 ZERO_STRUCT(r_o);
472
473                 r_o.data = sec_buf;
474                 reg_io_r_get_key_sec("", &r_o, &rbuf, 0);
475                 p = rbuf.offset != 0;
476
477                 if (p && r_o.status == 0x0000007a)
478                 {
479                         /*
480                          * get the maximum buffer size: it was too small
481                          */
482                         (*sec_buf_size) = r_o.hdr_sec.buf_max_len;
483                         DEBUG(5,("sec_buf_size too small.  use %d\n", *sec_buf_size));
484                         valid_query = True;
485                 }
486                 else if (p && r_o.status != 0)
487                 {
488                         /* report error code */
489                         DEBUG(0,("REG_GET_KEY_SEC: %s\n", get_nt_error_msg(r_o.status)));
490                         p = False;
491                 }
492                 else
493                 {
494                         valid_query = True;
495                         (*sec_buf_size) = r_o.data->len;
496                 }
497         }
498
499         prs_mem_free(&rbuf);
500         prs_mem_free(&buf );
501
502         return valid_query;
503 }
504
505 /****************************************************************************
506 do a REG Delete Value
507 ****************************************************************************/
508 BOOL do_reg_delete_val(struct cli_state *cli, POLICY_HND *hnd, char *val_name)
509 {
510         prs_struct rbuf;
511         prs_struct buf; 
512         REG_Q_DELETE_VALUE q_o;
513         BOOL valid_delete = False;
514
515         if (hnd == NULL) return False;
516
517         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
518         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
519
520         /* create and send a MSRPC command with api REG_DELETE_VALUE */
521
522         DEBUG(4,("REG Delete Value: %s\n", val_name));
523
524         make_reg_q_delete_val(&q_o, hnd, val_name);
525
526         /* turn parameters into data stream */
527         reg_io_q_delete_val("", &q_o, &buf, 0);
528
529         /* send the data on \PIPE\ */
530         if (rpc_api_pipe_req(cli, REG_DELETE_VALUE, &buf, &rbuf))
531         {
532                 REG_R_DELETE_VALUE r_o;
533                 BOOL p;
534
535                 ZERO_STRUCT(r_o);
536
537                 reg_io_r_delete_val("", &r_o, &rbuf, 0);
538                 p = rbuf.offset != 0;
539
540                 if (p && r_o.status != 0)
541                 {
542                         /* report error code */
543                         DEBUG(0,("REG_DELETE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
544                         p = False;
545                 }
546
547                 if (p)
548                 {
549                         valid_delete = True;
550                 }
551         }
552
553         prs_mem_free(&rbuf);
554         prs_mem_free(&buf );
555
556         return valid_delete;
557 }
558
559 /****************************************************************************
560 do a REG Delete Key
561 ****************************************************************************/
562 BOOL do_reg_delete_key(struct cli_state *cli, POLICY_HND *hnd, char *key_name)
563 {
564         prs_struct rbuf;
565         prs_struct buf; 
566         REG_Q_DELETE_KEY q_o;
567         BOOL valid_delete = False;
568
569         if (hnd == NULL) return False;
570
571         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
572         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
573
574         /* create and send a MSRPC command with api REG_DELETE_KEY */
575
576         DEBUG(4,("REG Delete Key: %s\n", key_name));
577
578         make_reg_q_delete_key(&q_o, hnd, key_name);
579
580         /* turn parameters into data stream */
581         reg_io_q_delete_key("", &q_o, &buf, 0);
582
583         /* send the data on \PIPE\ */
584         if (rpc_api_pipe_req(cli, REG_DELETE_KEY, &buf, &rbuf))
585         {
586                 REG_R_DELETE_KEY r_o;
587                 BOOL p;
588
589                 ZERO_STRUCT(r_o);
590
591                 reg_io_r_delete_key("", &r_o, &rbuf, 0);
592                 p = rbuf.offset != 0;
593
594                 if (p && r_o.status != 0)
595                 {
596                         /* report error code */
597                         DEBUG(0,("REG_DELETE_KEY: %s\n", get_nt_error_msg(r_o.status)));
598                         p = False;
599                 }
600
601                 if (p)
602                 {
603                         valid_delete = True;
604                 }
605         }
606
607         prs_mem_free(&rbuf);
608         prs_mem_free(&buf );
609
610         return valid_delete;
611 }
612
613 /****************************************************************************
614 do a REG Create Key
615 ****************************************************************************/
616 BOOL do_reg_create_key(struct cli_state *cli, POLICY_HND *hnd,
617                                 char *key_name, char *key_class,
618                                 SEC_INFO *sam_access,
619                                 POLICY_HND *key)
620 {
621         prs_struct rbuf;
622         prs_struct buf; 
623         REG_Q_CREATE_KEY q_o;
624         BOOL valid_create = False;
625
626         if (hnd == NULL) return False;
627
628         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
629         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
630
631         /* create and send a MSRPC command with api REG_CREATE_KEY */
632
633         DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class,
634                 sam_access != NULL ? sam_access->perms : 0));
635
636         make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access);
637
638         /* turn parameters into data stream */
639         reg_io_q_create_key("", &q_o, &buf, 0);
640
641         /* send the data on \PIPE\ */
642         if (rpc_api_pipe_req(cli, REG_CREATE_KEY, &buf, &rbuf))
643         {
644                 REG_R_CREATE_KEY r_o;
645                 BOOL p;
646
647                 ZERO_STRUCT(r_o);
648
649                 reg_io_r_create_key("", &r_o, &rbuf, 0);
650                 p = rbuf.offset != 0;
651
652                 if (p && r_o.status != 0)
653                 {
654                         /* report error code */
655                         DEBUG(0,("REG_CREATE_KEY: %s\n", get_nt_error_msg(r_o.status)));
656                         p = False;
657                 }
658
659                 if (p)
660                 {
661                         valid_create = True;
662                         memcpy(key, r_o.key_pol.data, sizeof(key->data));
663                 }
664         }
665
666         prs_mem_free(&rbuf);
667         prs_mem_free(&buf );
668
669         return valid_create;
670 }
671
672 /****************************************************************************
673 do a REG Enum Key
674 ****************************************************************************/
675 BOOL do_reg_enum_key(struct cli_state *cli, POLICY_HND *hnd,
676                                 int key_index, char *key_name,
677                                 uint32 *unk_1, uint32 *unk_2,
678                                 time_t *mod_time)
679 {
680         prs_struct rbuf;
681         prs_struct buf; 
682         REG_Q_ENUM_KEY q_o;
683         BOOL valid_query = False;
684
685         if (hnd == NULL) return False;
686
687         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
688         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
689
690         /* create and send a MSRPC command with api REG_ENUM_KEY */
691
692         DEBUG(4,("REG Enum Key\n"));
693
694         make_reg_q_enum_key(&q_o, hnd, key_index);
695
696         /* turn parameters into data stream */
697         reg_io_q_enum_key("", &q_o, &buf, 0);
698
699         /* send the data on \PIPE\ */
700         if (rpc_api_pipe_req(cli, REG_ENUM_KEY, &buf, &rbuf))
701         {
702                 REG_R_ENUM_KEY r_o;
703                 BOOL p;
704
705                 ZERO_STRUCT(r_o);
706
707                 reg_io_r_enum_key("", &r_o, &rbuf, 0);
708                 p = rbuf.offset != 0;
709
710                 if (p && r_o.status != 0)
711                 {
712                         /* report error code */
713                         DEBUG(0,("REG_ENUM_KEY: %s\n", get_nt_error_msg(r_o.status)));
714                         p = False;
715                 }
716
717                 if (p)
718                 {
719                         valid_query = True;
720                         (*unk_1) = r_o.unknown_1;
721                         (*unk_2) = r_o.unknown_2;
722                         fstrcpy(key_name, unistr2(r_o.key_name.str.buffer));
723                         (*mod_time) = nt_time_to_unix(&r_o.time);
724                 }
725         }
726
727         prs_mem_free(&rbuf);
728         prs_mem_free(&buf );
729
730         return valid_query;
731 }
732
733 /****************************************************************************
734 do a REG Create Value
735 ****************************************************************************/
736 BOOL do_reg_create_val(struct cli_state *cli, POLICY_HND *hnd,
737                                 char *val_name, uint32 type, BUFFER3 *data)
738 {
739         prs_struct rbuf;
740         prs_struct buf; 
741         REG_Q_CREATE_VALUE q_o;
742         BOOL valid_create = False;
743
744         if (hnd == NULL) return False;
745
746         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
747         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
748
749         /* create and send a MSRPC command with api REG_CREATE_VALUE */
750
751         DEBUG(4,("REG Create Value: %s\n", val_name));
752
753         make_reg_q_create_val(&q_o, hnd, val_name, type, data);
754
755         /* turn parameters into data stream */
756         reg_io_q_create_val("", &q_o, &buf, 0);
757
758         /* send the data on \PIPE\ */
759         if (rpc_api_pipe_req(cli, REG_CREATE_VALUE, &buf, &rbuf))
760         {
761                 REG_R_CREATE_VALUE r_o;
762                 BOOL p;
763
764                 ZERO_STRUCT(r_o);
765
766                 reg_io_r_create_val("", &r_o, &rbuf, 0);
767                 p = rbuf.offset != 0;
768
769                 if (p && r_o.status != 0)
770                 {
771                         /* report error code */
772                         DEBUG(0,("REG_CREATE_VALUE: %s\n", get_nt_error_msg(r_o.status)));
773                         p = False;
774                 }
775
776                 if (p)
777                 {
778                         valid_create = True;
779                 }
780         }
781
782         prs_mem_free(&rbuf);
783         prs_mem_free(&buf );
784
785         return valid_create;
786 }
787
788 /****************************************************************************
789 do a REG Enum Value
790 ****************************************************************************/
791 BOOL do_reg_enum_val(struct cli_state *cli, POLICY_HND *hnd,
792                                 int val_index, int max_valnamelen, int max_valbufsize,
793                                 fstring val_name,
794                                 uint32 *val_type, BUFFER2 *value)
795 {
796         prs_struct rbuf;
797         prs_struct buf; 
798         REG_Q_ENUM_VALUE q_o;
799         BOOL valid_query = False;
800
801         if (hnd == NULL) return False;
802
803         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
804         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
805
806         /* create and send a MSRPC command with api REG_ENUM_VALUE */
807
808         DEBUG(4,("REG Enum Value\n"));
809
810         make_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize);
811
812         /* turn parameters into data stream */
813         reg_io_q_enum_val("", &q_o, &buf, 0);
814
815         /* send the data on \PIPE\ */
816         if (rpc_api_pipe_req(cli, REG_ENUM_VALUE, &buf, &rbuf))
817         {
818                 REG_R_ENUM_VALUE r_o;
819                 BOOL p;
820
821                 ZERO_STRUCT(r_o);
822                 r_o.buf_value = value;
823
824                 reg_io_r_enum_val("", &r_o, &rbuf, 0);
825                 p = rbuf.offset != 0;
826
827                 if (p && r_o.status != 0)
828                 {
829                         /* report error code */
830                         DEBUG(0,("REG_ENUM_VALUE: %s\n", get_nt_error_msg(r_o.status)));
831                         p = False;
832                 }
833
834                 if (p)
835                 {
836                         valid_query = True;
837                         (*val_type) = r_o.type;
838                         fstrcpy(val_name, unistr2_to_str(&r_o.uni_name));
839                 }
840         }
841
842         prs_mem_free(&rbuf);
843         prs_mem_free(&buf );
844
845         return valid_query;
846 }
847
848 /****************************************************************************
849 do a REG Open Key
850 ****************************************************************************/
851 BOOL do_reg_open_entry(struct cli_state *cli, POLICY_HND *hnd,
852                                 char *key_name, uint32 unk_0,
853                                 POLICY_HND *key_hnd)
854 {
855         prs_struct rbuf;
856         prs_struct buf; 
857         REG_Q_OPEN_ENTRY q_o;
858         BOOL valid_pol = False;
859
860         if (hnd == NULL) return False;
861
862         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
863         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
864
865         /* create and send a MSRPC command with api REG_OPEN_ENTRY */
866
867         DEBUG(4,("REG Open Entry\n"));
868
869         make_reg_q_open_entry(&q_o, hnd, key_name, unk_0);
870
871         /* turn parameters into data stream */
872         reg_io_q_open_entry("", &q_o, &buf, 0);
873
874         /* send the data on \PIPE\ */
875         if (rpc_api_pipe_req(cli, REG_OPEN_ENTRY, &buf, &rbuf))
876         {
877                 REG_R_OPEN_ENTRY r_o;
878                 BOOL p;
879
880                 ZERO_STRUCT(r_o);
881
882                 reg_io_r_open_entry("", &r_o, &rbuf, 0);
883                 p = rbuf.offset != 0;
884
885                 if (p && r_o.status != 0)
886                 {
887                         /* report error code */
888                         DEBUG(0,("REG_OPEN_ENTRY: %s\n", get_nt_error_msg(r_o.status)));
889                         p = False;
890                 }
891
892                 if (p)
893                 {
894                         valid_pol = True;
895                         memcpy(key_hnd, r_o.pol.data, sizeof(key_hnd->data));
896                 }
897         }
898
899         prs_mem_free(&rbuf);
900         prs_mem_free(&buf );
901
902         return valid_pol;
903 }
904
905 /****************************************************************************
906 do a REG Close
907 ****************************************************************************/
908 BOOL do_reg_close(struct cli_state *cli, POLICY_HND *hnd)
909 {
910         prs_struct rbuf;
911         prs_struct buf; 
912         REG_Q_CLOSE q_c;
913         BOOL valid_close = False;
914
915         if (hnd == NULL) return False;
916
917         /* create and send a MSRPC command with api REG_CLOSE */
918
919         prs_init(&buf , 1024, 4, SAFETY_MARGIN, False);
920         prs_init(&rbuf, 0   , 4, SAFETY_MARGIN, True );
921
922         DEBUG(4,("REG Close\n"));
923
924         /* store the parameters */
925         make_reg_q_close(&q_c, hnd);
926
927         /* turn parameters into data stream */
928         reg_io_q_close("", &q_c, &buf, 0);
929
930         /* send the data on \PIPE\ */
931         if (rpc_api_pipe_req(cli, REG_CLOSE, &buf, &rbuf))
932         {
933                 REG_R_CLOSE r_c;
934                 BOOL p;
935
936                 ZERO_STRUCT(r_c);
937
938                 reg_io_r_close("", &r_c, &rbuf, 0);
939                 p = rbuf.offset != 0;
940
941                 if (p && r_c.status != 0)
942                 {
943                         /* report error code */
944                         DEBUG(0,("REG_CLOSE: %s\n", get_nt_error_msg(r_c.status)));
945                         p = False;
946                 }
947
948                 if (p)
949                 {
950                         /* check that the returned policy handle is all zeros */
951                         int i;
952                         valid_close = True;
953
954                         for (i = 0; i < sizeof(r_c.pol.data); i++)
955                         {
956                                 if (r_c.pol.data[i] != 0)
957                                 {
958                                         valid_close = False;
959                                         break;
960                                 }
961                         }       
962                         if (!valid_close)
963                         {
964                                 DEBUG(0,("REG_CLOSE: non-zero handle returned\n"));
965                         }
966                 }
967         }
968
969         prs_mem_free(&rbuf);
970         prs_mem_free(&buf );
971
972         return valid_close;
973 }
974
975