?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libcli/smbreadline/smbreadline.h: fix licence/copyright
[Samba.git] / source3 / rpc_client / cli_winreg.c
blob2517dbc50ab9c7d270810c7ee7bddd41a0702c71
1 /*
2 * Unix SMB/CIFS implementation.
3 *
4 * WINREG client routines
5 *
6 * Copyright (c) 2011 Andreas Schneider <asn@samba.org>
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "../librpc/gen_ndr/ndr_winreg_c.h"
24 #include "../librpc/gen_ndr/ndr_security.h"
25 #include "rpc_client/cli_winreg.h"
26 #include "../libcli/registry/util_reg.h"
27
28 NTSTATUS dcerpc_winreg_query_dword(TALLOC_CTX *mem_ctx,
29 struct dcerpc_binding_handle *h,
30 struct policy_handle *key_handle,
31 const char *value,
32 uint32_t *data,
33 WERROR *pwerr)
34 {
35 struct winreg_String wvalue;
36 enum winreg_Type type;
37 uint32_t value_len = 0;
38 uint32_t data_size = 0;
39 WERROR result = WERR_OK;
40 NTSTATUS status;
41 DATA_BLOB blob;
42
43 wvalue.name = value;
44
45 status = dcerpc_winreg_QueryValue(h,
46 mem_ctx,
47 key_handle,
48 &wvalue,
49 &type,
50 NULL,
51 &data_size,
52 &value_len,
53 &result);
54 if (!NT_STATUS_IS_OK(status)) {
55 return status;
56 }
57 if (!W_ERROR_IS_OK(result)) {
58 *pwerr = result;
59 return status;
60 }
61
62 if (type != REG_DWORD) {
63 *pwerr = WERR_INVALID_DATATYPE;
64 return status;
65 }
66
67 if (data_size != 4) {
68 *pwerr = WERR_INVALID_DATA;
69 return status;
70 }
71
72 blob = data_blob_talloc(mem_ctx, NULL, data_size);
73 if (blob.data == NULL) {
74 *pwerr = WERR_NOMEM;
75 return status;
76 }
77 value_len = 0;
78
79 status = dcerpc_winreg_QueryValue(h,
80 mem_ctx,
81 key_handle,
82 &wvalue,
83 &type,
84 blob.data,
85 &data_size,
86 &value_len,
87 &result);
88 if (!NT_STATUS_IS_OK(status)) {
89 return status;
90 }
91 if (!W_ERROR_IS_OK(result)) {
92 *pwerr = result;
93 return status;
94 }
95
96 if (data) {
97 *data = IVAL(blob.data, 0);
98 }
99
100 return status;
101 }
102
103 NTSTATUS dcerpc_winreg_query_binary(TALLOC_CTX *mem_ctx,
104 struct dcerpc_binding_handle *h,
105 struct policy_handle *key_handle,
106 const char *value,
107 DATA_BLOB *data,
108 WERROR *pwerr)
109 {
110 struct winreg_String wvalue;
111 enum winreg_Type type;
112 WERROR result = WERR_OK;
113 uint32_t value_len = 0;
114 uint32_t data_size = 0;
115 NTSTATUS status;
116 DATA_BLOB blob;
117
118 wvalue.name = value;
119
120 status = dcerpc_winreg_QueryValue(h,
121 mem_ctx,
122 key_handle,
123 &wvalue,
124 &type,
125 NULL,
126 &data_size,
127 &value_len,
128 &result);
129 if (!NT_STATUS_IS_OK(status)) {
130 return status;
131 }
132 if (!W_ERROR_IS_OK(result)) {
133 *pwerr = result;
134 return status;
135 }
136
137 if (type != REG_BINARY) {
138 *pwerr = WERR_INVALID_DATATYPE;
139 return status;
140 }
141
142 blob = data_blob_talloc(mem_ctx, NULL, data_size);
143 if (blob.data == NULL) {
144 *pwerr = WERR_NOMEM;
145 return status;
146 }
147 value_len = 0;
148
149 status = dcerpc_winreg_QueryValue(h,
150 mem_ctx,
151 key_handle,
152 &wvalue,
153 &type,
154 blob.data,
155 &data_size,
156 &value_len,
157 &result);
158 if (!NT_STATUS_IS_OK(status)) {
159 return status;
160 }
161 if (!W_ERROR_IS_OK(result)) {
162 *pwerr = result;
163 return status;
164 }
165
166 if (data) {
167 data->data = blob.data;
168 data->length = blob.length;
169 }
170
171 return status;
172 }
173
174 NTSTATUS dcerpc_winreg_query_multi_sz(TALLOC_CTX *mem_ctx,
175 struct dcerpc_binding_handle *h,
176 struct policy_handle *key_handle,
177 const char *value,
178 const char ***data,
179 WERROR *pwerr)
180 {
181 struct winreg_String wvalue;
182 enum winreg_Type type;
183 WERROR result = WERR_OK;
184 uint32_t value_len = 0;
185 uint32_t data_size = 0;
186 NTSTATUS status;
187 DATA_BLOB blob;
188
189 wvalue.name = value;
190
191 status = dcerpc_winreg_QueryValue(h,
192 mem_ctx,
193 key_handle,
194 &wvalue,
195 &type,
196 NULL,
197 &data_size,
198 &value_len,
199 &result);
200 if (!NT_STATUS_IS_OK(status)) {
201 return status;
202 }
203 if (!W_ERROR_IS_OK(result)) {
204 *pwerr = result;
205 return status;
206 }
207
208 if (type != REG_MULTI_SZ) {
209 *pwerr = WERR_INVALID_DATATYPE;
210 return status;
211 }
212
213 blob = data_blob_talloc(mem_ctx, NULL, data_size);
214 if (blob.data == NULL) {
215 *pwerr = WERR_NOMEM;
216 return status;
217 }
218 value_len = 0;
219
220 status = dcerpc_winreg_QueryValue(h,
221 mem_ctx,
222 key_handle,
223 &wvalue,
224 &type,
225 blob.data,
226 &data_size,
227 &value_len,
228 &result);
229 if (!NT_STATUS_IS_OK(status)) {
230 return status;
231 }
232 if (!W_ERROR_IS_OK(result)) {
233 *pwerr = result;
234 return status;
235 }
236
237 if (data) {
238 bool ok;
239
240 ok = pull_reg_multi_sz(mem_ctx, &blob, data);
241 if (!ok) {
242 *pwerr = WERR_NOMEM;
243 }
244 }
245
246 return status;
247 }
248
249 NTSTATUS dcerpc_winreg_query_sz(TALLOC_CTX *mem_ctx,
250 struct dcerpc_binding_handle *h,
251 struct policy_handle *key_handle,
252 const char *value,
253 const char **data,
254 WERROR *pwerr)
255 {
256 struct winreg_String wvalue;
257 enum winreg_Type type;
258 WERROR result = WERR_OK;
259 uint32_t value_len = 0;
260 uint32_t data_size = 0;
261 NTSTATUS status;
262 DATA_BLOB blob;
263
264 wvalue.name = value;
265
266 status = dcerpc_winreg_QueryValue(h,
267 mem_ctx,
268 key_handle,
269 &wvalue,
270 &type,
271 NULL,
272 &data_size,
273 &value_len,
274 &result);
275 if (!NT_STATUS_IS_OK(status)) {
276 return status;
277 }
278 if (!W_ERROR_IS_OK(result)) {
279 *pwerr = result;
280 return status;
281 }
282
283 if (type != REG_SZ) {
284 *pwerr = WERR_INVALID_DATATYPE;
285 return status;
286 }
287
288 blob = data_blob_talloc(mem_ctx, NULL, data_size);
289 if (blob.data == NULL) {
290 *pwerr = WERR_NOMEM;
291 return status;
292 }
293 value_len = 0;
294
295 status = dcerpc_winreg_QueryValue(h,
296 mem_ctx,
297 key_handle,
298 &wvalue,
299 &type,
300 blob.data,
301 &data_size,
302 &value_len,
303 &result);
304 if (!NT_STATUS_IS_OK(status)) {
305 return status;
306 }
307 if (!W_ERROR_IS_OK(result)) {
308 *pwerr = result;
309 return status;
310 }
311
312 if (data) {
313 bool ok;
314
315 ok = pull_reg_sz(mem_ctx, &blob, data);
316 if (!ok) {
317 *pwerr = WERR_NOMEM;
318 }
319 }
320
321 return status;
322 }
323
324 NTSTATUS dcerpc_winreg_query_sd(TALLOC_CTX *mem_ctx,
325 struct dcerpc_binding_handle *h,
326 struct policy_handle *key_handle,
327 const char *value,
328 struct security_descriptor **data,
329 WERROR *pwerr)
330 {
331 WERROR result = WERR_OK;
332 NTSTATUS status;
333 DATA_BLOB blob;
334
335 status = dcerpc_winreg_query_binary(mem_ctx,
336 h,
337 key_handle,
338 value,
339 &blob,
340 &result);
341 if (!NT_STATUS_IS_OK(status)) {
342 return status;
343 }
344 if (!W_ERROR_IS_OK(result)) {
345 *pwerr = result;
346 return status;
347 }
348
349 if (data) {
350 struct security_descriptor *sd;
351 enum ndr_err_code ndr_err;
352
353 sd = talloc_zero(mem_ctx, struct security_descriptor);
354 if (sd == NULL) {
355 *pwerr = WERR_NOMEM;
356 return NT_STATUS_OK;
357 }
358
359 ndr_err = ndr_pull_struct_blob(&blob,
360 sd,
361 sd,
362 (ndr_pull_flags_fn_t) ndr_pull_security_descriptor);
363 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
364 DEBUG(2, ("dcerpc_winreg_query_sd: Failed to marshall "
365 "security descriptor\n"));
366 *pwerr = WERR_NOMEM;
367 return NT_STATUS_OK;
368 }
369
370 *data = sd;
371 }
372
373 return status;
374 }
375
376 NTSTATUS dcerpc_winreg_set_dword(TALLOC_CTX *mem_ctx,
377 struct dcerpc_binding_handle *h,
378 struct policy_handle *key_handle,
379 const char *value,
380 uint32_t data,
381 WERROR *pwerr)
382 {
383 struct winreg_String wvalue = { 0, };
384 DATA_BLOB blob;
385 WERROR result = WERR_OK;
386 NTSTATUS status;
387
388 wvalue.name = value;
389 blob = data_blob_talloc(mem_ctx, NULL, 4);
390 SIVAL(blob.data, 0, data);
391
392 status = dcerpc_winreg_SetValue(h,
393 mem_ctx,
394 key_handle,
395 wvalue,
396 REG_DWORD,
397 blob.data,
398 blob.length,
399 &result);
400 if (!NT_STATUS_IS_OK(status)) {
401 return status;
402 }
403 if (!W_ERROR_IS_OK(result)) {
404 *pwerr = result;
405 }
406
407 return status;
408 }
409
410 NTSTATUS dcerpc_winreg_set_sz(TALLOC_CTX *mem_ctx,
411 struct dcerpc_binding_handle *h,
412 struct policy_handle *key_handle,
413 const char *value,
414 const char *data,
415 WERROR *pwerr)
416 {
417 struct winreg_String wvalue = { 0, };
418 DATA_BLOB blob;
419 WERROR result = WERR_OK;
420 NTSTATUS status;
421
422 wvalue.name = value;
423 if (data == NULL) {
424 blob = data_blob_string_const("");
425 } else {
426 if (!push_reg_sz(mem_ctx, &blob, data)) {
427 DEBUG(2, ("dcerpc_winreg_set_sz: Could not marshall "
428 "string %s for %s\n",
429 data, wvalue.name));
430 *pwerr = WERR_NOMEM;
431 return NT_STATUS_OK;
432 }
433 }
434
435 status = dcerpc_winreg_SetValue(h,
436 mem_ctx,
437 key_handle,
438 wvalue,
439 REG_SZ,
440 blob.data,
441 blob.length,
442 &result);
443 if (!NT_STATUS_IS_OK(status)) {
444 return status;
445 }
446 if (!W_ERROR_IS_OK(result)) {
447 *pwerr = result;
448 }
449
450 return status;
451 }
452
453 NTSTATUS dcerpc_winreg_set_expand_sz(TALLOC_CTX *mem_ctx,
454 struct dcerpc_binding_handle *h,
455 struct policy_handle *key_handle,
456 const char *value,
457 const char *data,
458 WERROR *pwerr)
459 {
460 struct winreg_String wvalue = { 0, };
461 DATA_BLOB blob;
462 WERROR result = WERR_OK;
463 NTSTATUS status;
464
465 wvalue.name = value;
466 if (data == NULL) {
467 blob = data_blob_string_const("");
468 } else {
469 if (!push_reg_sz(mem_ctx, &blob, data)) {
470 DEBUG(2, ("dcerpc_winreg_set_expand_sz: Could not marshall "
471 "string %s for %s\n",
472 data, wvalue.name));
473 *pwerr = WERR_NOMEM;
474 return NT_STATUS_OK;
475 }
476 }
477
478 status = dcerpc_winreg_SetValue(h,
479 mem_ctx,
480 key_handle,
481 wvalue,
482 REG_EXPAND_SZ,
483 blob.data,
484 blob.length,
485 &result);
486 if (!NT_STATUS_IS_OK(status)) {
487 return status;
488 }
489 if (!W_ERROR_IS_OK(result)) {
490 *pwerr = result;
491 }
492
493 return status;
494 }
495
496 NTSTATUS dcerpc_winreg_set_multi_sz(TALLOC_CTX *mem_ctx,
497 struct dcerpc_binding_handle *h,
498 struct policy_handle *key_handle,
499 const char *value,
500 const char **data,
501 WERROR *pwerr)
502 {
503 struct winreg_String wvalue = { 0, };
504 DATA_BLOB blob;
505 WERROR result = WERR_OK;
506 NTSTATUS status;
507
508 wvalue.name = value;
509 if (!push_reg_multi_sz(mem_ctx, &blob, data)) {
510 DEBUG(2, ("dcerpc_winreg_set_multi_sz: Could not marshall "
511 "string multi sz for %s\n",
512 wvalue.name));
513 *pwerr = WERR_NOMEM;
514 return NT_STATUS_OK;
515 }
516
517 status = dcerpc_winreg_SetValue(h,
518 mem_ctx,
519 key_handle,
520 wvalue,
521 REG_MULTI_SZ,
522 blob.data,
523 blob.length,
524 &result);
525 if (!NT_STATUS_IS_OK(status)) {
526 return status;
527 }
528 if (!W_ERROR_IS_OK(result)) {
529 *pwerr = result;
530 }
531
532 return status;
533 }
534
535 NTSTATUS dcerpc_winreg_set_binary(TALLOC_CTX *mem_ctx,
536 struct dcerpc_binding_handle *h,
537 struct policy_handle *key_handle,
538 const char *value,
539 DATA_BLOB *data,
540 WERROR *pwerr)
541 {
542 struct winreg_String wvalue = { 0, };
543 WERROR result = WERR_OK;
544 NTSTATUS status;
545
546 wvalue.name = value;
547
548 status = dcerpc_winreg_SetValue(h,
549 mem_ctx,
550 key_handle,
551 wvalue,
552 REG_BINARY,
553 data->data,
554 data->length,
555 &result);
556 if (!NT_STATUS_IS_OK(status)) {
557 return status;
558 }
559 if (!W_ERROR_IS_OK(result)) {
560 *pwerr = result;
561 }
562
563 return status;
564 }
565
566 NTSTATUS dcerpc_winreg_set_sd(TALLOC_CTX *mem_ctx,
567 struct dcerpc_binding_handle *h,
568 struct policy_handle *key_handle,
569 const char *value,
570 const struct security_descriptor *data,
571 WERROR *pwerr)
572 {
573 enum ndr_err_code ndr_err;
574 DATA_BLOB blob;
575
576 ndr_err = ndr_push_struct_blob(&blob,
577 mem_ctx,
578 data,
579 (ndr_push_flags_fn_t) ndr_push_security_descriptor);
580 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
581 DEBUG(2, ("dcerpc_winreg_set_sd: Failed to marshall security "
582 "descriptor\n"));
583 *pwerr = WERR_NOMEM;
584 return NT_STATUS_OK;
585 }
586
587 return dcerpc_winreg_set_binary(mem_ctx,
588 h,
589 key_handle,
590 value,
591 &blob,
592 pwerr);
593 }
594
595 NTSTATUS dcerpc_winreg_add_multi_sz(TALLOC_CTX *mem_ctx,
596 struct dcerpc_binding_handle *h,
597 struct policy_handle *key_handle,
598 const char *value,
599 const char *data,
600 WERROR *pwerr)
601 {
602 const char **a = NULL;
603 const char **p;
604 uint32_t i;
605 WERROR result = WERR_OK;
606 NTSTATUS status;
607
608 status = dcerpc_winreg_query_multi_sz(mem_ctx,
609 h,
610 key_handle,
611 value,
612 &a,
613 &result);
614
615 /* count the elements */
616 for (p = a, i = 0; p && *p; p++, i++);
617
618 p = TALLOC_REALLOC_ARRAY(mem_ctx, a, const char *, i + 2);
619 if (p == NULL) {
620 *pwerr = WERR_NOMEM;
621 return NT_STATUS_OK;
622 }
623
624 p[i] = data;
625 p[i + 1] = NULL;
626
627 status = dcerpc_winreg_set_multi_sz(mem_ctx,
628 h,
629 key_handle,
630 value,
631 p,
632 pwerr);
633
634 return status;
635 }
636
637 NTSTATUS dcerpc_winreg_enum_keys(TALLOC_CTX *mem_ctx,
638 struct dcerpc_binding_handle *h,
639 struct policy_handle *key_hnd,
640 uint32_t *pnum_subkeys,
641 const char ***psubkeys,
642 WERROR *pwerr)
643 {
644 const char **subkeys;
645 uint32_t num_subkeys, max_subkeylen, max_classlen;
646 uint32_t num_values, max_valnamelen, max_valbufsize;
647 uint32_t i;
648 NTTIME last_changed_time;
649 uint32_t secdescsize;
650 struct winreg_String classname;
651 WERROR result = WERR_OK;
652 NTSTATUS status;
653 TALLOC_CTX *tmp_ctx;
654
655 tmp_ctx = talloc_stackframe();
656 if (tmp_ctx == NULL) {
657 return NT_STATUS_NO_MEMORY;
658 }
659
660 ZERO_STRUCT(classname);
661
662 status = dcerpc_winreg_QueryInfoKey(h,
663 tmp_ctx,
664 key_hnd,
665 &classname,
666 &num_subkeys,
667 &max_subkeylen,
668 &max_classlen,
669 &num_values,
670 &max_valnamelen,
671 &max_valbufsize,
672 &secdescsize,
673 &last_changed_time,
674 &result);
675 if (!NT_STATUS_IS_OK(status)) {
676 goto error;
677 }
678 if (!W_ERROR_IS_OK(result)) {
679 *pwerr = result;
680 goto error;
681 }
682
683 subkeys = talloc_zero_array(tmp_ctx, const char *, num_subkeys + 2);
684 if (subkeys == NULL) {
685 *pwerr = WERR_NOMEM;
686 goto error;
687 }
688
689 if (num_subkeys == 0) {
690 subkeys[0] = talloc_strdup(subkeys, "");
691 if (subkeys[0] == NULL) {
692 *pwerr = WERR_NOMEM;
693 goto error;
694 }
695 *pnum_subkeys = 0;
696 if (psubkeys) {
697 *psubkeys = talloc_move(mem_ctx, &subkeys);
698 }
699
700 TALLOC_FREE(tmp_ctx);
701 return NT_STATUS_OK;
702 }
703
704 for (i = 0; i < num_subkeys; i++) {
705 char c = '\0';
706 char n = '\0';
707 char *name = NULL;
708 struct winreg_StringBuf class_buf;
709 struct winreg_StringBuf name_buf;
710 NTTIME modtime;
711
712 class_buf.name = &c;
713 class_buf.size = max_classlen + 2;
714 class_buf.length = 0;
715
716 name_buf.name = &n;
717 name_buf.size = max_subkeylen + 2;
718 name_buf.length = 0;
719
720 ZERO_STRUCT(modtime);
721
722 status = dcerpc_winreg_EnumKey(h,
723 tmp_ctx,
724 key_hnd,
725 i,
726 &name_buf,
727 &class_buf,
728 &modtime,
729 &result);
730 if (!NT_STATUS_IS_OK(status)) {
731 DEBUG(5, ("dcerpc_winreg_enum_keys: Could not enumerate keys: %s\n",
732 nt_errstr(status)));
733 goto error;
734 }
735
736 if (W_ERROR_EQUAL(result, WERR_NO_MORE_ITEMS) ) {
737 *pwerr = WERR_OK;
738 break;
739 }
740 if (!W_ERROR_IS_OK(result)) {
741 DEBUG(5, ("dcerpc_winreg_enum_keys: Could not enumerate keys: %s\n",
742 win_errstr(result)));
743 *pwerr = result;
744 goto error;
745 }
746
747 if (name_buf.name == NULL) {
748 *pwerr = WERR_INVALID_PARAMETER;
749 goto error;
750 }
751
752 name = talloc_strdup(subkeys, name_buf.name);
753 if (name == NULL) {
754 *pwerr = WERR_NOMEM;
755 goto error;
756 }
757
758 subkeys[i] = name;
759 }
760
761 *pnum_subkeys = num_subkeys;
762 if (psubkeys) {
763 *psubkeys = talloc_move(mem_ctx, &subkeys);
764 }
765
766 error:
767 TALLOC_FREE(tmp_ctx);
768
769 return status;
770 }
771
772 /* vim: set ts=8 sw=8 noet cindent syntax=c.doxygen: */
Samba GIT mirror