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