[FREELDR]
[reactos.git] / reactos / lib / newinflib / infrosgen.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 #include "infros.h"
13
14 #define NDEBUG
15 #include <debug.h>
16
17 /* PRIVATE FUNCTIONS ********************************************************/
18
19 static int InfpHeapRefCount;
20
21 static VOID
22 CheckHeap()
23 {
24 if (NULL == InfpHeap)
25 {
26 InfpHeap = RtlCreateHeap(HEAP_GROWABLE, NULL, 0, 0, NULL, NULL);
27 }
28 if (0 <= InfpHeapRefCount)
29 {
30 InfpHeapRefCount++;
31 }
32 }
33
34
35 /* PUBLIC FUNCTIONS *********************************************************/
36
37 PVOID InfpHeap;
38
39 VOID
40 InfSetHeap(PVOID Heap)
41 {
42 if (NULL == InfpHeap)
43 {
44 InfpHeap = Heap;
45 InfpHeapRefCount = -1;
46 }
47 }
48
49
50 NTSTATUS
51 InfOpenBufferedFile(PHINF InfHandle,
52 PVOID Buffer,
53 ULONG BufferSize,
54 LANGID LanguageId,
55 PULONG ErrorLine)
56 {
57 INFSTATUS Status;
58 PINFCACHE Cache;
59 PCHAR FileBuffer;
60 ULONG FileBufferSize;
61
62 CheckHeap();
63
64 *InfHandle = NULL;
65 *ErrorLine = (ULONG)-1;
66
67 /* Allocate file buffer */
68 FileBufferSize = BufferSize + 2;
69 FileBuffer = MALLOC(FileBufferSize);
70 if (FileBuffer == NULL)
71 {
72 DPRINT1("MALLOC() failed\n");
73 return(INF_STATUS_INSUFFICIENT_RESOURCES);
74 }
75
76 MEMCPY(FileBuffer, Buffer, BufferSize);
77
78 /* Append string terminator */
79 FileBuffer[BufferSize] = 0;
80 FileBuffer[BufferSize + 1] = 0;
81
82 /* Allocate infcache header */
83 Cache = (PINFCACHE)MALLOC(sizeof(INFCACHE));
84 if (Cache == NULL)
85 {
86 DPRINT("MALLOC() failed\n");
87 FREE(FileBuffer);
88 return(INF_STATUS_INSUFFICIENT_RESOURCES);
89 }
90
91 /* Initialize inicache header */
92 ZEROMEMORY(Cache,
93 sizeof(INFCACHE));
94
95 Cache->LanguageId = LanguageId;
96
97 /* Parse the inf buffer */
98 if (!RtlIsTextUnicode(FileBuffer, FileBufferSize, NULL))
99 {
100 // static const BYTE utf8_bom[3] = { 0xef, 0xbb, 0xbf };
101 WCHAR *new_buff;
102 // UINT codepage = CP_ACP;
103 UINT offset = 0;
104
105 // if (BufferSize > sizeof(utf8_bom) && !memcmp(FileBuffer, utf8_bom, sizeof(utf8_bom) ))
106 // {
107 // codepage = CP_UTF8;
108 // offset = sizeof(utf8_bom);
109 // }
110
111 new_buff = MALLOC(FileBufferSize * sizeof(WCHAR));
112 if (new_buff != NULL)
113 {
114 ULONG len;
115 Status = RtlMultiByteToUnicodeN(new_buff,
116 FileBufferSize * sizeof(WCHAR),
117 &len,
118 (char *)FileBuffer + offset,
119 FileBufferSize - offset);
120
121 Status = InfpParseBuffer(Cache,
122 new_buff,
123 new_buff + len,
124 ErrorLine);
125 FREE(new_buff);
126 }
127 else
128 Status = INF_STATUS_INSUFFICIENT_RESOURCES;
129 }
130 else
131 {
132 WCHAR *new_buff = (WCHAR *)FileBuffer;
133 /* UCS-16 files should start with the Unicode BOM; we should skip it */
134 if (*new_buff == 0xfeff)
135 {
136 new_buff++;
137 FileBufferSize -= sizeof(WCHAR);
138 }
139 Status = InfpParseBuffer(Cache,
140 new_buff,
141 (WCHAR*)((char*)new_buff + FileBufferSize),
142 ErrorLine);
143 }
144
145 if (!INF_SUCCESS(Status))
146 {
147 FREE(Cache);
148 Cache = NULL;
149 }
150
151 /* Free file buffer */
152 FREE(FileBuffer);
153
154 *InfHandle = (HINF)Cache;
155
156 return(Status);
157 }
158
159
160 NTSTATUS
161 InfOpenFile(PHINF InfHandle,
162 PUNICODE_STRING FileName,
163 LANGID LanguageId,
164 PULONG ErrorLine)
165 {
166 OBJECT_ATTRIBUTES ObjectAttributes;
167 FILE_STANDARD_INFORMATION FileInfo;
168 IO_STATUS_BLOCK IoStatusBlock;
169 HANDLE FileHandle;
170 NTSTATUS Status;
171 PCHAR FileBuffer;
172 ULONG FileLength;
173 ULONG FileBufferLength;
174 LARGE_INTEGER FileOffset;
175 PINFCACHE Cache;
176
177 CheckHeap();
178
179 *InfHandle = NULL;
180 *ErrorLine = (ULONG)-1;
181
182 /* Open the inf file */
183 InitializeObjectAttributes(&ObjectAttributes,
184 FileName,
185 0,
186 NULL,
187 NULL);
188
189 Status = NtOpenFile(&FileHandle,
190 GENERIC_READ | SYNCHRONIZE,
191 &ObjectAttributes,
192 &IoStatusBlock,
193 FILE_SHARE_READ,
194 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
195 if (!INF_SUCCESS(Status))
196 {
197 DPRINT("NtOpenFile() failed (Status %lx)\n", Status);
198 return(Status);
199 }
200
201 DPRINT("NtOpenFile() successful\n");
202
203 /* Query file size */
204 Status = NtQueryInformationFile(FileHandle,
205 &IoStatusBlock,
206 &FileInfo,
207 sizeof(FILE_STANDARD_INFORMATION),
208 FileStandardInformation);
209 if (!INF_SUCCESS(Status))
210 {
211 DPRINT("NtQueryInformationFile() failed (Status %lx)\n", Status);
212 NtClose(FileHandle);
213 return(Status);
214 }
215
216 FileLength = FileInfo.EndOfFile.u.LowPart;
217
218 DPRINT("File size: %lu\n", FileLength);
219
220 /* Allocate file buffer */
221 FileBufferLength = FileLength + 2;
222 FileBuffer = MALLOC(FileBufferLength);
223 if (FileBuffer == NULL)
224 {
225 DPRINT1("MALLOC() failed\n");
226 NtClose(FileHandle);
227 return(INF_STATUS_INSUFFICIENT_RESOURCES);
228 }
229
230 /* Read file */
231 FileOffset.QuadPart = 0ULL;
232 Status = NtReadFile(FileHandle,
233 NULL,
234 NULL,
235 NULL,
236 &IoStatusBlock,
237 FileBuffer,
238 FileLength,
239 &FileOffset,
240 NULL);
241
242 /* Append string terminator */
243 FileBuffer[FileLength] = 0;
244 FileBuffer[FileLength + 1] = 0;
245
246 NtClose(FileHandle);
247
248 if (!INF_SUCCESS(Status))
249 {
250 DPRINT("NtReadFile() failed (Status %lx)\n", Status);
251 FREE(FileBuffer);
252 return(Status);
253 }
254
255 /* Allocate infcache header */
256 Cache = (PINFCACHE)MALLOC(sizeof(INFCACHE));
257 if (Cache == NULL)
258 {
259 DPRINT("MALLOC() failed\n");
260 FREE(FileBuffer);
261 return(INF_STATUS_INSUFFICIENT_RESOURCES);
262 }
263
264 /* Initialize inicache header */
265 ZEROMEMORY(Cache,
266 sizeof(INFCACHE));
267
268 Cache->LanguageId = LanguageId;
269
270 /* Parse the inf buffer */
271 if (!RtlIsTextUnicode(FileBuffer, FileBufferLength, NULL))
272 {
273 // static const BYTE utf8_bom[3] = { 0xef, 0xbb, 0xbf };
274 WCHAR *new_buff;
275 // UINT codepage = CP_ACP;
276 UINT offset = 0;
277
278 // if (FileLength > sizeof(utf8_bom) && !memcmp(FileBuffer, utf8_bom, sizeof(utf8_bom) ))
279 // {
280 // codepage = CP_UTF8;
281 // offset = sizeof(utf8_bom);
282 // }
283
284 new_buff = MALLOC(FileBufferLength * sizeof(WCHAR));
285 if (new_buff != NULL)
286 {
287 ULONG len;
288 Status = RtlMultiByteToUnicodeN(new_buff,
289 FileBufferLength * sizeof(WCHAR),
290 &len,
291 (char *)FileBuffer + offset,
292 FileBufferLength - offset);
293
294 Status = InfpParseBuffer(Cache,
295 new_buff,
296 new_buff + len,
297 ErrorLine);
298 FREE(new_buff);
299 }
300 else
301 Status = INF_STATUS_INSUFFICIENT_RESOURCES;
302 }
303 else
304 {
305 WCHAR *new_buff = (WCHAR *)FileBuffer;
306 /* UCS-16 files should start with the Unicode BOM; we should skip it */
307 if (*new_buff == 0xfeff)
308 {
309 new_buff++;
310 FileBufferLength -= sizeof(WCHAR);
311 }
312 Status = InfpParseBuffer(Cache,
313 new_buff,
314 (WCHAR*)((char*)new_buff + FileBufferLength),
315 ErrorLine);
316 }
317
318 if (!INF_SUCCESS(Status))
319 {
320 FREE(Cache);
321 Cache = NULL;
322 }
323
324 /* Free file buffer */
325 FREE(FileBuffer);
326
327 *InfHandle = (HINF)Cache;
328
329 return(Status);
330 }
331
332
333 VOID
334 InfCloseFile(HINF InfHandle)
335 {
336 PINFCACHE Cache;
337
338 Cache = (PINFCACHE)InfHandle;
339
340 if (Cache == NULL)
341 {
342 return;
343 }
344
345 while (Cache->FirstSection != NULL)
346 {
347 Cache->FirstSection = InfpFreeSection(Cache->FirstSection);
348 }
349 Cache->LastSection = NULL;
350
351 FREE(Cache);
352
353 if (0 < InfpHeapRefCount)
354 {
355 InfpHeapRefCount--;
356 if (0 == InfpHeapRefCount)
357 {
358 RtlDestroyHeap(InfpHeap);
359 InfpHeap = NULL;
360 }
361 }
362 }
363
364
365 /* EOF */