~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Wine Cross Reference
wine/dlls/setupapi/misc.c

Version: ~ [ wine-1.1.9 ] ~ [ wine-1.1.8 ] ~ [ wine-1.1.7 ] ~ [ wine-1.0.1 ] ~ [ wine-1.1.6 ] ~ [ wine-1.1.5 ] ~ [ wine-1.1.4 ] ~ [ wine-1.1.3 ] ~ [ wine-1.1.2 ] ~ [ wine-1.1.1 ] ~ [ wine-1.1.0 ] ~ [ wine-1.0 ] ~ [ wine-1.0-rc5 ] ~ [ wine-1.0-rc4 ] ~ [ wine-1.0-rc3 ] ~ [ wine-1.0-rc2 ] ~ [ wine-1.0-rc1 ] ~ [ wine-0.9.61 ] ~ [ wine-0.9.60 ] ~ [ wine-0.9.59 ] ~ [ wine-0.9.58 ] ~ [ wine-0.9.57 ] ~ [ wine-0.9.56 ] ~ [ wine-0.9.55 ] ~ [ wine-0.9.54 ] ~ [ wine-0.9.53 ] ~ [ wine-0.9.52 ] ~ [ wine-0.9.51 ] ~ [ wine-0.9.50 ] ~ [ wine-0.9.49 ] ~ [ wine-0.9.48 ] ~ [ wine-0.9.47 ] ~ [ wine-0.9.46 ] ~ [ wine-0.9.45 ] ~ [ wine-0.9.44 ] ~ [ wine-0.9.43 ] ~ [ wine-0.9.42 ] ~ [ wine-0.9.41 ] ~ [ wine-0.9.40 ] ~ [ wine-0.9.39 ] ~ [ wine-0.9.38 ] ~ [ wine-0.9.37 ] ~ [ wine-0.9.36 ] ~ [ wine-0.9.35 ] ~ [ wine-0.9.34 ] ~ [ wine-0.9.33 ] ~ [ wine-0.9.32 ] ~ [ wine-0.9.31 ] ~ [ wine-0.9.30 ] ~ [ wine-0.9.29 ] ~ [ wine-0.9.28 ] ~ [ wine-0.9.27 ] ~ [ wine-0.9.26 ] ~ [ wine-0.9.25 ] ~ [ wine-0.9.24 ] ~ [ wine-0.9.23 ] ~ [ wine-0.9.22 ] ~ [ wine-0.9.21 ] ~ [ wine-0.9.20 ] ~ [ wine-0.9.19 ] ~ [ wine-0.9.18 ] ~ [ wine-0.9.17 ] ~ [ wine-0.9.16 ] ~ [ wine-0.9.15 ] ~ [ wine-0.9.14 ] ~ [ wine-0.9.13 ] ~ [ wine-0.9.12 ] ~ [ wine-0.9.11 ] ~ [ wine-0.9.10 ] ~ [ wine-0.9.9 ] ~ [ wine-0.9.8 ] ~ [ wine-0.9.7 ] ~ [ wine-0.9.6 ] ~ [ wine-0.9.5 ] ~ [ wine-0.9.4 ] ~ [ wine-0.9.3 ] ~ [ wine-0.9.2 ] ~ [ wine-0.9.1 ] ~ [ wine-0.9 ] ~ [ wine20050930 ] ~ [ wine20050830 ] ~ [ wine20050725 ] ~ [ wine20050628 ] ~ [ wine20050524 ] ~ [ wine20050419 ] ~ [ wine20050310 ] ~ [ wine20050211 ] ~ [ wine20050111 ] ~ [ wine20041201 ] ~ [ wine20041019 ] ~ [ wine20040914 ] ~ [ wine20040813 ] ~ [ wine20040716 ] ~ [ wine20040615 ] ~ [ wine20040505 ] ~ [ wine20040408 ] ~ [ wine20040309 ] ~ [ wine20040213 ] ~ [ wine20040121 ] ~ [ wine20031212 ] ~ [ wine20031118 ] ~ [ wine20031016 ] ~ [ wine20030911 ] ~ [ wine20030813 ] ~ [ wine20030709 ] ~ [ wine20030618 ] ~ [ wine20030508 ] ~ [ wine20030408 ] ~ [ wine20030318 ] ~ [ wine20030219 ] ~ [ wine20030115 ] ~ [ wine20021219 ] ~ [ wine20021125 ] ~ [ wine20021031 ] ~ [ wine20021007 ] ~ [ wine20020904 ] ~ [ wine20020804 ] ~ [ wine20020710 ] ~ [ wine20020605 ] ~ [ wine20020509 ] ~ [ wine20020411 ] ~ [ wine20020310 ] ~ [ wine20020228 ] ~ [ wine20011226 ] ~ [ wine20011108 ] ~ [ wine20011004 ] ~ [ wine20010824 ] ~ [ wine20010731 ] ~ [ wine20010629 ] ~ [ wine20010510 ] ~ [ wine20010418 ] ~ [ wine20010326 ] ~ [ wine20010305 ] ~ [ wine20010216 ] ~ [ wine20010112 ] ~ [ wine20001222 ] ~ [ wine20001202 ] ~ [ wine20001026 ] ~ [ wine20001002 ] ~ [ wine20000909 ] ~ [ wine20000821 ] ~ [ wine20000801 ] ~ [ wine20000716 ] ~ [ wine20000326 ] ~ [ wine20000227 ] ~ [ wine20000130 ] ~ [ wine20000109 ] ~

  1 /*
  2  * Setupapi miscellaneous functions
  3  *
  4  * Copyright 2005 Eric Kohl
  5  * Copyright 2007 Hans Leidekker
  6  *
  7  * This library is free software; you can redistribute it and/or
  8  * modify it under the terms of the GNU Lesser General Public
  9  * License as published by the Free Software Foundation; either
 10  * version 2.1 of the License, or (at your option) any later version.
 11  *
 12  * This library is distributed in the hope that it will be useful,
 13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 15  * Lesser General Public License for more details.
 16  *
 17  * You should have received a copy of the GNU Lesser General Public
 18  * License along with this library; if not, write to the Free Software
 19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 20  */
 21 
 22 #include <stdarg.h>
 23 
 24 #include "windef.h"
 25 #include "winbase.h"
 26 #include "wingdi.h"
 27 #include "winuser.h"
 28 #include "winreg.h"
 29 #include "setupapi.h"
 30 #include "lzexpand.h"
 31 #include "softpub.h"
 32 #include "mscat.h"
 33 
 34 #include "wine/unicode.h"
 35 #include "wine/debug.h"
 36 
 37 #include "setupapi_private.h"
 38 
 39 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
 40 
 41 /* arbitrary limit not related to what native actually uses */
 42 #define OEM_INDEX_LIMIT 999
 43 
 44 /**************************************************************************
 45  * MyFree [SETUPAPI.@]
 46  *
 47  * Frees an allocated memory block from the process heap.
 48  *
 49  * PARAMS
 50  *     lpMem [I] pointer to memory block which will be freed
 51  *
 52  * RETURNS
 53  *     None
 54  */
 55 VOID WINAPI MyFree(LPVOID lpMem)
 56 {
 57     HeapFree(GetProcessHeap(), 0, lpMem);
 58 }
 59 
 60 
 61 /**************************************************************************
 62  * MyMalloc [SETUPAPI.@]
 63  *
 64  * Allocates memory block from the process heap.
 65  *
 66  * PARAMS
 67  *     dwSize [I] size of the allocated memory block
 68  *
 69  * RETURNS
 70  *     Success: pointer to allocated memory block
 71  *     Failure: NULL
 72  */
 73 LPVOID WINAPI MyMalloc(DWORD dwSize)
 74 {
 75     return HeapAlloc(GetProcessHeap(), 0, dwSize);
 76 }
 77 
 78 
 79 /**************************************************************************
 80  * MyRealloc [SETUPAPI.@]
 81  *
 82  * Changes the size of an allocated memory block or allocates a memory
 83  * block from the process heap.
 84  *
 85  * PARAMS
 86  *     lpSrc  [I] pointer to memory block which will be resized
 87  *     dwSize [I] new size of the memory block
 88  *
 89  * RETURNS
 90  *     Success: pointer to the resized memory block
 91  *     Failure: NULL
 92  *
 93  * NOTES
 94  *     If lpSrc is a NULL-pointer, then MyRealloc allocates a memory
 95  *     block like MyMalloc.
 96  */
 97 LPVOID WINAPI MyRealloc(LPVOID lpSrc, DWORD dwSize)
 98 {
 99     if (lpSrc == NULL)
100         return HeapAlloc(GetProcessHeap(), 0, dwSize);
101 
102     return HeapReAlloc(GetProcessHeap(), 0, lpSrc, dwSize);
103 }
104 
105 
106 /**************************************************************************
107  * DuplicateString [SETUPAPI.@]
108  *
109  * Duplicates a unicode string.
110  *
111  * PARAMS
112  *     lpSrc  [I] pointer to the unicode string that will be duplicated
113  *
114  * RETURNS
115  *     Success: pointer to the duplicated unicode string
116  *     Failure: NULL
117  *
118  * NOTES
119  *     Call MyFree() to release the duplicated string.
120  */
121 LPWSTR WINAPI DuplicateString(LPCWSTR lpSrc)
122 {
123     LPWSTR lpDst;
124 
125     lpDst = MyMalloc((lstrlenW(lpSrc) + 1) * sizeof(WCHAR));
126     if (lpDst == NULL)
127         return NULL;
128 
129     strcpyW(lpDst, lpSrc);
130 
131     return lpDst;
132 }
133 
134 
135 /**************************************************************************
136  * QueryRegistryValue [SETUPAPI.@]
137  *
138  * Retrieves value data from the registry and allocates memory for the
139  * value data.
140  *
141  * PARAMS
142  *     hKey        [I] Handle of the key to query
143  *     lpValueName [I] Name of value under hkey to query
144  *     lpData      [O] Destination for the values contents,
145  *     lpType      [O] Destination for the value type
146  *     lpcbData    [O] Destination for the size of data
147  *
148  * RETURNS
149  *     Success: ERROR_SUCCESS
150  *     Failure: Otherwise
151  *
152  * NOTES
153  *     Use MyFree to release the lpData buffer.
154  */
155 LONG WINAPI QueryRegistryValue(HKEY hKey,
156                                LPCWSTR lpValueName,
157                                LPBYTE  *lpData,
158                                LPDWORD lpType,
159                                LPDWORD lpcbData)
160 {
161     LONG lError;
162 
163     TRACE("%p %s %p %p %p\n",
164           hKey, debugstr_w(lpValueName), lpData, lpType, lpcbData);
165 
166     /* Get required buffer size */
167     *lpcbData = 0;
168     lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, NULL, lpcbData);
169     if (lError != ERROR_SUCCESS)
170         return lError;
171 
172     /* Allocate buffer */
173     *lpData = MyMalloc(*lpcbData);
174     if (*lpData == NULL)
175         return ERROR_NOT_ENOUGH_MEMORY;
176 
177     /* Query registry value */
178     lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, *lpData, lpcbData);
179     if (lError != ERROR_SUCCESS)
180         MyFree(*lpData);
181 
182     return lError;
183 }
184 
185 
186 /**************************************************************************
187  * IsUserAdmin [SETUPAPI.@]
188  *
189  * Checks whether the current user is a member of the Administrators group.
190  *
191  * PARAMS
192  *     None
193  *
194  * RETURNS
195  *     Success: TRUE
196  *     Failure: FALSE
197  */
198 BOOL WINAPI IsUserAdmin(VOID)
199 {
200     SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
201     HANDLE hToken;
202     DWORD dwSize;
203     PTOKEN_GROUPS lpGroups;
204     PSID lpSid;
205     DWORD i;
206     BOOL bResult = FALSE;
207 
208     TRACE("\n");
209 
210     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
211     {
212         return FALSE;
213     }
214 
215     if (!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
216     {
217         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
218         {
219             CloseHandle(hToken);
220             return FALSE;
221         }
222     }
223 
224     lpGroups = MyMalloc(dwSize);
225     if (lpGroups == NULL)
226     {
227         CloseHandle(hToken);
228         return FALSE;
229     }
230 
231     if (!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
232     {
233         MyFree(lpGroups);
234         CloseHandle(hToken);
235         return FALSE;
236     }
237 
238     CloseHandle(hToken);
239 
240     if (!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
241                                   DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
242                                   &lpSid))
243     {
244         MyFree(lpGroups);
245         return FALSE;
246     }
247 
248     for (i = 0; i < lpGroups->GroupCount; i++)
249     {
250         if (EqualSid(lpSid, lpGroups->Groups[i].Sid))
251         {
252             bResult = TRUE;
253             break;
254         }
255     }
256 
257     FreeSid(lpSid);
258     MyFree(lpGroups);
259 
260     return bResult;
261 }
262 
263 
264 /**************************************************************************
265  * MultiByteToUnicode [SETUPAPI.@]
266  *
267  * Converts a multi-byte string to a Unicode string.
268  *
269  * PARAMS
270  *     lpMultiByteStr  [I] Multi-byte string to be converted
271  *     uCodePage       [I] Code page
272  *
273  * RETURNS
274  *     Success: pointer to the converted Unicode string
275  *     Failure: NULL
276  *
277  * NOTE
278  *     Use MyFree to release the returned Unicode string.
279  */
280 LPWSTR WINAPI MultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
281 {
282     LPWSTR lpUnicodeStr;
283     int nLength;
284 
285     nLength = MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
286                                   -1, NULL, 0);
287     if (nLength == 0)
288         return NULL;
289 
290     lpUnicodeStr = MyMalloc(nLength * sizeof(WCHAR));
291     if (lpUnicodeStr == NULL)
292         return NULL;
293 
294     if (!MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
295                              nLength, lpUnicodeStr, nLength))
296     {
297         MyFree(lpUnicodeStr);
298         return NULL;
299     }
300 
301     return lpUnicodeStr;
302 }
303 
304 
305 /**************************************************************************
306  * UnicodeToMultiByte [SETUPAPI.@]
307  *
308  * Converts a Unicode string to a multi-byte string.
309  *
310  * PARAMS
311  *     lpUnicodeStr  [I] Unicode string to be converted
312  *     uCodePage     [I] Code page
313  *
314  * RETURNS
315  *     Success: pointer to the converted multi-byte string
316  *     Failure: NULL
317  *
318  * NOTE
319  *     Use MyFree to release the returned multi-byte string.
320  */
321 LPSTR WINAPI UnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
322 {
323     LPSTR lpMultiByteStr;
324     int nLength;
325 
326     nLength = WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
327                                   NULL, 0, NULL, NULL);
328     if (nLength == 0)
329         return NULL;
330 
331     lpMultiByteStr = MyMalloc(nLength);
332     if (lpMultiByteStr == NULL)
333         return NULL;
334 
335     if (!WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
336                              lpMultiByteStr, nLength, NULL, NULL))
337     {
338         MyFree(lpMultiByteStr);
339         return NULL;
340     }
341 
342     return lpMultiByteStr;
343 }
344 
345 
346 /**************************************************************************
347  * DoesUserHavePrivilege [SETUPAPI.@]
348  *
349  * Check whether the current user has got a given privilege.
350  *
351  * PARAMS
352  *     lpPrivilegeName  [I] Name of the privilege to be checked
353  *
354  * RETURNS
355  *     Success: TRUE
356  *     Failure: FALSE
357  */
358 BOOL WINAPI DoesUserHavePrivilege(LPCWSTR lpPrivilegeName)
359 {
360     HANDLE hToken;
361     DWORD dwSize;
362     PTOKEN_PRIVILEGES lpPrivileges;
363     LUID PrivilegeLuid;
364     DWORD i;
365     BOOL bResult = FALSE;
366 
367     TRACE("%s\n", debugstr_w(lpPrivilegeName));
368 
369     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
370         return FALSE;
371 
372     if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize))
373     {
374         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
375         {
376             CloseHandle(hToken);
377             return FALSE;
378         }
379     }
380 
381     lpPrivileges = MyMalloc(dwSize);
382     if (lpPrivileges == NULL)
383     {
384         CloseHandle(hToken);
385         return FALSE;
386     }
387 
388     if (!GetTokenInformation(hToken, TokenPrivileges, lpPrivileges, dwSize, &dwSize))
389     {
390         MyFree(lpPrivileges);
391         CloseHandle(hToken);
392         return FALSE;
393     }
394 
395     CloseHandle(hToken);
396 
397     if (!LookupPrivilegeValueW(NULL, lpPrivilegeName, &PrivilegeLuid))
398     {
399         MyFree(lpPrivileges);
400         return FALSE;
401     }
402 
403     for (i = 0; i < lpPrivileges->PrivilegeCount; i++)
404     {
405         if (lpPrivileges->Privileges[i].Luid.HighPart == PrivilegeLuid.HighPart &&
406             lpPrivileges->Privileges[i].Luid.LowPart == PrivilegeLuid.LowPart)
407         {
408             bResult = TRUE;
409         }
410     }
411 
412     MyFree(lpPrivileges);
413 
414     return bResult;
415 }
416 
417 
418 /**************************************************************************
419  * EnablePrivilege [SETUPAPI.@]
420  *
421  * Enables or disables one of the current users privileges.
422  *
423  * PARAMS
424  *     lpPrivilegeName  [I] Name of the privilege to be changed
425  *     bEnable          [I] TRUE: Enables the privilege
426  *                          FALSE: Disables the privilege
427  *
428  * RETURNS
429  *     Success: TRUE
430  *     Failure: FALSE
431  */
432 BOOL WINAPI EnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
433 {
434     TOKEN_PRIVILEGES Privileges;
435     HANDLE hToken;
436     BOOL bResult;
437 
438     TRACE("%s %s\n", debugstr_w(lpPrivilegeName), bEnable ? "TRUE" : "FALSE");
439 
440     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
441         return FALSE;
442 
443     Privileges.PrivilegeCount = 1;
444     Privileges.Privileges[0].Attributes = (bEnable) ? SE_PRIVILEGE_ENABLED : 0;
445 
446     if (!LookupPrivilegeValueW(NULL, lpPrivilegeName,
447                                &Privileges.Privileges[0].Luid))
448     {
449         CloseHandle(hToken);
450         return FALSE;
451     }
452 
453     bResult = AdjustTokenPrivileges(hToken, FALSE, &Privileges, 0, NULL, NULL);
454 
455     CloseHandle(hToken);
456 
457     return bResult;
458 }
459 
460 
461 /**************************************************************************
462  * DelayedMove [SETUPAPI.@]
463  *
464  * Moves a file upon the next reboot.
465  *
466  * PARAMS
467  *     lpExistingFileName  [I] Current file name
468  *     lpNewFileName       [I] New file name
469  *
470  * RETURNS
471  *     Success: TRUE
472  *     Failure: FALSE
473  */
474 BOOL WINAPI DelayedMove(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
475 {
476     return MoveFileExW(lpExistingFileName, lpNewFileName,
477                        MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT);
478 }
479 
480 
481 /**************************************************************************
482  * FileExists [SETUPAPI.@]
483  *
484  * Checks whether a file exists.
485  *
486  * PARAMS
487  *     lpFileName     [I] Name of the file to check
488  *     lpNewFileName  [O] Optional information about the existing file
489  *
490  * RETURNS
491  *     Success: TRUE
492  *     Failure: FALSE
493  */
494 BOOL WINAPI FileExists(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFileFindData)
495 {
496     WIN32_FIND_DATAW FindData;
497     HANDLE hFind;
498     UINT uErrorMode;
499     DWORD dwError;
500 
501     uErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
502 
503     hFind = FindFirstFileW(lpFileName, &FindData);
504     if (hFind == INVALID_HANDLE_VALUE)
505     {
506         dwError = GetLastError();
507         SetErrorMode(uErrorMode);
508         SetLastError(dwError);
509         return FALSE;
510     }
511 
512     FindClose(hFind);
513 
514     if (lpFileFindData)
515         *lpFileFindData = FindData;
516 
517     SetErrorMode(uErrorMode);
518 
519     return TRUE;
520 }
521 
522 
523 /**************************************************************************
524  * CaptureStringArg [SETUPAPI.@]
525  *
526  * Captures a UNICODE string.
527  *
528  * PARAMS
529  *     lpSrc  [I] UNICODE string to be captured
530  *     lpDst  [O] Pointer to the captured UNICODE string
531  *
532  * RETURNS
533  *     Success: ERROR_SUCCESS
534  *     Failure: ERROR_INVALID_PARAMETER
535  *
536  * NOTE
537  *     Call MyFree to release the captured UNICODE string.
538  */
539 DWORD WINAPI CaptureStringArg(LPCWSTR pSrc, LPWSTR *pDst)
540 {
541     if (pDst == NULL)
542         return ERROR_INVALID_PARAMETER;
543 
544     *pDst = DuplicateString(pSrc);
545 
546     return ERROR_SUCCESS;
547 }
548 
549 
550 /**************************************************************************
551  * CaptureAndConvertAnsiArg [SETUPAPI.@]
552  *
553  * Captures an ANSI string and converts it to a UNICODE string.
554  *
555  * PARAMS
556  *     lpSrc  [I] ANSI string to be captured
557  *     lpDst  [O] Pointer to the captured UNICODE string
558  *
559  * RETURNS
560  *     Success: ERROR_SUCCESS
561  *     Failure: ERROR_INVALID_PARAMETER
562  *
563  * NOTE
564  *     Call MyFree to release the captured UNICODE string.
565  */
566 DWORD WINAPI CaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
567 {
568     if (pDst == NULL)
569         return ERROR_INVALID_PARAMETER;
570 
571     *pDst = MultiByteToUnicode(pSrc, CP_ACP);
572 
573     return ERROR_SUCCESS;
574 }
575 
576 
577 /**************************************************************************
578  * OpenAndMapFileForRead [SETUPAPI.@]
579  *
580  * Open and map a file to a buffer.
581  *
582  * PARAMS
583  *     lpFileName [I] Name of the file to be opened
584  *     lpSize     [O] Pointer to the file size
585  *     lpFile     [0] Pointer to the file handle
586  *     lpMapping  [0] Pointer to the mapping handle
587  *     lpBuffer   [0] Pointer to the file buffer
588  *
589  * RETURNS
590  *     Success: ERROR_SUCCESS
591  *     Failure: Other
592  *
593  * NOTE
594  *     Call UnmapAndCloseFile to release the file.
595  */
596 DWORD WINAPI OpenAndMapFileForRead(LPCWSTR lpFileName,
597                                    LPDWORD lpSize,
598                                    LPHANDLE lpFile,
599                                    LPHANDLE lpMapping,
600                                    LPVOID *lpBuffer)
601 {
602     DWORD dwError;
603 
604     TRACE("%s %p %p %p %p\n",
605           debugstr_w(lpFileName), lpSize, lpFile, lpMapping, lpBuffer);
606 
607     *lpFile = CreateFileW(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
608                           OPEN_EXISTING, 0, NULL);
609     if (*lpFile == INVALID_HANDLE_VALUE)
610         return GetLastError();
611 
612     *lpSize = GetFileSize(*lpFile, NULL);
613     if (*lpSize == INVALID_FILE_SIZE)
614     {
615         dwError = GetLastError();
616         CloseHandle(*lpFile);
617         return dwError;
618     }
619 
620     *lpMapping = CreateFileMappingW(*lpFile, NULL, PAGE_READONLY, 0,
621                                     *lpSize, NULL);
622     if (*lpMapping == NULL)
623     {
624         dwError = GetLastError();
625         CloseHandle(*lpFile);
626         return dwError;
627     }
628 
629     *lpBuffer = MapViewOfFile(*lpMapping, FILE_MAP_READ, 0, 0, *lpSize);
630     if (*lpBuffer == NULL)
631     {
632         dwError = GetLastError();
633         CloseHandle(*lpMapping);
634         CloseHandle(*lpFile);
635         return dwError;
636     }
637 
638     return ERROR_SUCCESS;
639 }
640 
641 
642 /**************************************************************************
643  * UnmapAndCloseFile [SETUPAPI.@]
644  *
645  * Unmap and close a mapped file.
646  *
647  * PARAMS
648  *     hFile    [I] Handle to the file
649  *     hMapping [I] Handle to the file mapping
650  *     lpBuffer [I] Pointer to the file buffer
651  *
652  * RETURNS
653  *     Success: TRUE
654  *     Failure: FALSE
655  */
656 BOOL WINAPI UnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
657 {
658     TRACE("%p %p %p\n",
659           hFile, hMapping, lpBuffer);
660 
661     if (!UnmapViewOfFile(lpBuffer))
662         return FALSE;
663 
664     if (!CloseHandle(hMapping))
665         return FALSE;
666 
667     if (!CloseHandle(hFile))
668         return FALSE;
669 
670     return TRUE;
671 }
672 
673 
674 /**************************************************************************
675  * StampFileSecurity [SETUPAPI.@]
676  *
677  * Assign a new security descriptor to the given file.
678  *
679  * PARAMS
680  *     lpFileName          [I] Name of the file
681  *     pSecurityDescriptor [I] New security descriptor
682  *
683  * RETURNS
684  *     Success: ERROR_SUCCESS
685  *     Failure: other
686  */
687 DWORD WINAPI StampFileSecurity(LPCWSTR lpFileName, PSECURITY_DESCRIPTOR pSecurityDescriptor)
688 {
689     TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
690 
691     if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
692                           GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
693                           pSecurityDescriptor))
694         return GetLastError();
695 
696     return ERROR_SUCCESS;
697 }
698 
699 
700 /**************************************************************************
701  * TakeOwnershipOfFile [SETUPAPI.@]
702  *
703  * Takes the ownership of the given file.
704  *
705  * PARAMS
706  *     lpFileName [I] Name of the file
707  *
708  * RETURNS
709  *     Success: ERROR_SUCCESS
710  *     Failure: other
711  */
712 DWORD WINAPI TakeOwnershipOfFile(LPCWSTR lpFileName)
713 {
714     SECURITY_DESCRIPTOR SecDesc;
715     HANDLE hToken = NULL;
716     PTOKEN_OWNER pOwner = NULL;
717     DWORD dwError;
718     DWORD dwSize;
719 
720     TRACE("%s\n", debugstr_w(lpFileName));
721 
722     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
723         return GetLastError();
724 
725     if (!GetTokenInformation(hToken, TokenOwner, NULL, 0, &dwSize))
726     {
727         goto fail;
728     }
729 
730     pOwner = (PTOKEN_OWNER)MyMalloc(dwSize);
731     if (pOwner == NULL)
732     {
733         CloseHandle(hToken);
734         return ERROR_NOT_ENOUGH_MEMORY;
735     }
736 
737     if (!GetTokenInformation(hToken, TokenOwner, pOwner, dwSize, &dwSize))
738     {
739         goto fail;
740     }
741 
742     if (!InitializeSecurityDescriptor(&SecDesc, SECURITY_DESCRIPTOR_REVISION))
743     {
744         goto fail;
745     }
746 
747     if (!SetSecurityDescriptorOwner(&SecDesc, pOwner->Owner, FALSE))
748     {
749         goto fail;
750     }
751 
752     if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION, &SecDesc))
753     {
754         goto fail;
755     }
756 
757     MyFree(pOwner);
758     CloseHandle(hToken);
759 
760     return ERROR_SUCCESS;
761 
762 fail:;
763     dwError = GetLastError();
764 
765     MyFree(pOwner);
766 
767     if (hToken != NULL)
768         CloseHandle(hToken);
769 
770     return dwError;
771 }
772 
773 
774 /**************************************************************************
775  * RetreiveFileSecurity [SETUPAPI.@]
776  *
777  * Retrieve the security descriptor that is associated with the given file.
778  *
779  * PARAMS
780  *     lpFileName [I] Name of the file
781  *
782  * RETURNS
783  *     Success: ERROR_SUCCESS
784  *     Failure: other
785  */
786 DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName,
787                                   PSECURITY_DESCRIPTOR *pSecurityDescriptor)
788 {
789     PSECURITY_DESCRIPTOR SecDesc;
790     DWORD dwSize = 0x100;
791     DWORD dwError;
792 
793     SecDesc = MyMalloc(dwSize);
794     if (SecDesc == NULL)
795         return ERROR_NOT_ENOUGH_MEMORY;
796 
797     if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
798                          GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
799                          SecDesc, dwSize, &dwSize))
800     {
801       *pSecurityDescriptor = SecDesc;
802       return ERROR_SUCCESS;
803     }
804 
805     dwError = GetLastError();
806     if (dwError != ERROR_INSUFFICIENT_BUFFER)
807     {
808         MyFree(SecDesc);
809         return dwError;
810     }
811 
812     SecDesc = MyRealloc(SecDesc, dwSize);
813     if (SecDesc == NULL)
814         return ERROR_NOT_ENOUGH_MEMORY;
815 
816     if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
817                          GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
818                          SecDesc, dwSize, &dwSize))
819     {
820       *pSecurityDescriptor = SecDesc;
821       return ERROR_SUCCESS;
822     }
823 
824     dwError = GetLastError();
825     MyFree(SecDesc);
826 
827     return dwError;
828 }
829 
830 
831 static DWORD global_flags = 0;  /* FIXME: what should be in here? */
832 
833 /***********************************************************************
834  *              pSetupGetGlobalFlags  (SETUPAPI.@)
835  */
836 DWORD WINAPI pSetupGetGlobalFlags(void)
837 {
838     FIXME( "stub\n" );
839     return global_flags;
840 }
841 
842 
843 /***********************************************************************
844  *              pSetupSetGlobalFlags  (SETUPAPI.@)
845  */
846 void WINAPI pSetupSetGlobalFlags( DWORD flags )
847 {
848     global_flags = flags;
849 }
850 
851 /***********************************************************************
852  *              CMP_WaitNoPendingInstallEvents  (SETUPAPI.@)
853  */
854 DWORD WINAPI CMP_WaitNoPendingInstallEvents( DWORD dwTimeout )
855 {
856     static BOOL warned = FALSE;
857 
858     if (!warned)
859     {
860         FIXME("%d\n", dwTimeout);
861         warned = TRUE;
862     }
863     return WAIT_OBJECT_0;
864 }
865 
866 /***********************************************************************
867  *              AssertFail  (SETUPAPI.@)
868  *
869  * Shows an assert fail error messagebox
870  *
871  * PARAMS
872  *   lpFile [I]         file where assert failed
873  *   uLine [I]          line number in file
874  *   lpMessage [I]      assert message
875  *
876  */
877 void WINAPI AssertFail(LPCSTR lpFile, UINT uLine, LPCSTR lpMessage)
878 {
879     FIXME("%s %u %s\n", lpFile, uLine, lpMessage);
880 }
881 
882 /***********************************************************************
883  *      SetupCopyOEMInfA  (SETUPAPI.@)
884  */
885 BOOL WINAPI SetupCopyOEMInfA( PCSTR source, PCSTR location,
886                               DWORD media_type, DWORD style, PSTR dest,
887                               DWORD buffer_size, PDWORD required_size, PSTR *component )
888 {
889     BOOL ret = FALSE;
890     LPWSTR destW = NULL, sourceW = NULL, locationW = NULL;
891     DWORD size;
892 
893     TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_a(source), debugstr_a(location),
894           media_type, style, dest, buffer_size, required_size, component);
895 
896     if (dest && !(destW = MyMalloc( buffer_size * sizeof(WCHAR) ))) return FALSE;
897     if (source && !(sourceW = strdupAtoW( source ))) goto done;
898     if (location && !(locationW = strdupAtoW( location ))) goto done;
899 
900     if (!(ret = SetupCopyOEMInfW( sourceW, locationW, media_type, style, destW,
901                                   buffer_size, &size, NULL )))
902     {
903         if (required_size) *required_size = size;
904         goto done;
905     }
906 
907     if (dest)
908     {
909         if (buffer_size >= size)
910         {
911             WideCharToMultiByte( CP_ACP, 0, destW, -1, dest, buffer_size, NULL, NULL );
912             if (component) *component = strrchr( dest, '\\' ) + 1;
913         }
914         else
915         {
916             SetLastError( ERROR_INSUFFICIENT_BUFFER );
917             goto done;
918         }
919     }
920 
921 done:
922     MyFree( destW );
923     HeapFree( GetProcessHeap(), 0, sourceW );
924     HeapFree( GetProcessHeap(), 0, locationW );
925     if (ret) SetLastError(ERROR_SUCCESS);
926     return ret;
927 }
928 
929 static int compare_files( HANDLE file1, HANDLE file2 )
930 {
931     char buffer1[2048];
932     char buffer2[2048];
933     DWORD size1;
934     DWORD size2;
935 
936     while( ReadFile(file1, buffer1, sizeof(buffer1), &size1, NULL) &&
937            ReadFile(file2, buffer2, sizeof(buffer2), &size2, NULL) )
938     {
939         int ret;
940         if (size1 != size2)
941             return size1 > size2 ? 1 : -1;
942         if (!size1)
943             return 0;
944         ret = memcmp( buffer1, buffer2, size1 );
945         if (ret)
946             return ret;
947     }
948 
949     return 0;
950 }
951 
952 /***********************************************************************
953  *      SetupCopyOEMInfW  (SETUPAPI.@)
954  */
955 BOOL WINAPI SetupCopyOEMInfW( PCWSTR source, PCWSTR location,
956                               DWORD media_type, DWORD style, PWSTR dest,
957                               DWORD buffer_size, PDWORD required_size, PWSTR *component )
958 {
959     BOOL ret = FALSE;
960     WCHAR target[MAX_PATH], catalog_file[MAX_PATH], *p;
961     static const WCHAR inf[] = { '\\','i','n','f','\\',0 };
962     static const WCHAR wszVersion[] = { 'V','e','r','s','i','o','n',0 };
963     static const WCHAR wszCatalogFile[] = { 'C','a','t','a','l','o','g','F','i','l','e',0 };
964     DWORD size;
965     HINF hinf;
966 
967     TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_w(source), debugstr_w(location),
968           media_type, style, dest, buffer_size, required_size, component);
969 
970     if (!source)
971     {
972         SetLastError(ERROR_INVALID_PARAMETER);
973         return FALSE;
974     }
975 
976     /* check for a relative path */
977     if (!(*source == '\\' || (*source && source[1] == ':')))
978     {
979         SetLastError(ERROR_FILE_NOT_FOUND);
980         return FALSE;
981     }
982 
983     if (!GetWindowsDirectoryW( target, sizeof(target)/sizeof(WCHAR) )) return FALSE;
984 
985     strcatW( target, inf );
986     if ((p = strrchrW( source, '\\' )))
987         strcatW( target, p + 1 );
988 
989     /* does the file exist already? */
990     if ((GetFileAttributesW( target ) != INVALID_FILE_ATTRIBUTES) &&
991         !(style & SP_COPY_NOOVERWRITE))
992     {
993         static const WCHAR oem[] = { 'o','e','m',0 };
994         unsigned int i;
995         LARGE_INTEGER source_file_size;
996         HANDLE source_file;
997 
998         source_file = CreateFileW( source, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
999                                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1000                                    NULL, OPEN_EXISTING, 0, NULL );
1001         if (source_file == INVALID_HANDLE_VALUE)
1002             return FALSE;
1003 
1004         if (!GetFileSizeEx( source_file, &source_file_size ))
1005         {
1006             CloseHandle( source_file );
1007             return FALSE;
1008         }
1009 
1010         p = strrchrW( target, '\\' ) + 1;
1011         memcpy( p, oem, sizeof(oem) );
1012         p += sizeof(oem)/sizeof(oem[0]) - 1;
1013 
1014         /* generate OEMnnn.inf ending */
1015         for (i = 0; i < OEM_INDEX_LIMIT; i++)
1016         {
1017             static const WCHAR format[] = { '%','u','.','i','n','f',0 };
1018             HANDLE dest_file;
1019             LARGE_INTEGER dest_file_size;
1020 
1021             wsprintfW( p, format, i );
1022             dest_file = CreateFileW( target, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
1023                                      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1024                                      NULL, OPEN_EXISTING, 0, NULL );
1025             /* if we found a file name that doesn't exist then we're done */
1026             if (dest_file == INVALID_HANDLE_VALUE)
1027                 break;
1028             /* now check if the same inf file has already been copied to the inf
1029              * directory. if so, use that file and don't create a new one */
1030             if (!GetFileSizeEx( dest_file, &dest_file_size ) ||
1031                 (dest_file_size.QuadPart != source_file_size.QuadPart) ||
1032                 compare_files( source_file, dest_file ))
1033             {
1034                 CloseHandle( dest_file );
1035                 continue;
1036             }
1037             CloseHandle( dest_file );
1038             break;
1039         }
1040 
1041         CloseHandle( source_file );
1042         if (i == OEM_INDEX_LIMIT)
1043         {
1044             SetLastError( ERROR_FILENAME_EXCED_RANGE );
1045             return FALSE;
1046         }
1047     }
1048 
1049     hinf = SetupOpenInfFileW( source, NULL, INF_STYLE_WIN4, NULL );
1050     if (hinf == INVALID_HANDLE_VALUE) return FALSE;
1051