?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
preparing for release of alpha-2.6
[Samba/gbeck.git] / source / rpc_client / cli_reg.c
blob23c9b7c366bec8951683acd3c3914d54f19c8c75
1 /*
2 * Unix SMB/Netbios implementation.
3 * Version 1.9.
4 * RPC Pipe client / server routines
5 * Copyright (C) Andrew Tridgell 1992-2000,
6 * Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
7 * Copyright (C) Paul Ashton 1997-2000.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "rpc_parse.h"
26 #include "rpc_client.h"
27
28 extern int DEBUGLEVEL;
29
30 /****************************************************************************
31 do a REG Open Policy
32 ****************************************************************************/
33 BOOL reg_connect(const char *srv_name,
34 const char *full_keyname,
35 char *key_name,
36 uint32 access_mask,
37 POLICY_HND *reg_hnd)
38 {
39 BOOL res = True;
40 uint32 reg_type = 0;
41
42 struct cli_connection *con = NULL;
43
44 if (!cli_connection_init(srv_name, PIPE_WINREG, &con))
45 {
46 return False;
47 }
48
49 ZERO_STRUCTP(reg_hnd);
50
51 if (full_keyname == NULL)
52 {
53 return False;
54 }
55
56 /*
57 * open registry receive a policy handle
58 */
59
60 if (!reg_split_key(full_keyname, &reg_type, key_name))
61 {
62 DEBUG(0,("reg_connect: unrecognised key name %s\n",
63 full_keyname));
64 return False;
65 }
66
67 switch (reg_type)
68 {
69 case HKEY_CLASSES_ROOT:
70 {
71 res = res ? reg_open_hkcr(con,
72 0x5428, access_mask,
73 reg_hnd) : False;
74 break;
75 }
76
77 case HKEY_LOCAL_MACHINE:
78 {
79 res = res ? reg_open_hklm(con,
80 0x84E0, access_mask,
81 reg_hnd) : False;
82 break;
83 }
84
85 case HKEY_USERS:
86 {
87 res = res ? reg_open_hku(con,
88 0x84E0, access_mask,
89 reg_hnd) : False;
90 break;
91 }
92 default:
93 {
94 DEBUG(0,("reg_connect: unrecognised hive key\n"));
95 return False;
96 }
97 }
98
99 if (res)
100 {
101 if (!register_policy_hnd(get_global_hnd_cache(),
102 cli_con_sec_ctx(con),
103 reg_hnd, access_mask)
104 || !set_policy_con(get_global_hnd_cache(), reg_hnd, con,
105 cli_connection_unlink))
106 {
107 cli_connection_unlink(con);
108 return False;
109 }
110 }
111
112 return res;
113 }
114
115 /****************************************************************************
116 do a REG Open Policy
117 ****************************************************************************/
118 BOOL reg_open_hkcr(struct cli_connection *con,
119 uint16 unknown_0, uint32 level, POLICY_HND *hnd)
120 {
121 prs_struct rbuf;
122 prs_struct buf;
123 REG_Q_OPEN_HKCR q_o;
124 BOOL valid_pol = False;
125
126 if (hnd == NULL) return False;
127
128 prs_init(&buf , 0, 4, False);
129 prs_init(&rbuf, 0, 4, True );
130
131 /* create and send a MSRPC command with api REG_OPEN_HKCR */
132
133 DEBUG(4,("REG Open HKCR\n"));
134
135 make_reg_q_open_hkcr(&q_o, unknown_0, level);
136
137 /* turn parameters into data stream */
138 if (reg_io_q_open_hkcr("", &q_o, &buf, 0) &&
139 rpc_con_pipe_req(con, REG_OPEN_HKCR, &buf, &rbuf))
140 {
141 REG_R_OPEN_HKCR r_o;
142 BOOL p;
143
144 ZERO_STRUCT(r_o);
145
146 reg_io_r_open_hkcr("", &r_o, &rbuf, 0);
147 p = rbuf.offset != 0;
148
149 if (p && r_o.status != 0)
150 {
151 /* report error code */
152 DEBUG(0, ("REG_OPEN_HKCR: %s\n",
153 get_nt_error_msg(r_o.status)));
154 p = False;
155 }
156
157 if (p)
158 {
159 /* ok, at last: we're happy. return the policy handle */
160 *hnd = r_o.pol;
161 valid_pol = True;
162 }
163 }
164
165 prs_free_data(&rbuf);
166 prs_free_data(&buf );
167
168 return valid_pol;
169 }
170
171 /****************************************************************************
172 do a REG Open Policy
173 ****************************************************************************/
174 BOOL reg_open_hklm(struct cli_connection *con,
175 uint16 unknown_0, uint32 level,
176 POLICY_HND *hnd)
177 {
178 prs_struct rbuf;
179 prs_struct buf;
180 REG_Q_OPEN_HKLM q_o;
181 BOOL valid_pol = False;
182
183 if (hnd == NULL) return False;
184
185 prs_init(&buf , 0, 4, False);
186 prs_init(&rbuf, 0, 4, True );
187
188 /* create and send a MSRPC command with api REG_OPEN_HKLM */
189
190 DEBUG(4,("REG Open HKLM\n"));
191
192 make_reg_q_open_hklm(&q_o, unknown_0, level);
193
194 /* turn parameters into data stream */
195 if (reg_io_q_open_hklm("", &q_o, &buf, 0) &&
196 rpc_con_pipe_req(con, REG_OPEN_HKLM, &buf, &rbuf))
197 {
198 REG_R_OPEN_HKLM r_o;
199 BOOL p;
200
201 ZERO_STRUCT(r_o);
202
203 reg_io_r_open_hklm("", &r_o, &rbuf, 0);
204 p = rbuf.offset != 0;
205
206 if (p && r_o.status != 0)
207 {
208 /* report error code */
209 DEBUG(0, ("REG_OPEN_HKLM: %s\n",
210 get_nt_error_msg(r_o.status)));
211 p = False;
212 }
213
214 if (p)
215 {
216 /* ok, at last: we're happy. return the policy handle */
217 *hnd = r_o.pol;
218 valid_pol = True;
219 }
220 }
221
222 prs_free_data(&rbuf);
223 prs_free_data(&buf );
224
225 return valid_pol;
226 }
227
228 /****************************************************************************
229 do a REG Open HKU
230 ****************************************************************************/
231 BOOL reg_open_hku(struct cli_connection *con,
232 uint16 unknown_0, uint32 level,
233 POLICY_HND *hnd)
234 {
235 prs_struct rbuf;
236 prs_struct buf;
237 REG_Q_OPEN_HKU q_o;
238 BOOL valid_pol = False;
239
240 if (hnd == NULL) return False;
241
242 prs_init(&buf , 0, 4, False);
243 prs_init(&rbuf, 0, 4, True );
244
245 /* create and send a MSRPC command with api REG_OPEN_HKU */
246
247 DEBUG(4,("REG Open HKU\n"));
248
249 make_reg_q_open_hku(&q_o, unknown_0, level);
250
251 /* turn parameters into data stream */
252 if (reg_io_q_open_hku("", &q_o, &buf, 0) &&
253 rpc_con_pipe_req(con, REG_OPEN_HKU, &buf, &rbuf))
254 {
255 REG_R_OPEN_HKU r_o;
256 BOOL p;
257
258 ZERO_STRUCT(r_o);
259
260 reg_io_r_open_hku("", &r_o, &rbuf, 0);
261 p = rbuf.offset != 0;
262
263 if (p && r_o.status != 0)
264 {
265 /* report error code */
266 DEBUG(0, ("REG_OPEN_HKU: %s\n",
267 get_nt_error_msg(r_o.status)));
268 p = False;
269 }
270
271 if (p)
272 {
273 /* ok, at last: we're happy. return the policy handle */
274 *hnd = r_o.pol;
275 valid_pol = True;
276 }
277 }
278
279 prs_free_data(&rbuf);
280 prs_free_data(&buf );
281
282 return valid_pol;
283 }
284
285 /****************************************************************************
286 do a REG Unknown 0xB command. sent after a create key or create value.
287 this might be some sort of "sync" or "refresh" command, sent after
288 modification of the registry...
289 ****************************************************************************/
290 BOOL reg_flush_key(POLICY_HND *hnd)
291 {
292 prs_struct rbuf;
293 prs_struct buf;
294 REG_Q_FLUSH_KEY q_o;
295 BOOL valid_query = False;
296
297 if (hnd == NULL) return False;
298
299 prs_init(&buf , 0, 4, False);
300 prs_init(&rbuf, 0, 4, True );
301
302 /* create and send a MSRPC command with api REG_FLUSH_KEY */
303
304 DEBUG(4,("REG Unknown 0xB\n"));
305
306 make_reg_q_flush_key(&q_o, hnd);
307
308 /* turn parameters into data stream */
309 if (reg_io_q_flush_key("", &q_o, &buf, 0) &&
310 rpc_hnd_pipe_req(hnd, REG_FLUSH_KEY, &buf, &rbuf))
311 {
312 REG_R_FLUSH_KEY r_o;
313 BOOL p;
314
315 ZERO_STRUCT(r_o);
316
317 reg_io_r_flush_key("", &r_o, &rbuf, 0);
318 p = rbuf.offset != 0;
319
320 if (p && r_o.status != 0)
321 {
322 /* report error code */
323 DEBUG(0, ("REG_FLUSH_KEY: %s\n",
324 get_nt_error_msg(r_o.status)));
325 p = False;
326 }
327
328 if (p)
329 {
330 valid_query = True;
331 }
332 }
333
334 prs_free_data(&rbuf);
335 prs_free_data(&buf );
336
337 return valid_query;
338 }
339
340 /****************************************************************************
341 do a REG Query Key
342 ****************************************************************************/
343 BOOL reg_query_key(POLICY_HND *hnd,
344 char *key_class, uint32 *class_len,
345 uint32 *num_subkeys, uint32 *max_subkeylen,
346 uint32 *max_subkeysize, uint32 *num_values,
347 uint32 *max_valnamelen, uint32 *max_valbufsize,
348 uint32 *sec_desc, NTTIME *mod_time)
349 {
350 prs_struct rbuf;
351 prs_struct buf;
352 REG_Q_QUERY_KEY q_o;
353 BOOL valid_query = False;
354
355 if (hnd == NULL) return False;
356
357 prs_init(&buf , 0, 4, False);
358 prs_init(&rbuf, 0, 4, True );
359
360 /* create and send a MSRPC command with api REG_QUERY_KEY */
361
362 DEBUG(4,("REG Query Key\n"));
363
364 make_reg_q_query_key(&q_o, hnd, *class_len);
365
366 /* turn parameters into data stream */
367 if (reg_io_q_query_key("", &q_o, &buf, 0) &&
368 rpc_hnd_pipe_req(hnd, REG_QUERY_KEY, &buf, &rbuf))
369 {
370 REG_R_QUERY_KEY r_o;
371 BOOL p;
372
373 ZERO_STRUCT(r_o);
374
375 reg_io_r_query_key("", &r_o, &rbuf, 0);
376 p = rbuf.offset != 0;
377
378 if (p && r_o.status != 0)
379 {
380 /* report error code */
381 DEBUG(0, ("REG_QUERY_KEY: %s\n",
382 get_nt_error_msg(r_o.status)));
383 p = False;
384 }
385
386 if (p)
387 {
388 valid_query = True;
389
390 *class_len = r_o.hdr_class.uni_max_len;
391 unistr2_to_ascii(key_class, &r_o.uni_class, sizeof(fstring)-1);
392 *num_subkeys = r_o.num_subkeys ;
393 *max_subkeylen = r_o.max_subkeylen ;
394 *max_subkeysize = r_o.max_subkeysize;
395 *num_values = r_o.num_values ;
396 *max_valnamelen = r_o.max_valnamelen;
397 *max_valbufsize = r_o.max_valbufsize;
398 *sec_desc = r_o.sec_desc ;
399 *mod_time = r_o.mod_time ;
400 }
401 }
402
403 prs_free_data(&rbuf);
404 prs_free_data(&buf );
405
406 return valid_query;
407 }
408
409 /****************************************************************************
410 do a REG Unknown 1A
411 ****************************************************************************/
412 BOOL reg_unknown_1a(POLICY_HND *hnd, uint32 *unk)
413 {
414 prs_struct rbuf;
415 prs_struct buf;
416 REG_Q_UNK_1A q_o;
417 BOOL valid_query = False;
418
419 if (hnd == NULL) return False;
420
421 prs_init(&buf , 0, 4, False);
422 prs_init(&rbuf, 0, 4, True );
423
424 /* create and send a MSRPC command with api REG_UNKNOWN_1A */
425
426 DEBUG(4,("REG Unknown 1a\n"));
427
428 make_reg_q_unk_1a(&q_o, hnd);
429
430 /* turn parameters into data stream */
431 if (reg_io_q_unk_1a("", &q_o, &buf, 0) &&
432 rpc_hnd_pipe_req(hnd, REG_UNK_1A, &buf, &rbuf))
433 {
434 REG_R_UNK_1A r_o;
435 BOOL p;
436
437 ZERO_STRUCT(r_o);
438
439 reg_io_r_unk_1a("", &r_o, &rbuf, 0);
440 p = rbuf.offset != 0;
441
442 if (p && r_o.status != 0)
443 {
444 /* report error code */
445 DEBUG(0, ("REG_UNK_1A: %s\n",
446 get_nt_error_msg(r_o.status)));
447 p = False;
448 }
449
450 if (p)
451 {
452 valid_query = True;
453 (*unk) = r_o.unknown;
454 }
455 }
456
457 prs_free_data(&rbuf);
458 prs_free_data(&buf );
459
460 return valid_query;
461 }
462
463 /****************************************************************************
464 do a REG Query Info
465 ****************************************************************************/
466 BOOL reg_query_info(POLICY_HND *hnd, const char *val_name,
467 uint32 *type, BUFFER2 *buffer)
468 {
469 prs_struct rbuf;
470 prs_struct buf;
471 REG_Q_INFO q_o;
472 BOOL valid_query = False;
473
474 if (hnd == NULL) return False;
475
476 prs_init(&buf , 0, 4, False);
477 prs_init(&rbuf, 0, 4, True );
478
479 /* create and send a MSRPC command with api REG_INFO */
480
481 DEBUG(4,("REG Query Info\n"));
482
483 make_reg_q_info(&q_o, hnd, val_name, 4, 0, buffer->buf_max_len);
484
485 /* turn parameters into data stream */
486 if (reg_io_q_info("", &q_o, &buf, 0) &&
487 rpc_hnd_pipe_req(hnd, REG_INFO, &buf, &rbuf))
488 {
489 REG_R_INFO r_o;
490 BOOL p;
491
492 ZERO_STRUCT(r_o);
493
494 r_o.type = *type;
495 r_o.uni_val = buffer;
496
497 reg_io_r_info("", &r_o, &rbuf, 0);
498 p = rbuf.offset != 0;
499
500 if (p && r_o.status != 0)
501 {
502 /* report error code */
503 DEBUG(0, ("REG_INFO: %s\n",
504 get_nt_error_msg(r_o.status)));
505 p = False;
506 }
507
508 if (p)
509 {
510 valid_query = True;
511 }
512 }
513
514 prs_free_data(&rbuf);
515 prs_free_data(&buf );
516
517 return valid_query;
518 }
519
520 /****************************************************************************
521 do a REG Set Key Security
522 ****************************************************************************/
523 BOOL reg_set_key_sec(POLICY_HND *hnd,
524 uint32 sec_info,
525 uint32 sec_buf_size, SEC_DESC *sec_buf)
526 {
527 prs_struct rbuf;
528 prs_struct buf;
529 REG_Q_SET_KEY_SEC q_o;
530 BOOL valid_query = False;
531
532 if (hnd == NULL) return False;
533
534 prs_init(&buf , 0, 4, False);
535 prs_init(&rbuf, 0, 4, True );
536
537 /* create and send a MSRPC command with api REG_SET_KEY_SEC */
538
539 DEBUG(4,("REG Set Key security.\n"));
540
541 make_reg_q_set_key_sec(&q_o, hnd, sec_info, sec_buf_size, sec_buf);
542
543 /* turn parameters into data stream */
544 if (reg_io_q_set_key_sec("", &q_o, &buf, 0) &&
545 rpc_hnd_pipe_req(hnd, REG_SET_KEY_SEC, &buf, &rbuf))
546 {
547 REG_R_SET_KEY_SEC r_o;
548 BOOL p;
549
550 ZERO_STRUCT(r_o);
551
552 reg_io_r_set_key_sec("", &r_o, &rbuf, 0);
553 p = rbuf.offset != 0;
554
555 if (p && r_o.status != 0)
556 {
557 valid_query = True;
558 }
559 }
560
561 prs_free_data(&rbuf);
562 prs_free_data(&buf );
563
564 return valid_query;
565 }
566
567
568 /****************************************************************************
569 do a REG Query Key Security
570 ****************************************************************************/
571 BOOL reg_get_key_sec(POLICY_HND *hnd,
572 uint32 sec_info,
573 uint32 *sec_buf_size, SEC_DESC_BUF *sec_buf)
574 {
575 prs_struct rbuf;
576 prs_struct buf;
577 REG_Q_GET_KEY_SEC q_o;
578 BOOL valid_query = False;
579
580 if (hnd == NULL) return False;
581
582 prs_init(&buf , 0, 4, False);
583 prs_init(&rbuf, 0, 4, True );
584
585 /* create and send a MSRPC command with api REG_GET_KEY_SEC */
586
587 DEBUG(4,("REG query key security. buf_size: %d\n", *sec_buf_size));
588
589 make_reg_q_get_key_sec(&q_o, hnd, sec_info, *sec_buf_size, sec_buf);
590
591 /* turn parameters into data stream */
592 if (reg_io_q_get_key_sec("", &q_o, &buf, 0) &&
593 rpc_hnd_pipe_req(hnd, REG_GET_KEY_SEC, &buf, &rbuf))
594 {
595 REG_R_GET_KEY_SEC r_o;
596 BOOL p;
597
598 ZERO_STRUCT(r_o);
599
600 r_o.data = sec_buf;
601 if (*sec_buf_size != 0)
602 {
603 sec_buf->sec = (SEC_DESC*)malloc(*sec_buf_size);
604 }
605 reg_io_r_get_key_sec("", &r_o, &rbuf, 0);
606 p = rbuf.offset != 0;
607
608 if (p && r_o.status == 0x0000007a)
609 {
610 /*
611 * get the maximum buffer size: it was too small
612 */
613 (*sec_buf_size) = r_o.hdr_sec.buf_max_len;
614 DEBUG(5, ("sec_buf_size too small. use %d\n",
615 *sec_buf_size));
616 valid_query = True;
617 }
618 else if (p && r_o.status != 0)
619 {
620 /* report error code */
621 DEBUG(0, ("REG_GET_KEY_SEC: %s\n",
622 get_nt_error_msg(r_o.status)));
623 p = False;
624 }
625 else
626 {
627 valid_query = True;
628 (*sec_buf_size) = r_o.data->len;
629 }
630 }
631
632 prs_free_data(&rbuf);
633 prs_free_data(&buf );
634
635 return valid_query;
636 }
637
638 /****************************************************************************
639 do a REG Delete Value
640 ****************************************************************************/
641 BOOL reg_delete_val(POLICY_HND *hnd, char *val_name)
642 {
643 prs_struct rbuf;
644 prs_struct buf;
645 REG_Q_DELETE_VALUE q_o;
646 BOOL valid_delete = False;
647
648 if (hnd == NULL) return False;
649
650 prs_init(&buf , 0, 4, False);
651 prs_init(&rbuf, 0, 4, True );
652
653 /* create and send a MSRPC command with api REG_DELETE_VALUE */
654
655 DEBUG(4,("REG Delete Value: %s\n", val_name));
656
657 make_reg_q_delete_val(&q_o, hnd, val_name);
658
659 /* turn parameters into data stream */
660 if (reg_io_q_delete_val("", &q_o, &buf, 0) &&
661 rpc_hnd_pipe_req(hnd, REG_DELETE_VALUE, &buf, &rbuf))
662 {
663 REG_R_DELETE_VALUE r_o;
664 BOOL p;
665
666 ZERO_STRUCT(r_o);
667
668 reg_io_r_delete_val("", &r_o, &rbuf, 0);
669 p = rbuf.offset != 0;
670
671 if (p && r_o.status != 0)
672 {
673 /* report error code */
674 DEBUG(0, ("REG_DELETE_VALUE: %s\n",
675 get_nt_error_msg(r_o.status)));
676 p = False;
677 }
678
679 if (p)
680 {
681 valid_delete = True;
682 }
683 }
684
685 prs_free_data(&rbuf);
686 prs_free_data(&buf );
687
688 return valid_delete;
689 }
690
691 /****************************************************************************
692 do a REG Delete Key
693 ****************************************************************************/
694 BOOL reg_delete_key(POLICY_HND *hnd, char *key_name)
695 {
696 prs_struct rbuf;
697 prs_struct buf;
698 REG_Q_DELETE_KEY q_o;
699 BOOL valid_delete = False;
700
701 if (hnd == NULL) return False;
702
703 prs_init(&buf , 0, 4, False);
704 prs_init(&rbuf, 0, 4, True );
705
706 /* create and send a MSRPC command with api REG_DELETE_KEY */
707
708 DEBUG(4,("REG Delete Key: %s\n", key_name));
709
710 make_reg_q_delete_key(&q_o, hnd, key_name);
711
712 /* turn parameters into data stream */
713 if (reg_io_q_delete_key("", &q_o, &buf, 0) &&
714 rpc_hnd_pipe_req(hnd, REG_DELETE_KEY, &buf, &rbuf))
715 {
716 REG_R_DELETE_KEY r_o;
717 BOOL p;
718
719 ZERO_STRUCT(r_o);
720
721 reg_io_r_delete_key("", &r_o, &rbuf, 0);
722 p = rbuf.offset != 0;
723
724 if (p && r_o.status != 0)
725 {
726 /* report error code */
727 DEBUG(0, ("REG_DELETE_KEY: %s\n",
728 get_nt_error_msg(r_o.status)));
729 p = False;
730 }
731
732 if (p)
733 {
734 valid_delete = True;
735 }
736 }
737
738 prs_free_data(&rbuf);
739 prs_free_data(&buf );
740
741 return valid_delete;
742 }
743
744 /****************************************************************************
745 do a REG Create Key
746 ****************************************************************************/
747 BOOL reg_create_key(POLICY_HND *hnd,
748 char *key_name, char *key_class,
749 SEC_ACCESS *sam_access,
750 POLICY_HND *key)
751 {
752 prs_struct rbuf;
753 prs_struct buf;
754 REG_Q_CREATE_KEY q_o;
755 BOOL valid_create = False;
756 SEC_DESC sec;
757 SEC_DESC_BUF sec_buf;
758 int sec_len;
759
760 ZERO_STRUCT(sec);
761 ZERO_STRUCT(sec_buf);
762 ZERO_STRUCT(q_o);
763
764 if (hnd == NULL) return False;
765
766 prs_init(&buf , 0, 4, False);
767 prs_init(&rbuf, 0, 4, True );
768
769 /* create and send a MSRPC command with api REG_CREATE_KEY */
770
771 DEBUG(4,("REG Create Key: %s %s 0x%08x\n", key_name, key_class,
772 sam_access != NULL ? sam_access->mask : 0));
773
774 sec_len = make_sec_desc(&sec, 1, SEC_DESC_SELF_RELATIVE,
775 NULL, NULL, NULL, NULL);
776
777 DEBUG(10,("make_sec_desc: len = %d\n", sec_len));
778
779 make_reg_q_create_key(&q_o, hnd, key_name, key_class, sam_access,
780 &sec_buf, sec_len, &sec);
781
782 /* turn parameters into data stream */
783 if (reg_io_q_create_key("", &q_o, &buf, 0) &&
784 rpc_hnd_pipe_req(hnd, REG_CREATE_KEY, &buf, &rbuf))
785 {
786 REG_R_CREATE_KEY r_o;
787 BOOL p;
788
789 ZERO_STRUCT(r_o);
790
791 reg_io_r_create_key("", &r_o, &rbuf, 0);
792 p = rbuf.offset != 0;
793
794 if (p && r_o.status != 0)
795 {
796 /* report error code */
797 DEBUG(0, ("REG_CREATE_KEY: %s\n",
798 get_nt_error_msg(r_o.status)));
799 p = False;
800 }
801
802 if (p)
803 {
804 valid_create = True;
805 *key = r_o.key_pol;
806 }
807 }
808
809 free_sec_desc(&sec);
810
811 prs_free_data(&rbuf);
812 prs_free_data(&buf );
813
814 return valid_create;
815 }
816
817 /****************************************************************************
818 do a REG Enum Key
819 ****************************************************************************/
820 BOOL reg_enum_key(POLICY_HND *hnd,
821 int key_index, char *key_name,
822 uint32 *unk_1, uint32 *unk_2,
823 time_t *mod_time)
824 {
825 prs_struct rbuf;
826 prs_struct buf;
827 REG_Q_ENUM_KEY q_o;
828 BOOL valid_query = False;
829
830 if (hnd == NULL) return False;
831
832 prs_init(&buf , 0, 4, False);
833 prs_init(&rbuf, 0, 4, True );
834
835 /* create and send a MSRPC command with api REG_ENUM_KEY */
836
837 DEBUG(4,("REG Enum Key\n"));
838
839 make_reg_q_enum_key(&q_o, hnd, key_index);
840
841 /* turn parameters into data stream */
842 if (reg_io_q_enum_key("", &q_o, &buf, 0) &&
843 rpc_hnd_pipe_req(hnd, REG_ENUM_KEY, &buf, &rbuf))
844 {
845 REG_R_ENUM_KEY r_o;
846 BOOL p;
847
848 ZERO_STRUCT(r_o);
849
850 reg_io_r_enum_key("", &r_o, &rbuf, 0);
851 p = rbuf.offset != 0;
852
853 if (p && r_o.status != 0)
854 {
855 /* report error code */
856 DEBUG(0, ("REG_ENUM_KEY: %s\n",
857 get_nt_error_msg(r_o.status)));
858 p = False;
859 }
860
861 if (p)
862 {
863 valid_query = True;
864 (*unk_1) = r_o.unknown_1;
865 (*unk_2) = r_o.unknown_2;
866 unistr_to_ascii(key_name, r_o.key_name.str.buffer,
867 sizeof(fstring)-1);
868 (*mod_time) = nt_time_to_unix(&r_o.time);
869 }
870 }
871
872 prs_free_data(&rbuf);
873 prs_free_data(&buf );
874
875 return valid_query;
876 }
877
878 /****************************************************************************
879 do a REG Create Value
880 ****************************************************************************/
881 BOOL reg_create_val(POLICY_HND *hnd,
882 char *val_name, uint32 type, BUFFER3 *data)
883 {
884 prs_struct rbuf;
885 prs_struct buf;
886 REG_Q_CREATE_VALUE q_o;
887 BOOL valid_create = False;
888
889 if (hnd == NULL) return False;
890
891 prs_init(&buf , 0, 4, False);
892 prs_init(&rbuf, 0, 4, True );
893
894 /* create and send a MSRPC command with api REG_CREATE_VALUE */
895
896 DEBUG(4,("REG Create Value: %s\n", val_name));
897
898 make_reg_q_create_val(&q_o, hnd, val_name, type, data);
899
900 /* turn parameters into data stream */
901 if (reg_io_q_create_val("", &q_o, &buf, 0) &&
902 rpc_hnd_pipe_req(hnd, REG_CREATE_VALUE, &buf, &rbuf))
903 {
904 REG_R_CREATE_VALUE r_o;
905 BOOL p;
906
907 ZERO_STRUCT(r_o);
908
909 reg_io_r_create_val("", &r_o, &rbuf, 0);
910 p = rbuf.offset != 0;
911
912 if (p && r_o.status != 0)
913 {
914 /* report error code */
915 DEBUG(0, ("REG_CREATE_VALUE: %s\n",
916 get_nt_error_msg(r_o.status)));
917 p = False;
918 }
919
920 if (p)
921 {
922 valid_create = True;
923 }
924 }
925
926 prs_free_data(&rbuf);
927 prs_free_data(&buf );
928
929 return valid_create;
930 }
931
932 /****************************************************************************
933 do a REG Enum Value
934 ****************************************************************************/
935 BOOL reg_enum_val(POLICY_HND *hnd,
936 int val_index, int max_valnamelen, int max_valbufsize,
937 fstring val_name,
938 uint32 *val_type, BUFFER2 *value)
939 {
940 prs_struct rbuf;
941 prs_struct buf;
942 REG_Q_ENUM_VALUE q_o;
943 BOOL valid_query = False;
944
945 if (hnd == NULL) return False;
946
947 prs_init(&buf , 0, 4, False);
948 prs_init(&rbuf, 0, 4, True );
949
950 /* create and send a MSRPC command with api REG_ENUM_VALUE */
951
952 DEBUG(4,("REG Enum Value\n"));
953
954 make_reg_q_enum_val(&q_o, hnd, val_index, max_valnamelen, max_valbufsize);
955
956 /* turn parameters into data stream */
957 if (reg_io_q_enum_val("", &q_o, &buf, 0) &&
958 rpc_hnd_pipe_req(hnd, REG_ENUM_VALUE, &buf, &rbuf))
959 {
960 REG_R_ENUM_VALUE r_o;
961 BOOL p;
962
963 ZERO_STRUCT(r_o);
964 r_o.buf_value = value;
965
966 reg_io_r_enum_val("", &r_o, &rbuf, 0);
967 p = rbuf.offset != 0;
968
969 if (p && r_o.status != 0)
970 {
971 /* report error code */
972 DEBUG(0, ("REG_ENUM_VALUE: %s\n",
973 get_nt_error_msg(r_o.status)));
974 p = False;
975 }
976
977 if (p)
978 {
979 valid_query = True;
980 (*val_type) = r_o.type;
981 unistr2_to_ascii(val_name, &r_o.uni_name, sizeof(fstring)-1);
982 }
983 }
984
985 prs_free_data(&rbuf);
986 prs_free_data(&buf );
987
988 return valid_query;
989 }
990
991 /****************************************************************************
992 do a REG Open Key
993 ****************************************************************************/
994 BOOL reg_open_entry(POLICY_HND *hnd,
995 char *key_name, uint32 unk_0,
996 POLICY_HND *key_hnd)
997 {
998 prs_struct rbuf;
999 prs_struct buf;
1000 REG_Q_OPEN_ENTRY q_o;
1001 BOOL valid_pol = False;
1002
1003 if (hnd == NULL) return False;
1004
1005 prs_init(&buf , 0, 4, False);
1006 prs_init(&rbuf, 0, 4, True );
1007
1008 /* create and send a MSRPC command with api REG_OPEN_ENTRY */
1009
1010 DEBUG(4,("REG Open Entry\n"));
1011
1012 make_reg_q_open_entry(&q_o, hnd, key_name, unk_0);
1013
1014 /* turn parameters into data stream */
1015 if (reg_io_q_open_entry("", &q_o, &buf, 0) &&
1016 rpc_hnd_pipe_req(hnd, REG_OPEN_ENTRY, &buf, &rbuf))
1017 {
1018 REG_R_OPEN_ENTRY r_o;
1019 BOOL p;
1020
1021 ZERO_STRUCT(r_o);
1022
1023 reg_io_r_open_entry("", &r_o, &rbuf, 0);
1024 p = rbuf.offset != 0;
1025
1026 if (p && r_o.status != 0)
1027 {
1028 /* report error code */
1029 DEBUG(0, ("REG_OPEN_ENTRY: %s\n",
1030 get_nt_error_msg(r_o.status)));
1031 p = False;
1032 }
1033
1034 if (p)
1035 {
1036 struct cli_connection *con = NULL;
1037
1038 if (!cli_connection_get(hnd, &con))
1039 {
1040 return False;
1041 }
1042
1043 *key_hnd = r_o.pol;
1044 valid_pol = cli_pol_link(key_hnd, hnd);
1045 }
1046 }
1047
1048 prs_free_data(&rbuf);
1049 prs_free_data(&buf );
1050
1051 return valid_pol;
1052 }
1053
1054 /****************************************************************************
1055 do a REG Close
1056 ****************************************************************************/
1057 BOOL reg_close(POLICY_HND *hnd)
1058 {
1059 prs_struct rbuf;
1060 prs_struct buf;
1061 REG_Q_CLOSE q_c;
1062 BOOL valid_close = False;
1063
1064 if (hnd == NULL) return False;
1065
1066 /* create and send a MSRPC command with api REG_CLOSE */
1067
1068 prs_init(&buf , 0, 4, False);
1069 prs_init(&rbuf, 0, 4, True );
1070
1071 DEBUG(4,("REG Close\n"));
1072
1073 /* store the parameters */
1074 make_reg_q_close(&q_c, hnd);
1075
1076 /* turn parameters into data stream */
1077 if (reg_io_q_close("", &q_c, &buf, 0) &&
1078 rpc_hnd_pipe_req(hnd, REG_CLOSE, &buf, &rbuf))
1079 {
1080 REG_R_CLOSE r_c;
1081 BOOL p;
1082
1083 ZERO_STRUCT(r_c);
1084
1085 reg_io_r_close("", &r_c, &rbuf, 0);
1086 p = rbuf.offset != 0;
1087
1088 if (p && r_c.status != 0)
1089 {
1090 /* report error code */
1091 DEBUG(0, ("REG_CLOSE: %s\n",
1092 get_nt_error_msg(r_c.status)));
1093 p = False;
1094 }
1095
1096 if (p)
1097 {
1098 valid_close = True;
1099 }
1100 }
1101
1102 prs_free_data(&rbuf);
1103 prs_free_data(&buf );
1104
1105 close_policy_hnd(get_global_hnd_cache(), hnd);
1106
1107 return valid_close;
1108 }
1109
1110 /****************************************************************************
1111 do a REG Shutdown Server
1112 ****************************************************************************/
1113 BOOL reg_shutdown(const char *srv_name,
1114 const char *msg, uint32 timeout, uint16 flags)
1115 {
1116 prs_struct rbuf;
1117 prs_struct buf;
1118 REG_Q_SHUTDOWN q_o;
1119 BOOL valid_shutdown = False;
1120
1121 struct cli_connection *con = NULL;
1122
1123 if (!cli_connection_init(srv_name, PIPE_WINREG, &con))
1124 {
1125 return False;
1126 }
1127
1128 if (msg == NULL) return False;
1129
1130 prs_init(&buf , 0, 4, False);
1131 prs_init(&rbuf, 0, 4, True );
1132
1133 /* create and send a MSRPC command with api REG_SHUTDOWN */
1134
1135 DEBUG(4,("REG Shutdown: (timeout: %d secs) %s\n", timeout, msg));
1136
1137 make_reg_q_shutdown(&q_o, msg, timeout, flags);
1138
1139 /* turn parameters into data stream */
1140 if (reg_io_q_shutdown("", &q_o, &buf, 0) &&
1141 rpc_con_pipe_req(con, REG_SHUTDOWN, &buf, &rbuf))
1142 {
1143 REG_R_SHUTDOWN r_o;
1144 BOOL p;
1145
1146 ZERO_STRUCT(r_o);
1147
1148 reg_io_r_shutdown("", &r_o, &rbuf, 0);
1149 p = rbuf.offset != 0;
1150
1151 if (p && r_o.status != 0)
1152 {
1153 /* report error code */
1154 DEBUG(0, ("REG_SHUTDOWN: %s\n",
1155 get_nt_error_msg(r_o.status)));
1156 p = False;
1157 }
1158
1159 if (p)
1160 {
1161 valid_shutdown = True;
1162 }
1163 }
1164
1165 prs_free_data(&rbuf);
1166 prs_free_data(&buf );
1167
1168 cli_connection_unlink(con);
1169
1170 return valid_shutdown;
1171 }
1172
1173
1174 /****************************************************************************
1175 do a REG Abort Shutdown
1176 ****************************************************************************/
1177 BOOL reg_abort_shutdown(const char *srv_name)
1178 {
1179 prs_struct rbuf;
1180 prs_struct buf;
1181 REG_Q_ABORT_SHUTDOWN q_o;
1182 BOOL valid_abort = False;
1183
1184 struct cli_connection *con = NULL;
1185
1186 if (!cli_connection_init(srv_name, PIPE_WINREG, &con))
1187 {
1188 return False;
1189 }
1190
1191 prs_init(&buf , 0, 4, False);
1192 prs_init(&rbuf, 0, 4, True );
1193
1194 /* create and send a MSRPC command with api REG_ABORT_SHUTDOWN */
1195
1196 DEBUG(4,("REG Abort Shutdown\n"));
1197
1198 make_reg_q_abort_shutdown(&q_o);
1199
1200 /* turn parameters into data stream */
1201 if (reg_io_q_abort_shutdown("", &q_o, &buf, 0) &&
1202 rpc_con_pipe_req(con, REG_ABORT_SHUTDOWN, &buf, &rbuf))
1203 {
1204 REG_R_ABORT_SHUTDOWN r_o;
1205 BOOL p;
1206
1207 ZERO_STRUCT(r_o);
1208
1209 reg_io_r_abort_shutdown("", &r_o, &rbuf, 0);
1210 p = rbuf.offset != 0;
1211
1212 if (p && r_o.status != 0)
1213 {
1214 /* report error code */
1215 DEBUG(0, ("REG_ABORT_SHUTDOWN: %s\n",
1216 get_nt_error_msg(r_o.status)));
1217 p = False;
1218 }
1219
1220 if (p)
1221 {
1222 valid_abort = True;
1223 }
1224 }
1225
1226 prs_free_data(&rbuf);
1227 prs_free_data(&buf );
1228
1229 cli_connection_unlink(con);
1230
1231 return valid_abort;
1232 }
WIP