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 unsigned 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 = §ion->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 §ion->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 static unsigned int PARSER_string_substW( const struct inf_file *file, const WCHAR *text,
369 WCHAR *buffer, 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 static unsigned int PARSER_string_substA( const struct inf_file *file, const WCHAR *text,
422 char *buffer, 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;
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 = 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 static void free_inf_file( struct inf_file *file )
860 {
861 unsigned int i;
862
863 for (i = 0; i < file->nb_sections; i++) HeapFree( GetProcessHeap(), 0, file->sections[i] );
864 HeapFree( GetProcessHeap(), 0, file->filename );
865 HeapFree( GetProcessHeap(), 0, file->sections );
866 HeapFree( GetProcessHeap(), 0, file->fields );
867 HeapFree( GetProcessHeap(), 0, file->strings );
868 HeapFree( GetProcessHeap(), 0, file );
869 }
870
871
872 /* parse a complete buffer */
873 static DWORD parse_buffer( struct inf_file *file, const WCHAR *buffer, const WCHAR *end,
874 UINT *error_line )
875 {
876 static const WCHAR Strings[] = {'S','t','r','i','n','g','s',0};
877
878 struct parser parser;
879 const WCHAR *pos = buffer;
880
881 parser.start = buffer;
882 parser.end = end;
883 parser.file = file;
884 parser.line = NULL;
885 parser.state = LINE_START;
886 parser.stack_pos = 0;
887 parser.cur_section = -1;
888 parser.line_pos = 1;
889 parser.error = 0;
890 parser.token_len = 0;
891
892 /* parser main loop */
893 while (pos) pos = (parser_funcs[parser.state])( &parser, pos );
894
895 /* trim excess buffer space */
896 if (file->alloc_sections > file->nb_sections)
897 {
898 file->sections = HeapReAlloc( GetProcessHeap(), 0, file->sections,
899 file->nb_sections * sizeof(file->sections[0]) );
900 file->alloc_sections = file->nb_sections;
901 }
902 if (file->alloc_fields > file->nb_fields)
903 {
904 file->fields = HeapReAlloc( GetProcessHeap(), 0, file->fields,
905 file->nb_fields * sizeof(file->fields[0]) );
906 file->alloc_fields = file->nb_fields;
907 }
908 file->strings = HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, file->strings,
909 (file->string_pos - file->strings) * sizeof(WCHAR) );
910
911 if (parser.error)
912 {
913 if (error_line) *error_line = parser.line_pos;
914 return parser.error;
915 }
916
917 /* find the [strings] section */
918 file->strings_section = find_section( file, Strings );
919 return 0;
920 }
921
922
923 /* append a child INF file to its parent list, in a thread-safe manner */
924 static void append_inf_file( struct inf_file *parent, struct inf_file *child )
925 {
926 struct inf_file **ppnext = &parent->next;
927 child->next = NULL;
928
929 for (;;)
930 {
931 struct inf_file *next = InterlockedCompareExchangePointer( (void **)ppnext, child, NULL );
932 if (!next) return;
933 ppnext = &next->next;
934 }
935 }
936
937
938 /***********************************************************************
939 * parse_file
940 *
941 * parse an INF file.
942 */
943 static struct inf_file *parse_file( HANDLE handle, const WCHAR *class, DWORD style, UINT *error_line )
944 {
945 void *buffer;
946 DWORD err = 0;
947 struct inf_file *file;
948
949 DWORD size = GetFileSize( handle, NULL );
950 HANDLE mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, size, NULL );
951 if (!mapping) return NULL;
952 buffer = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, size );
953 NtClose( mapping );
954 if (!buffer) return NULL;
955
956 if (class) FIXME( "class %s not supported yet\n", debugstr_w(class) );
957
958 if (!(file = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*file) )))
959 {
960 err = ERROR_NOT_ENOUGH_MEMORY;
961 goto done;
962 }
963
964 /* we won't need more strings space than the size of the file,
965 * so we can preallocate it here
966 */
967 if (!(file->strings = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )))
968 {
969 err = ERROR_NOT_ENOUGH_MEMORY;
970 goto done;
971 }
972 file->string_pos = file->strings;
973 file->strings_section = -1;
974
975 if (!RtlIsTextUnicode( buffer, size, NULL ))
976 {
977 static const BYTE utf8_bom[3] = { 0xef, 0xbb, 0xbf };
978 WCHAR *new_buff;
979 UINT codepage = CP_ACP;
980 UINT offset = 0;
981
982 if (size > sizeof(utf8_bom) && !memcmp( buffer, utf8_bom, sizeof(utf8_bom) ))
983 {
984 codepage = CP_UTF8;
985 offset = sizeof(utf8_bom);
986 }
987
988 if ((new_buff = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) )))
989 {
990 DWORD len = MultiByteToWideChar( codepage, 0, (char *)buffer + offset,
991 size - offset, new_buff, size );
992 err = parse_buffer( file, new_buff, new_buff + len, error_line );
993 HeapFree( GetProcessHeap(), 0, new_buff );
994 }
995 }
996 else
997 {
998 WCHAR *new_buff = buffer;
999 /* UCS-16 files should start with the Unicode BOM; we should skip it */
1000 if (*new_buff == 0xfeff)
1001 new_buff++;
1002 err = parse_buffer( file, new_buff, (WCHAR *)((char *)buffer + size), error_line );
1003 }
1004
1005 if (!err) /* now check signature */
1006 {
1007 int version_index = find_section( file, Version );
1008 if (version_index != -1)
1009 {
1010 struct line *line = find_line( file, version_index, Signature );
1011 if (line && line->nb_fields > 0)
1012 {
1013 struct field *field = file->fields + line->first_field;
1014 if (!strcmpiW( field->text, Chicago )) goto done;
1015 if (!strcmpiW( field->text, WindowsNT )) goto done;
1016 if (!strcmpiW( field->text, Windows95 )) goto done;
1017 }
1018 }
1019 if (error_line) *error_line = 0;
1020 if (style & INF_STYLE_WIN4) err = ERROR_WRONG_INF_STYLE;
1021 }
1022
1023 done:
1024 UnmapViewOfFile( buffer );
1025 if (err)
1026 {
1027 if (file) free_inf_file( file );
1028 SetLastError( err );
1029 file = NULL;
1030 }
1031 return file;
1032 }
1033
1034
1035 /***********************************************************************
1036 * PARSER_get_inf_filename
1037 *
1038 * Retrieve the filename of an inf file.
1039 */
1040 const WCHAR *PARSER_get_inf_filename( HINF hinf )
1041 {
1042 struct inf_file *file = hinf;
1043 return file->filename;
1044 }
1045
1046
1047 /***********************************************************************
1048 * PARSER_get_src_root
1049 *
1050 * Retrieve the source directory of an inf file.
1051 */
1052 WCHAR *PARSER_get_src_root( HINF hinf )
1053 {
1054 unsigned int len;
1055 const WCHAR *dir = get_inf_dir( hinf, &len );
1056 WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) );
1057 if (ret)
1058 {
1059 memcpy( ret, dir, len * sizeof(WCHAR) );
1060 ret[len] = 0;
1061 }
1062 return ret;
1063 }
1064
1065
1066 /***********************************************************************
1067 * PARSER_get_dest_dir
1068 *
1069 * retrieve a destination dir of the form "dirid,relative_path" in the given entry.
1070 * returned buffer must be freed by caller.
1071 */
1072 WCHAR *PARSER_get_dest_dir( INFCONTEXT *context )
1073 {
1074 const WCHAR *dir;
1075 WCHAR *ptr, *ret;
1076 INT dirid;
1077 unsigned int len1;
1078 DWORD len2;
1079
1080 if (!SetupGetIntField( context, 1, &dirid )) return NULL;
1081 if (!(dir = get_dirid_subst( context->Inf, dirid, &len1 ))) return NULL;
1082 if (!SetupGetStringFieldW( context, 2, NULL, 0, &len2 )) len2 = 0;
1083 if (!(ret = HeapAlloc( GetProcessHeap(), 0, (len1+len2+1) * sizeof(WCHAR) ))) return NULL;
1084 memcpy( ret, dir, len1 * sizeof(WCHAR) );
1085 ptr = ret + len1;
1086 if (len2 && ptr > ret && ptr[-1] != '\\') *ptr++ = '\\';
1087 if (!SetupGetStringFieldW( context, 2, ptr, len2, NULL )) *ptr = 0;
1088 return ret;
1089 }
1090
1091
1092 /***********************************************************************
1093 * SetupOpenInfFileA (SETUPAPI.@)
1094 */
1095 HINF WINAPI SetupOpenInfFileA( PCSTR name, PCSTR class, DWORD style, UINT *error )
1096 {
1097 UNICODE_STRING nameW, classW;
1098 HINF ret = INVALID_HANDLE_VALUE;
1099
1100 classW.Buffer = NULL;
1101 if (class && !RtlCreateUnicodeStringFromAsciiz( &classW, class ))
1102 {
1103 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1104 return ret;
1105 }
1106 if (RtlCreateUnicodeStringFromAsciiz( &nameW, name ))
1107 {
1108 ret = SetupOpenInfFileW( nameW.Buffer, classW.Buffer, style, error );
1109 RtlFreeUnicodeString( &nameW );
1110 }
1111 RtlFreeUnicodeString( &classW );
1112 return ret;
1113 }
1114
1115
1116 /***********************************************************************
1117 * SetupOpenInfFileW (SETUPAPI.@)
1118 */
1119 HINF WINAPI SetupOpenInfFileW( PCWSTR name, PCWSTR class, DWORD style, UINT *error )
1120 {
1121 struct inf_file *file = NULL;
1122 HANDLE handle;
1123 WCHAR *path, *p;
1124 UINT len;
1125
1126 if (strchrW( name, '\\' ) || strchrW( name, '/' ))
1127 {
1128 if (!(len = GetFullPathNameW( name, 0, NULL, NULL ))) return INVALID_HANDLE_VALUE;
1129 if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1130 {
1131 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1132 return INVALID_HANDLE_VALUE;
1133 }
1134 GetFullPathNameW( name, len, path, NULL );
1135 handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1136 }
1137 else /* try Windows directory */
1138 {
1139 static const WCHAR Inf[] = {'\\','i','n','f','\\',0};
1140 static const WCHAR System32[] = {'\\','s','y','s','t','e','m','3','2','\\',0};
1141
1142 len = GetWindowsDirectoryW( NULL, 0 ) + strlenW(name) + 12;
1143 if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
1144 {
1145 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1146 return INVALID_HANDLE_VALUE;
1147 }
1148 GetWindowsDirectoryW( path, len );
1149 p = path + strlenW(path);
1150 strcpyW( p, Inf );
1151 strcatW( p, name );
1152 handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1153 if (handle == INVALID_HANDLE_VALUE)
1154 {
1155 strcpyW( p, System32 );
1156 strcatW( p, name );
1157 handle = CreateFileW( path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1158 }
1159 }
1160
1161 if (handle != INVALID_HANDLE_VALUE)
1162 {
1163 file = parse_file( handle, class, style, error );
1164 CloseHandle( handle );
1165 }
1166 if (!file)
1167 {
1168 HeapFree( GetProcessHeap(), 0, path );
1169 return INVALID_HANDLE_VALUE;
1170 }
1171 TRACE( "%s -> %p\n", debugstr_w(path), file );
1172 file->filename = path;
1173 SetLastError( 0 );
1174 return file;
1175 }
1176
1177
1178 /***********************************************************************
1179 * SetupOpenAppendInfFileA (SETUPAPI.@)
1180 */
1181 BOOL WINAPI SetupOpenAppendInfFileA( PCSTR name, HINF parent_hinf, UINT *error )
1182 {
1183 HINF child_hinf;
1184
1185 if (!name) return SetupOpenAppendInfFileW( NULL, parent_hinf, error );
1186 child_hinf = SetupOpenInfFileA( name, NULL, INF_STYLE_WIN4, error );
1187 if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
1188 append_inf_file( parent_hinf, child_hinf );
1189 TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_a(name), child_hinf );
1190 return TRUE;
1191 }
1192
1193
1194 /***********************************************************************
1195 * SetupOpenAppendInfFileW (SETUPAPI.@)
1196 */
1197 BOOL WINAPI SetupOpenAppendInfFileW( PCWSTR name, HINF parent_hinf, UINT *error )
1198 {
1199 HINF child_hinf;
1200
1201 if (!name)
1202 {
1203 INFCONTEXT context;
1204 WCHAR filename[MAX_PATH];
1205 int idx = 1;
1206
1207 if (!SetupFindFirstLineW( parent_hinf, Version, LayoutFile, &context )) return FALSE;
1208 while (SetupGetStringFieldW( &context, idx++, filename,
1209 sizeof(filename)/sizeof(WCHAR), NULL ))
1210 {
1211 child_hinf = SetupOpenInfFileW( filename, NULL, INF_STYLE_WIN4, error );
1212 if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
1213 append_inf_file( parent_hinf, child_hinf );
1214 TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(filename), child_hinf );
1215 }
1216 return TRUE;
1217 }
1218 child_hinf = SetupOpenInfFileW( name, NULL, INF_STYLE_WIN4, error );
1219 if (child_hinf == INVALID_HANDLE_VALUE) return FALSE;
1220 append_inf_file( parent_hinf, child_hinf );
1221 TRACE( "%p: appended %s (%p)\n", parent_hinf, debugstr_w(name), child_hinf );
1222 return TRUE;
1223 }
1224
1225
1226 /***********************************************************************
1227 * SetupOpenMasterInf (SETUPAPI.@)
1228 */
1229 HINF WINAPI SetupOpenMasterInf( VOID )
1230 {
1231 static const WCHAR Layout[] = {'\\','i','n','f','\\', 'l', 'a', 'y', 'o', 'u', 't', '.', 'i', 'n', 'f', 0};
1232 WCHAR Buffer[MAX_PATH];
1233
1234 GetWindowsDirectoryW( Buffer, MAX_PATH );
1235 strcatW( Buffer, Layout );
1236 return SetupOpenInfFileW( Buffer, NULL, INF_STYLE_WIN4, NULL);
1237 }
1238
1239
1240
1241 /***********************************************************************
1242 * SetupCloseInfFile (SETUPAPI.@)
1243 */
1244 void WINAPI SetupCloseInfFile( HINF hinf )
1245 {
1246 struct inf_file *file = hinf;
1247
1248 if (!hinf || (hinf == INVALID_HANDLE_VALUE)) return;
1249
1250 free_inf_file( file );
1251 }
1252
1253
1254 /***********************************************************************
1255 * SetupEnumInfSectionsA (SETUPAPI.@)
1256 */
1257 BOOL WINAPI SetupEnumInfSectionsA( HINF hinf, UINT index, PSTR buffer, DWORD size, DWORD *need )
1258 {
1259 struct inf_file *file = hinf;
1260
1261 for (file = hinf; file; file = file->next)
1262 {
1263 if (index < file->nb_sections)
1264 {
1265 DWORD len = WideCharToMultiByte( CP_ACP, 0, file->sections[index]->name, -1,
1266 NULL, 0, NULL, NULL );
1267 if (need) *need = len;
1268 if (!buffer)
1269 {
1270 if (!size) return TRUE;
1271 SetLastError( ERROR_INVALID_USER_BUFFER );
1272 return FALSE;
1273 }
1274 if (len > size)
1275 {
1276 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1277 return FALSE;
1278 }
1279 WideCharToMultiByte( CP_ACP, 0, file->sections[index]->name, -1, buffer, size, NULL, NULL );
1280 return TRUE;
1281 }
1282 index -= file->nb_sections;
1283 }
1284 SetLastError( ERROR_NO_MORE_ITEMS );
1285 return FALSE;
1286 }
1287
1288
1289 /***********************************************************************
1290 * SetupEnumInfSectionsW (SETUPAPI.@)
1291 */
1292 BOOL WINAPI SetupEnumInfSectionsW( HINF hinf, UINT index, PWSTR buffer, DWORD size, DWORD *need )
1293 {
1294 struct inf_file *file = hinf;
1295
1296 for (file = hinf; file; file = file->next)
1297 {
1298 if (index < file->nb_sections)
1299 {
1300 DWORD len = strlenW( file->sections[index]->name ) + 1;
1301 if (need) *need = len;
1302 if (!buffer)
1303 {
1304 if (!size) return TRUE;
1305 SetLastError( ERROR_INVALID_USER_BUFFER );
1306 return FALSE;
1307 }
1308 if (len > size)
1309 {
1310 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1311 return FALSE;
1312 }
1313 memcpy( buffer, file->sections[index]->name, len * sizeof(WCHAR) );
1314 return TRUE;
1315 }
1316 index -= file->nb_sections;
1317 }
1318 SetLastError( ERROR_NO_MORE_ITEMS );
1319 return FALSE;
1320 }
1321
1322
1323 /***********************************************************************
1324 * SetupGetLineCountA (SETUPAPI.@)
1325 */
1326 LONG WINAPI SetupGetLineCountA( HINF hinf, PCSTR name )
1327 {
1328 UNICODE_STRING sectionW;
1329 LONG ret = -1;
1330
1331 if (!RtlCreateUnicodeStringFromAsciiz( §ionW, name ))
1332 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1333 else
1334 {
1335 ret = SetupGetLineCountW( hinf, sectionW.Buffer );
1336 RtlFreeUnicodeString( §ionW );
1337 }
1338 return ret;
1339 }
1340
1341
1342 /***********************************************************************
1343 * SetupGetLineCountW (SETUPAPI.@)
1344 */
1345 LONG WINAPI SetupGetLineCountW( HINF hinf, PCWSTR section )
1346 {
1347 struct inf_file *file = hinf;
1348 int section_index;
1349 LONG ret = -1;
1350
1351 for (file = hinf; file; file = file->next)
1352 {
1353 if ((section_index = find_section( file, section )) == -1) continue;
1354 if (ret == -1) ret = 0;
1355 ret += file->sections[section_index]->nb_lines;
1356 }
1357 TRACE( "(%p,%s) returning %d\n", hinf, debugstr_w(section), ret );
1358 SetLastError( (ret == -1) ? ERROR_SECTION_NOT_FOUND : 0 );
1359 return ret;
1360 }
1361
1362
1363 /***********************************************************************
1364 * SetupGetLineByIndexA (SETUPAPI.@)
1365 */
1366 BOOL WINAPI SetupGetLineByIndexA( HINF hinf, PCSTR section, DWORD index, INFCONTEXT *context )
1367 {
1368 UNICODE_STRING sectionW;
1369 BOOL ret = FALSE;
1370
1371 if (!RtlCreateUnicodeStringFromAsciiz( §ionW, section ))
1372 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1373 else
1374 {
1375 ret = SetupGetLineByIndexW( hinf, sectionW.Buffer, index, context );
1376 RtlFreeUnicodeString( §ionW );
1377 }
1378 return ret;
1379 }
1380
1381
1382 /***********************************************************************
1383 * SetupGetLineByIndexW (SETUPAPI.@)
1384 */
1385 BOOL WINAPI SetupGetLineByIndexW( HINF hinf, PCWSTR section, DWORD index, INFCONTEXT *context )
1386 {
1387 struct inf_file *file = hinf;
1388 int section_index;
1389
1390 for (file = hinf; file; file = file->next)
1391 {
1392 if ((section_index = find_section( file, section )) == -1) continue;
1393 if (index < file->sections[section_index]->nb_lines)
1394 {
1395 context->Inf = hinf;
1396 context->CurrentInf = file;
1397 context->Section = section_index;
1398 context->Line = index;
1399 SetLastError( 0 );
1400 TRACE( "(%p,%s): returning %d/%d\n",
1401 hinf, debugstr_w(section), section_index, index );
1402 return TRUE;
1403 }
1404 index -= file->sections[section_index]->nb_lines;
1405 }
1406 TRACE( "(%p,%s) not found\n", hinf, debugstr_w(section) );
1407 SetLastError( ERROR_LINE_NOT_FOUND );
1408 return FALSE;
1409 }
1410
1411
1412 /***********************************************************************
1413 * SetupFindFirstLineA (SETUPAPI.@)
1414 */
1415 BOOL WINAPI SetupFindFirstLineA( HINF hinf, PCSTR section, PCSTR key, INFCONTEXT *context )
1416 {
1417 UNICODE_STRING sectionW, keyW;
1418 BOOL ret = FALSE;
1419
1420 if (!RtlCreateUnicodeStringFromAsciiz( §ionW, section ))
1421 {
1422 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1423 return FALSE;
1424 }
1425
1426 if (!key) ret = SetupFindFirstLineW( hinf, sectionW.Buffer, NULL, context );
1427 else
1428 {
1429 if (RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
1430 {
1431 ret = SetupFindFirstLineW( hinf, sectionW.Buffer, keyW.Buffer, context );
1432 RtlFreeUnicodeString( &keyW );
1433 }
1434 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1435 }
1436 RtlFreeUnicodeString( §ionW );
1437 return ret;
1438 }
1439
1440
1441 /***********************************************************************
1442 * SetupFindFirstLineW (SETUPAPI.@)
1443 */
1444 BOOL WINAPI SetupFindFirstLineW( HINF hinf, PCWSTR section, PCWSTR key, INFCONTEXT *context )
1445 {
1446 struct inf_file *file;
1447 int section_index;
1448
1449 for (file = hinf; file; file = file->next)
1450 {
1451 if ((section_index = find_section( file, section )) == -1) continue;
1452 if (key)
1453 {
1454 INFCONTEXT ctx;
1455 ctx.Inf = hinf;
1456 ctx.CurrentInf = file;
1457 ctx.Section = section_index;
1458 ctx.Line = -1;
1459 return SetupFindNextMatchLineW( &ctx, key, context );
1460 }
1461 if (file->sections[section_index]->nb_lines)
1462 {
1463 context->Inf = hinf;
1464 context->CurrentInf = file;
1465 context->Section = section_index;
1466 context->Line = 0;
1467 SetLastError( 0 );
1468 TRACE( "(%p,%s,%s): returning %d/0\n",
1469 hinf, debugstr_w(section), debugstr_w(key), section_index );
1470 return TRUE;
1471 }
1472 }
1473 TRACE( "(%p,%s,%s): not found\n", hinf, debugstr_w(section), debugstr_w(key) );
1474 SetLastError( ERROR_LINE_NOT_FOUND );
1475 return FALSE;
1476 }
1477
1478
1479 /***********************************************************************
1480 * SetupFindNextLine (SETUPAPI.@)
1481 */
1482 BOOL WINAPI SetupFindNextLine( PINFCONTEXT context_in, PINFCONTEXT context_out )
1483 {
1484 struct inf_file *file = context_in->CurrentInf;
1485 struct section *section;
1486
1487 if (context_in->Section >= file->nb_sections) goto error;
1488
1489 section = file->sections[context_in->Section];
1490 if (context_in->Line+1 < section->nb_lines)
1491 {
1492 if (context_out != context_in) *context_out = *context_in;
1493 context_out->Line++;
1494 SetLastError( 0 );
1495 return TRUE;
1496 }
1497
1498 /* now search the appended files */
1499
1500 for (file = file->next; file; file = file->next)
1501 {
1502 int section_index = find_section( file, section->name );
1503 if (section_index == -1) continue;
1504 if (file->sections[section_index]->nb_lines)
1505 {
1506 context_out->Inf = context_in->Inf;
1507 context_out->CurrentInf = file;
1508 context_out->Section = section_index;
1509 context_out->Line = 0;
1510 SetLastError( 0 );
1511 return TRUE;
1512 }
1513 }
1514 error:
1515 SetLastError( ERROR_LINE_NOT_FOUND );
1516 return FALSE;
1517 }
1518
1519
1520 /***********************************************************************
1521 * SetupFindNextMatchLineA (SETUPAPI.@)
1522 */
1523 BOOL WINAPI SetupFindNextMatchLineA( PINFCONTEXT context_in, PCSTR key,
1524 PINFCONTEXT context_out )
1525 {
1526 UNICODE_STRING keyW;
1527 BOOL ret = FALSE;
1528
1529 if (!key) return SetupFindNextLine( context_in, context_out );
1530
1531 if (!RtlCreateUnicodeStringFromAsciiz( &keyW, key ))
1532 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1533 else
1534 {
1535 ret = SetupFindNextMatchLineW( context_in, keyW.Buffer, context_out );
1536 RtlFreeUnicodeString( &keyW );
1537 }
1538 return ret;
1539 }
1540
1541
1542 /***********************************************************************
1543 * SetupFindNextMatchLineW (SETUPAPI.@)
1544 */
1545 BOOL WINAPI SetupFindNextMatchLineW( PINFCONTEXT context_in, PCWSTR key,
1546 PINFCONTEXT context_out )
1547 {
1548 struct inf_file *file = context_in->CurrentInf;
1549 struct section *section;
1550 struct line *line;
1551 unsigned int i;
1552
1553 if (!key) return SetupFindNextLine( context_in, context_out );
1554
1555 if (context_in->Section >= file->nb_sections) goto error;
1556
1557 section = file->sections[context_in->Section];
1558
1559 for (i = context_in->Line+1, line = §ion->lines[i]; i < section->nb_lines; i++, line++)
1560 {
1561 if (line->key_field == -1) continue;
1562 if (!strcmpiW( key, file->fields[line->key_field].text ))
1563 {
1564 if (context_out != context_in) *context_out = *context_in;
1565 context_out->Line = i;
1566 SetLastError( 0 );
1567 TRACE( "(%p,%s,%s): returning %d\n",
1568 file, debugstr_w(section->name), debugstr_w(key), i );
1569 return TRUE;
1570 }
1571 }
1572
1573 /* now search the appended files */
1574
1575 for (file = file->next; file; file = file->next)
1576 {
1577 int section_index = find_section( file, section->name );
1578 if (section_index == -1) continue;
1579 section = file->sections[section_index];
1580 for (i = 0, line = section->lines; i < section->nb_lines; i++, line++)
1581 {
1582 if (line->key_field == -1) continue;
1583 if (!strcmpiW( key, file->fields[line->key_field].text ))
1584 {
1585 context_out->Inf = context_in->Inf;
1586 context_out->CurrentInf = file;
1587 context_out->Section = section_index;
1588 context_out->Line = i;
1589 SetLastError( 0 );
1590 TRACE( "(%p,%s,%s): returning %d/%d\n",
1591 file, debugstr_w(section->name), debugstr_w(key), section_index, i );
1592 return TRUE;
1593 }
1594 }
1595 }
1596 TRACE( "(%p,%s,%s): not found\n",
1597 context_in->CurrentInf, debugstr_w(section->name), debugstr_w(key) );
1598 error:
1599 SetLastError( ERROR_LINE_NOT_FOUND );
1600 return FALSE;
1601 }
1602
1603
1604 /***********************************************************************
1605 * SetupGetLineTextW (SETUPAPI.@)
1606 */
1607 BOOL WINAPI SetupGetLineTextW( PINFCONTEXT context, HINF hinf, PCWSTR section_name,
1608 PCWSTR key_name, PWSTR buffer, DWORD size, PDWORD required )
1609 {
1610 struct inf_file *file;
1611 struct line *line;
1612 struct field *field;
1613 int i;
1614 DWORD total = 0;
1615
1616 if (!context)
1617 {
1618 INFCONTEXT new_context;
1619 if (!SetupFindFirstLineW( hinf, section_name, key_name, &new_context )) return FALSE;
1620 file = new_context.CurrentInf;
1621 line = get_line( file, new_context.Section, new_context.Line );
1622 }
1623 else
1624 {
1625 file = context->CurrentInf;
1626 if (!(line = get_line( file, context->Section, context->Line )))
1627 {
1628 SetLastError( ERROR_LINE_NOT_FOUND );
1629 return FALSE;
1630 }
1631 }
1632
1633 for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1634 total += PARSER_string_substW( file, field->text, NULL, 0 ) + 1;
1635
1636 if (required) *required = total;
1637 if (buffer)
1638 {
1639 if (total > size)
1640 {
1641 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1642 return FALSE;
1643 }
1644 for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1645 {
1646 unsigned int len = PARSER_string_substW( file, field->text, buffer, size );
1647 if (i+1 < line->nb_fields) buffer[len] = ',';
1648 buffer += len + 1;
1649 }
1650 }
1651 return TRUE;
1652 }
1653
1654
1655 /***********************************************************************
1656 * SetupGetLineTextA (SETUPAPI.@)
1657 */
1658 BOOL WINAPI SetupGetLineTextA( PINFCONTEXT context, HINF hinf, PCSTR section_name,
1659 PCSTR key_name, PSTR buffer, DWORD size, PDWORD required )
1660 {
1661 struct inf_file *file;
1662 struct line *line;
1663 struct field *field;
1664 int i;
1665 DWORD total = 0;
1666
1667 if (!context)
1668 {
1669 INFCONTEXT new_context;
1670 if (!SetupFindFirstLineA( hinf, section_name, key_name, &new_context )) return FALSE;
1671 file = new_context.CurrentInf;
1672 line = get_line( file, new_context.Section, new_context.Line );
1673 }
1674 else
1675 {
1676 file = context->CurrentInf;
1677 if (!(line = get_line( file, context->Section, context->Line )))
1678 {
1679 SetLastError( ERROR_LINE_NOT_FOUND );
1680 return FALSE;
1681 }
1682 }
1683
1684 for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1685 total += PARSER_string_substA( file, field->text, NULL, 0 ) + 1;
1686
1687 if (required) *required = total;
1688 if (buffer)
1689 {
1690 if (total > size)
1691 {
1692 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1693 return FALSE;
1694 }
1695 for (i = 0, field = &file->fields[line->first_field]; i < line->nb_fields; i++, field++)
1696 {
1697 unsigned int len = PARSER_string_substA( file, field->text, buffer, size );
1698 if (i+1 < line->nb_fields) buffer[len] = ',';
1699 buffer += len + 1;
1700 }
1701 }
1702 return TRUE;
1703 }
1704
1705
1706 /***********************************************************************
1707 * SetupGetFieldCount (SETUPAPI.@)
1708 */
1709 DWORD WINAPI SetupGetFieldCount( PINFCONTEXT context )
1710 {
1711 struct inf_file *file = context->CurrentInf;
1712 struct line *line = get_line( file, context->Section, context->Line );
1713
1714 if (!line) return 0;
1715 return line->nb_fields;
1716 }
1717
1718
1719 /***********************************************************************
1720 * SetupGetStringFieldA (SETUPAPI.@)
1721 */
1722 BOOL WINAPI SetupGetStringFieldA( PINFCONTEXT context, DWORD index, PSTR buffer,
1723 DWORD size, PDWORD required )
1724 {
1725 struct inf_file *file = context->CurrentInf;
1726 struct field *field = get_field( file, context->Section, context->Line, index );
1727 unsigned int len;
1728
1729 SetLastError(0);
1730 if (!field) return FALSE;
1731 len = PARSER_string_substA( file, field->text, NULL, 0 );
1732 if (required) *required = len + 1;
1733 if (buffer)
1734 {
1735 if (size <= len)
1736 {
1737 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1738 return FALSE;
1739 }
1740 PARSER_string_substA( file, field->text, buffer, size );
1741
1742 TRACE( "context %p/%p/%d/%d index %d returning %s\n",
1743 context->Inf, context->CurrentInf, context->Section, context->Line,
1744 index, debugstr_a(buffer) );
1745 }
1746 return TRUE;
1747 }
1748
1749
1750 /***********************************************************************
1751 * SetupGetStringFieldW (SETUPAPI.@)
1752 */
1753 BOOL WINAPI SetupGetStringFieldW( PINFCONTEXT context, DWORD index, PWSTR buffer,
1754 DWORD size, PDWORD required )
1755 {
1756 struct inf_file *file = context->CurrentInf;
1757 struct field *field = get_field( file, context->Section, context->Line, index );
1758 unsigned int len;
1759
1760 SetLastError(0);
1761 if (!field) return FALSE;
1762 len = PARSER_string_substW( file, field->text, NULL, 0 );
1763 if (required) *required = len + 1;
1764 if (buffer)
1765 {
1766 if (size <= len)
1767 {
1768 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1769 return FALSE;
1770 }
1771 PARSER_string_substW( file, field->text, buffer, size );
1772
1773 TRACE( "context %p/%p/%d/%d index %d returning %s\n",
1774 context->Inf, context->CurrentInf, context->Section, context->Line,
1775 index, debugstr_w(buffer) );
1776 }
1777 return TRUE;
1778 }
1779
1780
1781 /***********************************************************************
1782 * SetupGetIntField (SETUPAPI.@)
1783 */
1784 BOOL WINAPI SetupGetIntField( PINFCONTEXT context, DWORD index, PINT result )
1785 {
1786 char localbuff[20];
1787 char *end, *buffer = localbuff;
1788 DWORD required;
1789 INT res;
1790 BOOL ret;
1791
1792 if (!(ret = SetupGetStringFieldA( context, index, localbuff, sizeof(localbuff), &required )))
1793 {
1794 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) return FALSE;
1795 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required ))) return FALSE;
1796 if (!(ret = SetupGetStringFieldA( context, index, buffer, required, NULL ))) goto done;
1797 }
1798 /* The call to SetupGetStringFieldA succeeded. If buffer is empty we have an optional field */
1799 if (!*buffer) *result = 0;
1800 else
1801 {
1802 res = strtol( buffer, &end, 0 );
1803 if (end != buffer && !*end) *result = res;
1804 else
1805 {
1806 SetLastError( ERROR_INVALID_DATA );
1807 ret = FALSE;
1808 }
1809 }
1810
1811 done:
1812 if (buffer != localbuff) HeapFree( GetProcessHeap(), 0, buffer );
1813 return ret;
1814 }
1815
1816
1817 /***********************************************************************
1818 * SetupGetBinaryField (SETUPAPI.@)
1819 */
1820 BOOL WINAPI SetupGetBinaryField( PINFCONTEXT context, DWORD index, BYTE *buffer,
1821 DWORD size, LPDWORD required )
1822 {
1823 struct inf_file *file = context->CurrentInf;
1824 struct line *line = get_line( file, context->Section, context->Line );
1825 struct field *field;
1826 int i;
1827
1828 if (!line)
1829 {
1830 SetLastError( ERROR_LINE_NOT_FOUND );
1831 return FALSE;
1832 }
1833 if (!index || index > line->nb_fields)
1834 {
1835 SetLastError( ERROR_INVALID_PARAMETER );
1836 return FALSE;
1837 }
1838 index--; /* fields start at 0 */
1839 if (required) *required = line->nb_fields - index;
1840 if (!buffer) return TRUE;
1841 if (size < line->nb_fields - index)
1842 {
1843 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1844 return FALSE;
1845 }
1846 field = &file->fields[line->first_field + index];
1847 for (i = index; i < line->nb_fields; i++, field++)
1848 {
1849 const WCHAR *p;
1850 DWORD value = 0;
1851 for (p = field->text; *p && isxdigitW(*p); p++)
1852 {
1853 if ((value <<= 4) > 255)
1854 {
1855 SetLastError( ERROR_INVALID_DATA );
1856 return FALSE;
1857 }
1858 if (*p <= '9') value |= (*p - '');
1859 else value |= (tolowerW(*p) - 'a' + 10);
1860 }
1861 buffer[i - index] = value;
1862 }
1863 if (TRACE_ON(setupapi))
1864 {
1865 TRACE( "%p/%p/%d/%d index %d returning",
1866 context->Inf, context->CurrentInf, context->Section, context->Line, index );
1867 for (i = index; i < line->nb_fields; i++) TRACE( " %02x", buffer[i - index] );
1868 TRACE( "\n" );
1869 }
1870 return TRUE;
1871 }
1872
1873
1874 /***********************************************************************
1875 * SetupGetMultiSzFieldA (SETUPAPI.@)
1876 */
1877 BOOL WINAPI SetupGetMultiSzFieldA( PINFCONTEXT context, DWORD index, PSTR buffer,
1878 DWORD size, LPDWORD required )
1879 {
1880 struct inf_file *file = context->CurrentInf;
1881 struct line *line = get_line( file, context->Section, context->Line );
1882 struct field *field;
1883 unsigned int len;
1884 int i;
1885 DWORD total = 1;
1886
1887 if (!line)
1888 {
1889 SetLastError( ERROR_LINE_NOT_FOUND );
1890 return FALSE;
1891 }
1892 if (!index || index > line->nb_fields)
1893 {
1894 SetLastError( ERROR_INVALID_PARAMETER );
1895 return FALSE;
1896 }
1897 index--; /* fields start at 0 */
1898 field = &file->fields[line->first_field + index];
1899 for (i = index; i < line->nb_fields; i++, field++)
1900 {
1901 if (!(len = PARSER_string_substA( file, field->text, NULL, 0 ))) break;
1902 total += len + 1;
1903 }
1904
1905 if (required) *required = total;
1906 if (!buffer) return TRUE;
1907 if (total > size)
1908 {
1909 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1910 return FALSE;
1911 }
1912 field = &file->fields[line->first_field + index];
1913 for (i = index; i < line->nb_fields; i++, field++)
1914 {
1915 if (!(len = PARSER_string_substA( file, field->text, buffer, size ))) break;
1916 buffer += len + 1;
1917 }
1918 *buffer = 0; /* add final null */
1919 return TRUE;
1920 }
1921
1922
1923 /***********************************************************************
1924 * SetupGetMultiSzFieldW (SETUPAPI.@)
1925 */
1926 BOOL WINAPI SetupGetMultiSzFieldW( PINFCONTEXT context, DWORD index, PWSTR buffer,
1927 DWORD size, LPDWORD required )
1928 {
1929 struct inf_file *file = context->CurrentInf;
1930 struct line *line = get_line( file, context->Section, context->Line );
1931 struct field *field;
1932 unsigned int len;
1933 int i;
1934 DWORD total = 1;
1935
1936 if (!line)
1937 {
1938 SetLastError( ERROR_LINE_NOT_FOUND );
1939 return FALSE;
1940 }
1941 if (!index || index > line->nb_fields)
1942 {
1943 SetLastError( ERROR_INVALID_PARAMETER );
1944 return FALSE;
1945 }
1946 index--; /* fields start at 0 */
1947 field = &file->fields[line->first_field + index];
1948 for (i = index; i < line->nb_fields; i++, field++)
1949 {
1950 if (!(len = PARSER_string_substW( file, field->text, NULL, 0 ))) break;
1951 total += len + 1;
1952 }
1953
1954 if (required) *required = total;
1955 if (!buffer) return TRUE;
1956 if (total > size)
1957 {
1958 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1959 return FALSE;
1960 }
1961 field = &file->fields[line->first_field + index];
1962 for (i = index; i < line->nb_fields; i++, field++)
1963 {
1964 if (!(len = PARSER_string_substW( file, field->text, buffer, size ))) break;
1965 buffer += len + 1;
1966 }
1967 *buffer = 0; /* add final null */
1968 return TRUE;
1969 }
1970
1971 /***********************************************************************
1972 * pSetupGetField (SETUPAPI.@)
1973 */
1974 LPCWSTR WINAPI pSetupGetField( PINFCONTEXT context, DWORD index )
1975 {
1976 struct inf_file *file = context->CurrentInf;
1977 struct field *field = get_field( file, context->Section, context->Line, index );
1978
1979 if (!field)
1980 {
1981 SetLastError( ERROR_INVALID_PARAMETER );
1982 return NULL;
1983 }
1984 return field->text;
1985 }
1986
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.