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