source: trunk/server/source3/registry/reg_format.c

Last change on this file was 751, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.9
File size: 17.6 KB
Line 
1/*
2 * Samba Unix/Linux SMB client library
3 *
4 * Copyright (C) Gregor Beck 2010
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20/**
21 * @brief Format dot.reg files
22 * @file reg_format.c
23 * @author Gregor Beck <gb@sernet.de>
24 * @date Sep 2010
25 */
26
27#include "includes.h"
28#include "reg_format.h"
29#include "reg_parse.h"
30#include "reg_parse_internal.h"
31#include "cbuf.h"
32#include "srprs.h"
33#include "registry.h"
34#include "registry/reg_objects.h"
35#include <assert.h>
36
37static void cstr_unescape(char* val)
38{
39 all_string_sub(val, "\\r", "\r", 0);
40 all_string_sub(val, "\\n", "\n", 0);
41 all_string_sub(val, "\\t", "\t", 0);
42 all_string_sub(val, "\\\\", "\\", 0);
43}
44
45/******************************************************************************/
46
47/**
48 * Print value assign to stream.
49 *
50 * @param[out] ost outstream
51 * @param[in] name string
52 *
53 * @return numner of bytes written, -1 on error
54 * @see srprs_val_name
55 */
56static int cbuf_print_value_assign(cbuf* ost, const char* name) {
57 int ret, n;
58 if (*name == '\0') {
59 ret = cbuf_putc(ost, '@');
60 } else {
61 ret = cbuf_print_quoted_string(ost, name);
62 }
63
64 if (ret<0) {
65 return ret;
66 }
67
68 n = cbuf_putc(ost, '=');
69 if (n < 0) {
70 return n;
71 }
72 ret += n;
73
74 return ret;
75}
76
77enum fmt_hive {
78 FMT_HIVE_PRESERVE=0,
79 FMT_HIVE_SHORT,
80 FMT_HIVE_LONG
81};
82
83
84struct fmt_key {
85 enum fmt_hive hive_fmt;
86 enum fmt_case hive_case;
87 enum fmt_case key_case;
88 const char* sep;
89};
90
91
92static int
93cbuf_print_hive(cbuf* ost, const char* hive, int len, const struct fmt_key* fmt)
94{
95 if (fmt->hive_fmt != FMT_HIVE_PRESERVE) {
96 const struct hive_info* hinfo = hive_info(hive, len);
97 if (hinfo == NULL) {
98 DEBUG(0, ("Unknown hive %*s", len, hive));
99 } else {
100 switch(fmt->hive_fmt) {
101 case FMT_HIVE_SHORT:
102 hive = hinfo->short_name;
103 len = hinfo->short_name_len;
104 break;
105 case FMT_HIVE_LONG:
106 hive = hinfo->long_name;
107 len = hinfo->long_name_len;
108 break;
109 default:
110 DEBUG(0, ("Unsupported hive format %d",
111 (int)fmt->hive_fmt));
112 return -1;
113 }
114 }
115 }
116
117 return cbuf_puts_case(ost, hive, len, fmt->hive_case);
118}
119
120static int
121cbuf_print_keyname(cbuf* ost, const char* key[], int n, const struct fmt_key* fmt)
122{
123 int r, ret=0;
124 size_t pos = cbuf_getpos(ost);
125 bool hive = true;
126
127 for (; n>0; key++, n--) {
128 const char* start = *key;
129 while(*start != '\0') {
130 const char* end = start;
131 while(*end != '\\' && *end != '\0') {
132 end++;
133 }
134
135 if (hive) {
136 r = cbuf_print_hive(ost, start, end-start, fmt);
137 if (r < 0) {
138 goto fail;
139 }
140
141 ret += r;
142 hive = false;
143 } else {
144 r = cbuf_puts(ost, fmt->sep, -1);
145 if (r < 0) {
146 goto fail;
147 }
148 ret += r;
149
150 r = cbuf_puts_case(ost, start, end-start, fmt->key_case);
151 if (r < 0) {
152 goto fail;
153 }
154 ret += r;
155 }
156
157 while(*end == '\\') {
158 end++;
159 }
160 start = end;
161 }
162 }
163 return ret;
164fail:
165 cbuf_setpos(ost, pos);
166 return r;
167}
168/**@}*/
169
170/**
171 * @defgroup reg_format Format dot.reg file.
172 * @{
173 */
174
175struct reg_format
176{
177 struct reg_parse_callback reg_parse_callback;
178 struct reg_format_callback call;
179 unsigned flags;
180 smb_iconv_t fromUTF16;
181 const char* sep;
182};
183
184int reg_format_value_delete(struct reg_format* f, const char* name)
185{
186 int ret;
187 cbuf* line = cbuf_new(f);
188
189 ret = cbuf_print_value_assign(line, name);
190 if (ret < 0) {
191 goto done;
192 }
193
194 ret = cbuf_putc(line, '-');
195 if (ret < 0 ) {
196 goto done;
197 }
198
199 ret = f->call.writeline(f->call.data, cbuf_gets(line, 0));
200done:
201 talloc_free(line);
202 return ret;
203}
204
205/* Todo: write hex if str contains CR or LF */
206static int
207reg_format_value_sz(struct reg_format* f, const char* name, const char* str)
208{
209 int ret;
210 cbuf* line = cbuf_new(f);
211
212 ret = cbuf_print_value_assign(line, name);
213 if (ret < 0) {
214 goto done;
215 }
216
217 ret = cbuf_print_quoted_string(line, str);
218 if (ret < 0) {
219 goto done;
220 }
221
222 ret = f->call.writeline(f->call.data, cbuf_gets(line, 0));
223
224done:
225 talloc_free(line);
226 return ret;
227}
228
229static int reg_format_value_dw(struct reg_format* f, const char* name, uint32_t dw)
230{
231 int ret;
232 cbuf* line = cbuf_new(f);
233
234 ret = cbuf_print_value_assign(line, name);
235 if (ret < 0) {
236 goto done;
237 }
238
239 ret = cbuf_printf(line, "dword:%08x", dw);
240 if (ret < 0) {
241 goto done;
242 }
243
244 ret = f->call.writeline(f->call.data, cbuf_gets(line, 0));
245done:
246 talloc_free(line);
247 return ret;
248}
249
250static int reg_format_value_hex(struct reg_format* f, const char* name, uint32_t type,
251 const void* data, size_t len)
252{
253 int n;
254 int cpl=0;
255 int ret=0;
256 const unsigned char* ptr;
257
258 cbuf* line = cbuf_new(f);
259
260 n = cbuf_print_value_assign(line, name);
261 if (n < 0) {
262 ret = n;
263 goto done;
264 }
265
266 cpl += n;
267
268 if (type==REG_BINARY && !(f->flags & REG_FMT_HEX_BIN)) {
269 n=cbuf_puts(line, "hex:", -1);
270 } else {
271 n=cbuf_printf(line, "hex(%x):", type);
272 }
273 if (n < 0) {
274 ret = n;
275 goto done;
276 }
277
278 cpl += n;
279
280 for (ptr=(const unsigned char *)data; len>1; len--,ptr++) {
281 n = cbuf_printf(line, "%02x,", (unsigned)(*ptr));
282 if (n < 0) {
283 return n;
284 }
285 cpl += n;
286
287 if ( cpl > 76 ) {
288 n = cbuf_putc(line, '\\');
289 if (n< 0) {
290 return n;
291 }
292
293 n = f->call.writeline(f->call.data, cbuf_gets(line,0));
294 if (n < 0) {
295 ret = n;
296 goto done;
297 }
298 ret += n;
299
300 cbuf_clear(line);
301 cpl = cbuf_puts(line, " ", -1);
302 if (cpl < 0) {
303 ret = cpl;
304 goto done;
305 }
306 }
307 }
308
309 if ( len > 0 ) {
310 n = cbuf_printf(line, "%02x", (unsigned)(*ptr));
311 if (n < 0) {
312 ret = n;
313 goto done;
314 }
315 cpl += n;
316 }
317
318 n = f->call.writeline(f->call.data, cbuf_gets(line,0));
319 if (n < 0) {
320 ret = n;
321 goto done;
322 }
323 ret += n;
324done:
325 talloc_free(line);
326 return ret;
327}
328
329static bool is_zero_terminated_ucs2(const uint8_t* data, size_t len) {
330 const size_t idx = len/sizeof(smb_ucs2_t);
331 const smb_ucs2_t *str = (const smb_ucs2_t*)data;
332
333 if ((len % sizeof(smb_ucs2_t)) != 0) {
334 return false;
335 }
336
337 if (idx == 0) {
338 return false;
339 }
340
341 return (str[idx-1] == 0);
342}
343
344int reg_format_value(struct reg_format* f, const char* name, uint32_t type,
345 const uint8_t* data, size_t len)
346{
347 int ret = 0;
348 void* mem_ctx = talloc_new(f);
349
350 switch (type) {
351 case REG_SZ:
352 if (!(f->flags & REG_FMT_HEX_SZ)
353 && is_zero_terminated_ucs2(data, len))
354 {
355 char* str = NULL;
356 size_t dlen;
357 if (pull_ucs2_talloc(mem_ctx, &str, (const smb_ucs2_t*)data, &dlen)) {
358 ret = reg_format_value_sz(f, name, str);
359 goto done;
360 } else {
361 DEBUG(0, ("reg_format_value %s: "
362 "pull_ucs2_talloc failed"
363 ", try to write hex\n", name));
364 }
365 }
366 break;
367
368 case REG_DWORD:
369 if (!(f->flags & REG_FMT_HEX_SZ) && (len == sizeof(uint32_t))) {
370 uint32_t dw = IVAL(data,0);
371 ret = reg_format_value_dw(f, name, dw);
372 goto done;
373 }
374 break;
375
376 case REG_MULTI_SZ:
377 case REG_EXPAND_SZ:
378 if (f->fromUTF16 && (f->fromUTF16 != ((smb_iconv_t)-1))) {
379 char* str = NULL;
380 size_t dlen = iconvert_talloc(mem_ctx, f->fromUTF16,
381 (const char*)data, len, &str);
382 if (dlen != -1) {
383 ret = reg_format_value_hex(f, name, type, str, dlen);
384 goto done;
385 } else {
386 DEBUG(0, ("reg_format_value %s: "
387 "iconvert_talloc failed"
388 ", try to write hex\n", name));
389 }
390 }
391 break;
392 default:
393 break;
394 }
395
396 ret = reg_format_value_hex(f, name, type, data, len);
397done:
398 talloc_free(mem_ctx);
399 return ret;
400}
401
402
403int reg_format_comment(struct reg_format* f, const char* txt)
404{
405 int ret;
406 cbuf* line = cbuf_new(f);
407
408 ret = cbuf_putc(line,';');
409 if (ret<0) {
410 goto done;
411 }
412
413 ret = cbuf_puts(line, txt, -1);
414 if (ret < 0) {
415 goto done;
416 }
417
418 ret = f->call.writeline(f->call.data, cbuf_gets(line, 0));
419done:
420 talloc_free(line);
421 return ret;
422}
423
424
425/******************************************************************************/
426
427
428
429struct reg_format* reg_format_new(const void* talloc_ctx,
430 struct reg_format_callback cb,
431 const char* str_enc, unsigned flags,
432 const char* sep)
433{
434 static const struct reg_parse_callback reg_parse_callback_default = {
435 .key = (reg_parse_callback_key_t)&reg_format_key,
436 .val = (reg_parse_callback_val_t)&reg_format_value,
437 .val_del = (reg_parse_callback_val_del_t)&reg_format_value_delete,
438 .comment = (reg_parse_callback_comment_t)&reg_format_comment,
439 };
440
441 struct reg_format* f = talloc_zero(talloc_ctx, struct reg_format);
442 if (f == NULL) {
443 return NULL;
444 }
445
446 f->reg_parse_callback = reg_parse_callback_default;
447 f->reg_parse_callback.data = f;
448
449 f->call = cb;
450 f->flags = flags;
451 f->sep = sep;
452
453 if (str_enc && !set_iconv(&f->fromUTF16, str_enc, "UTF-16LE")) {
454 DEBUG(0, ("reg_format_new: failed to set encoding: %s\n",
455 str_enc));
456 goto fail;
457 }
458
459 assert(&f->reg_parse_callback == (struct reg_parse_callback*)f);
460 return f;
461fail:
462 talloc_free(f);
463 return NULL;
464}
465
466int reg_format_set_options(struct reg_format* fmt, const char* options)
467{
468 static const char* DEFAULT ="enc=unix,flags=0,sep=\\";
469
470 int ret = 0;
471 char *key, *val;
472 void* ctx = talloc_new(fmt);
473
474 if (options == NULL) {
475 options = DEFAULT;
476 }
477
478 while (srprs_option(&options, ctx, &key, &val)) {
479 if ((strcmp(key, "enc") == 0) || (strcmp(key, "strenc") == 0)) {
480 if (!set_iconv(&fmt->fromUTF16, val, "UTF-16LE")) {
481 DEBUG(0, ("Failed to set encoding: %s\n", val));
482 ret = -1;
483 }
484 } else if ((strcmp(key, "flags") == 0) && (val != NULL)) {
485 char* end = NULL;
486 if (val != NULL) {
487 fmt->flags = strtol(val, &end, 0);
488 }
489 if ((end==NULL) || (*end != '\0')) {
490 DEBUG(0, ("Invalid flags format: %s\n",
491 val ? val : "<NULL>"));
492 ret = -1;
493 }
494 } else if ((strcmp(key, "sep") == 0) && (val != NULL)) {
495 cstr_unescape(val);
496 fmt->sep = talloc_steal(fmt, val);
497 }
498
499 /* else if (strcmp(key, "hive") == 0) { */
500 /* if (strcmp(val, "short") == 0) { */
501 /* f->hive_fmt = REG_FMT_SHORT_HIVES; */
502 /* } else if (strcmp(val, "long") == 0) { */
503 /* f->hive_fmt = REG_FMT_LONG_HIVES; */
504 /* } else if (strcmp(val, "preserve") == 0) { */
505 /* f->hive_fmt = REG_FMT_PRESERVE_HIVES; */
506 /* } else { */
507 /* DEBUG(0, ("Invalid hive format: %s\n", val)); */
508 /* ret = -1; */
509 /* } */
510 /* } */
511 }
512 talloc_free(ctx);
513 return ret;
514}
515
516int reg_format_key(struct reg_format* f, const char* key[], size_t n, bool del)
517{
518 int ret, r;
519 cbuf* line = cbuf_new(f);
520 struct fmt_key key_fmt = {
521 .key_case = (f->flags >> 4) & 0x0F,
522 .hive_case = (f->flags >> 8) & 0x0F,
523 .hive_fmt = (f->flags >> 12) & 0x0F,
524 .sep = f->sep,
525 };
526
527 ret = cbuf_putc(line, '[');
528 if (ret < 0) {
529 goto done;
530 }
531
532 if (del) {
533 ret = cbuf_putc(line, '-');
534 if (ret < 0) {
535 goto done;
536 }
537 }
538
539 ret = cbuf_print_keyname(line, key, n, &key_fmt);
540 if (ret < 0) {
541 goto done;
542 }
543
544 ret = cbuf_putc(line, ']');
545 if (ret < 0) {
546 goto done;
547 }
548
549 ret = f->call.writeline(f->call.data, "");
550 if (ret < 0) {
551 goto done;
552 }
553
554 r = f->call.writeline(f->call.data, cbuf_gets(line, 0));
555 if (r < 0) {
556 ret = r;
557 goto done;
558 }
559 ret += r;
560
561done:
562 talloc_free(line);
563 return ret;
564}
565
566
567int reg_format_registry_key(struct reg_format* f, struct registry_key* key,
568 bool del)
569{
570 return reg_format_key(f, (const char**)&key->key->name, 1, del);
571}
572
573int reg_format_registry_value(struct reg_format* f, const char* name,
574 struct registry_value* val)
575{
576 return reg_format_value(f, name, val->type,
577 val->data.data, val->data.length);
578}
579
580int reg_format_regval_blob(struct reg_format* f, const char* name,
581 struct regval_blob* val)
582{
583
584 return reg_format_value(f,
585 name ? name : regval_name(val),
586 regval_type(val),
587 regval_data_p(val),
588 regval_size(val));
589}
590
591/**@}*/
592
593
594struct reg_format_file
595{
596 FILE* file;
597 const char* encoding;
598 smb_iconv_t fromUnix;
599 char* nl;
600 size_t nl_len;
601};
602
603
604static int reg_format_file_close(struct reg_format* fmt)
605{
606 struct reg_format_file* fmt_ctx
607 = (struct reg_format_file*) fmt->call.data;
608 int ret = 0;
609 FILE* file = fmt_ctx->file;
610
611 if (fmt_ctx->encoding) {
612 char buf[32];
613 snprintf(buf, sizeof(buf), "coding: %s", fmt_ctx->encoding);
614 reg_format_comment(fmt, "Local Variables:");
615 reg_format_comment(fmt, buf);
616 reg_format_comment(fmt, "End:");
617 }
618
619 if (file != NULL) {
620 ret = fclose(file);
621 }
622
623 return ret;
624}
625
626static int reg_format_file_writeline(void* ptr, const char* line)
627{
628 size_t size;
629 char* dst=NULL;
630 struct reg_format_file* fmt_ctx = (struct reg_format_file*)ptr;
631 int ret, r;
632
633 size = iconvert_talloc(ptr, fmt_ctx->fromUnix, line, strlen(line), &dst);
634 if (size == -1 ) {
635 DEBUG(0, ("reg_format_file_writeline: iconvert_talloc failed >%s<\n", line));
636 return -1;
637 }
638
639 ret = fwrite(dst, 1, size, fmt_ctx->file);
640 if (ret < 0) {
641 goto done;
642 }
643
644 r = fwrite(fmt_ctx->nl, 1, fmt_ctx->nl_len, fmt_ctx->file);
645 ret = (r < 0) ? r : ret + r;
646
647done:
648 talloc_free(dst);
649 return ret;
650}
651
652struct reg_format_file_opt {
653 const char* head;
654 const char* nl;
655 const char* enc;
656 bool bom;
657 const char* str_enc;
658 unsigned flags;
659 const char* sep;
660};
661
662static struct reg_format_file_opt reg_format_file_opt(void* mem_ctx, const char* opt)
663{
664 static const struct reg_format_file_opt REG4 = {
665 .head = "REGEDIT4",
666 .nl = "\r\n",
667 .enc = "dos",
668 .str_enc = "dos",
669 .bom = false,
670 .flags = (FMT_HIVE_LONG << 12),
671 .sep = "\\",
672 };
673
674 static const struct reg_format_file_opt REG5 = {
675 .head = "Windows Registry Editor Version 5.00",
676 .nl = "\r\n",
677 .enc = "UTF-16LE",
678 .str_enc = "UTF-16LE",
679 .bom = true,
680 .flags = (FMT_HIVE_LONG << 12),
681 .sep = "\\",
682 };
683
684 struct reg_format_file_opt ret = {
685 .head = REG5.head,
686 .nl = "\n",
687 .enc = "unix",
688 .bom = false,
689 .str_enc = "UTF-16LE",
690 .flags = 0,
691 .sep = "\\",
692 };
693
694 void* tmp_ctx = talloc_new(mem_ctx);
695
696 char *key, *val;
697
698 if (opt == NULL) {
699 goto done;
700 }
701
702 while(srprs_option(&opt, tmp_ctx, &key, &val)) {
703 if (strcmp(key, "enc") == 0) {
704 ret.enc = talloc_steal(mem_ctx, val);
705 ret.str_enc = ret.enc;
706 } else if (strcmp(key, "strenc") == 0) {
707 ret.str_enc = talloc_steal(mem_ctx, val);
708 } else if (strcmp(key, "fileenc") == 0) {
709 ret.enc = talloc_steal(mem_ctx, val);
710 } else if ((strcmp(key, "flags") == 0) && (val != NULL)) {
711 char* end = NULL;
712 if (val != NULL) {
713 ret.flags = strtol(val, &end, 0);
714 }
715 if ((end==NULL) || (*end != '\0')) {
716 DEBUG(0, ("Invalid flags format: %s\n",
717 val ? val : "<NULL>"));
718 }
719 } else if ((strcmp(key, "sep") == 0) && (val != NULL)) {
720 cstr_unescape(val);
721 ret.sep = talloc_steal(mem_ctx, val);
722 } else if (strcmp(key, "head") == 0) {
723 cstr_unescape(val);
724 ret.head = talloc_steal(mem_ctx, val);
725 } else if (strcmp(key, "nl") == 0) {
726 cstr_unescape(val);
727 ret.nl = talloc_steal(mem_ctx, val);
728 } else if (strcmp(key, "bom") == 0) {
729 if (val == NULL) {
730 ret.bom = true;
731 } else {
732 ret.bom = atoi(val);
733 }
734 } else if (strcmp(key, "regedit4") == 0) {
735 ret = REG4;
736 } else if (strcmp(key, "regedit5") == 0) {
737 ret = REG5;
738 }
739 }
740done:
741 talloc_free(tmp_ctx);
742 return ret;
743}
744
745
746struct reg_format* reg_format_file(const void* talloc_ctx,
747 const char* filename,
748 const char* options)
749{
750 struct reg_format_file* fmt_ctx;
751 struct reg_format* fmt;
752 int ret;
753 struct reg_format_file_opt opt;
754
755 struct reg_format_callback reg_format_cb = {
756 .writeline = &reg_format_file_writeline
757 };
758
759 fmt_ctx = talloc_zero(talloc_ctx, struct reg_format_file);
760 if (fmt_ctx == NULL) {
761 errno = ENOMEM;
762 return NULL;
763 }
764
765 opt = reg_format_file_opt(fmt_ctx, options);
766
767 reg_format_cb.data = fmt_ctx;
768
769 fmt = reg_format_new(talloc_ctx, reg_format_cb,
770 opt.str_enc, opt.flags, opt.sep);
771 if (fmt == NULL) {
772 errno = ENOMEM;
773 talloc_free(fmt_ctx);
774 return NULL;
775 }
776
777 talloc_steal(fmt, fmt_ctx);
778
779 if (!set_iconv(&fmt->fromUTF16, opt.str_enc, "UTF-16LE")) { /* HACK */
780 DEBUG(0, ("reg_format_file: failed to set string encoding %s",
781 opt.str_enc));
782 goto fail;
783 }
784
785 if (!set_iconv(&fmt_ctx->fromUnix, opt.enc, "unix")) {
786 DEBUG(0, ("reg_format_file: failed to set file encoding %s",
787 opt.enc));
788 goto fail;
789 }
790 fmt_ctx->encoding = talloc_strdup(fmt_ctx, get_charset(opt.enc));
791
792 fmt_ctx->file = fopen(filename, "w");
793 if (fmt_ctx->file == NULL) {
794 DEBUG(0, ("reg_format_file: fopen failed: %s\n", strerror(errno)));
795 goto fail;
796 }
797
798 if (setvbuf(fmt_ctx->file, NULL, _IOFBF, 64000) < 0) {
799 DEBUG(0, ("reg_format_file: setvbuf failed: %s\n", strerror(errno)));
800 }
801
802 talloc_set_destructor(fmt, reg_format_file_close);
803
804 fmt_ctx->nl_len = iconvert_talloc(fmt, fmt_ctx->fromUnix, opt.nl, strlen(opt.nl), &fmt_ctx->nl);
805 if (fmt_ctx->nl_len == -1) {
806 DEBUG(0, ("iconvert_talloc failed\n"));
807 goto fail;
808 }
809
810 if (opt.bom) {
811 ret = write_bom(fmt_ctx->file, opt.enc, -1);
812 if (ret < 0) {
813 goto fail;
814 }
815 }
816
817 ret = fmt->call.writeline(fmt->call.data, opt.head);
818 if (ret < 0) {
819 goto fail;
820 }
821
822 return fmt;
823fail:
824 talloc_free(fmt);
825 return NULL;
826}
Note: See TracBrowser for help on using the repository browser.