source: vendor/current/source3/registry/reg_parse.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 19.4 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 Parser for dot.reg files
22 * @file reg_parse.c
23 * @author Gregor Beck <gb@sernet.de>
24 * @date Jun 2010
25 *
26 */
27
28#include "includes.h"
29#include "system/filesys.h"
30#include "cbuf.h"
31#include "srprs.h"
32#include "reg_parse_internal.h"
33#include "reg_parse.h"
34#include "reg_format.h"
35
36#include <stdio.h>
37#include <talloc.h>
38#include <stdbool.h>
39#include <string.h>
40#include <regex.h>
41#include <assert.h>
42#include <stdint.h>
43
44enum reg_parse_state {
45 STATE_DEFAULT,
46 STATE_KEY_OPEN,
47 STATE_VAL_HEX_CONT,
48 STATE_VAL_SZ_CONT
49};
50
51struct reg_parse {
52 struct reg_format_callback reg_format_callback;
53 cbuf* key;
54 cbuf* valname;
55 uint32_t valtype;
56 cbuf* valblob;
57 cbuf* tmp;
58 struct reg_parse_callback call;
59 int ret;
60 int linenum;
61 enum reg_parse_state state;
62 struct reg_parse_options* opt;
63 smb_iconv_t str2UTF16;
64 unsigned flags;
65};
66
67/**
68 * @defgroup action Action
69 * @{
70 */
71static bool act_key(struct reg_parse* p, cbuf* keyname, bool del)
72{
73 const char* name = cbuf_gets(keyname, 0);
74 cbuf_swap(p->key, keyname);
75
76 assert(p->state == STATE_DEFAULT || p->state == STATE_KEY_OPEN);
77 p->state = del ? STATE_DEFAULT : STATE_KEY_OPEN;
78
79 assert(p->call.key);
80 p->ret = p->call.key(p->call.data, &name, 1, del);
81 return p->ret >= 0;
82}
83
84static bool value_callback(struct reg_parse* p)
85{
86 const char* name = cbuf_gets(p->valname,0);
87 const uint8_t* val = (const uint8_t*)cbuf_gets(p->valblob,0);
88 size_t len = cbuf_getpos(p->valblob);
89
90 assert(p->call.val);
91 p->ret = p->call.val(p->call.data, name, p->valtype, val, len);
92 return p->ret >= 0;
93}
94
95static bool act_val_hex(struct reg_parse* p, cbuf* value, bool cont)
96{
97 cbuf_swap(p->valblob, value);
98 assert((p->state == STATE_KEY_OPEN) || (p->state == STATE_VAL_HEX_CONT));
99
100 if (cont) {
101 p->state = STATE_VAL_HEX_CONT;
102 } else {
103 p->state = STATE_KEY_OPEN;
104
105 switch (p->valtype) {
106 case REG_EXPAND_SZ:
107 case REG_MULTI_SZ:
108 if (p->str2UTF16 != NULL) {
109 char* dst = NULL;
110 const char* src = cbuf_gets(p->valblob, 0);
111 const size_t slen = cbuf_getpos(p->valblob);
112 size_t dlen = iconvert_talloc(p,
113 p->str2UTF16,
114 src, slen,
115 &dst);
116 if (dlen != -1) {
117 cbuf_swapptr(p->valblob, &dst, dlen);
118 } else {
119 DEBUG(0, ("iconvert_talloc failed\n"));
120 }
121 talloc_free(dst);
122 }
123 default:
124 break;
125 }
126 return value_callback(p);
127 }
128 return true;
129}
130
131static bool act_val_dw(struct reg_parse* p, uint32_t val)
132{
133 assert(p->valtype == REG_DWORD);
134 assert(p->state == STATE_KEY_OPEN);
135
136 cbuf_clear(p->valblob);
137
138 if (cbuf_putdw(p->valblob, val) < 0) {
139 return false;
140 }
141 return value_callback(p);
142}
143
144static bool act_val_sz(struct reg_parse* p, cbuf* value, bool cont)
145{
146 cbuf_swap(p->valblob, value);
147
148 assert(p->valtype == REG_SZ);
149 assert((p->state == STATE_KEY_OPEN) || (p->state == STATE_VAL_SZ_CONT));
150
151 if (cont) {
152 p->state = STATE_VAL_SZ_CONT;
153 } else {
154 char* dst = NULL;
155 size_t dlen;
156 const char* src = cbuf_gets(p->valblob, 0);
157
158 p->state = STATE_KEY_OPEN;
159
160
161 if (convert_string_talloc(p->valblob, CH_UNIX, CH_UTF16LE,
162 src, strlen(src)+1,
163 &dst, &dlen))
164 {
165 cbuf_swapptr(p->valblob, &dst, dlen);
166 } else {
167 DEBUG(0, ("convert_string_talloc failed: >%s<\n"
168 "use it as is\t", src));
169 }
170 talloc_free(dst);
171
172 return value_callback(p);
173 }
174 return true;
175}
176
177static bool act_val_del(struct reg_parse* p)
178{
179 const char* name = cbuf_gets(p->valname, 0);
180
181 assert(p->call.val_del);
182 p->ret = p->call.val_del(p->call.data, name);
183 return p->ret >= 0;
184}
185
186static bool act_comment (struct reg_parse* p, const char* txt)
187{
188 assert(p->call.comment);
189 p->ret = p->call.comment(p->call.data, txt);
190 return p->ret >= 0;
191}
192/**@}*/
193
194
195static int nop(void* data)
196{
197 return 0;
198}
199
200
201struct reg_parse* reg_parse_new(const void* ctx,
202 struct reg_parse_callback cb,
203 const char* str_enc, unsigned flags)
204{
205 struct reg_parse* s = talloc_zero(ctx, struct reg_parse);
206 if (s == NULL)
207 return NULL;
208 s->key = cbuf_new(s);
209 s->valname = cbuf_new(s);
210 s->valblob = cbuf_new(s);
211 s->tmp = cbuf_new(s);
212 if ( (s->tmp == NULL) || (s->valblob == NULL)
213 || (s->valname == NULL) || (s->key == NULL) )
214 {
215 goto fail;
216 }
217
218 s->reg_format_callback.writeline = (reg_format_callback_writeline_t)&reg_parse_line;
219 s->reg_format_callback.data = s;
220
221 s->valtype = 0;
222 if (cb.key == NULL) {
223 cb.key = (reg_parse_callback_key_t)&nop;
224 }
225 if (cb.val == NULL) {
226 cb.val = (reg_parse_callback_val_t)&nop;
227 }
228 if (cb.val_del == NULL) {
229 cb.val_del = (reg_parse_callback_val_del_t)&nop;
230 }
231 if (cb.comment == NULL) {
232 cb.comment = (reg_parse_callback_comment_t)&nop;
233 }
234
235 s->call = cb;
236 s->linenum = 0;
237 s->state = STATE_DEFAULT;
238 s->flags = flags;
239
240 if (str_enc && !set_iconv(&s->str2UTF16, "UTF-16LE", str_enc)) {
241 DEBUG(0, ("reg_parse_new: failed to set encoding: %s",
242 str_enc));
243 goto fail;
244 }
245
246 assert(&s->reg_format_callback == (struct reg_format_callback*)s);
247 return s;
248fail:
249 talloc_free(s);
250 return NULL;
251}
252
253/**
254 * @defgroup parse Parser Primitive
255 * @ingroup internal
256 * @{
257 */
258
259
260static bool srprs_key(const char** ptr, cbuf* key, bool* del)
261{
262 const char* pos = *ptr;
263 const char* closing_bracket_pos = NULL;
264 size_t closing_bracket_idx = 0;
265
266 if (!srprs_skipws(&pos) || !srprs_char(&pos, '[')) {
267 return false;
268 }
269
270 *del = srprs_char(&pos, '-');
271
272 cbuf_clear(key);
273
274 while (true) {
275 while (srprs_charsetinv(&pos, "]\\", key))
276 ;
277
278 switch (*pos) {
279
280 case ']':
281 closing_bracket_idx = cbuf_getpos(key);
282 closing_bracket_pos = pos;
283 cbuf_putc(key, ']');
284 pos++;
285 break;
286
287 case '\\':
288 cbuf_putc(key, '\\');
289 /* n++; */
290 /* cbuf_puts(subkeyidx, cbuf_getpos(key), sizeof(size_t)) */
291 while (srprs_char(&pos,'\\'))
292 ;
293 break;
294
295 case '\0':
296 if (closing_bracket_pos == NULL) {
297 return false;
298 }
299
300 /* remove trailing backslash (if any) */
301 if (*(closing_bracket_pos-1)=='\\') {
302 closing_bracket_idx--;
303 }
304
305 cbuf_setpos(key, closing_bracket_idx);
306 *ptr = closing_bracket_pos+1;
307 return true;
308
309 default:
310 assert(false);
311 }
312 }
313}
314
315static bool srprs_val_name(const char** ptr, cbuf* name)
316{
317 const char* pos = *ptr;
318 const size_t spos = cbuf_getpos(name);
319
320 if ( !srprs_skipws(&pos) ) {
321 goto fail;
322 }
323
324 if ( srprs_char(&pos, '@') ) {
325 cbuf_puts(name, "", -1);
326 }
327 else if (!srprs_quoted_string(&pos, name, NULL)) {
328 goto fail;
329 }
330
331 if (!srprs_skipws(&pos) || !srprs_char(&pos, '=')) {
332 goto fail;
333 }
334
335 *ptr = pos;
336 return true;
337
338fail:
339 cbuf_setpos(name, spos);
340 return false;
341}
342
343static bool srprs_val_dword(const char** ptr, uint32_t* type, uint32_t* val)
344{
345 const char* pos = *ptr;
346
347 if (!srprs_str(&pos, "dword:", -1)) {
348 return false;
349 }
350
351 if (!srprs_hex(&pos, 8, val)) {
352 return false;
353 }
354
355 *type = REG_DWORD;
356 *ptr = pos;
357 return true;
358}
359
360static bool srprs_val_sz(const char** ptr, uint32_t* type, cbuf* val, bool* cont)
361{
362 if (!srprs_quoted_string(ptr, val, cont)) {
363 return false;
364 }
365
366 *type = REG_SZ;
367 return true;
368}
369
370
371static bool srprs_nl_no_eos(const char** ptr, cbuf* str, bool eof)
372{
373 const char* pos = *ptr;
374 const size_t spos = cbuf_getpos(str);
375
376 if( srprs_nl(&pos, str) && (eof || *pos != '\0')) {
377 *ptr = pos;
378 return true;
379 }
380 cbuf_setpos(str, spos);
381 return false;
382}
383
384
385static bool srprs_eol_cont(const char** ptr, bool* cont)
386{
387 const char* pos = *ptr;
388 bool bs = srprs_char(&pos, '\\');
389
390 if (!srprs_eol(&pos, NULL)) {
391 return false;
392 }
393
394 *cont = bs;
395 *ptr = pos;
396 return true;
397}
398
399/* matches the empty string, for zero length lists */
400static bool srprs_val_hex_values(const char** ptr, cbuf* val, bool* cont)
401{
402 const char* pos = *ptr;
403 unsigned u;
404
405 do {
406 if (!srprs_skipws(&pos) || !srprs_hex(&pos, 2, &u) || !srprs_skipws(&pos)) {
407 break;
408 }
409 cbuf_putc(val, (char)u);
410 } while(srprs_char(&pos, ','));
411
412 *ptr = pos;
413
414 if (srprs_skipws(&pos) && srprs_eol_cont(&pos, cont)) {
415 *ptr = pos;
416 }
417
418 return true;
419}
420
421static bool srprs_val_hex(const char** ptr, uint32_t* ptype, cbuf* val,
422 bool* cont)
423{
424 const char* pos = *ptr;
425 uint32_t type;
426
427 if (!srprs_str(&pos, "hex", -1)) {
428 return false;
429 }
430
431 if (srprs_char(&pos, ':')) {
432 type = REG_BINARY;
433 }
434 else if (!srprs_char(&pos, '(') ||
435 !srprs_hex(&pos, 8, &type) ||
436 !srprs_char(&pos,')') ||
437 !srprs_char(&pos, ':'))
438 {
439 return false;
440 }
441
442 if (!srprs_val_hex_values(&pos, val, cont)) {
443 return false;
444 }
445
446 *ptype = type;
447 *ptr = pos;
448 return true;
449}
450
451
452static bool srprs_comment(const char** ptr, cbuf* str)
453{
454 return srprs_char(ptr, ';') && srprs_line(ptr, str);
455}
456
457/**@}*/
458
459int reg_parse_set_options(struct reg_parse* parser, const char* options)
460{
461 static const char* DEFAULT ="enc=unix,flags=0";
462
463 int ret = 0;
464 char *key, *val;
465 void* ctx = talloc_new(parser);
466
467 if (options == NULL) {
468 options = DEFAULT;
469 }
470
471 while (srprs_option(&options, ctx, &key, &val)) {
472 if ((strcmp(key, "enc") == 0) || (strcmp(key, "strenc") == 0)) {
473 } else if ((strcmp(key, "flags") == 0) && (val != NULL)) {
474 char* end = NULL;
475 if (val != NULL) {
476 parser->flags = strtol(val, &end, 0);
477 }
478 if ((end==NULL) || (*end != '\0')) {
479 DEBUG(0, ("Invalid flags format: %s\n",
480 val ? val : "<NULL>"));
481 ret = -1;
482 }
483 }
484 /* else if (strcmp(key, "hive") == 0) { */
485 /* if (strcmp(val, "short") == 0) { */
486 /* f->hive_fmt = REG_FMT_SHORT_HIVES; */
487 /* } else if (strcmp(val, "long") == 0) { */
488 /* f->hive_fmt = REG_FMT_LONG_HIVES; */
489 /* } else if (strcmp(val, "preserve") == 0) { */
490 /* f->hive_fmt = REG_FMT_PRESERVE_HIVES; */
491 /* } else { */
492 /* DEBUG(0, ("Invalid hive format: %s\n", val)); */
493 /* ret = -1; */
494 /* } */
495 /* } */
496 }
497 talloc_free(ctx);
498 return ret;
499}
500
501
502int reg_parse_line(struct reg_parse* parser, const char* line)
503{
504 const char* pos;
505 bool del=false;
506 cbuf* tmp=cbuf_clear(parser->tmp);
507 bool cb_ok = true;
508 bool cont = true;
509
510 if (!line) {
511 return -4;
512 }
513
514 parser->linenum++;
515 pos = line;
516
517 switch (parser->state) {
518 case STATE_VAL_HEX_CONT:
519 if (srprs_val_hex_values(&pos, parser->valblob, &cont)) {
520 cb_ok = act_val_hex(parser, parser->valblob, cont);
521 }
522 goto done;
523 case STATE_VAL_SZ_CONT:
524 if (srprs_quoted_string(&pos, parser->valblob, &cont)) {
525 cb_ok = act_val_sz(parser, parser->valblob, cont);
526 }
527 goto done;
528 default:
529 cont = false;
530 }
531
532 if ( !srprs_skipws(&pos) ) {
533 return -4;
534 }
535
536 /* empty line ?*/
537 if ( srprs_eol(&pos, NULL) ) {
538 return 0;
539 }
540
541 /* key line ?*/
542 else if (srprs_key(&pos, tmp, &del)) {
543 cb_ok = act_key(parser, tmp, del);
544 }
545
546 /* comment line ? */
547 else if (srprs_comment(&pos, tmp)) {
548 cb_ok = act_comment(parser, cbuf_gets(tmp, 0));
549 }
550
551 /* head line */
552 else if ((parser->linenum == 1) && srprs_line(&pos, tmp) ) {
553 /* cb_ok = act_head(parser, cbuf_gets(tmp, 0)); */
554 }
555
556 /* value line ?*/
557 else if (srprs_val_name(&pos, tmp)) {
558 uint32_t dw;
559 cbuf_swap(parser->valname, tmp);
560 cbuf_clear(tmp);
561
562 if (parser->state != STATE_KEY_OPEN) {
563 DEBUG(0, ("value \"%s\" without a key at line: %i",
564 cbuf_gets(parser->valname, 0), parser->linenum));
565 return -3;
566 }
567
568 if (!srprs_skipws(&pos)) {
569 return -4;
570 }
571
572 if (srprs_char(&pos, '-')) {
573 cb_ok = act_val_del(parser);
574 }
575 else if (srprs_val_dword(&pos, &parser->valtype, &dw)) {
576 cb_ok = act_val_dw(parser, dw);
577 }
578 else if (srprs_val_sz(&pos, &parser->valtype, tmp, &cont)) {
579 cb_ok = act_val_sz(parser, tmp, cont);
580 }
581 else if (srprs_val_hex(&pos, &parser->valtype, tmp, &cont)){
582 cb_ok = act_val_hex(parser, tmp, cont);
583 }
584 else {
585 DEBUG(0, ("value \"%s\" parse error"
586 "at line: %i pos: %li : %s",
587 cbuf_gets(parser->valname, 0), parser->linenum,
588 (long int)(pos-line), pos));
589 return -3;
590 }
591 }
592 else {
593 DEBUG(0, ("unrecognized line %i : %s\n", parser->linenum, line));
594 return -3;
595 }
596
597done:
598 if (!cb_ok)
599 return -2;
600
601 if (!srprs_skipws(&pos) || !srprs_eol(&pos, NULL)) {
602 DEBUG(0, ("trailing garbage at line: %i pos: %li : %s\n",
603 parser->linenum, (long int)(pos-line), pos));
604 return -1;
605 }
606 return 0;
607}
608
609/******************************************************************************/
610/**
611 * @addtogroup misc
612 * @{
613 */
614static bool lookslike_utf16(const char* line, size_t len, bool* little_endian)
615{
616 static const uint16_t M_LE = 0xFF80;
617 static const uint16_t M_BE = 0x80FF;
618 uint16_t mask;
619 bool le;
620
621 size_t l = MIN(len/2, 64);
622 const uint16_t* u = (const uint16_t*)line;
623 int i;
624
625 assert(len >= 2);
626
627 if ( u[0] & M_LE ) {
628 le = true;
629 mask = M_LE;
630 } else if ( u[0] & M_BE ) {
631 le = false;
632 mask = M_BE;
633 } else {
634 return false;
635 }
636
637 for (i=1; i<l; i++) {
638 if ( u[i] & mask ) {
639 return false;
640 }
641 }
642
643 *little_endian = le;
644 return true;
645}
646
647static bool lookslike_dos(const char* line, size_t len)
648{
649 int i;
650 for (i=0; i<len; i++) {
651 if ( (line[i] == '\0') || (line[i] & 0x80) ) {
652 return false;
653 }
654 if ( (line[i] == '\r') && (i+1 < len) && (line[i+1] == '\n') ) {
655 return true;
656 }
657 }
658 return false;
659}
660
661static bool guess_charset(const char** ptr,
662 size_t* len,
663 const char** file_enc,
664 const char** str_enc)
665{
666 const char* charset = NULL;
667 const char* pos = *ptr;
668
669 if (*len < 4) {
670 return false;
671 }
672
673 if (srprs_bom(&pos, &charset, NULL)) {
674 *len -= (pos - *ptr);
675 *ptr = pos;
676 if (*file_enc == NULL) {
677 *file_enc = charset;
678 }
679 else if( strcmp(*file_enc, charset) != 0 ) {
680 DEBUG(0, ("file encoding forced to %s\n",
681 *file_enc));
682 }
683 }
684 else if (*file_enc == NULL) {
685 bool le;
686 if (lookslike_utf16(*ptr, *len, &le)) {
687 *file_enc = le ? "UTF-16LE" : "UTF-16BE";
688 }
689 else if (lookslike_dos(*ptr, *len)) {
690 *file_enc = "dos";
691 }
692 else {
693 *file_enc = "unix";
694 }
695 }
696
697 if ((str_enc != NULL) && (*str_enc == NULL)) {
698 *str_enc = ( strncmp(*ptr, "REGEDIT4", 8) == 0)
699 ? *file_enc
700 : "UTF-16LE";
701 }
702
703 return true;
704}
705/**@}*/
706
707struct reg_parse_fd_opt {
708 const char* file_enc;
709 const char* str_enc;
710 unsigned flags;
711 int fail_level;
712};
713
714static struct reg_parse_fd_opt
715reg_parse_fd_opt(void* mem_ctx, const char* options)
716{
717 struct reg_parse_fd_opt ret = {
718 .file_enc = NULL,
719 .str_enc = NULL,
720 .flags = 0,
721 };
722
723 void* ctx = talloc_new(mem_ctx);
724 char *key, *val;
725
726 if (options == NULL) {
727 goto done;
728 }
729
730 while (srprs_option(&options, ctx, &key, &val)) {
731 if (strcmp(key, "enc") == 0) {
732 ret.file_enc = talloc_steal(mem_ctx, val);
733 ret.str_enc = ret.file_enc;
734 } else if (strcmp(key, "strenc") == 0) {
735 ret.str_enc = talloc_steal(mem_ctx, val);
736 } else if (strcmp(key, "fileenc") == 0) {
737 ret.file_enc = talloc_steal(mem_ctx, val);
738 } else if ((strcmp(key, "flags") == 0) && (val != NULL)) {
739 char* end = NULL;
740 if (val != NULL) {
741 ret.flags = strtol(val, &end, 0);
742 }
743 if ((end==NULL) || (*end != '\0')) {
744 DEBUG(0, ("Invalid format \"%s\": %s\n",
745 key, val ? val : "<NULL>"));
746 }
747 } else if ((strcmp(key, "fail") == 0) && (val != NULL)) {
748 char* end = NULL;
749 if (val != NULL) {
750 ret.fail_level = -strtol(val, &end, 0);
751 }
752 if ((end==NULL) || (*end != '\0')) {
753 DEBUG(0, ("Invalid format \"%s\": %s\n",
754 key, val ? val : "<NULL>"));
755 }
756 }
757 }
758done:
759 talloc_free(ctx);
760 return ret;
761}
762
763
764static void
765handle_iconv_errno(int err, const char* obuf, size_t linenum,
766 smb_iconv_t cd, const char** iptr, size_t* ilen,
767 char** optr, size_t *olen)
768{
769 const char *pos = obuf;
770 const char *ptr = obuf;
771 switch(err) {
772 case EINVAL:
773 /* DEBUG(0, ("Incomplete multibyte sequence\n")); */
774 case E2BIG:
775 return;
776 case EILSEQ:
777 break;
778 default:
779 assert(false);
780 }
781
782 **optr = '\0';
783 while (srprs_line(&ptr, NULL) && srprs_nl(&ptr, NULL)) {
784 pos = ptr;
785 linenum++;
786 }
787 if (pos == *optr) {
788 pos = MAX(obuf, *optr-60);
789 }
790 DEBUG(0, ("Illegal multibyte sequence at line %lu: %s",
791 (long unsigned)(linenum+1), pos));
792
793 assert((*ilen) > 0);
794 do {
795 size_t il = 1;
796 DEBUGADD(0, ("<%02x>", (unsigned char)**iptr));
797
798 if ((*olen) > 0) {
799 *(*optr)++ = '\?';
800 (*iptr)++;
801 /* Todo: parametrize, e.g. skip: *optr++ = *iptr++; */
802 (*ilen)--;
803 }
804
805 if (smb_iconv(cd, iptr, &il, optr, olen) != (size_t)-1 || (errno != EILSEQ)) {
806 if(il == 0)
807 (*ilen)-- ;
808 break;
809 }
810
811 }
812 while ((*ilen > 0) && (*olen > 0));
813
814 DEBUGADD(0, ("\n"));
815
816}
817
818int reg_parse_fd(int fd, const struct reg_parse_callback* cb, const char* opts)
819{
820 void* mem_ctx = talloc_stackframe();
821 cbuf* line = cbuf_new(mem_ctx);
822 smb_iconv_t cd = (smb_iconv_t)-1;
823 struct reg_parse* parser = NULL;
824 char buf_raw[1024];
825 char buf_unix[1025];
826
827 ssize_t nread;
828 size_t nconv;
829 const char* pos;
830 const char* iptr;
831 char* optr;
832 size_t ilen;
833 size_t olen;
834 int ret = -1;
835 bool eof = false;
836 size_t linenum = 0;
837
838 struct reg_parse_fd_opt opt = reg_parse_fd_opt(mem_ctx, opts);
839
840 if (cb == NULL) {
841 DEBUG(0,("reg_parse_fd: NULL callback\n"));
842 goto done;
843 }
844
845 nread = read(fd, buf_raw, sizeof(buf_raw));
846 if (nread < 0) {
847 DEBUG(0, ("reg_parse_fd: read failed: %s\n", strerror(errno)));
848 ret = nread;
849 goto done;
850 }
851
852 iptr = &buf_raw[0];
853 ilen = nread;
854
855 if (!guess_charset(&iptr, &ilen,
856 &opt.file_enc, &opt.str_enc))
857 {
858 DEBUG(0, ("reg_parse_fd: failed to guess encoding\n"));
859 goto done;
860 }
861
862 DEBUG(10, ("reg_parse_fd: encoding file: %s str: %s\n",
863 opt.file_enc, opt.str_enc));
864
865
866 if (!set_iconv(&cd, "unix", opt.file_enc)) {
867 DEBUG(0, ("reg_parse_fd: failed to set file encoding %s\n",
868 opt.file_enc));
869 goto done;
870 }
871
872 parser = reg_parse_new(mem_ctx, *cb, opt.str_enc, opt.flags);
873
874 optr = &buf_unix[0];
875 while (!eof) {
876 olen = sizeof(buf_unix) - (optr - buf_unix) - 1 ;
877 while ( olen > 0 ) {
878 memmove(buf_raw, iptr, ilen);
879
880 nread = read(fd, buf_raw + ilen, sizeof(buf_raw) - ilen);
881 if (nread < 0) {
882 DEBUG(0, ("reg_parse_fd: read failed: %s\n", strerror(errno)));
883 ret = nread;
884 goto done;
885 }
886
887 iptr = buf_raw;
888 ilen += nread;
889
890 if (ilen == 0) {
891 smb_iconv(cd, NULL, NULL, &optr, &olen);
892 eof = true;
893 break;
894 }
895
896 nconv = smb_iconv(cd, &iptr, &ilen, &optr, &olen);
897
898 if (nconv == (size_t)-1) {
899 handle_iconv_errno(errno, buf_unix, linenum,
900 cd, &iptr, &ilen,
901 &optr, &olen);
902 break;
903 }
904 }
905 /* process_lines: */
906 *optr = '\0';
907 pos = &buf_unix[0];
908
909 while ( srprs_line(&pos, line) && srprs_nl_no_eos(&pos, line, eof)) {
910 linenum ++;
911 ret = reg_parse_line(parser, cbuf_gets(line, 0));
912 if (ret < opt.fail_level) {
913 goto done;
914 }
915 cbuf_clear(line);
916 }
917 memmove(buf_unix, pos, optr - pos);
918 optr -= (pos - buf_unix);
919 }
920
921 ret = 0;
922done:
923 set_iconv(&cd, NULL, NULL);
924 talloc_free(mem_ctx);
925 return ret;
926}
927
928int reg_parse_file(const char* fname, const struct reg_parse_callback* cb,
929 const char* opt)
930{
931 int ret = -1;
932 int fd;
933
934 fd = open(fname, O_RDONLY);
935 if (fd < 0) {
936 DEBUG(0, ("reg_parse_file: open %s failed: %s\n", fname,
937 strerror(errno)));
938 return -1;
939 }
940
941 ret = reg_parse_fd(fd, cb, opt);
942
943 close(fd);
944 return ret;
945}
946
947/* static struct registry_key *find_regkey_by_hnd(pipes_struct *p, */
948/* struct policy_handle *hnd) */
949/* { */
950/* struct registry_key *regkey = NULL; */
951
952/* if(!find_policy_by_hnd(p,hnd,(void **)(void *)&regkey)) { */
953/* DEBUG(2,("find_regkey_index_by_hnd: Registry Key not found: ")); */
954/* return NULL; */
955/* } */
956
957/* return regkey; */
958/* } */
Note: See TracBrowser for help on using the repository browser.