[NEWINFLIB]
[reactos.git] / reactos / lib / newinflib / infget.c
1 /*
2 * PROJECT: .inf file parser
3 * LICENSE: GPL - See COPYING in the top level directory
4 * PROGRAMMER: Royce Mitchell III
5 * Eric Kohl
6 * Ge van Geldorp <gvg@reactos.org>
7 */
8
9 /* INCLUDES *****************************************************************/
10
11 #include "inflib.h"
12
13 #define NDEBUG
14 #include <debug.h>
15
16 static unsigned int
17 InfpSubstituteString(PINFCACHE Inf,
18 const WCHAR *text,
19 WCHAR *buffer,
20 unsigned int size);
21
22 /* retrieve the string substitution for a given string, or NULL if not found */
23 /* if found, len is set to the substitution length */
24 static PCWSTR
25 InfpGetSubstitutionString(PINFCACHE Inf,
26 PCWSTR str,
27 unsigned int *len,
28 BOOL no_trailing_slash)
29 {
30 static const WCHAR percent = '%';
31
32 INFSTATUS Status = INF_STATUS_NOT_FOUND;
33 PINFCONTEXT Context = NULL;
34 PWCHAR Data = NULL;
35 WCHAR ValueName[MAX_INF_STRING_LENGTH +1];
36 WCHAR StringLangId[13];
37
38 if (!*len) /* empty string (%%) is replaced by single percent */
39 {
40 *len = 1;
41 return &percent;
42 }
43
44 memcpy(ValueName, str, *len * sizeof(WCHAR));
45 ValueName[*len] = 0;
46
47 DPRINT("Value name: %S\n", ValueName);
48
49 if (Inf->LanguageId != 0)
50 {
51 swprintf(StringLangId,
52 L"Strings.%04hx",
53 Inf->LanguageId);
54
55 Status = InfpFindFirstLine(Inf,
56 StringLangId,
57 ValueName,
58 &Context);
59 if (Status != INF_STATUS_SUCCESS)
60 {
61 swprintf(StringLangId,
62 L"Strings.%04hx",
63 MAKELANGID(PRIMARYLANGID(Inf->LanguageId), SUBLANG_NEUTRAL));
64
65 Status = InfpFindFirstLine(Inf,
66 StringLangId,
67 ValueName,
68 &Context);
69 if (Status != INF_STATUS_SUCCESS)
70 {
71 Status = InfpFindFirstLine(Inf,
72 L"Strings",
73 ValueName,
74 &Context);
75 }
76 }
77 }
78 else
79 {
80 Status = InfpFindFirstLine(Inf,
81 L"Strings",
82 ValueName,
83 &Context);
84 }
85
86 if (Status != INF_STATUS_SUCCESS || Context == NULL)
87 return NULL;
88
89 Status = InfpGetData(Context,
90 NULL,
91 &Data);
92
93 InfpFreeContext(Context);
94
95 if (Status == STATUS_SUCCESS)
96 {
97 *len = strlenW(Data);
98 DPRINT("Substitute: %S Length: %ul\n", Data, *len);
99 return Data;
100 }
101
102 return NULL;
103 }
104
105
106 /* do string substitutions on the specified text */
107 /* the buffer is assumed to be large enough */
108 /* returns necessary length not including terminating null */
109 static unsigned int
110 InfpSubstituteString(PINFCACHE Inf,
111 PCWSTR text,
112 PWSTR buffer,
113 unsigned int size)
114 {
115 const WCHAR *start, *subst, *p;
116 unsigned int len, total = 0;
117 int inside = 0;
118
119 if (!buffer) size = MAX_INF_STRING_LENGTH + 1;
120 for (p = start = text; *p; p++)
121 {
122 if (*p != '%') continue;
123 inside = !inside;
124 if (inside) /* start of a %xx% string */
125 {
126 len = (unsigned int)(p - start);
127 if (len > size - 1) len = size - 1;
128 if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
129 total += len;
130 size -= len;
131 start = p;
132 }
133 else /* end of the %xx% string, find substitution */
134 {
135 len = (unsigned int)(p - start - 1);
136 subst = InfpGetSubstitutionString( Inf, start + 1, &len, p[1] == '\\' );
137 if (!subst)
138 {
139 subst = start;
140 len = (unsigned int)(p - start + 1);
141 }
142 if (len > size - 1) len = size - 1;
143 if (buffer) memcpy( buffer + total, subst, len * sizeof(WCHAR) );
144 total += len;
145 size -= len;
146 start = p + 1;
147 }
148 }
149
150 if (start != p) /* unfinished string, copy it */
151 {
152 len = (unsigned int)(p - start);
153 if (len > size - 1) len = size - 1;
154 if (buffer) memcpy( buffer + total, start, len * sizeof(WCHAR) );
155 total += len;
156 }
157 if (buffer && size) buffer[total] = 0;
158 return total;
159 }
160
161
162 INFSTATUS
163 InfpFindFirstLine(PINFCACHE Cache,
164 PCWSTR Section,
165 PCWSTR Key,
166 PINFCONTEXT *Context)
167 {
168 PINFCACHESECTION CacheSection;
169 PINFCACHELINE CacheLine;
170
171 if (Cache == NULL || Section == NULL || Context == NULL)
172 {
173 DPRINT1("Invalid parameter\n");
174 return INF_STATUS_INVALID_PARAMETER;
175 }
176
177 CacheSection = InfpFindSection(Cache, Section);
178 if (NULL == CacheSection)
179 {
180 DPRINT("Section not found\n");
181 return INF_STATUS_NOT_FOUND;
182 }
183
184 if (Key != NULL)
185 {
186 CacheLine = InfpFindKeyLine(CacheSection, Key);
187 }
188 else
189 {
190 CacheLine = CacheSection->FirstLine;
191 }
192
193 if (NULL == CacheLine)
194 {
195 DPRINT("Key not found\n");
196 return INF_STATUS_NOT_FOUND;
197 }
198
199 *Context = MALLOC(sizeof(INFCONTEXT));
200 if (NULL == *Context)
201 {
202 DPRINT1("MALLOC() failed\n");
203 return INF_STATUS_NO_MEMORY;
204 }
205 (*Context)->Inf = (PVOID)Cache;
206 (*Context)->Section = (PVOID)CacheSection;
207 (*Context)->Line = (PVOID)CacheLine;
208
209 return INF_STATUS_SUCCESS;
210 }
211
212
213 INFSTATUS
214 InfpFindNextLine(PINFCONTEXT ContextIn,
215 PINFCONTEXT ContextOut)
216 {
217 PINFCACHELINE CacheLine;
218
219 if (ContextIn == NULL || ContextOut == NULL)
220 return INF_STATUS_INVALID_PARAMETER;
221
222 if (ContextIn->Line == NULL)
223 return INF_STATUS_INVALID_PARAMETER;
224
225 CacheLine = (PINFCACHELINE)ContextIn->Line;
226 if (CacheLine->Next == NULL)
227 return INF_STATUS_NOT_FOUND;
228
229 if (ContextIn != ContextOut)
230 {
231 ContextOut->Inf = ContextIn->Inf;
232 ContextOut->Section = ContextIn->Section;
233 }
234 ContextOut->Line = (PVOID)(CacheLine->Next);
235
236 return INF_STATUS_SUCCESS;
237 }
238
239
240 INFSTATUS
241 InfpFindFirstMatchLine(PINFCONTEXT ContextIn,
242 PCWSTR Key,
243 PINFCONTEXT ContextOut)
244 {
245 PINFCACHELINE CacheLine;
246
247 if (ContextIn == NULL || ContextOut == NULL || Key == NULL || *Key == 0)
248 return INF_STATUS_INVALID_PARAMETER;
249
250 if (ContextIn->Inf == NULL || ContextIn->Section == NULL)
251 return INF_STATUS_INVALID_PARAMETER;
252
253 CacheLine = ((PINFCACHESECTION)(ContextIn->Section))->FirstLine;
254 while (CacheLine != NULL)
255 {
256 if (CacheLine->Key != NULL && strcmpiW (CacheLine->Key, Key) == 0)
257 {
258
259 if (ContextIn != ContextOut)
260 {
261 ContextOut->Inf = ContextIn->Inf;
262 ContextOut->Section = ContextIn->Section;
263 }
264 ContextOut->Line = (PVOID)CacheLine;
265
266 return INF_STATUS_SUCCESS;
267 }
268
269 CacheLine = CacheLine->Next;
270 }
271
272 return INF_STATUS_NOT_FOUND;
273 }
274
275
276 INFSTATUS
277 InfpFindNextMatchLine(PINFCONTEXT ContextIn,
278 PCWSTR Key,
279 PINFCONTEXT ContextOut)
280 {
281 PINFCACHELINE CacheLine;
282
283 if (ContextIn == NULL || ContextOut == NULL || Key == NULL || *Key == 0)
284 return INF_STATUS_INVALID_PARAMETER;
285
286 if (ContextIn->Inf == NULL || ContextIn->Section == NULL || ContextIn->Line == NULL)
287 return INF_STATUS_INVALID_PARAMETER;
288
289 CacheLine = (PINFCACHELINE)ContextIn->Line;
290 while (CacheLine != NULL)
291 {
292 if (CacheLine->Key != NULL && strcmpiW (CacheLine->Key, Key) == 0)
293 {
294
295 if (ContextIn != ContextOut)
296 {
297 ContextOut->Inf = ContextIn->Inf;
298 ContextOut->Section = ContextIn->Section;
299 }
300 ContextOut->Line = (PVOID)CacheLine;
301
302 return INF_STATUS_SUCCESS;
303 }
304
305 CacheLine = CacheLine->Next;
306 }
307
308 return INF_STATUS_NOT_FOUND;
309 }
310
311
312 LONG
313 InfpGetLineCount(HINF InfHandle,
314 PCWSTR Section)
315 {
316 PINFCACHE Cache;
317 PINFCACHESECTION CacheSection;
318
319 if (InfHandle == NULL || Section == NULL)
320 {
321 DPRINT("Invalid parameter\n");
322 return -1;
323 }
324
325 Cache = (PINFCACHE)InfHandle;
326
327 /* Iterate through list of sections */
328 CacheSection = Cache->FirstSection;
329 while (CacheSection != NULL)
330 {
331 /* Are the section names the same? */
332 if (strcmpiW(CacheSection->Name, Section) == 0)
333 {
334 return CacheSection->LineCount;
335 }
336
337 /* Get the next section */
338 CacheSection = CacheSection->Next;
339 }
340
341 DPRINT("Section not found\n");
342
343 return -1;
344 }
345
346
347 /* InfpGetLineText */
348
349
350 LONG
351 InfpGetFieldCount(PINFCONTEXT Context)
352 {
353 if (Context == NULL || Context->Line == NULL)
354 return 0;
355
356 return ((PINFCACHELINE)Context->Line)->FieldCount;
357 }
358
359
360 INFSTATUS
361 InfpGetBinaryField(PINFCONTEXT Context,
362 ULONG FieldIndex,
363 PUCHAR ReturnBuffer,
364 ULONG ReturnBufferSize,
365 PULONG RequiredSize)
366 {
367 PINFCACHELINE CacheLine;
368 PINFCACHEFIELD CacheField;
369 ULONG Index;
370 ULONG Size;
371 PUCHAR Ptr;
372
373 if (Context == NULL || Context->Line == NULL || FieldIndex == 0)
374 {
375 DPRINT("Invalid parameter\n");
376 return INF_STATUS_INVALID_PARAMETER;
377 }
378
379 if (RequiredSize != NULL)
380 *RequiredSize = 0;
381
382 CacheLine = (PINFCACHELINE)Context->Line;
383
384 if (FieldIndex > (ULONG)CacheLine->FieldCount)
385 return INF_STATUS_NOT_FOUND;
386
387 CacheField = CacheLine->FirstField;
388 for (Index = 1; Index < FieldIndex; Index++)
389 CacheField = CacheField->Next;
390
391 Size = (ULONG)CacheLine->FieldCount - FieldIndex + 1;
392
393 if (RequiredSize != NULL)
394 *RequiredSize = Size;
395
396 if (ReturnBuffer != NULL)
397 {
398 if (ReturnBufferSize < Size)
399 return INF_STATUS_BUFFER_OVERFLOW;
400
401 /* Copy binary data */
402 Ptr = ReturnBuffer;
403 while (CacheField != NULL)
404 {
405 *Ptr = (UCHAR)strtoulW(CacheField->Data, NULL, 16);
406
407 Ptr++;
408 CacheField = CacheField->Next;
409 }
410 }
411
412 return INF_STATUS_SUCCESS;
413 }
414
415
416 INFSTATUS
417 InfpGetIntField(PINFCONTEXT Context,
418 ULONG FieldIndex,
419 INT *IntegerValue)
420 {
421 PINFCACHELINE CacheLine;
422 PINFCACHEFIELD CacheField;
423 ULONG Index;
424 PWCHAR Ptr;
425
426 if (Context == NULL || Context->Line == NULL || IntegerValue == NULL)
427 {
428 DPRINT("Invalid parameter\n");
429 return INF_STATUS_INVALID_PARAMETER;
430 }
431
432 CacheLine = (PINFCACHELINE)Context->Line;
433
434 if (FieldIndex > (ULONG)CacheLine->FieldCount)
435 {
436 DPRINT("Invalid parameter\n");
437 return INF_STATUS_INVALID_PARAMETER;
438 }
439
440 if (FieldIndex == 0)
441 {
442 Ptr = CacheLine->Key;
443 }
444 else
445 {
446 CacheField = CacheLine->FirstField;
447 for (Index = 1; Index < FieldIndex; Index++)
448 CacheField = CacheField->Next;
449
450 Ptr = CacheField->Data;
451 }
452
453 *IntegerValue = (LONG)strtolW(Ptr, NULL, 0);
454
455 return INF_STATUS_SUCCESS;
456 }
457
458
459 INFSTATUS
460 InfpGetMultiSzField(PINFCONTEXT Context,
461 ULONG FieldIndex,
462 PWSTR ReturnBuffer,
463 ULONG ReturnBufferSize,
464 PULONG RequiredSize)
465 {
466 PINFCACHELINE CacheLine;
467 PINFCACHEFIELD CacheField;
468 PINFCACHEFIELD FieldPtr;
469 ULONG Index;
470 ULONG Size;
471 PWCHAR Ptr;
472
473 if (Context == NULL || Context->Line == NULL || FieldIndex == 0)
474 {
475 DPRINT("Invalid parameter\n");
476 return INF_STATUS_INVALID_PARAMETER;
477 }
478
479 if (RequiredSize != NULL)
480 *RequiredSize = 0;
481
482 CacheLine = (PINFCACHELINE)Context->Line;
483
484 if (FieldIndex > (ULONG)CacheLine->FieldCount)
485 return INF_STATUS_INVALID_PARAMETER;
486
487 CacheField = CacheLine->FirstField;
488 for (Index = 1; Index < FieldIndex; Index++)
489 CacheField = CacheField->Next;
490
491 /* Calculate the required buffer size */
492 FieldPtr = CacheField;
493 Size = 0;
494 while (FieldPtr != NULL)
495 {
496 Size += ((ULONG)strlenW(FieldPtr->Data) + 1);
497 FieldPtr = FieldPtr->Next;
498 }
499 Size++;
500
501 if (RequiredSize != NULL)
502 *RequiredSize = Size;
503
504 if (ReturnBuffer != NULL)
505 {
506 if (ReturnBufferSize < Size)
507 return INF_STATUS_BUFFER_OVERFLOW;
508
509 /* Copy multi-sz string */
510 Ptr = ReturnBuffer;
511 FieldPtr = CacheField;
512 while (FieldPtr != NULL)
513 {
514 Size = (ULONG)strlenW(FieldPtr->Data) + 1;
515
516 strcpyW(Ptr, FieldPtr->Data);
517
518 Ptr = Ptr + Size;
519 FieldPtr = FieldPtr->Next;
520 }
521 *Ptr = 0;
522 }
523
524 return INF_STATUS_SUCCESS;
525 }
526
527
528 INFSTATUS
529 InfpGetStringField(PINFCONTEXT Context,
530 ULONG FieldIndex,
531 PWSTR ReturnBuffer,
532 ULONG ReturnBufferSize,
533 PULONG RequiredSize)
534 {
535 PINFCACHELINE CacheLine;
536 PINFCACHEFIELD CacheField;
537 ULONG Index;
538 PWCHAR Ptr;
539 ULONG Size;
540
541 if (Context == NULL || Context->Line == NULL || FieldIndex == 0)
542 {
543 DPRINT("Invalid parameter\n");
544 return INF_STATUS_INVALID_PARAMETER;
545 }
546
547 if (RequiredSize != NULL)
548 *RequiredSize = 0;
549
550 CacheLine = (PINFCACHELINE)Context->Line;
551
552 if (FieldIndex > (ULONG)CacheLine->FieldCount)
553 return INF_STATUS_INVALID_PARAMETER;
554
555 if (FieldIndex == 0)
556 {
557 Ptr = CacheLine->Key;
558 }
559 else
560 {
561 CacheField = CacheLine->FirstField;
562 for (Index = 1; Index < FieldIndex; Index++)
563 CacheField = CacheField->Next;
564
565 Ptr = CacheField->Data;
566 }
567
568 // Size = (ULONG)strlenW(Ptr) + 1;
569 Size = InfpSubstituteString(Context->Inf,
570 Ptr,
571 NULL,
572 0);
573
574 if (RequiredSize != NULL)
575 *RequiredSize = Size + 1;
576
577 if (ReturnBuffer != NULL)
578 {
579 if (ReturnBufferSize <= Size)
580 return INF_STATUS_BUFFER_OVERFLOW;
581
582 // strcpyW(ReturnBuffer, Ptr);
583 InfpSubstituteString(Context->Inf,
584 Ptr,
585 ReturnBuffer,
586 ReturnBufferSize);
587 }
588
589 return INF_STATUS_SUCCESS;
590 }
591
592
593 INFSTATUS
594 InfpGetData(PINFCONTEXT Context,
595 PWCHAR *Key,
596 PWCHAR *Data)
597 {
598 PINFCACHELINE CacheKey;
599
600 if (Context == NULL || Context->Line == NULL || Data == NULL)
601 {
602 DPRINT("Invalid parameter\n");
603 return INF_STATUS_INVALID_PARAMETER;
604 }
605
606 CacheKey = (PINFCACHELINE)Context->Line;
607 if (Key != NULL)
608 *Key = CacheKey->Key;
609
610 if (Data != NULL)
611 {
612 if (CacheKey->FirstField == NULL)
613 {
614 *Data = NULL;
615 }
616 else
617 {
618 *Data = CacheKey->FirstField->Data;
619 }
620 }
621
622 return INF_STATUS_SUCCESS;
623 }
624
625
626 INFSTATUS
627 InfpGetDataField(PINFCONTEXT Context,
628 ULONG FieldIndex,
629 PWCHAR *Data)
630 {
631 PINFCACHELINE CacheLine;
632 PINFCACHEFIELD CacheField;
633 ULONG Index;
634
635 if (Context == NULL || Context->Line == NULL || Data == NULL)
636 {
637 DPRINT("Invalid parameter\n");
638 return INF_STATUS_INVALID_PARAMETER;
639 }
640
641 CacheLine = (PINFCACHELINE)Context->Line;
642
643 if (FieldIndex > (ULONG)CacheLine->FieldCount)
644 return INF_STATUS_INVALID_PARAMETER;
645
646 if (FieldIndex == 0)
647 {
648 *Data = CacheLine->Key;
649 }
650 else
651 {
652 CacheField = CacheLine->FirstField;
653 for (Index = 1; Index < FieldIndex; Index++)
654 CacheField = CacheField->Next;
655
656 *Data = CacheField->Data;
657 }
658
659 return INF_STATUS_SUCCESS;
660 }
661
662 VOID
663 InfpFreeContext(PINFCONTEXT Context)
664 {
665 FREE(Context);
666 }
667
668 /* EOF */