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 <talloc.h>
  38 #include <stdbool.h>
  39 #include <string.h>
  40 #include <regex.h>
  41 #include <assert.h>
  42 #include <stdint.h>
  43
  44 enum reg_parse_state {
  45         STATE_DEFAULT,
  46         STATE_KEY_OPEN,
  47         STATE_VAL_HEX_CONT,
  48         STATE_VAL_SZ_CONT
  49 };
  50
  51 struct 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  */
  71 static 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
  84 static 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
  95 static 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                                         return false;
 121                                 }
 122                                 talloc_free(dst);
 123                         }
 124                         break;
 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))
 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                         return false;
 172                 }
 173                 talloc_free(dst);
 174
 175                 return value_callback(p);
 176         }
 177         return true;
 178 }
 179
 180 static bool act_val_del(struct reg_parse* p)
 181 {
 182         const char* name = cbuf_gets(p->valname, 0);
 183
 184         assert(p->call.val_del);
 185         p->ret = p->call.val_del(p->call.data, name);
 186         return p->ret >= 0;
 187 }
 188
 189 static bool act_comment (struct reg_parse* p, const char* txt)
 190 {
 191         assert(p->call.comment);
 192         p->ret = p->call.comment(p->call.data, txt);
 193         return p->ret >= 0;
 194 }
 195 /**@}*/
 196
 197
 198 static int nop_callback_key(void* private_data,
 199                 const char* key[],
 200                 size_t klen,
 201                 bool del)
 202 {
 203         return 0;
 204 }
 205
 206 static int nop_callback_val(void* private_data,
 207                 const char* name,
 208                 uint32_t type,
 209                 const uint8_t* data,
 210                 size_t len)
 211 {
 212         return 0;
 213 }
 214
 215 static int nop_callback_del(void* data, const char* str)
 216 {
 217         return 0;
 218 }
 219
 220 struct reg_parse* reg_parse_new(const void* ctx,
 221                                 struct reg_parse_callback cb,
 222                                 const char* str_enc, unsigned flags)
 223 {
 224         struct reg_parse* s = talloc_zero(ctx, struct reg_parse);
 225         if (s == NULL)
 226                 return NULL;
 227         s->key     = cbuf_new(s);
 228         s->valname = cbuf_new(s);
 229         s->valblob = cbuf_new(s);
 230         s->tmp     = cbuf_new(s);
 231         if ( (s->tmp == NULL) || (s->valblob == NULL)
 232              || (s->valname == NULL) || (s->key == NULL) )
 233         {
 234                 goto fail;
 235         }
 236
 237         s->reg_format_callback.writeline = (reg_format_callback_writeline_t)&reg_parse_line;
 238         s->reg_format_callback.data      = s;
 239
 240         s->valtype = 0;
 241         if (cb.key == NULL) {
 242                 cb.key = (reg_parse_callback_key_t)&nop_callback_key;
 243         }
 244         if (cb.val == NULL) {
 245                 cb.val = (reg_parse_callback_val_t)&nop_callback_val;
 246         }
 247         if (cb.val_del == NULL) {
 248                 cb.val_del = (reg_parse_callback_val_del_t)&nop_callback_del;
 249         }
 250         if (cb.comment == NULL) {
 251                 cb.comment =
 252                         (reg_parse_callback_comment_t)&nop_callback_del;
 253         }
 254
 255         s->call = cb;
 256         s->linenum = 0;
 257         s->state = STATE_DEFAULT;
 258         s->flags = flags;
 259
 260         if (str_enc && !set_iconv(&s->str2UTF16, "UTF-16LE", str_enc)) {
 261                 DEBUG(0, ("reg_parse_new: failed to set encoding: %s",
 262                           str_enc));
 263                 goto fail;
 264         }
 265
 266         assert(&s->reg_format_callback == (struct reg_format_callback*)s);
 267         return s;
 268 fail:
 269         set_iconv(&s->str2UTF16, NULL, NULL);
 270         talloc_free(s);
 271         return NULL;
 272 }
 273
 274 /**
 275  * @defgroup parse Parser Primitive
 276  * @ingroup internal
 277  * @{
 278  */
 279
 280
 281 static bool srprs_key(const char** ptr, cbuf* key, bool* del)
 282 {
 283         const char* pos = *ptr;
 284         const char* closing_bracket_pos = NULL;
 285         size_t      closing_bracket_idx = 0;
 286
 287         if (!srprs_skipws(&pos) || !srprs_char(&pos, '[')) {
 288                 return false;
 289         }
 290
 291         *del = srprs_char(&pos, '-');
 292
 293         cbuf_clear(key);
 294
 295         while (true) {
 296                 while (srprs_charsetinv(&pos, "]\\", key))
 297                         ;
 298
 299                 switch (*pos) {
 300
 301                 case ']':
 302                         closing_bracket_idx = cbuf_getpos(key);
 303                         closing_bracket_pos = pos;
 304                         cbuf_putc(key, ']');
 305                         pos++;
 306                         break;
 307
 308                 case '\\':
 309                         cbuf_putc(key, '\\');
 310                         /* n++; */
 311                         /* cbuf_puts(subkeyidx, cbuf_getpos(key), sizeof(size_t)) */
 312                         while (srprs_char(&pos,'\\'))
 313                                 ;
 314                         break;
 315
 316                 case '\0':
 317                         if (closing_bracket_pos == NULL) {
 318                                 return false;
 319                         }
 320
 321                         /* remove trailing backslash (if any) */
 322                         if (*(closing_bracket_pos-1)=='\\') {
 323                                 closing_bracket_idx--;
 324                         }
 325
 326                         cbuf_setpos(key, closing_bracket_idx);
 327                         *ptr = closing_bracket_pos+1;
 328                         return true;
 329
 330                 default:
 331                         assert(false);
 332                 }
 333         }
 334 }
 335
 336 static bool srprs_val_name(const char** ptr, cbuf* name)
 337 {
 338         const char* pos = *ptr;
 339         const size_t spos = cbuf_getpos(name);
 340
 341         if ( !srprs_skipws(&pos) ) {
 342                 goto fail;
 343         }
 344
 345         if ( srprs_char(&pos, '@') ) {
 346                 cbuf_puts(name, "", -1);
 347         }
 348         else if (!srprs_quoted_string(&pos, name, NULL)) {
 349                 goto fail;
 350         }
 351
 352         if (!srprs_skipws(&pos) || !srprs_char(&pos, '=')) {
 353                 goto fail;
 354         }
 355
 356         *ptr = pos;
 357         return true;
 358
 359 fail:
 360         cbuf_setpos(name, spos);
 361         return false;
 362 }
 363
 364 static bool srprs_val_dword(const char** ptr, uint32_t* type, uint32_t* val)
 365 {
 366         const char* pos = *ptr;
 367
 368         if (!srprs_str(&pos, "dword:", -1)) {
 369                 return false;
 370         }
 371
 372         if (!srprs_hex(&pos, 8, val)) {
 373                 return false;
 374         }
 375
 376         *type = REG_DWORD;
 377         *ptr  = pos;
 378         return true;
 379 }
 380
 381 static bool srprs_val_sz(const char** ptr, uint32_t* type, cbuf* val, bool* cont)
 382 {
 383         if (!srprs_quoted_string(ptr, val, cont)) {
 384                 return false;
 385         }
 386
 387         *type = REG_SZ;
 388         return true;
 389 }
 390
 391
 392 static bool srprs_nl_no_eos(const char** ptr, cbuf* str, bool eof)
 393 {
 394         const char* pos = *ptr;
 395         const size_t spos = cbuf_getpos(str);
 396
 397         if( srprs_nl(&pos, str) && (eof || *pos != '\0')) {
 398                 *ptr = pos;
 399                 return true;
 400         }
 401         cbuf_setpos(str, spos);
 402         return false;
 403 }
 404
 405
 406 static bool srprs_eol_cont(const char** ptr, bool* cont)
 407 {
 408         const char* pos = *ptr;
 409         bool bs = srprs_char(&pos, '\\');
 410
 411         if (!srprs_eol(&pos, NULL)) {
 412                 return false;
 413         }
 414
 415         *cont = bs;
 416         *ptr = pos;
 417         return true;
 418 }
 419
 420 /* matches the empty string, for zero length lists */
 421 static bool srprs_val_hex_values(const char** ptr, cbuf* val, bool* cont)
 422 {
 423         const char* pos = *ptr;
 424         unsigned u;
 425
 426         do {
 427                 if (!srprs_skipws(&pos) || !srprs_hex(&pos, 2, &u) || !srprs_skipws(&pos)) {
 428                         break;
 429                 }
 430                 cbuf_putc(val, (char)u);
 431         } while(srprs_char(&pos, ','));
 432
 433         *ptr = pos;
 434
 435         if (srprs_skipws(&pos) && srprs_eol_cont(&pos, cont)) {
 436                 *ptr = pos;
 437         }
 438
 439         return true;
 440 }
 441
 442 static bool srprs_val_hex(const char** ptr, uint32_t* ptype, cbuf* val,
 443                        bool* cont)
 444 {
 445         const char* pos = *ptr;
 446         uint32_t type;
 447
 448         if (!srprs_str(&pos, "hex", -1)) {
 449                 return false;
 450         }
 451
 452         if (srprs_char(&pos, ':')) {
 453                 type = REG_BINARY;
 454         }
 455         else if (!srprs_char(&pos, '(') ||
 456                  !srprs_hex(&pos, 8, &type) ||
 457                  !srprs_char(&pos,')') ||
 458                  !srprs_char(&pos, ':'))
 459         {
 460                 return false;
 461         }
 462
 463         if (!srprs_val_hex_values(&pos, val, cont)) {
 464                 return false;
 465         }
 466
 467         *ptype = type;
 468         *ptr = pos;
 469         return true;
 470 }
 471
 472
 473 static bool srprs_comment(const char** ptr, cbuf* str)
 474 {
 475         return srprs_char(ptr, ';') && srprs_line(ptr, str);
 476 }
 477
 478 /**@}*/
 479
 480 int reg_parse_set_options(struct reg_parse* parser, const char* options)
 481 {
 482         static const char* DEFAULT ="enc=unix,flags=0";
 483
 484         int ret = 0;
 485         char *key, *val;
 486         void* ctx = talloc_new(parser);
 487
 488         if (options == NULL) {
 489                 options = DEFAULT;
 490         }
 491
 492         while (srprs_option(&options, ctx, &key, &val)) {
 493                 if ((strcmp(key, "enc") == 0) || (strcmp(key, "strenc") == 0)) {
 494                 } else if ((strcmp(key, "flags") == 0) && (val != NULL)) {
 495                         char* end = NULL;
 496                         if (val != NULL) {
 497                                 parser->flags = strtol(val, &end, 0);
 498                         }
 499                         if ((end==NULL) || (*end != '\0')) {
 500                                 DEBUG(0, ("Invalid flags format: %s\n",
 501                                           val ? val : "<NULL>"));
 502                                 ret = -1;
 503                         }
 504                 }
 505                 /* else if (strcmp(key, "hive") == 0) { */
 506                 /*      if (strcmp(val, "short") == 0) { */
 507                 /*              f->hive_fmt = REG_FMT_SHORT_HIVES; */
 508                 /*      } else if (strcmp(val, "long") == 0) { */
 509                 /*              f->hive_fmt = REG_FMT_LONG_HIVES; */
 510                 /*      } else if (strcmp(val, "preserve") == 0) { */
 511                 /*              f->hive_fmt = REG_FMT_PRESERVE_HIVES; */
 512                 /*      } else { */
 513                 /*              DEBUG(0, ("Invalid hive format: %s\n", val)); */
 514                 /*              ret = -1; */
 515                 /*      } */
 516                 /* } */
 517         }
 518         talloc_free(ctx);
 519         return ret;
 520 }
 521
 522
 523 int reg_parse_line(struct reg_parse* parser, const char* line)
 524 {
 525         const char* pos;
 526         bool del=false;
 527         cbuf* tmp=cbuf_clear(parser->tmp);
 528         bool cb_ok = true;
 529         bool cont = true;
 530
 531         if (!line) {
 532                 return -4;
 533         }
 534
 535         parser->linenum++;
 536         pos = line;
 537
 538         switch (parser->state) {
 539         case STATE_VAL_HEX_CONT:
 540                 if (srprs_val_hex_values(&pos, parser->valblob, &cont)) {
 541                         cb_ok = act_val_hex(parser, parser->valblob, cont);
 542                 }
 543                 goto done;
 544         case STATE_VAL_SZ_CONT:
 545                 if (srprs_quoted_string(&pos, parser->valblob, &cont)) {
 546                         cb_ok = act_val_sz(parser, parser->valblob, cont);
 547                 }
 548                 goto done;
 549         default:
 550                 cont = false;
 551         }
 552
 553         if ( !srprs_skipws(&pos) ) {
 554                 return -4;
 555         }
 556
 557         /* empty line ?*/
 558         if ( srprs_eol(&pos, NULL) ) {
 559                 return 0;
 560         }
 561
 562         /* key line ?*/
 563         else if (srprs_key(&pos, tmp, &del)) {
 564                 cb_ok = act_key(parser, tmp, del);
 565         }
 566
 567         /* comment line ? */
 568         else if (srprs_comment(&pos, tmp)) {
 569                 cb_ok = act_comment(parser, cbuf_gets(tmp, 0));
 570         }
 571
 572         /* head line */
 573         else if ((parser->linenum == 1) && srprs_line(&pos, tmp) ) {
 574                 /* cb_ok = act_head(parser, cbuf_gets(tmp, 0)); */
 575         }
 576
 577         /* value line ?*/
 578         else if (srprs_val_name(&pos, tmp)) {
 579                 uint32_t dw;
 580                 cbuf_swap(parser->valname, tmp);
 581                 cbuf_clear(tmp);
 582
 583                 if (parser->state != STATE_KEY_OPEN) {
 584                         DEBUG(0, ("value \"%s\" without a key at line: %i",
 585                                   cbuf_gets(parser->valname, 0), parser->linenum));
 586                         return -3;
 587                 }
 588
 589                 if (!srprs_skipws(&pos)) {
 590                         return -4;
 591                 }
 592
 593                 if (srprs_char(&pos, '-')) {
 594                         cb_ok = act_val_del(parser);
 595                 }
 596                 else if (srprs_val_dword(&pos, &parser->valtype, &dw)) {
 597                         cb_ok = act_val_dw(parser, dw);
 598                 }
 599                 else if (srprs_val_sz(&pos, &parser->valtype, tmp, &cont)) {
 600                         cb_ok = act_val_sz(parser, tmp, cont);
 601                 }
 602                 else if (srprs_val_hex(&pos, &parser->valtype, tmp, &cont)){
 603                         cb_ok = act_val_hex(parser, tmp, cont);
 604                 }
 605                 else {
 606                         DEBUG(0, ("value \"%s\" parse error"
 607                                   "at line: %i pos: %li : %s",
 608                                   cbuf_gets(parser->valname, 0), parser->linenum,
 609                                   (long int)(pos-line), pos));
 610                         return -3;
 611                 }
 612         }
 613         else {
 614                 DEBUG(0, ("unrecognized line %i : %s\n", parser->linenum, line));
 615                 return -3;
 616         }
 617
 618 done:
 619         if (!cb_ok)
 620                 return -2;
 621
 622         if (!srprs_skipws(&pos) || !srprs_eol(&pos, NULL)) {
 623                 DEBUG(0, ("trailing garbage at line: %i pos: %li : %s\n",
 624                           parser->linenum, (long int)(pos-line), pos));
 625                 return -1;
 626         }
 627         return 0;
 628 }
 629
 630 /******************************************************************************/
 631 /**
 632  * @addtogroup misc
 633  * @{
 634  */
 635 static bool lookslike_utf16(const char* line, size_t len, bool* little_endian)
 636 {
 637         static const uint16_t M_LE = 0xFF80;
 638         static const uint16_t M_BE = 0x80FF;
 639         uint16_t mask;
 640         bool le;
 641
 642         size_t l = MIN(len/2, 64);
 643         const uint16_t* u = (const uint16_t*)line;
 644         size_t i;
 645
 646         assert(len >= 2);
 647
 648         if ( u[0] & M_LE ) {
 649                 le = true;
 650                 mask = M_LE;
 651         } else  if ( u[0] & M_BE ) {
 652                 le = false;
 653                 mask = M_BE;
 654         } else {
 655                 return false;
 656         }
 657
 658         for (i=1; i<l; i++) {
 659                 if ( u[i] & mask ) {
 660                         return false;
 661                 }
 662         }
 663
 664         *little_endian = le;
 665         return true;
 666 }
 667
 668 static bool lookslike_dos(const char* line, size_t len)
 669 {
 670         size_t i;
 671         for (i=0; i<len; i++) {
 672                 if ( (line[i] == '\0') || (line[i] & 0x80) ) {
 673                         return false;
 674                 }
 675                 if ( (line[i] == '\r') && (i+1 < len) && (line[i+1] == '\n') ) {
 676                         return true;
 677                 }
 678         }
 679         return false;
 680 }
 681
 682 static bool guess_charset(const char** ptr,
 683                           size_t* len,
 684                           const char** file_enc,
 685                           const char** str_enc)
 686 {
 687         const char* charset = NULL;
 688         const char* pos = *ptr;
 689
 690         if (*len < 4) {
 691                 return false;
 692         }
 693
 694         if (srprs_bom(&pos, &charset, NULL)) {
 695                 size_t declen;
 696                 if (pos < *ptr) {
 697                         return false;
 698                 }
 699                 declen = (pos - *ptr);
 700                 if (*len < declen) {
 701                         return false;
 702                 }
 703                 *len -= declen;
 704                 *ptr = pos;
 705                 if (*file_enc == NULL) {
 706                         *file_enc = charset;
 707                 }
 708                 else if( strcmp(*file_enc, charset) != 0 ) {
 709                         DEBUG(0, ("file encoding forced to %s\n",
 710                                   *file_enc));
 711                 }
 712         }
 713         else if (*file_enc == NULL) {
 714                 bool le;
 715                 if (lookslike_utf16(*ptr, *len, &le)) {
 716                         *file_enc = le ? "UTF-16LE" : "UTF-16BE";
 717                 }
 718                 else if (lookslike_dos(*ptr, *len)) {
 719                         *file_enc = "dos";
 720                 }
 721                 else {
 722                         *file_enc = "unix";
 723                 }
 724         }
 725
 726         if ((str_enc != NULL) && (*str_enc == NULL)) {
 727                 *str_enc = ( strncmp(*ptr, "REGEDIT4", 8) == 0)
 728                         ? *file_enc
 729                         : "UTF-16LE";
 730         }
 731
 732         return true;
 733 }
 734 /**@}*/
 735
 736 struct reg_parse_fd_opt {
 737         const char* file_enc;
 738         const char* str_enc;
 739         unsigned flags;
 740         int fail_level;
 741 };
 742
 743 static struct reg_parse_fd_opt
 744 reg_parse_fd_opt(void* mem_ctx, const char* options)
 745 {
 746         struct reg_parse_fd_opt ret = {
 747                 .file_enc = NULL,
 748                 .str_enc  = NULL,
 749                 .flags    = 0,
 750         };
 751
 752         void* ctx = talloc_new(mem_ctx);
 753         char *key, *val;
 754
 755         if (options == NULL) {
 756                 goto done;
 757         }
 758
 759         while (srprs_option(&options, ctx, &key, &val)) {
 760                 if (strcmp(key, "enc") == 0) {
 761                         ret.file_enc = talloc_steal(mem_ctx, val);
 762                         ret.str_enc  = ret.file_enc;
 763                 } else if (strcmp(key, "strenc") == 0) {
 764                         ret.str_enc = talloc_steal(mem_ctx, val);
 765                 } else if (strcmp(key, "fileenc") == 0) {
 766                         ret.file_enc = talloc_steal(mem_ctx, val);
 767                 } else if ((strcmp(key, "flags") == 0) && (val != NULL)) {
 768                         char* end = NULL;
 769                         if (val != NULL) {
 770                                 ret.flags = strtol(val, &end, 0);
 771                         }
 772                         if ((end==NULL) || (*end != '\0')) {
 773                                 DEBUG(0, ("Invalid format \"%s\": %s\n",
 774                                           key, val ? val : "<NULL>"));
 775                         }
 776                 } else if ((strcmp(key, "fail") == 0) && (val != NULL)) {
 777                         char* end = NULL;
 778                         if (val != NULL) {
 779                                 ret.fail_level = -strtol(val, &end, 0);
 780                         }
 781                         if ((end==NULL) || (*end != '\0')) {
 782                                 DEBUG(0, ("Invalid format \"%s\": %s\n",
 783                                           key, val ? val : "<NULL>"));
 784                         }
 785                 }
 786         }
 787 done:
 788         talloc_free(ctx);
 789         return ret;
 790 }
 791
 792 static void display_iconv_error_bytes(const char *inbuf, size_t len)
 793 {
 794         size_t i;
 795         for (i = 0; i < 4 && i < len; i++) {
 796                 DEBUGADD(0, ("<%02x>", (unsigned char)inbuf[i]));
 797         }
 798         DEBUGADD(0, ("\n"));
 799 }
 800
 801 int reg_parse_fd(int fd, const struct reg_parse_callback* cb, const char* opts)
 802 {
 803         void* mem_ctx            = talloc_stackframe();
 804         cbuf* line               = cbuf_new(mem_ctx);
 805         smb_iconv_t cd           = (smb_iconv_t)-1;
 806         struct reg_parse* parser = NULL;
 807         char buf_in[1024];
 808         char buf_out[1025] = { 0 };
 809         ssize_t nread;
 810         const char* iptr;
 811         char* optr;
 812         size_t ilen;
 813         size_t olen;
 814         size_t avail_osize = sizeof(buf_out)-1;
 815         size_t space_to_read = sizeof(buf_in);
 816         int ret = -1;
 817         bool eof = false;
 818         size_t linecount = 0;
 819
 820         struct reg_parse_fd_opt opt = reg_parse_fd_opt(mem_ctx, opts);
 821
 822         if (cb == NULL) {
 823                 DBG_ERR("NULL callback\n");
 824                 ret = -1;
 825                 goto done;
 826         }
 827
 828         nread = read(fd, buf_in, space_to_read);
 829         if (nread < 0) {
 830                 DBG_ERR("read failed: %s\n", strerror(errno));
 831                 ret = -1;
 832                 goto done;
 833         }
 834         if (nread == 0) {
 835                 /* Empty file. */
 836                 eof = true;
 837                 goto done;
 838         }
 839
 840         iptr = buf_in;
 841         ilen = nread;
 842
 843         if (!guess_charset(&iptr, &ilen,
 844                            &opt.file_enc, &opt.str_enc))
 845         {
 846                 DBG_ERR("reg_parse_fd: failed to guess encoding\n");
 847                 ret = -1;
 848                 goto done;
 849         }
 850
 851         if (ilen == 0) {
 852                 /* File only contained charset info. */
 853                 eof = true;
 854                 ret = -1;
 855                 goto done;
 856         }
 857
 858         DBG_DEBUG("reg_parse_fd: encoding file: %s str: %s\n",
 859                   opt.file_enc, opt.str_enc);
 860
 861
 862         if (!set_iconv(&cd, "unix", opt.file_enc)) {
 863                 DBG_ERR("reg_parse_fd: failed to set file encoding %s\n",
 864                           opt.file_enc);
 865                 ret = -1;
 866                 goto done;
 867         }
 868
 869         parser = reg_parse_new(mem_ctx, *cb, opt.str_enc, opt.flags);
 870         if (parser == NULL) {
 871                 ret = -1;
 872                 goto done;
 873         }
 874
 875         /* Move input data to start of buf_in. */
 876         if (iptr > buf_in) {
 877                 memmove(buf_in, iptr, ilen);
 878                 iptr = buf_in;
 879         }
 880
 881         optr = buf_out;
 882         /* Leave last byte for null termination. */
 883         olen = avail_osize;
 884
 885         /*
 886          * We read from buf_in (iptr), iconv converting into
 887          * buf_out (optr).
 888          */
 889
 890         while (!eof) {
 891                 const char *pos;
 892                 size_t nconv;
 893
 894                 if (olen == 0) {
 895                         /* We're out of possible room. */
 896                         DBG_ERR("no room in output buffer\n");
 897                         ret = -1;
 898                         goto done;
 899                 }
 900                 nconv = smb_iconv(cd, &iptr, &ilen, &optr, &olen);
 901                 if (nconv == (size_t)-1) {
 902                         bool valid_err = false;
 903                         if (errno == EINVAL) {
 904                                 valid_err = true;
 905                         }
 906                         if (errno == E2BIG) {
 907                                 valid_err = true;
 908                         }
 909                         if (!valid_err) {
 910                                 DBG_ERR("smb_iconv error in file at line %zu: ",
 911                                           linecount);
 912                                 display_iconv_error_bytes(iptr, ilen);
 913                                 ret = -1;
 914                                 goto done;
 915                         }
 916                         /*
 917                          * For valid errors process the
 918                          * existing buffer then continue.
 919                          */
 920                 }
 921
 922                 /*
 923                  * We know this is safe as we have an extra
 924                  * enforced zero byte at the end of buf_out.
 925                  */
 926                 *optr = '\0';
 927                 pos = buf_out;
 928
 929                 while (srprs_line(&pos, line) && srprs_nl_no_eos(&pos, line, eof)) {
 930                         int retval;
 931
 932                         /* Process all lines we got. */
 933                         retval = reg_parse_line(parser, cbuf_gets(line, 0));
 934                         if (retval < opt.fail_level) {
 935                                 DBG_ERR("reg_parse_line %zu fail %d\n",
 936                                         linecount,
 937                                         retval);
 938                                 ret = -1;
 939                                 goto done;
 940                         }
 941                         cbuf_clear(line);
 942                         linecount++;
 943                 }
 944                 if (pos > buf_out) {
 945                         /*
 946                          * The output data we have
 947                          * processed starts at buf_out
 948                          * and ends at pos.
 949                          * The unprocessed output
 950                          * data starts at pos and
 951                          * ends at optr.
 952                          *
 953                          *  <------ sizeof(buf_out) - 1------------->|0|
 954                          *  <--------- avail_osize------------------>|0|
 955                          *  +----------------------+-------+-----------+
 956                          *  |                      |       |         |0|
 957                          *  +----------------------+-------+-----------+
 958                          *  ^                      ^       ^
 959                          *  |                      |       |
 960                          * buf_out               pos      optr
 961                          */
 962                         size_t unprocessed_len;
 963
 964                         /* Paranoia checks. */
 965                         if (optr < pos) {
 966                                 ret = -1;
 967                                 goto done;
 968                         }
 969                         unprocessed_len = optr - pos;
 970
 971                         /* Paranoia checks. */
 972                         if (avail_osize < unprocessed_len) {
 973                                 ret = -1;
 974                                 goto done;
 975                         }
 976                         /* Move down any unprocessed data. */
 977                         memmove(buf_out, pos, unprocessed_len);
 978
 979                         /*
 980                          * After the move, reset the output length.
 981                          *
 982                          *  <------ sizeof(buf_out) - 1------------->|0|
 983                          *  <--------- avail_osize------------------>|0|
 984                          *  +----------------------+-------+-----------+
 985                          *  |       |                                |0|
 986                          *  +----------------------+-------+-----------+
 987                          *  ^       ^
 988                          *  |       optr
 989                          * buf_out
 990                          */
 991                         optr = buf_out + unprocessed_len;
 992                         /*
 993                          * Calculate the new output space available
 994                          * for iconv.
 995                          * We already did the paranoia check for this
 996                          * arithmetic above.
 997                          */
 998                         olen = avail_osize - unprocessed_len;
 999                 }
1000
1001                 /*
1002                  * Move any unprocessed data to the start of
1003                  * the input buffer (buf_in).
1004                  */
1005                 if (ilen > 0 && iptr > buf_in) {
1006                         memmove(buf_in, iptr, ilen);
1007                 }
1008
1009                 /* Is there any space to read more input ? */
1010                 if (ilen >= sizeof(buf_in)) {
1011                         /* No space. Nothing was converted. Error. */
1012                         DBG_ERR("no space in input buffer\n");
1013                         ret = -1;
1014                         goto done;
1015                 }
1016
1017                 space_to_read = sizeof(buf_in) - ilen;
1018
1019                 /* Read the next chunk from the file. */
1020                 nread = read(fd, buf_in + ilen, space_to_read);
1021                 if (nread < 0) {
1022                         DBG_ERR("read failed: %s\n", strerror(errno));
1023                         ret = -1;
1024                         goto done;
1025                 }
1026                 if (nread == 0) {
1027                         /* Empty file. */
1028                         eof = true;
1029                         continue;
1030                 }
1031
1032                 /* Paranoia check. */
1033                 if (nread + ilen < ilen) {
1034                         ret = -1;
1035                         goto done;
1036                 }
1037
1038                 /* Paranoia check. */
1039                 if (nread + ilen > sizeof(buf_in)) {
1040                         ret = -1;
1041                         goto done;
1042                 }
1043
1044                 iptr = buf_in;
1045                 ilen = nread + ilen;
1046         }
1047
1048         ret = 0;
1049
1050 done:
1051
1052         set_iconv(&cd, NULL, NULL);
1053         if (parser) {
1054                 set_iconv(&parser->str2UTF16, NULL, NULL);
1055         }
1056         talloc_free(mem_ctx);
1057         return ret;
1058 }
1059
1060 int reg_parse_file(const char* fname, const struct reg_parse_callback* cb,
1061                    const char* opt)
1062 {
1063         int ret = -1;
1064         int fd;
1065
1066         fd = open(fname, O_RDONLY);
1067         if (fd < 0) {
1068                 DEBUG(0, ("reg_parse_file: open %s failed: %s\n", fname,
1069                           strerror(errno)));
1070                 return -1;
1071         }
1072
1073         ret = reg_parse_fd(fd, cb, opt);
1074
1075         close(fd);
1076         return ret;
1077 }
1078
1079 /* static struct registry_key *find_regkey_by_hnd(pipes_struct *p, */
1080 /*                                             struct policy_handle *hnd) */
1081 /* { */
1082 /*      struct registry_key *regkey = NULL; */
1083
1084 /*      if(!find_policy_by_hnd(p,hnd,(void **)(void *)&regkey)) { */
1085 /*              DEBUG(2,("find_regkey_index_by_hnd: Registry Key not found: ")); */
1086 /*              return NULL; */
1087 /*      } */
1088
1089 /*      return regkey; */
1090 /* } */