source3/registry/reg_parse.c

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