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