git.oblomov.eu Git - wine/blob - dlls/setupapi/parser.c

   1 /*
   2  * INF file parsing
   3  *
   4  * Copyright 2002 Alexandre Julliard for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <assert.h>
  25 #include <limits.h>
  26 #include <stdarg.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winuser.h"
  34 #include "winnls.h"
  35 #include "winreg.h"
  36 #include "winternl.h"
  37 #include "winerror.h"
  38 #include "setupapi.h"
  39 #include "setupapi_private.h"
  40
  41 #include "wine/unicode.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  45
  46 #define CONTROL_Z  '\x1a'
  47 #define MAX_SECTION_NAME_LEN  255
  48 #define MAX_FIELD_LEN         511  /* larger fields get silently truncated */
  49 /* actual string limit is MAX_INF_STRING_LENGTH+1 (plus terminating null) under Windows */
  50 #define MAX_STRING_LEN        (MAX_INF_STRING_LENGTH+1)
  51
  52 /* inf file structure definitions */
  53
  54 struct field
  55 {
  56     const WCHAR *text;         /* field text */
  57 };
  58
  59 struct line
  60 {
  61     int first_field;           /* index of first field in field array */
  62     int nb_fields;             /* number of fields in line */
  63     int key_field;             /* index of field for key or -1 if no key */
  64 };
  65
  66 struct section
  67 {
  68     const WCHAR *name;         /* section name */
  69     unsigned int nb_lines;     /* number of used lines */
  70     unsigned int alloc_lines;  /* total number of allocated lines in array below */
  71     struct line  lines[16];    /* lines information (grown dynamically, 16 is initial size) */
  72 };
  73
  74 struct inf_file
  75 {
  76     struct inf_file *next;            /* next appended file */
  77     WCHAR           *strings;         /* buffer for string data (section names and field values) */
  78     WCHAR           *string_pos;      /* position of next available string in buffer */
  79     unsigned int     nb_sections;     /* number of used sections */
  80     unsigned int     alloc_sections;  /* total number of allocated section pointers */
  81     struct section **sections;        /* section pointers array */
  82     unsigned int     nb_fields;
  83     unsigned int     alloc_fields;
  84     struct field    *fields;
  85     int              strings_section; /* index of [Strings] section or -1 if none */
  86     WCHAR           *filename;        /* filename of the INF */
  87 };
  88
  89 /* parser definitions */
  90
  91 enum parser_state
  92 {
  93     LINE_START,      /* at beginning of a line */
  94     SECTION_NAME,    /* parsing a section name */
  95     KEY_NAME,        /* parsing a key name */
  96     VALUE_NAME,      /* parsing a value name */
  97     EOL_BACKSLASH,   /* backslash at end of line */
  98     QUOTES,          /* inside quotes */
  99     LEADING_SPACES,  /* leading spaces */
 100     TRAILING_SPACES, /* trailing spaces */
 101     COMMENT,         /* inside a comment */
 102     NB_PARSER_STATES
 103 };
 104
 105 struct parser
 106 {
 107     const WCHAR      *start;        /* start position of item being parsed */
 108     const WCHAR      *end;          /* end of buffer */
 109     struct inf_file  *file;         /* file being built */
 110     enum parser_state state;        /* current parser state */
 111     enum parser_state stack[4];     /* state stack */
 112     int               stack_pos;    /* current pos in stack */
 113
 114     int               cur_section;  /* index of section being parsed*/
 115     struct line      *line;         /* current line */
 116     unsigned int      line_pos;     /* current line position in file */
 117     unsigned int      error;        /* error code */
 118     unsigned int      token_len;    /* current token len */
 119     WCHAR token[MAX_FIELD_LEN+1];   /* current token */
 120 };
 121
 122 typedef const WCHAR * (*parser_state_func)( struct parser *parser, const WCHAR *pos );
 123
 124 /* parser state machine functions */
 125 static const WCHAR *line_start_state( struct parser *parser, const WCHAR *pos );
 126 static const WCHAR *section_name_state( struct parser *parser, const WCHAR *pos );
 127 static const WCHAR *key_name_state( struct parser *parser, const WCHAR *pos );
 128 static const WCHAR *value_name_state( struct parser *parser, const WCHAR *pos );
 129 static const WCHAR *eol_backslash_state( struct parser *parser, const WCHAR *pos );
 130 static const WCHAR *quotes_state( struct parser *parser, const WCHAR *pos );
 131 static const WCHAR *leading_spaces_state( struct parser *parser, const WCHAR *pos );
 132 static const WCHAR *trailing_spaces_state( struct parser *parser, const WCHAR *pos );
 133 static const WCHAR *comment_state( struct parser *parser, const WCHAR *pos );
 134
 135 static const parser_state_func parser_funcs[NB_PARSER_STATES] =
 136 {
 137     line_start_state,      /* LINE_START */
 138     section_name_state,    /* SECTION_NAME */
 139     key_name_state,        /* KEY_NAME */
 140     value_name_state,      /* VALUE_NAME */
 141     eol_backslash_state,   /* EOL_BACKSLASH */
 142     quotes_state,          /* QUOTES */
 143     leading_spaces_state,  /* LEADING_SPACES */
 144     trailing_spaces_state, /* TRAILING_SPACES */
 145     comment_state          /* COMMENT */
 146 };
 147
 148
 149 /* Unicode string constants */
 150 static const WCHAR Version[]    = {'V','e','r','s','i','o','n',0};
 151 static const WCHAR Signature[]  = {'S','i','g','n','a','t','u','r','e',0};
 152 static const WCHAR Chicago[]    = {'$','C','h','i','c','a','g','o','$',0};
 153 static const WCHAR WindowsNT[]  = {'$','W','i','n','d','o','w','s',' ','N','T','$',0};
 154 static const WCHAR Windows95[]  = {'$','W','i','n','d','o','w','s',' ','9','5','$',0};
 155 static const WCHAR LayoutFile[] = {'L','a','y','o','u','t','F','i','l','e',0};
 156
 157 /* extend an array, allocating more memory if necessary */
 158 static void *grow_array( void *array, unsigned int *count, size_t elem )
 159 {
 160     void *new_array;
 161     unsigned int new_count = *count + *count / 2;
 162     if (new_count < 32) new_count = 32;
 163
 164     if (array)
 165         new_array = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, array, new_count * elem );
 166     else
 167         new_array = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, new_count * elem );
 168
 169     if (new_array)
 170         *count = new_count;
 171     else
 172         HeapFree( GetProcessHeap(), 0, array );
 173     return new_array;
 174 }
 175
 176
 177 /* get the directory of the inf file (as counted string, not null-terminated) */
 178 static const WCHAR *get_inf_dir( struct inf_file *file, unsigned int *len )
 179 {
 180     const WCHAR *p = strrchrW( file->filename, '\\' );
 181     *len = p ? (p + 1 - file->filename) : 0;
 182     return file->filename;
 183 }
 184
 185
 186 /* find a section by name */
 187 static int find_section( struct inf_file *file, const WCHAR *name )
 188 {
 189     unsigned int i;
 190
 191     for (i = 0; i < file->nb_sections; i++)
 192         if (!strcmpiW( name, file->sections[i]->name )) return i;
 193     return -1;
 194 }
 195
 196
 197 /* find a line by name */
 198 static struct line *find_line( struct inf_file *file, int section_index, const WCHAR *name )
 199 {
 200     struct section *section;
 201     struct line *line;
 202     int i;
 203
 204     if (section_index < 0 || section_index >= file->nb_sections) return NULL;
 205     section = file->sections[section_index];
 206     for (i = 0, line = section->lines; i < section->nb_lines; i++, line++)
 207     {
 208         if (line->key_field == -1) continue;
 209         if (!strcmpiW( name, file->fields[line->key_field].text )) return line;
 210     }
 211     return NULL;
 212 }
 213
 214
 215 /* add a section to the file and return the section index */
 216 static int add_section( struct inf_file *file, const WCHAR *name )
 217 {
 218     struct section *section;
 219
 220     if (file->nb_sections >= file->alloc_sections)
 221     {
 222         if (!(file->sections = grow_array( file->sections, &file->alloc_sections,
 223                                            sizeof(file->sections[0]) ))) return -1;
 224     }
 225     if (!(section = HeapAlloc( GetProcessHeap(), 0, sizeof(*section) ))) return -1;
 226     section->name        = name;
 227     section->nb_lines    = 0;
 228     section->alloc_lines = sizeof(section->lines)/sizeof(section->lines[0]);
 229     file->sections[file->nb_sections] = section;
 230     return file->nb_sections++;
 231 }
 232
 233
 234 /* add a line to a given section */
 235 static struct line *add_line( struct inf_file *file, int section_index )
 236 {
 237     struct section *section;
 238     struct line *line;
 239
 240     assert( section_index >= 0 && section_index < file->nb_sections );
 241
 242     section = file->sections[section_index];
 243     if (section->nb_lines == section->alloc_lines)  /* need to grow the section */
 244     {
 245         int size = sizeof(*section) - sizeof(section->lines) + 2*section->alloc_lines*sizeof(*line);
 246         if (!(section = HeapReAlloc( GetProcessHeap(), 0, section, size ))) return NULL;
 247         section->alloc_lines *= 2;
 248         file->sections[section_index] = section;
 249     }
 250     line = &section->lines[section->nb_lines++];
 251     line->first_field = file->nb_fields;
 252     line->nb_fields   = 0;
 253     line->key_field   = -1;
 254     return line;
 255 }
 256
 257
 258 /* retrieve a given line from section/line index */
 259 inline static struct line *get_line( struct inf_file *file, unsigned int section_index,
 260                                      unsigned int line_index )
 261 {
 262     struct section *section;
 263
 264     if (section_index >= file->nb_sections) return NULL;
 265     section = file->sections[section_index];
 266     if (line_index >= section->nb_lines) return NULL;
 267     return &section->lines[line_index];
 268 }
 269
 270
 271 /* retrieve a given field from section/line/field index */
 272 static struct field *get_field( struct inf_file *file, int section_index, int line_index,
 273                                 int field_index )
 274 {
 275     struct line *line = get_line( file, section_index, line_index );
 276
 277     if (!line) return NULL;
 278     if (!field_index)  /* get the key */
 279     {
 280         if (line->key_field == -1) return NULL;
 281         return &file->fields[line->key_field];
 282     }
 283     field_index--;
 284     if (field_index >= line->nb_fields) return NULL;
 285     return &file->fields[line->first_field + field_index];
 286 }
 287
 288
 289 /* allocate a new field, growing the array if necessary */
 290 static struct field *add_field( struct inf_file *file, const WCHAR *text )
 291 {
 292     struct field *field;
 293
 294     if (file->nb_fields >= file->alloc_fields)
 295     {
 296         if (!(file->fields = grow_array( file->fields, &file->alloc_fields,
 297                                          sizeof(file->fields[0]) ))) return NULL;
 298     }
 299     field = &file->fields[file->nb_fields++];
 300     field->text = text;
 301     return field;
 302 }
 303
 304
 305 /* retrieve the string substitution for a directory id */
 306 static const WCHAR *get_dirid_subst( struct inf_file *file, int dirid, unsigned int *len )
 307 {
 308     const WCHAR *ret;
 309
 310     if (dirid == DIRID_SRCPATH) return get_inf_dir( file, len );
 311     ret = DIRID_get_string( dirid );
 312     if (ret) *len = strlenW(ret);
 313     return ret;
 314 }
 315
 316
 317 /* retrieve the string substitution for a given string, or NULL if not found */
 318 /* if found, len is set to the substitution length */
 319 static const WCHAR *get_string_subst( struct inf_file *file, const WCHAR *str, unsigned int *len )
 320 {
 321     static const WCHAR percent = '%';
 322
 323     struct section *strings_section;
 324     struct line *line;
 325     struct field *field;
 326     unsigned int i;
 327     int dirid;
 328     WCHAR *dirid_str, *end;
 329     const WCHAR *ret = NULL;
 330
 331     if (!*len)  /* empty string (%%) is replaced by single percent */
 332     {
 333         *len = 1;
 334         return &percent;
 335     }
 336     if (file->strings_section == -1) goto not_found;
 337     strings_section = file->sections[file->strings_section];
 338     for (i = 0, line = strings_section->lines; i < strings_section->nb_lines; i++, line++)
 339     {
 340         if (line->key_field == -1) continue;
 341         if (strncmpiW( str, file->fields[line->key_field].text, *len )) continue;
 342         if (!file->fields[line->key_field].text[*len]) break;
 343     }
 344     if (i == strings_section->nb_lines || !line->nb_fields) goto not_found;
 345     field = &file->fields[line->first_field];
 346     *len = strlenW( field->text );
 347     return field->text;
 348
 349  not_found:  /* check for integer id */
 350     if ((dirid_str = HeapAlloc( GetProcessHeap(), 0, (*len+1) * sizeof(WCHAR) )))
 351     {
 352         memcpy( dirid_str, str, *len * sizeof(WCHAR) );
 353         dirid_str[*len] = 0;
 354         dirid = strtolW( dirid_str, &end, 10 );
 355         if (!*end) ret = get_dirid_subst( file, dirid, len );
 356         HeapFree( GetProcessHeap(), 0, dirid_str );
 357         return ret;
 358     }
 359     return NULL;
 360 }
 361
 362
 363 /* do string substitutions on the specified text */
 364 /* the buffer is assumed to be large enough */
 365 /* returns necessary length not including terminating null */
 366 unsigned int PARSER_string_substW( struct inf_file *file, const WCHAR *text, WCHAR *buffer,
 367                                    unsigned int size )
 368 {
 369     const WCHAR *start, *subst, *p;
 370     unsigned int len, total = 0;
 371     int inside = 0;
 372
 373     if (!buffer) size = MAX_STRING_LEN + 1;
 374     for (p = start = text; *p; p++)
 375     {
 376         if (*p != '%') continue;
 377         inside = !inside;
 378         if (inside)  /* start of a %xx% string */
 379         {
 380             len = p - start;
 381             if (len > size - 1) len = size - 1;
 382             if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
 383             total += len;
 384             size -= len;
 385             start = p;
 386         }
 387         else /* end of the %xx% string, find substitution */
 388         {
 389             len = p - start - 1;
 390             subst = get_string_subst( file, start + 1, &len );
 391             if (!subst)
 392             {
 393                 subst = start;
 394                 len = p - start + 1;
 395             }
 396             if (len > size - 1) len = size - 1;
 397             if (buffer) memcpy( buffer + total, subst, len * sizeof(WCHAR) );
 398             total += len;
 399             size -= len;
 400             start = p + 1;
 401         }
 402     }
 403
 404     if (start != p) /* unfinished string, copy it */
 405     {
 406         len = p - start;
 407         if (len > size - 1) len = size - 1;
 408         if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
 409         total += len;
 410     }
 411     if (buffer && size) buffer[total] = 0;
 412     return total;
 413 }
 414
 415
 416 /* do string substitutions on the specified text */
 417 /* the buffer is assumed to be large enough */
 418 /* returns necessary length not including terminating null */
 419 unsigned int PARSER_string_substA( struct inf_file *file, const WCHAR *text, char *buffer,
 420                                    unsigned int size )
 421 {
 422     WCHAR buffW[MAX_STRING_LEN+1];
 423     DWORD ret;
 424
 425     unsigned int len = PARSER_string_substW( file, text, buffW, sizeof(buffW)/sizeof(WCHAR) );
 426     if (!buffer) RtlUnicodeToMultiByteSize( &ret, buffW, len * sizeof(WCHAR) );
 427     else
 428     {
 429         RtlUnicodeToMultiByteN( buffer, size-1, &ret, buffW, len * sizeof(WCHAR) );
 430         buffer[ret] = 0;
 431     }
 432     return ret;
 433 }
 434
 435
 436 /* push some string data into the strings buffer */
 437 static WCHAR *push_string( struct inf_file *file, const WCHAR *string )
 438 {
 439     WCHAR *ret = file->string_pos;
 440     strcpyW( ret, string );
 441     file->string_pos += strlenW( ret ) + 1;
 442     return ret;
 443 }
 444
 445
 446 /* push the current state on the parser stack */
 447 inline static void push_state( struct parser *parser, enum parser_state state )
 448 {
 449     assert( parser->stack_pos < sizeof(parser->stack)/sizeof(parser->stack[0]) );
 450     parser->stack[parser->stack_pos++] = state;
 451 }
 452
 453
 454 /* pop the current state */
 455 inline static void pop_state( struct parser *parser )
 456 {
 457     assert( parser->stack_pos );
 458     parser->state = parser->stack[--parser->stack_pos];
 459 }
 460
 461
 462 /* set the parser state and return the previous one */
 463 inline static enum parser_state set_state( struct parser *parser, enum parser_state state )
 464 {
 465     enum parser_state ret = parser->state;
 466     parser->state = state;
 467     return ret;
 468 }
 469
 470
 471 /* check if the pointer points to an end of file */
 472 inline static int is_eof( struct parser *parser, const WCHAR *ptr )
 473 {
 474     return (ptr >= parser->end || *ptr == CONTROL_Z);
 475 }
 476
 477
 478 /* check if the pointer points to an end of line */
 479 inline static int is_eol( struct parser *parser, const WCHAR *ptr )
 480 {
 481     return (ptr >= parser->end || *ptr == CONTROL_Z || *ptr == '\n');
 482 }
 483
 484
 485 /* push data from current token start up to pos into the current token */
 486 static int push_token( struct parser *parser, const WCHAR *pos )
 487 {
 488     int len = pos - parser->start;
 489     const WCHAR *src = parser->start;
 490     WCHAR *dst = parser->token + parser->token_len;
 491
 492     if (len > MAX_FIELD_LEN - parser->token_len) len = MAX_FIELD_LEN - parser->token_len;
 493
 494     parser->token_len += len;
 495     for ( ; len > 0; len--, dst++, src++) *dst = *src ? *src : ' ';
 496     *dst = 0;
 497     parser->start = pos;
 498     return 0;
 499 }
 500
 501
 502 /* add a section with the current token as name */
 503 static int add_section_from_token( struct parser *parser )
 504 {
 505     int section_index;
 506
 507     if (parser->token_len > MAX_SECTION_NAME_LEN)
 508     {
 509         parser->error = ERROR_SECTION_NAME_TOO_LONG;
 510         return -1;
 511     }
 512     if ((section_index = find_section( parser->file, parser->token )) == -1)
 513     {
 514         /* need to create a new one */
 515         const WCHAR *name = push_string( parser->file, parser->token );
 516         if ((section_index = add_section( parser->file, name )) == -1)
 517         {
 518             parser->error = ERROR_NOT_ENOUGH_MEMORY;
 519             return -1;
 520         }
 521     }
 522     parser->token_len = 0;
 523     parser->cur_section = section_index;
 524     return section_index;
 525 }
 526
 527
 528 /* add a field containing the current token to the current line */
 529 static struct field *add_field_from_token( struct parser *parser, int is_key )
 530 {
 531     struct field *field;
 532     WCHAR *text;
 533
 534     if (!parser->line)  /* need to start a new line */
 535     {
 536         if (parser->cur_section == -1)  /* got a line before the first section */
 537         {
 538             parser->error = ERROR_EXPECTED_SECTION_NAME;
 539             return NULL;
 540         }
 541         if (!(parser->line = add_line( parser->file, parser->cur_section ))) goto error;
 542     }
 543     else assert(!is_key);
 544
 545     text = push_string( parser->file, parser->token );
 546     if ((field = add_field( parser->file, text )))
 547     {
 548         if (!is_key) parser->line->nb_fields++;
 549         else
 550         {
 551             /* replace first field by key field */
 552             parser->line->key_field = parser->line->first_field;
 553             parser->line->first_field++;
 554         }
 555         parser->token_len = 0;
 556         return field;
 557     }
 558  error:
 559     parser->error = ERROR_NOT_ENOUGH_MEMORY;
 560     return NULL;
 561 }
 562
 563
 564 /* close the current line and prepare for parsing a new one */
 565 static void close_current_line( struct parser *parser )
 566 {
 567     struct line *cur_line = parser->line;
 568
 569     if (cur_line)
 570     {
 571         /* if line has a single field and no key, the field is the key too */
 572         if (cur_line->nb_fields == 1 && cur_line->key_field == -1)
 573             cur_line->key_field = cur_line->first_field;
 574     }
 575     parser->line = NULL;
 576 }
 577
 578
 579 /* handler for parser LINE_START state */
 580 static const WCHAR *line_start_state( struct parser *parser, const WCHAR *pos )
 581 {
 582     const WCHAR *p;
 583
 584     for (p = pos; !is_eof( parser, p ); p++)
 585     {
 586         switch(*p)
 587         {
 588         case '\n':
 589             parser->line_pos++;
 590             close_current_line( parser );
 591             break;
 592         case ';':
 593             push_state( parser, LINE_START );
 594             set_state( parser, COMMENT );
 595             return p + 1;
 596         case '[':
 597             parser->start = p + 1;
 598             set_state( parser, SECTION_NAME );
 599             return p + 1;
 600         default:
 601             if (!isspaceW(*p))
 602             {
 603                 parser->start = p;
 604                 set_state( parser, KEY_NAME );
 605                 return p;
 606             }
 607             break;
 608         }
 609     }
 610     close_current_line( parser );
 611     return NULL;
 612 }
 613
 614
 615 /* handler for parser SECTION_NAME state */
 616 static const WCHAR *section_name_state( struct parser *parser, const WCHAR *pos )
 617 {
 618     const WCHAR *p;
 619
 620     for (p = pos; !is_eol( parser, p ); p++)
 621     {
 622         if (*p == ']')
 623         {
 624             push_token( parser, p );
 625             if (add_section_from_token( parser ) == -1) return NULL;
 626             push_state( parser, LINE_START );
 627             set_state( parser, COMMENT );  /* ignore everything else on the line */
 628             return p + 1;
 629         }
 630     }
 631     parser->error = ERROR_BAD_SECTION_NAME_LINE; /* unfinished section name */
 632     return NULL;
 633 }
 634
 635
 636 /* handler for parser KEY_NAME state */
 637 static const WCHAR *key_name_state( struct parser *parser, const WCHAR *pos )
 638 {
 639     const WCHAR *p, *token_end = parser->start;
 640
 641     for (p = pos; !is_eol( parser, p ); p++)
 642     {
 643         if (*p == ',') break;
 644         switch(*p)
 645         {
 646
 647          case '=':
 648             push_token( parser, token_end );
 649             if (!add_field_from_token( parser, 1 )) return NULL;
 650             parser->start = p + 1;
 651             push_state( parser, VALUE_NAME );
 652             set_state( parser, LEADING_SPACES );
 653             return p + 1;
 654         case ';':
 655             push_token( parser, token_end );
 656             if (!add_field_from_token( parser, 0 )) return NULL;
 657             push_state( parser, LINE_START );
 658             set_state( parser, COMMENT );
 659             return p + 1;
 660         case '"':
 661             push_token( parser, p );
 662             parser->start = p + 1;
 663             push_state( parser, KEY_NAME );
 664             set_state( parser, QUOTES );
 665             return p + 1;
 666         case '\\':
 667             push_token( parser, token_end );
 668             parser->start = p;
 669             push_state( parser, KEY_NAME );
 670             set_state( parser, EOL_BACKSLASH );
 671             return p;
 672         default:
 673             if (!isspaceW(*p)) token_end = p + 1;
 674             else
 675             {
 676                 push_token( parser, p );
 677                 push_state( parser, KEY_NAME );
 678                 set_state( parser, TRAILING_SPACES );
 679                 return p;
 680             }
 681             break;
 682         }
 683     }
 684     push_token( parser, token_end );
 685     set_state( parser, VALUE_NAME );
 686     return p;
 687 }
 688
 689
 690 /* handler for parser VALUE_NAME state */
 691 static const WCHAR *value_name_state( struct parser *parser, const WCHAR *pos )
 692 {
 693     const WCHAR *p, *token_end = parser->start;
 694
 695     for (p = pos; !is_eol( parser, p ); p++)
 696     {
 697         switch(*p)
 698         {
 699         case ';':
 700             push_token( parser, token_end );
 701             if (!add_field_from_token( parser, 0 )) return NULL;
 702             push_state( parser, LINE_START );
 703             set_state( parser, COMMENT );
 704             return p + 1;
 705         case ',':
 706             push_token( parser, token_end );
 707             if (!add_field_from_token( parser, 0 )) return NULL;
 708             parser->start = p + 1;
 709             push_state( parser, VALUE_NAME );
 710             set_state( parser, LEADING_SPACES );
 711             return p + 1;
 712         case '"':
 713             push_token( parser, p );
 714             parser->start = p + 1;
 715             push_state( parser, VALUE_NAME );
 716             set_state( parser, QUOTES );
 717             return p + 1;
 718         case '\\':
 719             push_token( parser, token_end );
 720             parser->start = p;
 721             push_state( parser, VALUE_NAME );
 722             set_state( parser, EOL_BACKSLASH );
 723             return p;
 724         default:
 725             if (!isspaceW(*p)) token_end = p + 1;
 726             else
 727             {
 728                 push_token( parser, p );
 729                 push_state( parser, VALUE_NAME );
 730                 set_state( parser, TRAILING_SPACES );
 731                 return p;
 732             }
 733             break;
 734         }
 735     }
 736     push_token( parser, token_end );
 737     if (!add_field_from_token( parser, 0 )) return NULL;
 738     set_state( parser, LINE_START );
 739     return p;
 740 }
 741
 742
 743 /* handler for parser EOL_BACKSLASH state */
 744 static const WCHAR *eol_backslash_state( struct parser *parser, const WCHAR *pos )
 745 {
 746     const WCHAR *p;
 747
 748     for (p = pos; !is_eof( parser, p ); p++)
 749     {
 750         switch(*p)
 751         {
 752         case '\n':
 753             parser->line_pos++;
 754             parser->start = p + 1;
 755             set_state( parser, LEADING_SPACES );
 756             return p + 1;
 757         case '\\':
 758             continue;
 759         case ';':
 760             push_state( parser, EOL_BACKSLASH );
 761             set_state( parser, COMMENT );
 762             return p + 1;
 763         default:
 764             if (isspaceW(*p)) continue;
 765             push_token( parser, p );
 766             pop_state( parser );
 767             return p;
 768         }
 769     }
 770     parser->start = p;
 771     pop_state( parser );
 772     return p;
 773 }
 774
 775
 776 /* handler for parser QUOTES state */
 777 static const WCHAR *quotes_state( struct parser *parser, const WCHAR *pos )
 778 {
 779     const WCHAR *p, *token_end = parser->start;
 780
 781     for (p = pos; !is_eol( parser, p ); p++)
 782     {
 783         if (*p == '"')
 784         {
 785             if (p+1 < parser->end && p[1] == '"')  /* double quotes */
 786             {
 787                 push_token( parser, p + 1 );
 788                 parser->start = token_end = p + 2;
 789                 p++;
 790             }
 791             else  /* end of quotes */
 792             {
 793                 push_token( parser, p );
 794                 parser->start = p + 1;
 795                 pop_state( parser );
 796                 return p + 1;
 797             }
 798         }
 799     }
 800     push_token( parser, p );
 801     pop_state( parser );
 802     return p;
 803 }
 804
 805
 806 /* handler for parser LEADING_SPACES state */
 807 static const WCHAR *leading_spaces_state( struct parser *parser, const WCHAR *pos )
 808 {
 809     const WCHAR *p;
 810
 811     for (p = pos; !is_eol( parser, p ); p++)
 812     {
 813         if (*p == '\\')
 814         {
 815             parser->start = p;
 816             set_state( parser, EOL_BACKSLASH );
 817             return p;
 818         }
 819         if (!isspaceW(*p)) break;
 820     }
 821     parser->start = p;
 822     pop_state( parser );
 823     return p;
 824 }
 825
 826
 827 /* handler for parser TRAILING_SPACES state */
 828 static const WCHAR *trailing_spaces_state( struct parser *parser, const WCHAR *pos )
 829 {
 830     const WCHAR *p;
 831
 832     for (p = pos; !is_eol( parser, p ); p++)
 833     {
 834         if (*p == '\\')
 835         {
 836             set_state( parser, EOL_BACKSLASH );
 837             return p;
 838         }
 839         if (!isspaceW(*p)) break;
 840     }
 841     pop_state( parser );
 842     return p;
 843 }
 844
 845
 846 /* handler for parser COMMENT state */
 847 static const WCHAR *comment_state( struct parser *parser, const WCHAR *pos )
 848 {
 849     const WCHAR *p = pos;
 850
 851     while (!is_eol( parser, p )) p++;
 852     pop_state( parser );
 853     return p;
 854 }
 855
 856
 857 /* parse a complete buffer */
 858 static DWORD parse_buffer( struct inf_file *file, const WCHAR *buffer, const WCHAR *end,
 859                            UINT *error_line )
 860 {
 861     static const WCHAR Strings[] = {'S','t','r','i','n','g','s',0};
 862
 863     struct parser parser;
 864     const WCHAR *pos = buffer;
 865
 866     parser.start       = buffer;
 867     parser.end         = end;
 868     parser.file        = file;
 869     parser.line        = NULL;
 870     parser.state       = LINE_START;
 871     parser.stack_pos   = 0;
 872     parser.cur_section = -1;
 873     parser.line_pos    = 1;
 874     parser.error       = 0;
 875     parser.token_len   = 0;
 876
 877     /* parser main loop */
 878     while (pos) pos = (parser_funcs[parser.state])( &parser, pos );
 879
 880     /* trim excess buffer space */
 881     if (file->alloc_sections > file->nb_sections)
 882     {
 883         file->sections = HeapReAlloc( GetProcessHeap(), 0, file->sections,
 884                                       file->nb_sections * sizeof(file->sections[0]) );
 885         file->alloc_sections = file->nb_sections;
 886     }
 887     if (file->alloc_fields > file->nb_fields)
 888     {
 889         file->fields = HeapReAlloc( GetProcessHeap(), 0, file->fields,
 890                                     file->nb_fields * sizeof(file->fields[0]) );
 891         file->alloc_fields = file->nb_fields;
 892     }
 893     file->strings = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, file->strings,
 894                                  (file->string_pos - file->strings) * sizeof(WCHAR) );
 895
 896     if (parser.error)
 897     {
 898         if (error_line) *error_line = parser.line_pos;
 899         return parser.error;
 900     }
 901
 902     /* find the [strings] section */
 903     file->strings_section = find_section( file, Strings );
 904     return 0;
 905 }
 906
 907
 908 /* append a child INF file to its parent list, in a thread-safe manner */
 909 static void append_inf_file( struct inf_file *parent, struct inf_file *child )
 910 {
 911     struct inf_file **ppnext = &parent->next;
 912     child->next = NULL;
 913
 914     for (;;)
 915     {
 916         struct inf_file *next = InterlockedCompareExchangePointer( (void **)ppnext, child, NULL );
 917         if (!next) return;
 918         ppnext = &next->next;
 919     }
 920 }
 921
 922
 923 /***********************************************************************
 924  *            parse_file
 925  *
 926  * parse an INF file.
 927  */
 928 static struct inf_file *parse_file( HANDLE handle, const WCHAR *class, UINT *error_line )
 929 {
 930     void *buffer;
 931     DWORD err = 0;
 932     struct inf_file *file;
 933
 934     DWORD size = GetFileSize( handle, NULL );
 935     HANDLE mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, size, NULL );
 936     if (!mapping) return NULL;
 937     buffer = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, size );
 938     NtClose( mapping );
 939     if (!buffer) return NULL;
 940
 941     if (class) FIXME( "class %s not supported yet\n", debugstr_w(class) );
 942
 943     if (!(file = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*file) )))
 944     {
 945         err = ERROR_NOT_ENOUGH_MEMORY;
 946         goto done;
 947     }
 948
 949     /* we won't need more strings space than the size of the file,
 950      * so we can preallocate it here
 951      */
 952     if (!(file->strings = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )))
 953     {
 954         err = ERROR_NOT_ENOUGH_MEMORY;
 955         goto done;
 956     }
 957     file->string_pos = file->strings;
 958     file->strings_section = -1;
 959
 960     if (!RtlIsTextUnicode( buffer, size, NULL ))
 961     {
 962         WCHAR *new_buff = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
 963         if (new_buff)
 964         {
 965             DWORD len = MultiByteToWideChar( CP_ACP, 0, buffer, size, new_buff, size );
 966             err = parse_buffer( file, new_buff, new_buff + len, error_line );
 967             HeapFree( GetProcessHeap(), 0, new_buff );
 968         }
 969     }
 970     else
 971     {
 972         WCHAR *new_buff = (WCHAR *)buffer;
 973         /* UCS-16 files should start with the Unicode BOM; we should skip it */
 974         if (*new_buff == 0xfeff)
 975             new_buff++;
 976         err = parse_buffer( file, new_buff, (WCHAR *)((char *)buffer + size), error_line );
 977     }
 978
 979     if (!err)  /* now check signature */
 980     {
 981         int version_index = find_section( file, Version );
 982         if (version_index != -1)
 983         {
 984             struct line *line = find_line( file, version_index, Signature );
 985             if (line && line->nb_fields > 0)
 986             {
 987                 struct field *field = file->fields + line->first_field;
 988                 if (!strcmpiW( field->text, Chicago )) goto done;
 989                 if (!strcmpiW( field->text, WindowsNT )) goto done;
 990                 if (!strcmpiW( field->text, Windows95 )) goto done;
 991             }
 992         }
 993         if (error_line) *error_line = 0;
 994         err = ERROR_WRONG_INF_STYLE;
 995     }
 996
 997  done:
 998     UnmapViewOfFile( buffer );
 999     if (err)
1000     {
1001         HeapFree( GetProcessHeap(), 0, file );
1002         SetLastError( err );
1003         file = NULL;
1004     }
1005     return file;
1006 }
1007
1008
1009 /***********************************************************************
1010  *            PARSER_get_inf_filename
1011  *
1012  * Retrieve the filename of an inf file.
1013  */
1014 const WCHAR *PARSER_get_inf_filename( HINF hinf )
1015 {
1016     struct inf_file *file = hinf;
1017     return file->filename;
1018 }
1019
1020
1021 /***********************************************************************
1022  *            PARSER_get_src_root
1023  *
1024  * Retrieve the source directory of an inf file.
1025  */
1026 WCHAR *PARSER_get_src_root( HINF hinf )
1027 {
1028     unsigned int len;
1029     const WCHAR *dir = get_inf_dir( hinf, &len );
1030     WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
1031     if (ret)
1032     {
1033         memcpy( ret, dir, len * sizeof(WCHAR) );
1034         ret[len] = 0;
1035     }
1036     return ret;
1037 }
1038
1039
1040 /***********************************************************************
1041  *            PARSER_get_dest_dir
1042  *
1043  * retrieve a destination dir of the form "dirid,relative_path" in the given entry.
1044  * returned buffer must be freed by caller.
1045  */
1046 WCHAR *PARSER_get_dest_dir( INFCONTEXT *context )
1047 {
1048     const WCHAR *dir;
1049     WCHAR *ptr, *ret;
1050     INT dirid;
1051     unsigned int len1;
1052     DWORD len2;
1053
1054     if (!SetupGetIntField( context, 1, &dirid )) return NULL;
1055     if (!(dir = get_dirid_subst( context->Inf, dirid, &len1 ))) return NULL;
1056     if (!SetupGetStringFieldW( context, 2, NULL, 0, &len2 )) len2 = 0;
1057     if (!(ret = HeapAlloc( GetProcessHeap(), 0, (len1+len2+1) * sizeof(WCHAR) ))) return NULL;
1058     memcpy( ret, dir, len1 * sizeof(WCHAR) );
1059     ptr = ret + len1;
1060     if (len2 && ptr > ret && ptr[-1] != '\\') *ptr++ = '\\';
1061     if (!SetupGetStringFieldW( context, 2, ptr, len2, NULL )) *ptr = 0;
1062     return ret;
1063 }
1064
1065
1066 /***********************************************************************
1067  *            SetupOpenInfFileA   (SETUPAPI.@)
1068  */
1069 HINF WINAPI SetupOpenInfFileA( PCSTR name, PCSTR class, DWORD style, UINT *error )
1070 {
1071     UNICODE_STRING nameW, classW;
1072     HINF ret = (HINF)INVALID_HANDLE_VALUE;
1073
1074     classW.Buffer = NULL;
1075     if (class && !RtlCreateUnicodeStringFromAsciiz( &classW, class ))
1076     {
1077         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1078         return ret;
1079     }
1080     if (RtlCreateUnicodeStringFromAsciiz( &nameW, name ))
1081     {
1082         ret = SetupOpenInfFileW( nameW.Buffer, classW.Buffer, style, error );
1083         RtlFreeUnicodeString( &nameW );
1084     }
1085     RtlFreeUnicodeString( &classW );
1086     return ret;
1087 }
1088
1089
1090 /***********************************************************************
1091  *            SetupOpenInfFileW   (SETUPAPI.@)
1092  */
1093 HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *error )
1094 {
1095     struct inf_file *file = NULL;
1096     HANDLE handle;
1097     WCHAR *path, *p;
1098     UINT len;
1099
1100     if (strchrW( name, '\\' ) || strchrW( name, '/' ))
1101     {
1102         if (!(len = GetFullPathNameW( name, 0, NULL, NULL ))) return (HINF)INVALID_HANDLE_VALUE;
1103         if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1104         {
1105             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1106             return (HINF)INVALID_HANDLE_VALUE;
1107         }
1108         GetFullPathNameW( name, len, path, NULL );
1109         handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1110     }
1111     else  /* try Windows directory */
1112     {
1113         static const WCHAR Inf[]      = {'\\','i','n','f','\\',0};
1114         static const WCHAR System32[] = {'\\','s','y','s','t','e','m','3','2','\\',0};
1115
1116         len = GetWindowsDirectoryW( NULL, 0 ) + strlenW(name) + 12;
1117         if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1118         {
1119             SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1120             return (HINF)INVALID_HANDLE_VALUE;
1121         }
1122         GetWindowsDirectoryW( path, len );
1123         p = path + strlenW(path);
1124         strcpyW( p, Inf );
1125         strcatW( p, name );
1126         handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1127         if (handle == INVALID_HANDLE_VALUE)
1128         {
1129             strcpyW( p, System32 );
1130             strcatW( p, name );
1131             handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1132         }
1133     }
1134
1135     if (handle != INVALID_HANDLE_VALUE)
1136     {
1137         file = parse_file( handle, class, error );
1138         CloseHandle( handle );
1139     }
1140     if (!file)
1141     {
1142         HeapFree( GetProcessHeap(), 0, path );
1143         return (HINF)INVALID_HANDLE_VALUE;
1144     }
1145     TRACE( "%s -> %p\n", debugstr_w(path), file );
1146     file->filename = path;
1147     SetLastError( 0 );
1148     return (HINF)file;
1149 }
1150
1151
1152 /***********************************************************************
1153  *            SetupOpenAppendInfFileA    (SETUPAPI.@)
1154  */
1155 BOOL WINAPI SetupOpenAppendInfFileA( PCSTR name, HINF parent_hinf, UINT *error )
1156 {
1157     HINF child_hinf;
1158
1159     if (!name) return SetupOpenAppendInfFileW( NULL, parent_hinf, error );
1160     child_hinf = SetupOpenInfFileA( name, NULL, INF_STYLE_WIN4, error );
1161     if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE;
1162     append_inf_file( parent_hinf, child_hinf );
1163     TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_a(name), child_hinf );
1164     return TRUE;
1165 }
1166
1167
1168 /***********************************************************************
1169  *            SetupOpenAppendInfFileW    (SETUPAPI.@)
1170  */
1171 BOOL WINAPI SetupOpenAppendInfFileW( PCWSTR name, HINF parent_hinf, UINT *error )
1172 {
1173     HINF child_hinf;
1174
1175     if (!name)
1176     {
1177         INFCONTEXT context;
1178         WCHAR filename[MAX_PATH];
1179         int idx = 1;
1180
1181         if (!SetupFindFirstLineW( parent_hinf, Version, LayoutFile, &context )) return FALSE;
1182         while (SetupGetStringFieldW( &context, idx++, filename,
1183                                      sizeof(filename)/sizeof(WCHAR), NULL ))
1184         {
1185             child_hinf = SetupOpenInfFileW( filename, NULL, INF_STYLE_WIN4, error );
1186             if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE;
1187             append_inf_file( parent_hinf, child_hinf );
1188             TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(filename), child_hinf );
1189         }
1190         return TRUE;
1191     }
1192     child_hinf = SetupOpenInfFileW( name, NULL, INF_STYLE_WIN4, error );
1193     if (child_hinf == (HINF)INVALID_HANDLE_VALUE) return FALSE;
1194     append_inf_file( parent_hinf, child_hinf );
1195     TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(name), child_hinf );
1196     return TRUE;
1197 }
1198
1199
1200 /***********************************************************************
1201  *            SetupOpenMasterInf   (SETUPAPI.@)
1202  */
1203 HINF WINAPI SetupOpenMasterInf( VOID )
1204 {
1205     static const WCHAR Layout[] = {'\\','i','n','f','\\', 'l', 'a', 'y', 'o', 'u', 't', '.', 'i', 'n', 'f', 0};
1206     WCHAR Buffer[MAX_PATH];
1207
1208     GetWindowsDirectoryW( Buffer, MAX_PATH );
1209     strcatW( Buffer, Layout );
1210     return SetupOpenInfFileW( Buffer, NULL, INF_STYLE_WIN4, NULL);
1211 }
1212
1213
1214
1215 /***********************************************************************
1216  *            SetupCloseInfFile   (SETUPAPI.@)
1217  */
1218 void WINAPI SetupCloseInfFile( HINF hinf )
1219 {
1220     struct inf_file *file = hinf;
1221     unsigned int i;
1222
1223     if (!file) return;
1224
1225     for (i = 0; i < file->nb_sections; i++) HeapFree( GetProcessHeap(), 0, file->sections[i] );
1226     HeapFree( GetProcessHeap(), 0, file->filename );
1227     HeapFree( GetProcessHeap(), 0, file->sections );
1228     HeapFree( GetProcessHeap(), 0, file->fields );
1229     HeapFree( GetProcessHeap(), 0, file->strings );
1230     HeapFree( GetProcessHeap(), 0, file );
1231 }
1232
1233
1234 /***********************************************************************
1235  *            SetupGetLineCountA   (SETUPAPI.@)
1236  */
1237 LONG WINAPI SetupGetLineCountA( HINF hinf, PCSTR name )
1238 {
1239     UNICODE_STRING sectionW;
1240     LONG ret = -1;
1241
1242     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, name ))
1243         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1244     else
1245     {
1246         ret = SetupGetLineCountW( hinf, sectionW.Buffer );
1247         RtlFreeUnicodeString( &sectionW );
1248     }
1249     return ret;
1250 }
1251
1252
1253 /***********************************************************************
1254  *            SetupGetLineCountW   (SETUPAPI.@)
1255  */
1256 LONG WINAPI SetupGetLineCountW( HINF hinf, PCWSTR section )
1257 {
1258     struct inf_file *file = hinf;
1259     int section_index;
1260     LONG ret = -1;
1261
1262     for (file = hinf; file; file = file->next)
1263     {
1264         if ((section_index = find_section( file, section )) == -1) continue;
1265         if (ret == -1) ret = 0;
1266         ret += file->sections[section_index]->nb_lines;
1267     }
1268     TRACE( "(%p,%s) returning %ld\n", hinf, debugstr_w(section), ret );
1269     SetLastError( (ret == -1) ? ERROR_SECTION_NOT_FOUND : 0 );
1270     return ret;
1271 }
1272
1273
1274 /***********************************************************************
1275  *            SetupGetLineByIndexA   (SETUPAPI.@)
1276  */
1277 BOOL WINAPI SetupGetLineByIndexA( HINF hinf, PCSTR section, DWORD index, INFCONTEXT *context )
1278 {
1279     UNICODE_STRING sectionW;
1280     BOOL ret = FALSE;
1281
1282     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1283         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1284     else
1285     {
1286         ret = SetupGetLineByIndexW( hinf, sectionW.Buffer, index, context );
1287         RtlFreeUnicodeString( &sectionW );
1288     }
1289     return ret;
1290 }
1291
1292
1293 /***********************************************************************
1294  *            SetupGetLineByIndexW   (SETUPAPI.@)
1295  */
1296 BOOL WINAPI SetupGetLineByIndexW( HINF hinf, PCWSTR section, DWORD index, INFCONTEXT *context )
1297 {
1298     struct inf_file *file = hinf;
1299     int section_index;
1300
1301     SetLastError( ERROR_SECTION_NOT_FOUND );
1302     for (file = hinf; file; file = file->next)
1303     {
1304         if ((section_index = find_section( file, section )) == -1) continue;
1305         SetLastError( ERROR_LINE_NOT_FOUND );
1306         if (index < file->sections[section_index]->nb_lines)
1307         {
1308             context->Inf        = hinf;
1309             context->CurrentInf = file;
1310             context->Section    = section_index;
1311             context->Line       = index;
1312             SetLastError( 0 );
1313             TRACE( "(%p,%s): returning %d/%ld\n",
1314                    hinf, debugstr_w(section), section_index, index );
1315             return TRUE;
1316         }
1317         index -= file->sections[section_index]->nb_lines;
1318     }
1319     TRACE( "(%p,%s) not found\n", hinf, debugstr_w(section) );
1320     return FALSE;
1321 }
1322
1323
1324 /***********************************************************************
1325  *            SetupFindFirstLineA   (SETUPAPI.@)
1326  */
1327 BOOL WINAPI SetupFindFirstLineA( HINF hinf, PCSTR section, PCSTR key, INFCONTEXT *context )
1328 {
1329     UNICODE_STRING sectionW, keyW;
1330     BOOL ret = FALSE;
1331
1332     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1333     {
1334         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1335         return FALSE;
1336     }
1337
1338     if (!key) ret = SetupFindFirstLineW( hinf, sectionW.Buffer, NULL, context );
1339     else
1340     {
1341         if (RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
1342         {
1343             ret = SetupFindFirstLineW( hinf, sectionW.Buffer, keyW.Buffer, context );
1344             RtlFreeUnicodeString( &keyW );
1345         }
1346         else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1347     }
1348     RtlFreeUnicodeString( &sectionW );
1349     return ret;
1350 }
1351
1352
1353 /***********************************************************************
1354  *            SetupFindFirstLineW   (SETUPAPI.@)
1355  */
1356 BOOL WINAPI SetupFindFirstLineW( HINF hinf, PCWSTR section, PCWSTR key, INFCONTEXT *context )
1357 {
1358     struct inf_file *file;
1359     int section_index;
1360
1361     SetLastError( ERROR_SECTION_NOT_FOUND );
1362     for (file = hinf; file; file = file->next)
1363     {
1364         if ((section_index = find_section( file, section )) == -1) continue;
1365         if (key)
1366         {
1367             INFCONTEXT ctx;
1368             ctx.Inf        = hinf;
1369             ctx.CurrentInf = file;
1370             ctx.Section    = section_index;
1371             ctx.Line       = -1;
1372             return SetupFindNextMatchLineW( &ctx, key, context );
1373         }
1374         SetLastError( ERROR_LINE_NOT_FOUND );  /* found at least one section */
1375         if (file->sections[section_index]->nb_lines)
1376         {
1377             context->Inf        = hinf;
1378             context->CurrentInf = file;
1379             context->Section    = section_index;
1380             context->Line       = 0;
1381             SetLastError( 0 );
1382             TRACE( "(%p,%s,%s): returning %d/0\n",
1383                    hinf, debugstr_w(section), debugstr_w(key), section_index );
1384             return TRUE;
1385         }
1386     }
1387     TRACE( "(%p,%s,%s): not found\n", hinf, debugstr_w(section), debugstr_w(key) );
1388     return FALSE;
1389 }
1390
1391
1392 /***********************************************************************
1393  *            SetupFindNextLine   (SETUPAPI.@)
1394  */
1395 BOOL WINAPI SetupFindNextLine( PINFCONTEXT context_in, PINFCONTEXT context_out )
1396 {
1397     struct inf_file *file = context_in->CurrentInf;
1398     struct section *section;
1399
1400     if (context_in->Section >= file->nb_sections) goto error;
1401
1402     section = file->sections[context_in->Section];
1403     if (context_in->Line+1 < section->nb_lines)
1404     {
1405         if (context_out != context_in) *context_out = *context_in;
1406         context_out->Line++;
1407         SetLastError( 0 );
1408         return TRUE;
1409     }
1410
1411     /* now search the appended files */
1412
1413     for (file = file->next; file; file = file->next)
1414     {
1415         int section_index = find_section( file, section->name );
1416         if (section_index == -1) continue;
1417         if (file->sections[section_index]->nb_lines)
1418         {
1419             context_out->Inf        = context_in->Inf;
1420             context_out->CurrentInf = file;
1421             context_out->Section    = section_index;
1422             context_out->Line       = 0;
1423             SetLastError( 0 );
1424             return TRUE;
1425         }
1426     }
1427  error:
1428     SetLastError( ERROR_LINE_NOT_FOUND );
1429     return FALSE;
1430 }
1431
1432
1433 /***********************************************************************
1434  *            SetupFindNextMatchLineA   (SETUPAPI.@)
1435  */
1436 BOOL WINAPI SetupFindNextMatchLineA( PINFCONTEXT context_in, PCSTR key,
1437                                      PINFCONTEXT context_out )
1438 {
1439     UNICODE_STRING keyW;
1440     BOOL ret = FALSE;
1441
1442     if (!key) return SetupFindNextLine( context_in, context_out );
1443
1444     if (!RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
1445         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1446     else
1447     {
1448         ret = SetupFindNextMatchLineW( context_in, keyW.Buffer, context_out );
1449         RtlFreeUnicodeString( &keyW );
1450     }
1451     return ret;
1452 }
1453
1454
1455 /***********************************************************************
1456  *            SetupFindNextMatchLineW   (SETUPAPI.@)
1457  */
1458 BOOL WINAPI SetupFindNextMatchLineW( PINFCONTEXT context_in, PCWSTR key,
1459                                      PINFCONTEXT context_out )
1460 {
1461     struct inf_file *file = context_in->CurrentInf;
1462     struct section *section;
1463     struct line *line;
1464     unsigned int i;
1465
1466     if (!key) return SetupFindNextLine( context_in, context_out );
1467
1468     if (context_in->Section >= file->nb_sections) goto error;
1469
1470     section = file->sections[context_in->Section];
1471
1472     for (i = context_in->Line+1, line = &section->lines[i]; i < section->nb_lines; i++, line++)
1473     {
1474         if (line->key_field == -1) continue;
1475         if (!strcmpiW( key, file->fields[line->key_field].text ))
1476         {
1477             if (context_out != context_in) *context_out = *context_in;
1478             context_out->Line = i;
1479             SetLastError( 0 );
1480             TRACE( "(%p,%s,%s): returning %d\n",
1481                    file, debugstr_w(section->name), debugstr_w(key), i );
1482             return TRUE;
1483         }
1484     }
1485
1486     /* now search the appended files */
1487
1488     for (file = file->next; file; file = file->next)
1489     {
1490         int section_index = find_section( file, section->name );
1491         if (section_index == -1) continue;
1492         section = file->sections[section_index];
1493         for (i = 0, line = section->lines; i < section->nb_lines; i++, line++)
1494         {
1495             if (line->key_field == -1) continue;
1496             if (!strcmpiW( key, file->fields[line->key_field].text ))
1497             {
1498                 context_out->Inf        = context_in->Inf;
1499                 context_out->CurrentInf = file;
1500                 context_out->Section    = section_index;
1501                 context_out->Line       = i;
1502                 SetLastError( 0 );
1503                 TRACE( "(%p,%s,%s): returning %d/%d\n",
1504                        file, debugstr_w(section->name), debugstr_w(key), section_index, i );
1505                 return TRUE;
1506             }
1507         }
1508     }
1509     TRACE( "(%p,%s,%s): not found\n",
1510            context_in->CurrentInf, debugstr_w(section->name), debugstr_w(key) );
1511  error:
1512     SetLastError( ERROR_LINE_NOT_FOUND );
1513     return FALSE;
1514 }
1515
1516
1517 /***********************************************************************
1518  *              SetupGetLineTextW    (SETUPAPI.@)
1519  */
1520 BOOL WINAPI SetupGetLineTextW( PINFCONTEXT context, HINF hinf, PCWSTR section_name,
1521                                PCWSTR key_name, PWSTR buffer, DWORD size, PDWORD required )
1522 {
1523     struct inf_file *file;
1524     struct line *line;
1525     struct field *field;
1526     int i;
1527     DWORD total = 0;
1528
1529     if (!context)
1530     {
1531         INFCONTEXT new_context;
1532         if (!SetupFindFirstLineW( hinf, section_name, key_name, &new_context )) return FALSE;
1533         file = new_context.CurrentInf;
1534         line = get_line( file, new_context.Section, new_context.Line );
1535     }
1536     else
1537     {
1538         file = context->CurrentInf;
1539         if (!(line = get_line( file, context->Section, context->Line )))
1540         {
1541             SetLastError( ERROR_LINE_NOT_FOUND );
1542             return FALSE;
1543         }
1544     }
1545
1546     for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1547         total += PARSER_string_substW( file, field->text, NULL, 0 ) + 1;
1548
1549     if (required) *required = total;
1550     if (buffer)
1551     {
1552         if (total > size)
1553         {
1554             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1555             return FALSE;
1556         }
1557         for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1558         {
1559             unsigned int len = PARSER_string_substW( file, field->text, buffer, size );
1560             if (i+1 < line->nb_fields) buffer[len] = ',';
1561             buffer += len + 1;
1562         }
1563     }
1564     return TRUE;
1565 }
1566
1567
1568 /***********************************************************************
1569  *              SetupGetLineTextA    (SETUPAPI.@)
1570  */
1571 BOOL WINAPI SetupGetLineTextA( PINFCONTEXT context, HINF hinf, PCSTR section_name,
1572                                PCSTR key_name, PSTR buffer, DWORD size, PDWORD required )
1573 {
1574     struct inf_file *file;
1575     struct line *line;
1576     struct field *field;
1577     int i;
1578     DWORD total = 0;
1579
1580     if (!context)
1581     {
1582         INFCONTEXT new_context;
1583         if (!SetupFindFirstLineA( hinf, section_name, key_name, &new_context )) return FALSE;
1584         file = new_context.CurrentInf;
1585         line = get_line( file, new_context.Section, new_context.Line );
1586     }
1587     else
1588     {
1589         file = context->CurrentInf;
1590         if (!(line = get_line( file, context->Section, context->Line )))
1591         {
1592             SetLastError( ERROR_LINE_NOT_FOUND );
1593             return FALSE;
1594         }
1595     }
1596
1597     for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1598         total += PARSER_string_substA( file, field->text, NULL, 0 ) + 1;
1599
1600     if (required) *required = total;
1601     if (buffer)
1602     {
1603         if (total > size)
1604         {
1605             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1606             return FALSE;
1607         }
1608         for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1609         {
1610             unsigned int len = PARSER_string_substA( file, field->text, buffer, size );
1611             if (i+1 < line->nb_fields) buffer[len] = ',';
1612             buffer += len + 1;
1613         }
1614     }
1615     return TRUE;
1616 }
1617
1618
1619 /***********************************************************************
1620  *              SetupGetFieldCount    (SETUPAPI.@)
1621  */
1622 DWORD WINAPI SetupGetFieldCount( PINFCONTEXT context )
1623 {
1624     struct inf_file *file = context->CurrentInf;
1625     struct line *line = get_line( file, context->Section, context->Line );
1626
1627     if (!line) return 0;
1628     return line->nb_fields;
1629 }
1630
1631
1632 /***********************************************************************
1633  *              SetupGetStringFieldA    (SETUPAPI.@)
1634  */
1635 BOOL WINAPI SetupGetStringFieldA( PINFCONTEXT context, DWORD index, PSTR buffer,
1636                                   DWORD size, PDWORD required )
1637 {
1638     struct inf_file *file = context->CurrentInf;
1639     struct field *field = get_field( file, context->Section, context->Line, index );
1640     unsigned int len;
1641
1642     SetLastError(0);
1643     if (!field) return FALSE;
1644     len = PARSER_string_substA( file, field->text, NULL, 0 );
1645     if (required) *required = len + 1;
1646     if (buffer)
1647     {
1648         if (size <= len)
1649         {
1650             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1651             return FALSE;
1652         }
1653         PARSER_string_substA( file, field->text, buffer, size );
1654
1655         TRACE( "context %p/%p/%d/%d index %ld returning %s\n",
1656                context->Inf, context->CurrentInf, context->Section, context->Line,
1657                index, debugstr_a(buffer) );
1658     }
1659     return TRUE;
1660 }
1661
1662
1663 /***********************************************************************
1664  *              SetupGetStringFieldW    (SETUPAPI.@)
1665  */
1666 BOOL WINAPI SetupGetStringFieldW( PINFCONTEXT context, DWORD index, PWSTR buffer,
1667                                   DWORD size, PDWORD required )
1668 {
1669     struct inf_file *file = context->CurrentInf;
1670     struct field *field = get_field( file, context->Section, context->Line, index );
1671     unsigned int len;
1672
1673     SetLastError(0);
1674     if (!field) return FALSE;
1675     len = PARSER_string_substW( file, field->text, NULL, 0 );
1676     if (required) *required = len + 1;
1677     if (buffer)
1678     {
1679         if (size <= len)
1680         {
1681             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1682             return FALSE;
1683         }
1684         PARSER_string_substW( file, field->text, buffer, size );
1685
1686         TRACE( "context %p/%p/%d/%d index %ld returning %s\n",
1687                context->Inf, context->CurrentInf, context->Section, context->Line,
1688                index, debugstr_w(buffer) );
1689     }
1690     return TRUE;
1691 }
1692
1693
1694 /***********************************************************************
1695  *              SetupGetIntField    (SETUPAPI.@)
1696  */
1697 BOOL WINAPI SetupGetIntField( PINFCONTEXT context, DWORD index, PINT result )
1698 {
1699     char localbuff[20];
1700     char *end, *buffer = localbuff;
1701     DWORD required;
1702     INT res;
1703     BOOL ret = FALSE;
1704
1705     if (!SetupGetStringFieldA( context, index, localbuff, sizeof(localbuff), &required ))
1706     {
1707         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
1708         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required ))) return FALSE;
1709         if (!SetupGetStringFieldA( context, index, buffer, required, NULL )) goto done;
1710     }
1711     res = strtol( buffer, &end, 0 );
1712     if (end != buffer && !*end)
1713     {
1714         *result = res;
1715         ret = TRUE;
1716     }
1717     else SetLastError( ERROR_INVALID_DATA );
1718
1719  done:
1720     if (buffer != localbuff) HeapFree( GetProcessHeap(), 0, buffer );
1721     return ret;
1722 }
1723
1724
1725 /***********************************************************************
1726  *              SetupGetBinaryField    (SETUPAPI.@)
1727  */
1728 BOOL WINAPI SetupGetBinaryField( PINFCONTEXT context, DWORD index, BYTE *buffer,
1729                                  DWORD size, LPDWORD required )
1730 {
1731     struct inf_file *file = context->CurrentInf;
1732     struct line *line = get_line( file, context->Section, context->Line );
1733     struct field *field;
1734     int i;
1735
1736     if (!line)
1737     {
1738         SetLastError( ERROR_LINE_NOT_FOUND );
1739         return FALSE;
1740     }
1741     if (!index || index > line->nb_fields)
1742     {
1743         SetLastError( ERROR_INVALID_PARAMETER );
1744         return FALSE;
1745     }
1746     index--;  /* fields start at 0 */
1747     if (required) *required = line->nb_fields - index;
1748     if (!buffer) return TRUE;
1749     if (size < line->nb_fields - index)
1750     {
1751         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1752         return FALSE;
1753     }
1754     field = &file->fields[line->first_field + index];
1755     for (i = index; i < line->nb_fields; i++, field++)
1756     {
1757         const WCHAR *p;
1758         DWORD value = 0;
1759         for (p = field->text; *p && isxdigitW(*p); p++)
1760         {
1761             if ((value <<= 4) > 255)
1762             {
1763                 SetLastError( ERROR_INVALID_DATA );
1764                 return FALSE;
1765             }
1766             if (*p <= '9') value |= (*p - '0');
1767             else value |= (tolowerW(*p) - 'a' + 10);
1768         }
1769         buffer[i - index] = value;
1770     }
1771     if (TRACE_ON(setupapi))
1772     {
1773         TRACE( "%p/%p/%d/%d index %ld returning",
1774                context->Inf, context->CurrentInf, context->Section, context->Line, index );
1775         for (i = index; i < line->nb_fields; i++) TRACE( " %02x", buffer[i - index] );
1776         TRACE( "\n" );
1777     }
1778     return TRUE;
1779 }
1780
1781
1782 /***********************************************************************
1783  *              SetupGetMultiSzFieldA    (SETUPAPI.@)
1784  */
1785 BOOL WINAPI SetupGetMultiSzFieldA( PINFCONTEXT context, DWORD index, PSTR buffer,
1786                                    DWORD size, LPDWORD required )
1787 {
1788     struct inf_file *file = context->CurrentInf;
1789     struct line *line = get_line( file, context->Section, context->Line );
1790     struct field *field;
1791     unsigned int len;
1792     int i;
1793     DWORD total = 1;
1794
1795     if (!line)
1796     {
1797         SetLastError( ERROR_LINE_NOT_FOUND );
1798         return FALSE;
1799     }
1800     if (!index || index > line->nb_fields)
1801     {
1802         SetLastError( ERROR_INVALID_PARAMETER );
1803         return FALSE;
1804     }
1805     index--;  /* fields start at 0 */
1806     field = &file->fields[line->first_field + index];
1807     for (i = index; i < line->nb_fields; i++, field++)
1808     {
1809         if (!(len = PARSER_string_substA( file, field->text, NULL, 0 ))) break;
1810         total += len + 1;
1811     }
1812
1813     if (required) *required = total;
1814     if (!buffer) return TRUE;
1815     if (total > size)
1816     {
1817         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1818         return FALSE;
1819     }
1820     field = &file->fields[line->first_field + index];
1821     for (i = index; i < line->nb_fields; i++, field++)
1822     {
1823         if (!(len = PARSER_string_substA( file, field->text, buffer, size ))) break;
1824         buffer += len + 1;
1825     }
1826     *buffer = 0;  /* add final null */
1827     return TRUE;
1828 }
1829
1830
1831 /***********************************************************************
1832  *              SetupGetMultiSzFieldW    (SETUPAPI.@)
1833  */
1834 BOOL WINAPI SetupGetMultiSzFieldW( PINFCONTEXT context, DWORD index, PWSTR buffer,
1835                                    DWORD size, LPDWORD required )
1836 {
1837     struct inf_file *file = context->CurrentInf;
1838     struct line *line = get_line( file, context->Section, context->Line );
1839     struct field *field;
1840     unsigned int len;
1841     int i;
1842     DWORD total = 1;
1843
1844     if (!line)
1845     {
1846         SetLastError( ERROR_LINE_NOT_FOUND );
1847         return FALSE;
1848     }
1849     if (!index || index > line->nb_fields)
1850     {
1851         SetLastError( ERROR_INVALID_PARAMETER );
1852         return FALSE;
1853     }
1854     index--;  /* fields start at 0 */
1855     field = &file->fields[line->first_field + index];
1856     for (i = index; i < line->nb_fields; i++, field++)
1857     {
1858         if (!(len = PARSER_string_substW( file, field->text, NULL, 0 ))) break;
1859         total += len + 1;
1860     }
1861
1862     if (required) *required = total;
1863     if (!buffer) return TRUE;
1864     if (total > size)
1865     {
1866         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1867         return FALSE;
1868     }
1869     field = &file->fields[line->first_field + index];
1870     for (i = index; i < line->nb_fields; i++, field++)
1871     {
1872         if (!(len = PARSER_string_substW( file, field->text, buffer, size ))) break;
1873         buffer += len + 1;
1874     }
1875     *buffer = 0;  /* add final null */
1876     return TRUE;
1877 }